diff --git a/.actrc b/.actrc
new file mode 100644
index 00000000..a078f640
--- /dev/null
+++ b/.actrc
@@ -0,0 +1 @@
+-e contrib/act/event.json
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000..453228e1
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,8 @@
+# Set update schedule for GitHub Actions
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"
diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
new file mode 100644
index 00000000..fbc9c32d
--- /dev/null
+++ b/.github/workflows/fuzz.yml
@@ -0,0 +1,77 @@
+# Automatically generated by fuzz/generate-files.sh
+name: Fuzz
+
+on:
+  push:
+    branches:
+      - update_on_bitcoin_0.31.x
+      - master
+      - 'test-ci/**'
+  pull_request:
+
+jobs:
+  fuzz:
+    if: ${{ !github.event.act }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        fuzz_target: [
+          tapyrus_deserialize_address,
+          tapyrus_deserialize_amount,
+          tapyrus_deserialize_block,
+          tapyrus_deserialize_prefilled_transaction,
+          tapyrus_deserialize_psbt,
+          tapyrus_deserialize_script,
+          tapyrus_deserialize_transaction,
+          tapyrus_deserialize_witness,
+          tapyrus_deser_net_msg,
+          tapyrus_outpoint_string,
+          tapyrus_script_bytes_to_asm_fmt,
+          hashes_cbor,
+          hashes_json,
+          hashes_ripemd160,
+          hashes_sha1,
+          hashes_sha256,
+          hashes_sha512_256,
+          hashes_sha512,
+        ]
+    steps:
+      - name: Install test dependencies
+        run: sudo apt-get update -y && sudo apt-get install -y binutils-dev libunwind8-dev libcurl4-openssl-dev libelf-dev libdw-dev cmake gcc libiberty-dev
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v3
+        id: cache-fuzz
+        with:
+          path: |
+            ~/.cargo/bin
+            fuzz/target
+            target
+          key: cache-${{ matrix.target }}-${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: '1.65.0'
+      - name: fuzz
+        run: |
+          if [[ "${{ matrix.fuzz_target }}" =~ ^bitcoin ]]; then
+              export RUSTFLAGS='--cfg=hashes_fuzz --cfg=secp256k1_fuzz'
+          fi
+          echo "Using RUSTFLAGS $RUSTFLAGS"
+          cd fuzz && ./fuzz.sh "${{ matrix.fuzz_target }}"
+      - run: echo "${{ matrix.fuzz_target }}" >executed_${{ matrix.fuzz_target }}
+      - uses: actions/upload-artifact@v3
+        with:
+          name: executed_${{ matrix.fuzz_target }}
+          path: executed_${{ matrix.fuzz_target }}
+
+  verify-execution:
+    if: ${{ !github.event.act }}
+    needs: fuzz
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v3
+      - name: Display structure of downloaded files
+        run: ls -R
+      - run: find executed_* -type f -exec cat {} + | sort > executed
+      - run: source ./fuzz/fuzz-util.sh && listTargetNames | sort | diff - executed
diff --git a/.github/workflows/gh-release.yml b/.github/workflows/gh-release.yml
new file mode 100644
index 00000000..69ea930c
--- /dev/null
+++ b/.github/workflows/gh-release.yml
@@ -0,0 +1,15 @@
+name: GitHub Release
+
+on:
+  push:
+    tags:
+    - '*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ncipollo/release-action@v1
+      with:
+        generateReleaseNotes: true
diff --git a/.github/workflows/kani.yml b/.github/workflows/kani.yml
new file mode 100644
index 00000000..520ad176
--- /dev/null
+++ b/.github/workflows/kani.yml
@@ -0,0 +1,14 @@
+# From https://model-checking.github.io/kani/install-github-ci.html
+name: Kani CI
+on:
+  schedule:
+    - cron: '59 23 * * *'       # midnight every day.
+jobs:
+  run-kani:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: 'Checkout your code.'
+        uses: actions/checkout@v4
+
+      - name: 'Run Kani on your code.'
+        uses: model-checking/kani-github-action@v1.0
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000..cd2a8725
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,22 @@
+on:
+  push:
+    branches:
+      - master
+      - 0.28.x
+      - 0.29.x
+      - 'test-ci/**'
+  pull_request:
+
+name: Release
+
+jobs:
+  release:
+    name: Release - dry-run
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: run cargo
+        run: contrib/release.sh
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
new file mode 100644
index 00000000..aba635f0
--- /dev/null
+++ b/.github/workflows/rust.yml
@@ -0,0 +1,172 @@
+on:
+  push:
+    branches:
+      - master
+      - update_on_bitcoin_0.31.x
+      - 'test-ci/**'
+  pull_request:
+
+name: Continuous integration
+
+jobs:
+  Stable:
+    name: Test - stable toolchain
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        # https://github.com/dtolnay/rust-toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Running test script
+        env:
+          DO_COV: true
+          AS_DEPENDENCY: false
+          DO_NO_STD: true
+          DO_DOCS: true
+          DO_FEATURE_MATRIX: true
+          DO_SCHEMARS_TESTS: true # Currently only used in hashes crate.
+        run: ./contrib/test.sh
+
+  Beta:
+    name: Test - beta toolchain
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@beta
+      - name: Running test script
+        env:
+          AS_DEPENDENCY: false
+          DO_NO_STD: true
+        run: ./contrib/test.sh
+
+  Nightly:
+    name: Test - nightly toolchain
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@nightly
+      - name: Install clippy
+        run: rustup component add clippy
+      - name: Running test script
+        env:
+          DO_LINT: true
+          DO_FMT: false
+          DO_BENCH: true
+          AS_DEPENDENCY: false
+          DO_NO_STD: true
+          DO_DOCSRS: true
+        run: ./contrib/test.sh
+
+  MSRV:
+    name: Test - 1.56.1 toolchain
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: "1.56.1"
+      - name: Running test script
+        env:
+          DO_FEATURE_MATRIX: true
+          DO_NO_STD: true
+        run: ./contrib/test.sh
+
+  Arch32bit:
+    name: Test 32-bit version
+    runs-on: ubuntu-latest
+    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 test on i686
+        run: cargo test --target i686-unknown-linux-gnu
+
+  Cross:
+    name: Cross test
+    if: ${{ !github.event.act }}
+    runs-on: ubuntu-latest
+    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
+
+  Embedded:
+    name: Embedded test
+    runs-on: ubuntu-latest
+    env:
+      RUSTFLAGS: "-C link-arg=-Tlink.x"
+      CARGO_TARGET_THUMBV7M_NONE_EABI_RUNNER: "qemu-system-arm -cpu cortex-m3 -machine mps2-an385 -nographic -semihosting-config enable=on,target=native -kernel"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        run: sudo apt update && sudo apt install -y qemu-system-arm gcc-arm-none-eabi
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          targets: thumbv7m-none-eabi
+      - name: Install src
+        run: rustup component add rust-src
+      - name: Run tapyrus/embedded
+        run: cd tapyrus/embedded && cargo run --target thumbv7m-none-eabi
+      - name: Run hashes/embedded no alloc
+        run: cd hashes/embedded && cargo run --target thumbv7m-none-eabi
+      - name: Run hashes/embedded with alloc
+        run: cd hashes/embedded && cargo run --target thumbv7m-none-eabi --features=alloc
+
+  ASAN:
+    name: Address sanitizer     # hashes crate only.
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@nightly
+      - name: Install src
+        run: rustup component add rust-src
+      - name: Running address sanitizer
+        env:
+          DO_ASAN: true
+        run: cd hashes && ./contrib/test.sh
+
+  WASM:
+    name: WebAssembly Build # hashes crate only.
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Crate
+        uses: actions/checkout@v4
+      - name: Checkout Toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Running WASM build
+        env:
+          DO_WASM: true
+        run: cd hashes && ./contrib/test.sh
diff --git a/.github/workflows/rustfmt.yml b/.github/workflows/rustfmt.yml
new file mode 100644
index 00000000..4fb721e0
--- /dev/null
+++ b/.github/workflows/rustfmt.yml
@@ -0,0 +1,26 @@
+name: Nightly rustfmt
+on:
+  schedule:
+    - cron: "0 0 * * 0" # runs weekly on Sunday at 00:00
+  workflow_dispatch: # allows manual triggering
+jobs:
+  format:
+    name: Nightly rustfmt
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustfmt
+      - name: Run Nightly rustfmt
+        run: cargo +nightly fmt
+      - name: Get the current date
+        run: echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_ENV
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v5
+        with:
+          title: Automated nightly rustfmt (${{ env.date }})
+          body: |
+           Automated nightly `rustfmt` changes by [create-pull-request](https://github.com/peter-evans/create-pull-request) GitHub action
+          commit-message: ${{ env.date }} automated rustfmt nightly 
+          labels: rustfmt
diff --git a/.gitignore b/.gitignore
index 93426a2c..76ab8e9b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,20 @@
-target
+# .gitignore for rust-tapyrus repository workspace.
+
+# Lock files
 Cargo.lock
+internals/Cargo.lock
+tapyrus/Cargo.lock
+hashes/Cargo.lock
+
+# Build artifacts
+target
+internals/target
+tapyrus/target
+hashes/target
 
-#fuzz
-fuzz/hfuzz_target
-fuzz/hfuzz_workspace
+# Test artifacts
+tapyrus/dep_test
 
-#IntelliJ project files
-.idea
-*.iml
+# Fuzz artifacts
+hfuzz_target
+hfuzz_workspace
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 9bfabdeb..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-language: rust
-cache: cargo
-
-addons:
-  apt:
-    update: true
-    packages:
-      - binutils-dev
-      - libunwind8-dev
-      - libcurl4-openssl-dev
-      - libelf-dev
-      - libdw-dev
-      - cmake
-      - gcc
-      - libiberty-dev
-
-
-matrix:
-  include:
-    - rust: stable
-      env: DO_FUZZ=true DO_COV=true AS_DEPENDENCY=true
-    - rust: beta
-      env: AS_DEPENDENCY=true
-    - rust: nightly
-      env: DO_BENCH=true AS_DEPENDENCY=true
-    - rust: 1.22.0
-      env: AS_DEPENDENCY=true
-
-script:
-  - ./contrib/test.sh
-
-after_success: |
-  if [ "$DO_COV" = true ]; then
-    wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz &&
-    tar xzf master.tar.gz &&
-    cd kcov-master &&
-    mkdir build &&
-    cd build &&
-    cmake .. &&
-    make &&
-    make install DESTDIR=../../kcov-build &&
-    cd ../.. &&
-    rm -rf kcov-master &&
-    for file in target/debug/bitcoin-*; do [ -x "${file}" ] || continue; mkdir -p "target/cov/$(basename $file)"; ./kcov-build/usr/local/bin/kcov --exclude-pattern=/.cargo,/usr/lib --verify "target/cov/$(basename $file)" "$file"; done &&
-    bash <(curl -s https://codecov.io/bash) &&
-    echo "Uploaded code coverage"; fi
diff --git a/CHANGELOG.md b/CHANGELOG.md
deleted file mode 100644
index 6a4475e8..00000000
--- a/CHANGELOG.md
+++ /dev/null
@@ -1,192 +0,0 @@
-
-# 0.23.0 - 2020-01-07
-
-- Update `secp256k1` dependency to `0.17.1`.
-- Update `bitcoinconsensus` dependency to `0.19.0-1`.
-- Update `bech32` dependency to `0.7.2`.
-
-# 0.22.0 - 2020-01-07
-
-- Add `ServiceFlags` type.
-- Add `NetworkMessage::command`.
-- Add `key::Error`.
-- Add newtypes for specific hashes:
-    - `Txid`
-    - `Wtxid`
-    - `BlockHash`
-    - `SigHash`
-    - `PubkeyHash`
-    - `ScriptHash`
-    - `WPubkeyHash`
-    - `WScriptHash`
-    - `TxMerkleNode`
-    - `WitnessMerkleNode`
-    - `WitnessCommitment`
-    - `XpubIdentifier`
-    - `FilterHash`
-- Refactor `CommandString`.
-- Refactor `Reject` message.
-- Rename `RejectReason` enum variants.
-- Refactor `encode::Error`.
-- Implement `Default` for `TxIn`.
-- Implement `std::hash::Hash` for `Inventory`.
-- Implement `Copy` for `InvType` enum.
-- Use `psbt::Error` in `PartiallySignedTransaction::from_unsigned_tx`.
-- Drop message decode max length to 4_000_000.
-- Drop `hex` and `byteorder` dependencies.
-
-# 0.21.0 - 2019-10-02
-
-* Add [serde to `BlockHeader` and `Block`](https://github.com/rust-bitcoin/rust-bitcoin/pull/321)
-* [Clean up `StreamReader` API](https://github.com/rust-bitcoin/rust-bitcoin/pull/318) (breaking change)
-* Add [reject message](https://github.com/rust-bitcoin/rust-bitcoin/pull/323) to p2p messages
-
-# 0.20.0 - 2019-08-23
-
-* Update `secp256k1` 0.15 and `bitcoinconsensus` 0.17
-
-# 0.19.0 - 2019-08-16
-
-* Add `Amount` and `SignedAmount` types.
-* Add BIP-158 support with `BlockFilter` and related types.
-* Add `util::misc::signed_msg_hash()` for signing messages.
-* Add `MerkleBlock` and `PartialMerkleTree` types.
-* bip32: Support serde serializaton for types and add some utility methods:
-    * `ChildNumber::increment`
-    * `DerivationPath::children_from`
-    * `DerivationPath::normal_children`
-    * `DerivationPath::hardened_children`
-* Add `blockdata::script::Builder::push_verify` to verify-ify an opcode.
-* Add `sendheaders` network message.
-* Add `OutPoint::new()` method and JSON-serialize as `<txid>:<vout>`.
-* Refactor `Address` type:
-    * Now supports segwit addresses with version >0.
-    * Add `Address::from_script` constructor.
-    * Add `Address::address_type` inspector.
-    * Parsing now returns an `address::Error` instead of `encode::Error`.
-    * Removed `bitcoin_bech32` dependency for bech32 payloads.
-* bip143: Rename `witness_script` to `script_code`
-* Rename `BlockHeader::spv_validate` to `validate_pow`
-* Rename `OP_NOP2` and `OP_NOP3` to `OP_CLTV` and `OP_CSV`
-* psbt: Use `BTreeMap` instead of `HashMap` to ensure serialization roundtrips.
-* Drop `Decimal` type.
-* Drop `LoneHeaders` type.
-* Replace `strason` dependency with (optional) `serde_json`.
-* Export the `bitcoin_hashes` and `secp256k1` dependent crates.
-* Updated `bitcoin_hashes` dependency to v0.7.
-* Removed `rand` and `serde_test` dependencies.
-* Internal improvements to consensus encoding logic.
-
-# 0.18.0 - 2019-03-21
-
-* Update `bitcoin-bech32` version to 0.9
-* add `to_bytes` method for `util::key` types
-* add serde impls for `util::key` types
-* contracthash: minor cleanups, use `util::key` types instead of `secp256k1` types
-
-# 0.17.1 - 2019-03-04
-
-* Add some trait impls to `PublicKey` for miniscript interoperability
-
-# 0.17.0 - 2019-02-28 - ``The PSBT Release''
-
-* **Update minimum rustc version to 1.22**.
-* [Replace `rust-crypto` with `bitcoin_hashes`; refactor hash types](https://github.com/rust-bitcoin/rust-bitcoin/pull/215)
-* [Remove `Address::p2pk`](https://github.com/rust-bitcoin/rust-bitcoin/pull/222/)
-* Remove misleading blanket `MerkleRoot` implementation; [it is now only defined for `Block`](https://github.com/rust-bitcoin/rust-bitcoin/pull/218)
-* [Add BIP157](https://github.com/rust-bitcoin/rust-bitcoin/pull/215) (client-side block filtering messages)
-* Allow network messages [to be deserialized even across multiple packets](https://github.com/rust-bitcoin/rust-bitcoin/pull/231)
-* [Replace all key types](https://github.com/rust-bitcoin/rust-bitcoin/pull/183) to better match abstractions needed for PSBT
-* [Clean up BIP32](https://github.com/rust-bitcoin/rust-bitcoin/pull/233) in preparation for PSBT; [use new native key types rather than `secp256k1` ones](https://github.com/rust-bitcoin/rust-bitcoin/pull/238/)
-* Remove [apparently-used `Option` serialization](https://github.com/rust-bitcoin/rust-bitcoin/pull/236#event-2158116421) code
-* Finally merge [PSBT](https://github.com/rust-bitcoin/rust-bitcoin/pull/103) after nearly nine months
-
-# 0.16.0 - 2019-01-15
-
-* Reorganize opcode types to eliminate unsafe code
-* Un-expose some macros that were unintentionally exported
-* Update rust-secp256k1 dependency to 0.12
-* Remove `util::iter::Pair` type which does not belong in this library
-* Minor bugfixes and optimizations
-
-# 0.15.1 - 2018-11-08
-
-* [Detect p2pk addresses with compressed keys](https://github.com/rust-bitcoin/rust-bitcoin/pull/189)
-
-# 0.15.0 - 2018-11-03
-
-* [Significant API overhaul](https://github.com/rust-bitcoin/rust-bitcoin/pull/156):
-    * Remove `nu_select` macro and low-level networking support
-    * Move `network::consensus_params` to `consensus::params`
-    * Move many other things into `consensus::params`
-    * Move `BitcoinHash` from `network::serialize` to `util::hash`; remove impl for `Vec<u8>`
-    * Rename/restructure error types
-    * Rename `Consensus{De,En}coder` to `consensus::{De,En}coder`
-    * Replace `Raw{De,En}coder` with blanket impls of `consensus::{De,En}coder` on `io::Read` and `io::Write`
-    * make `serialize` and `serialize_hex` infallible
-* Make 0-input transaction de/serialization [always use segwit](https://github.com/rust-bitcoin/rust-bitcoin/pull/153)
-* Implement `FromStr` and `Display` for many more types
-
-# 0.14.2 - 2018-09-11
-
-* Add serde support for `Address`
-
-# 0.14.1 - 2018-08-28
-
-* Reject non-compact `VarInt`s on various types
-* Expose many types at the top level of the crate
-* Add `Ord`, `PartialOrd` impls for `Script`
-
-# 0.14.0 - 2018-08-22
-
-* Add [regtest network](https://github.com/rust-bitcoin/rust-bitcoin/pull/84) to `Network` enum
-* Add [`Script::is_op_return()`](https://github.com/rust-bitcoin/rust-bitcoin/pull/101/) which is more specific than
-  `Script::is_provably_unspendable()`
-* Update to bech32 0.8.0; [add Regtest bech32 address support](https://github.com/rust-bitcoin/rust-bitcoin/pull/110)
-* [Replace rustc-serialize dependency with hex](https://github.com/rust-bitcoin/rust-bitcoin/pull/107) as a stopgap
-  toward eliminating any extra dependencies for this; clean up the many independent hex encoders and decoders
-  throughout the codebase.
-* [Add conversions between `ChildNumber` and `u32`](https://github.com/rust-bitcoin/rust-bitcoin/pull/126); make
-  representation non-public; fix documentation
-* [Add several derivation convenience](https://github.com/rust-bitcoin/rust-bitcoin/pull/129) to `bip32` extended keys
-* Make `deserialize::deserialize()` [enforce no trailing bytes](https://github.com/rust-bitcoin/rust-bitcoin/pull/129)
-* Replace `TxOutRef` with `OutPoint`; use it in `TxIn` struct.
-* Use modern `as_` `to_` `into_` conventions for array-wrapping types; impl `Display` rather than `ToString` for most types
-* Change `script::Instructions` iterator [to allow rejecting non-minimal pushes](https://github.com/rust-bitcoin/rust-bitcoin/pull/136);
-  fix bug where errors would iterate forever.
-* Overhaul `util::Error`; introduce `serialize::Error` [and use it for `SimpleDecoder` and `SimpleDecoder` rather
-  than parameterizing these over their error type](https://github.com/rust-bitcoin/rust-bitcoin/pull/137).
-* Overhaul `UDecimal` and `Decimal` serialization and parsing [and fix many lingering parsing bugs](https://github.com/rust-bitcoin/rust-bitcoin/pull/142)
-* [Update to serde 1.0 and strason 0.4](https://github.com/rust-bitcoin/rust-bitcoin/pull/125)
-* Update to secp256k1 0.11.0
-* Many, many documentation and test improvements.
-
-# 0.13.1
-
-* Add `Display` trait to uints, `FromStr` trait to `Network` enum
-* Add witness inv types to inv enum, constants for Bitcoin regtest network, `is_coin_base` accessor for tx inputs
-* Expose `merkleroot(Vec<Sha256dHash>)`
-
-# 0.13
-
-* Move witnesses inside the `TxIn` structure
-* Add `Transaction::get_weight()`
-* Update bip143 `sighash_all` API to be more ergonomic
-
-# 0.12
-
-* The in-memory blockchain was moved into a dedicated project rust-bitcoin-chain.
-* Removed old script interpreter
-* A new optional feature "bitcoinconsensus" lets this library use Bitcoin Core's native
-script verifier, wrappend into Rust by the rust-bitcoinconsenus project.
-See `Transaction::verify` and `Script::verify` methods.
-* Replaced Base58 traits with `encode_slice`, `check_encode_slice`, from and `from_check` functions in the base58 module.
-* Un-reversed the Debug output for Sha256dHash
-* Add bech32 support
-* Support segwit address types
-
-### 0.11
-
-* Remove `num` dependency at Matt's request; agree this is obnoxious to require all
-downstream users to also have a `num` dependency just so they can use `Uint256::from_u64`.
-
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000..813c57e7
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,255 @@
+# Contributing to rust-bitcoin
+
+:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
+
+The following is a set of guidelines for contributing to Rust Bitcoin
+implementation and other Rust Bitcoin-related projects, which are hosted in the
+[Rust Bitcoin Community](https://github.com/rust-bitcoin) on GitHub. These are
+mostly guidelines, not rules. Use your best judgment, and feel free to propose
+changes to this document in a pull request.
+
+#### Table Of Contents
+
+- [General](#general)
+- [Communication channels](#communication-channels)
+- [Asking questions](#asking-questions)
+- [Contribution workflow](#contribution-workflow)
+  * [Preparing PRs](#preparing-prs)
+  * [Peer review](#peer-review)
+  * [Repository maintainers](#repository-maintainers)
+- [Coding conventions](#coding-conventions)
+  * [Formatting](#formatting)
+  * [MSRV](#msrv)
+  * [Naming conventions](#naming-conventions)
+  * [Upgrading dependencies](#upgrading-dependencies)
+  * [Unsafe code](#unsafe-code)
+- [Security](#security)
+- [Testing](#testing)
+- [Going further](#going-further)
+
+
+## General
+
+The Rust Bitcoin project operates an open contributor model where anyone is
+welcome to contribute towards development in the form of peer review,
+documentation, testing and patches.
+
+Anyone is invited to contribute without regard to technical experience,
+"expertise", OSS experience, age, or other concern. However, the development of
+standards & reference implementations demands a high-level of rigor, adversarial
+thinking, thorough testing and risk-minimization. Any bug may cost users real
+money. That being said, we deeply welcome people contributing for the first time
+to an open source project or pick up Rust while contributing. Don't be shy,
+you'll learn.
+
+
+## Communication channels
+
+Communication about Rust Bitcoin happens primarily in
+[#bitcoin-rust](https://web.libera.chat/?channel=#bitcoin-rust) IRC chat on
+[Libera](https://libera.chat/) with the logs available at
+<https://gnusha.org/bitcoin-rust/> (starting from Jun 2021 and now on) and
+<https://gnusha.org/rust-bitcoin/> (historical archive before Jun 2021).
+
+Discussion about code base improvements happens in GitHub issues and on pull
+requests.
+
+Major projects are tracked [here](https://github.com/orgs/rust-bitcoin/projects).
+Major milestones are tracked [here](https://github.com/rust-bitcoin/rust-bitcoin/milestones).
+
+
+## Asking questions
+
+> **Note:** Please don't file an issue to ask a question. You'll get faster
+> results by using the resources below.
+
+We have a dedicated developer channel on IRC, #bitcoin-rust@libera.chat where
+you may get helpful advice if you have questions.
+
+
+## Contribution workflow
+
+The codebase is maintained using the "contributor workflow" where everyone
+without exception contributes patch proposals using "pull requests". This
+facilitates social contribution, easy testing and peer review.
+
+To contribute a patch, the workflow is a as follows:
+
+1. Fork Repository
+2. Create topic branch
+3. Commit patches
+
+Please keep commits should atomic and diffs easy to read. For this reason
+do not mix any formatting fixes or code moves with actual code changes.
+Further, each commit, individually, should compile and pass tests, in order to
+ensure git bisect and other automated tools function properly.
+
+Please cover every new feature with unit tests.
+
+When refactoring, structure your PR to make it easy to review and don't hesitate
+to split it into multiple small, focused PRs.
+
+Commits should cover both the issue fixed and the solution's rationale.
+Please keep these [guidelines](https://chris.beams.io/posts/git-commit/) in mind.
+
+To facilitate communication with other contributors, the project is making use
+of GitHub's "assignee" field. First check that no one is assigned and then
+comment suggesting that you're working on it. If someone is already assigned,
+don't hesitate to ask if the assigned party or previous commenters are still
+working on it if it has been awhile.
+
+
+## Preparing PRs
+
+The main library development happens in the `master` branch. This branch must
+always compile without errors (using GitHub CI). All external contributions are
+made within PRs into this branch.
+
+Prerequisites that a PR must satisfy for merging into the `master` branch:
+* each commit within a PR must compile and pass unit tests with no errors, with
+  every feature combination (including compiling the fuzztests) on some
+  reasonably recent compiler (this is partially automated with CI, so the rule
+  is that we will not accept commits which do not pass GitHub CI);
+* the tip of any PR branch must also compile and pass tests with no errors on
+  MSRV (check [README.md] on current MSRV requirements) and pass fuzz tests on
+  nightly rust;
+* contain all necessary tests for the introduced functional (either as a part of
+  commits, or, more preferably, as separate commits, so that it's easy to
+  reorder them during review and check that the new tests fail without the new
+  code);
+* contain all inline docs for newly introduced API and pass doc tests;
+* be based on the recent `master` tip from the original repository at
+  <https://github.com/rust-bitcoin/rust-bitcoin>.
+
+NB: reviewers may run more complex test/CI scripts, thus, satisfying all the
+requirements above is just a preliminary, but not necessary sufficient step for
+getting the PR accepted as a valid candidate PR for the `master` branch.
+
+PR authors may also find it useful to run the following script locally in order
+to check that each of the commits within the PR satisfies the requirements
+above, before submitting the PR to review:
+```shell script
+RUSTUP_TOOLCHAIN=1.41.1 ./contrib/test.sh
+```
+Please replace the value in `RUSTUP_TOOLCHAIN=1.41.1` with the current MSRV from
+[README.md].
+
+NB: Please keep in mind that the script above replaces `Cargo.lock` file, which
+is necessary to support current MSRV, incompatible with `stable` and newer cargo
+versions.
+
+### Peer review
+
+Anyone may participate in peer review which is expressed by comments in the pull
+request. Typically, reviewers will review the code for obvious errors, as well as
+test out the patch set and opine on the technical merits of the patch. Please,
+first review PR on the conceptual level before focusing on code style or
+grammar fixes.
+
+### Repository maintainers
+
+Pull request merge requirements:
+- all CI test should pass,
+- at least two "accepts"/ACKs from the repository maintainers (see "refactor carve-out").
+- no reasonable "rejects"/NACKs from anybody who reviewed the code.
+
+Current list of the project maintainers:
+
+- [Andrew Poelstra](https://github.com/apoelstra)
+- [Steven Roose](https://github.com/stevenroose)
+- [Matt Corallo](https://github.com/TheBlueMatt)
+- [Elichai Turkel](https://github.com/elichai)
+- [Sanket Kanjalkar](https://github.com/sanket1729)
+- [Martin Habovštiak](https://github.com/Kixunil)
+- [Riccardo Casatta](https://github.com/RCasatta)
+- [Tobin Harding](https://github.com/tcharding)
+
+#### Refactor carve-out
+
+The repository is going through heavy refactoring and "trivial" API redesign
+(eg, rename `Foo::empty` to `Foo::new`) as we push towards API stabilization. As
+such reviewers are either bored or overloaded with notifications, hence we have
+created a carve out to the 2-ACK rule.
+
+A PR may be considered for merge if it has a single ACK and has sat open for at
+least two weeks with no comments, questions, or NACKs.
+
+#### One ACK carve-out
+
+We reserve the right to merge PRs with a single ACK [0], at any time, if they match
+any of the following conditions:
+
+1. PR only touches CI i.e, only changes any of the `test.sh` scripts and/or
+   stuff in `.github/workflows`.
+2. Non-content changing documentation fixes i.e., grammar/typos, spelling, full
+   stops, capital letters. Any change with more substance must still get two
+   ACKs.
+3. Code moves that do not change the API e.g., moving error types to a private
+   submodule and re-exporting them from the original module. Must not include
+   any code changes except to import paths. This rule is more restrictive than
+   the refactor carve-out. It requires absolutely no change to the public API.
+
+[0] - Obviously author and ACK'er must not be the same person.
+
+## Coding conventions
+
+Library reflects Bitcoin Core approach whenever possible.
+
+### Naming conventions
+
+Naming of data structures/enums and their fields/variants must follow names used
+in Bitcoin Core, with the following exceptions:
+- the case should follow Rust standards (i.e. PascalCase for types and
+  snake_case for fields and variants);
+- omit `C`-prefixes.
+
+### Upgrading dependencies
+
+If your change requires a dependency to be upgraded you must do the following:
+
+1. Modify `Cargo.toml`
+2. Copy `Cargo-minimal.lock` to `Cargo.lock`
+3. Trigger cargo to update the required entries in the lock file - use `--precise` using the minimum version number that works
+4. Test your change
+5. Copy `Cargo.lock` to `Cargo-minimal.lock`
+6. Update `Cargo-recent.lock` if it is also behind
+7. Commit both lock files together with `Cargo.toml` and your code changes
+
+### Unsafe code
+
+Use of `unsafe` code is prohibited unless there is a unanimous decision among
+library maintainers on the exclusion from this rule. In such cases there is a
+requirement to test unsafe code with sanitizers including Miri.
+
+
+## Security
+
+Security is the primary focus for this library; disclosure of security
+vulnerabilities helps prevent user loss of funds. If you believe a vulnerability
+may affect other implementations, please disclose this information according to
+the [security guidelines](./SECURITY.md), work on which is currently in progress.
+Before it is completed, feel free to send disclosure to Andrew Poelstra,
+apoelstra@wpsoftware.net, encrypted with his public key from
+<https://www.wpsoftware.net/andrew/andrew.gpg>.
+
+
+## Testing
+
+Related to the security aspect, rust bitcoin developers take testing very
+seriously. Due to the modular nature of the project, writing new test cases is
+easy and good test coverage of the codebase is an important goal. Refactoring
+the project to enable fine-grained unit testing is also an ongoing effort.
+
+Various methods of testing are in use (e.g. fuzzing, mutation), please see
+the [readme](./REAME.md) for more information.
+
+
+## Going further
+
+You may be interested in the guide by Jon Atack on
+[How to review Bitcoin Core PRs](https://github.com/jonatack/bitcoin-development/blob/master/how-to-review-bitcoin-core-prs.md)
+and [How to make Bitcoin Core PRs](https://github.com/jonatack/bitcoin-development/blob/master/how-to-make-bitcoin-core-prs.md).
+While there are differences between the projects in terms of context and
+maturity, many of the suggestions offered apply to this project.
+
+Overall, have fun :)
diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
new file mode 100644
index 00000000..319a62df
--- /dev/null
+++ b/Cargo-minimal.lock
@@ -0,0 +1,510 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08f9b8508dccb7687a1d6c4ce66b2b0ecef467c94667de27d8d7fe1f8d2a9cdc"
+
+[[package]]
+name = "autocfg"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+
+[[package]]
+name = "base64"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "414dcefbc63d77c526a76b3afcf6fbb9b5e2791c19c3aa2297733208750c6e53"
+
+[[package]]
+name = "bech32"
+version = "0.10.0-beta"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98f7eed2b2781a6f0b5c903471d48e15f56fb4e1165df8a9a2337fd1a59d45ea"
+
+[[package]]
+name = "bincode"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f30d3a39baa26f9651f17b375061f3233dde33424a8b72b0dbe93a68a0bc896d"
+dependencies = [
+ "byteorder",
+ "serde",
+]
+
+[[package]]
+name = "bitcoin-internals"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9425c3bf7089c983facbae04de54513cce73b41c7f9ff8c845b54e7bc64ebbfb"
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1930a4dabfebb8d7d9992db18ebe3ae2876f0a305fab206fd168df931ede293b"
+dependencies = [
+ "bitcoin-internals",
+ "hex-conservative",
+]
+
+[[package]]
+name = "bitcoinconsensus"
+version = "0.20.2-0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54505558b77e0aa21b2491a7b39cbae9db22ac8b1bc543ef4600edb762306f9c"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60f0b0d4c0a382d2734228fd12b5a6b5dac185c60e938026fd31b265b94f9bd2"
+
+[[package]]
+name = "cc"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb4a8b715cb4597106ea87c7c84b2f1d452c7492033765df7f32651e66fcf749"
+
+[[package]]
+name = "cfg-if"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4c819a1287eb618df47cc647173c5c4c66ba19d888a6e50d605672aed3140de"
+
+[[package]]
+name = "core2"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cf12d2dad3ed124aa116f59561428478993d69ab81ae4d30e5349c9c5b5a5f6"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0da518043f6481364cd454be81dfe096cfd3f82daa1466f4946d24ea325b0941"
+
+[[package]]
+name = "getrandom"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee8025cf36f917e6a52cce185b7c7177689b838b7ec138364e50cc2277a56cf4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "half"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62aca2aba2d62b4a7f5b33f3712cb1b0692779a56fb510499d5c0aa594daeaf3"
+
+[[package]]
+name = "hex-conservative"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30ed443af458ccb6d81c1e7e661545f94d3176752fb1df2f543b902a1e0f51e2"
+dependencies = [
+ "core2",
+]
+
+[[package]]
+name = "hex_lit"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd"
+
+[[package]]
+name = "honggfuzz"
+version = "0.5.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "848e9c511092e0daa0a35a63e8e6e475a3e8f870741448b9f6028d69b142f18e"
+dependencies = [
+ "lazy_static",
+ "memmap2",
+ "rustc_version",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"
+
+[[package]]
+name = "json"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "078e285eafdfb6c4b434e0d31e8cfcb5115b651496faca5749b88fafd4f23bfd"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74dfca3d9957906e8d1e6a0b641dc9a59848e793f1da2165889fd4f62d10d79c"
+
+[[package]]
+name = "memchr"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01e64d9017d18e7fc09d8e4fe0e28ff6931019e979fb8019319db7ca827f8a6"
+
+[[package]]
+name = "memmap2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "mutagen"
+version = "0.2.0"
+source = "git+https://github.com/llogiq/mutagen#a6377c4c3f360afeb7a287c1c17e4b69456d5f53"
+dependencies = [
+ "mutagen-core",
+ "mutagen-transform",
+]
+
+[[package]]
+name = "mutagen-core"
+version = "0.2.0"
+source = "git+https://github.com/llogiq/mutagen#a6377c4c3f360afeb7a287c1c17e4b69456d5f53"
+dependencies = [
+ "anyhow",
+ "json",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "syn",
+]
+
+[[package]]
+name = "mutagen-transform"
+version = "0.2.0"
+source = "git+https://github.com/llogiq/mutagen#a6377c4c3f360afeb7a287c1c17e4b69456d5f53"
+dependencies = [
+ "mutagen-core",
+ "proc-macro2",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+ "rand",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a76330fb486679b4ace3670f117bbc9e16204005c4bde9c4bd372f45bed34f12"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e12735cf05c9e10bf21534da50a147b924d555dc7a547c42e6bb2d5b6017ae0d"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34cf66eb183df1c5876e2dcf6b13d57340741e8dc255b48e40a26de954d06ae7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3190ef7066a446f2e7f42e239d161e905420ccab01eb967c9eb27d21b2322a73"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c92464b447c0ee8c4fb3824ecc8383b81717b9f1e74ba2e72540aef7b9f82997"
+
+[[package]]
+name = "schemars"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc6ab463ae35acccb5cba66c0084c985257b797d288b6050cc2f6ac1b266cb78"
+dependencies = [
+ "dyn-clone",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "902fdfbcf871ae8f653bddf4b2c05905ddaabc08f69d32a915787e3be0d31356"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn",
+]
+
+[[package]]
+name = "secp256k1"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acea373acb8c21ecb5a23741452acd2593ed44ee3d343e72baaa143bc89d0d5"
+dependencies = [
+ "bitcoin_hashes",
+ "rand",
+ "secp256k1-sys",
+ "serde",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09e67c467c38fd24bd5499dc9a18183b31575c12ee549197e3e20d57aa4fe3b7"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
+
+[[package]]
+name = "serde"
+version = "1.0.156"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_cbor"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45cd6d95391b16cd57e88b68be41d504183b7faae22030c0cc3b3f73dd57b2fd"
+dependencies = [
+ "byteorder",
+ "half",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.156"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7e29c4601e36bcec74a223228dce795f4cd3616341a4af93520ca1a837c087d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1dbab34ca63057a1f15280bdf3c39f2b1eb1b54c17e98360e511637aef7418c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.68"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f690853975602e1bfe1ccbf50504d67174e3bcf340f23b5ea9992e0587a52d8"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_test"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "482765e11e55174e2d74a611674d09ed96712c00e0777e305a0c416dfef5fa40"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tapyrus"
+version = "0.5.0"
+dependencies = [
+ "base64",
+ "bech32",
+ "bincode",
+ "bitcoinconsensus",
+ "core2",
+ "hex-conservative",
+ "hex_lit",
+ "mutagen",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "secp256k1",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "serde_test",
+ "tapyrus-internals",
+ "tapyrus_hashes",
+]
+
+[[package]]
+name = "tapyrus-fuzz"
+version = "0.0.1"
+dependencies = [
+ "honggfuzz",
+ "serde",
+ "serde_cbor",
+ "serde_json",
+ "tapyrus",
+]
+
+[[package]]
+name = "tapyrus-internals"
+version = "0.2.0"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "tapyrus_hashes"
+version = "0.13.0"
+dependencies = [
+ "core2",
+ "hex-conservative",
+ "schemars",
+ "serde",
+ "serde_json",
+ "serde_test",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
+
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
new file mode 100644
index 00000000..5d38625b
--- /dev/null
+++ b/Cargo-recent.lock
@@ -0,0 +1,499 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+
+[[package]]
+name = "base64"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "414dcefbc63d77c526a76b3afcf6fbb9b5e2791c19c3aa2297733208750c6e53"
+
+[[package]]
+name = "bech32"
+version = "0.10.0-beta"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98f7eed2b2781a6f0b5c903471d48e15f56fb4e1165df8a9a2337fd1a59d45ea"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitcoin-internals"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9425c3bf7089c983facbae04de54513cce73b41c7f9ff8c845b54e7bc64ebbfb"
+
+[[package]]
+name = "bitcoin_hashes"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1930a4dabfebb8d7d9992db18ebe3ae2876f0a305fab206fd168df931ede293b"
+dependencies = [
+ "bitcoin-internals",
+ "hex-conservative",
+]
+
+[[package]]
+name = "bitcoinconsensus"
+version = "0.20.2-0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54505558b77e0aa21b2491a7b39cbae9db22ac8b1bc543ef4600edb762306f9c"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
+[[package]]
+name = "cc"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "core2"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "239fa3ae9b63c2dc74bd3fa852d4792b8b305ae64eeede946265b6af62f1fff3"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68b0cf012f1230e43cd00ebb729c6bb58707ecfa8ad08b52ef3a4ccd2697fc30"
+
+[[package]]
+name = "getrandom"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "half"
+version = "1.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62aca2aba2d62b4a7f5b33f3712cb1b0692779a56fb510499d5c0aa594daeaf3"
+
+[[package]]
+name = "hex-conservative"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30ed443af458ccb6d81c1e7e661545f94d3176752fb1df2f543b902a1e0f51e2"
+dependencies = [
+ "core2",
+]
+
+[[package]]
+name = "hex_lit"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3011d1213f159867b13cfd6ac92d2cd5f1345762c63be3554e84092d85a50bbd"
+
+[[package]]
+name = "honggfuzz"
+version = "0.5.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "848e9c511092e0daa0a35a63e8e6e475a3e8f870741448b9f6028d69b142f18e"
+dependencies = [
+ "lazy_static",
+ "memmap2",
+ "rustc_version",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "json"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "078e285eafdfb6c4b434e0d31e8cfcb5115b651496faca5749b88fafd4f23bfd"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.142"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "memmap2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "mutagen"
+version = "0.2.0"
+source = "git+https://github.com/llogiq/mutagen#a6377c4c3f360afeb7a287c1c17e4b69456d5f53"
+dependencies = [
+ "mutagen-core",
+ "mutagen-transform",
+]
+
+[[package]]
+name = "mutagen-core"
+version = "0.2.0"
+source = "git+https://github.com/llogiq/mutagen#a6377c4c3f360afeb7a287c1c17e4b69456d5f53"
+dependencies = [
+ "anyhow",
+ "json",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "syn",
+]
+
+[[package]]
+name = "mutagen-transform"
+version = "0.2.0"
+source = "git+https://github.com/llogiq/mutagen#a6377c4c3f360afeb7a287c1c17e4b69456d5f53"
+dependencies = [
+ "mutagen-core",
+ "proc-macro2",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+ "rand",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
+dependencies = [
+ "proc-macro2",
+]
+
+[[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",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "schemars"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02c613288622e5f0c3fdc5dbd4db1c5fbe752746b1d1a56a0630b78fd00de44f"
+dependencies = [
+ "dyn-clone",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "109da1e6b197438deb6db99952990c7f959572794b80ff93707d55a232545e7c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn",
+]
+
+[[package]]
+name = "secp256k1"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acea373acb8c21ecb5a23741452acd2593ed44ee3d343e72baaa143bc89d0d5"
+dependencies = [
+ "bitcoin_hashes",
+ "rand",
+ "secp256k1-sys",
+ "serde",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09e67c467c38fd24bd5499dc9a18183b31575c12ee549197e3e20d57aa4fe3b7"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
+
+[[package]]
+name = "serde"
+version = "1.0.156"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_cbor"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45cd6d95391b16cd57e88b68be41d504183b7faae22030c0cc3b3f73dd57b2fd"
+dependencies = [
+ "byteorder",
+ "half",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.156"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7e29c4601e36bcec74a223228dce795f4cd3616341a4af93520ca1a837c087d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.96"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "057d394a50403bcac12672b2b18fb387ab6d289d957dab67dd201875391e52f1"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_test"
+version = "1.0.160"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c95a500e3923258f7fc3a16bf29934e403aef5ca1096e184d85e3b1926675e8"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tapyrus"
+version = "0.5.0"
+dependencies = [
+ "base64",
+ "bech32",
+ "bincode",
+ "bitcoinconsensus",
+ "core2",
+ "hex-conservative",
+ "hex_lit",
+ "mutagen",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "secp256k1",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "serde_test",
+ "tapyrus-internals",
+ "tapyrus_hashes",
+]
+
+[[package]]
+name = "tapyrus-fuzz"
+version = "0.0.1"
+dependencies = [
+ "honggfuzz",
+ "serde",
+ "serde_cbor",
+ "serde_json",
+ "tapyrus",
+]
+
+[[package]]
+name = "tapyrus-internals"
+version = "0.2.0"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "tapyrus_hashes"
+version = "0.13.0"
+dependencies = [
+ "core2",
+ "hex-conservative",
+ "schemars",
+ "serde",
+ "serde_json",
+ "serde_test",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
diff --git a/Cargo.toml b/Cargo.toml
index 0409be7a..763f5be7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,37 +1,11 @@
-[package]
-name = "bitcoin"
-version = "0.23.0"
-authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
-license = "CC0-1.0"
-homepage = "https://github.com/rust-bitcoin/rust-bitcoin/"
-repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
-documentation = "https://docs.rs/bitcoin/"
-description = "General purpose library for using and interoperating with Bitcoin and other cryptocurrencies."
-keywords = [ "crypto", "bitcoin" ]
-readme = "README.md"
+[workspace]
+members = ["tapyrus", "hashes", "internals", "fuzz"]
 
-[lib]
-name = "bitcoin"
-path = "src/lib.rs"
+[patch.crates-io.tapyrus]
+path = "tapyrus"
 
-[features]
-fuzztarget = ["secp256k1/fuzztarget", "bitcoin_hashes/fuzztarget"]
-unstable = []
-rand = ["secp256k1/rand"]
-use-serde = ["hex", "serde", "bitcoin_hashes/serde", "secp256k1/serde"]
+[patch.crates-io.tapyrus_hashes]
+path = "hashes"
 
-[dependencies]
-bech32 = "0.7.2"
-bitcoin_hashes = "0.7.3"
-secp256k1 = "0.17.1"
-
-bitcoinconsensus = { version = "0.19.0-1", optional = true }
-serde = { version = "1", optional = true }
-hex = { version = "=0.3.2", optional = true }
-
-[dev-dependencies]
-hex = "=0.3.2"
-serde_derive = "<1.0.99"
-serde_json = "1"
-serde_test = "1"
-secp256k1 = { version = "0.17.1", features = ["rand"] }
+[patch.crates-io.tapyrus-internals]
+path = "internals"
diff --git a/README.md b/README.md
index d0b4d8eb..29cfd8af 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,22 @@
-[![Status](https://travis-ci.org/rust-bitcoin/rust-bitcoin.png?branch=master)](https://travis-ci.org/rust-bitcoin/rust-bitcoin)
-[![Safety Dance](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
-
-# Rust Bitcoin Library
-
-Library with support for de/serialization, parsing and executing on data
-structures and network messages related to Bitcoin.
+<div align="center">
+  <h1>Rust Bitcoin</h1>
+
+  <img alt="Rust Bitcoin logo by Hunter Trujillo, see license and source files under /logo" src="./logo/rust-bitcoin.png" width="300" />
+
+  <p>Library with support for de/serialization, parsing and executing on data-structures
+    and network messages related to Bitcoin.
+  </p>
+
+  <p>
+    <a href="https://crates.io/crates/bitcoin"><img alt="Crate Info" src="https://img.shields.io/crates/v/bitcoin.svg"/></a>
+    <a href="https://github.com/rust-bitcoin/rust-bitcoin/blob/master/LICENSE"><img alt="CC0 1.0 Universal Licensed" src="https://img.shields.io/badge/license-CC0--1.0-blue.svg"/></a>
+    <a href="https://github.com/rust-bitcoin/rust-bitcoin/actions?query=workflow%3AContinuous%20integration"><img alt="CI Status" src="https://github.com/rust-bitcoin/rust-bitcoin/workflows/Continuous%20integration/badge.svg"></a>
+    <a href="https://docs.rs/bitcoin"><img alt="API Docs" src="https://img.shields.io/badge/docs.rs-bitcoin-green"/></a>
+    <a href="https://blog.rust-lang.org/2020/02/27/Rust-1.56.1.html"><img alt="Rustc Version 1.56.1+" src="https://img.shields.io/badge/rustc-1.56.1%2B-lightgrey.svg"/></a>
+    <a href="https://gnusha.org/bitcoin-rust/"><img alt="Chat on IRC" src="https://img.shields.io/badge/irc-%23bitcoin--rust%20on%20libera.chat-blue"></a>
+    <a href="https://github.com/model-checking/kani"><imp alt="kani" src="https://github.com/rust-bitcoin/rust-bitcoin/actions/workflows/kani.yaml/badge.svg"></a>
+  </p>
+</div>
 
 [Documentation](https://docs.rs/bitcoin/)
 
@@ -14,54 +26,84 @@ Supports (or should support)
 * De/serialization of blocks and transactions
 * Script de/serialization
 * Private keys and address creation, de/serialization and validation (including full BIP32 support)
-* PSBT creation, manipulation, merging and finalization
-* Pay-to-contract support as in Appendix A of the [Blockstream sidechains whitepaper](https://www.blockstream.com/sidechains.pdf)
+* PSBT v0 de/serialization and all but the Input Finalizer role. Use [rust-miniscript](https://docs.rs/miniscript/latest/miniscript/psbt/index.html) to finalize.
 
 For JSONRPC interaction with Bitcoin Core, it is recommended to use
 [rust-bitcoincore-rpc](https://github.com/rust-bitcoin/rust-bitcoincore-rpc).
 
-# Known limitations
+It is recommended to always use [cargo-crev](https://github.com/crev-dev/cargo-crev) to verify the
+trustworthiness of each of your dependencies, including this one.
+
+## Known limitations
 
-## Consensus
+### Consensus
 
-This library **must not** be used for consensus code (i.e. fully validating
-blockchain data). It technically supports doing this, but doing so is very
-ill-advised because there are many deviations, known and unknown, between
-this library and the Bitcoin Core reference implementation. In a consensus
-based cryptocurrency such as Bitcoin it is critical that all parties are
-using the same rules to validate data, and this library is simply unable
-to implement the same rules as Core.
+This library **must not** be used for consensus code (i.e. fully validating blockchain data). It
+technically supports doing this, but doing so is very ill-advised because there are many deviations,
+known and unknown, between this library and the Bitcoin Core reference implementation. In a
+consensus based cryptocurrency such as Bitcoin it is critical that all parties are using the same
+rules to validate data, and this library is simply unable to implement the same rules as Core.
 
-Given the complexity of both C++ and Rust, it is unlikely that this will
-ever be fixed, and there are no plans to do so. Of course, patches to
-fix specific consensus incompatibilities are welcome.
+Given the complexity of both C++ and Rust, it is unlikely that this will ever be fixed, and there
+are no plans to do so. Of course, patches to fix specific consensus incompatibilities are welcome.
+
+### Support for 16-bit pointer sizes
+
+16-bit pointer sizes are not supported and we can't promise they will be. If you care about them
+please let us know, so we can know how large the interest is and possibly decide to support them.
 
 ## Documentation
 
-Currently can be found on [docs.rs/bitcoin](https://docs.rs/bitcoin/).
-Patches to add usage examples and to expand on existing docs would be extremely
-appreciated.
+Currently can be found on [docs.rs/bitcoin](https://docs.rs/bitcoin/). Patches to add usage examples
+and to expand on existing docs would be extremely appreciated.
+
+## Contributing
 
-# Contributing
-Contributions are generally welcome. If you intend to make larger changes please
-discuss them in an issue before PRing them to avoid duplicate work and
-architectural mismatches. If you have any questions or ideas you want to discuss
-please join us in
-[#rust-bitcoin](http://webchat.freenode.net/?channels=%23rust-bitcoin) on
-freenode.
+Contributions are generally welcome. If you intend to make larger changes please discuss them in an
+issue before PRing them to avoid duplicate work and architectural mismatches. If you have any
+questions or ideas you want to discuss please join us in
+[#bitcoin-rust](https://web.libera.chat/?channel=#bitcoin-rust) on
+[libera.chat](https://libera.chat).
+
+For more information please see `./CONTRIBUTING.md`.
 
 ## Minimum Supported Rust Version (MSRV)
-This library should always compile with any combination of features on **Rust 1.22**.
+
+This library should always compile with any combination of features on **Rust 1.56.1**.
+
+To build with the MSRV you will likely need to pin a bunch of dependencies, see `./contrib/test.sh`
+for the current list.
+
+## External dependencies
+
+We integrate with a few external libraries, most notably `serde`. These
+are available via feature flags. To ensure compatibility and MSRV stability we
+provide two lock files as a means of inspecting compatible versions:
+`Cargo-minimal.lock` containing minimal versions of dependencies and
+`Cargo-recent.lock` containing recent versions of dependencies tested in our CI.
+
+We do not provide any guarantees about the content of these lock files outside
+of "our CI didn't fail with these versions". Specifically, we do not guarantee
+that the committed hashes are free from malware. It is your responsibility to
+review them.
 
 ## Installing Rust
-Rust can be installed using your package manager of choice or
-[rustup.rs](https://rustup.rs). The former way is considered more secure since
-it typically doesn't involve trust in the CA system. But you should be aware
-that the version of Rust shipped by your distribution might be out of date.
-Generally this isn't a problem for `rust-bitcoin` since we support much older
-versions (>=1.22) than the current stable one.
+
+Rust can be installed using your package manager of choice or [rustup.rs](https://rustup.rs). The
+former way is considered more secure since it typically doesn't involve trust in the CA system. But
+you should be aware that the version of Rust shipped by your distribution might be out of date.
+Generally this isn't a problem for `rust-bitcoin` since we support much older versions than the
+current stable one (see MSRV section).
 
 ## Building
+
+The cargo feature `std` is enabled by default. At least one of the features `std` or `no-std` or
+both must be enabled.
+
+Enabling the `no-std` feature does not disable `std`. To disable the `std` feature you must disable
+default features. The `no-std` feature only enables additional features required for this crate to
+be usable without `std`. Both can be enabled without conflict.
+
 The library can be built and tested using [`cargo`](https://github.com/rust-lang/cargo/):
 
 ```
@@ -76,35 +118,103 @@ You can run tests with:
 cargo test
 ```
 
-Please refer to the [`cargo` documentation](https://doc.rust-lang.org/stable/cargo/) for more detailed instructions. 
+Please refer to the [`cargo` documentation](https://doc.rust-lang.org/stable/cargo/) for more
+detailed instructions.
+
+### Just
+
+We support [`just`](https://just.systems/man/en/) for running dev workflow commands. Run `just` from
+your shell to see list available sub-commands.
+
+### Building the docs
+
+We build docs with the nightly toolchain, you may wish to use the following shell alias to check
+your documentation changes build correctly.
+
+```
+alias build-docs='RUSTDOCFLAGS="--cfg docsrs" cargo +nightly rustdoc --features="$FEATURES" -- -D rustdoc::broken-intra-doc-links'
+```
+
+## Testing
+
+Unit and integration tests are available for those interested, along with benchmarks. For project
+developers, especially new contributors looking for something to work on, we do:
+
+- Fuzz testing with [`Hongfuzz`](https://github.com/rust-fuzz/honggfuzz-rs)
+- Mutation testing with [`Mutagen`](https://github.com/llogiq/mutagen)
+- Code verification with [`Kani`](https://github.com/model-checking/kani)
+
+There are always more tests to write and more bugs to find, contributions to our testing efforts
+extremely welcomed. Please consider testing code a first class citizen, we definitely do take PRs
+improving and cleaning up test code.
+
+### Unit/Integration tests
+
+Run as for any other Rust project `cargo test --all-features`.
+
+### Benchmarks
+
+We use a custom Rust compiler configuration conditional to guard the bench mark code. To run the
+bench marks use: `RUSTFLAGS='--cfg=bench' cargo +nightly bench`.
+
+### Mutation tests
+
+We have started doing mutation testing with [mutagen](https://github.com/llogiq/mutagen). To run
+these tests first install the latest dev version with `cargo +nightly install --git https://github.com/llogiq/mutagen`
+then run with `RUSTFLAGS='--cfg=mutate' cargo +nightly mutagen`.
+
+### Code verification
+
+We have started using [kani](https://github.com/model-checking/kani), install with `cargo install --locked kani-verifier`
+ (no need to run `cargo kani setup`). Run the tests with `cargo kani`.
 
 ## Pull Requests
-Every PR needs at least two reviews to get merged. During the review phase
-maintainers and contributors are likely to leave comments and request changes.
-Please try to address them, otherwise your PR might get closed without merging
-after a longer time of inactivity. If your PR isn't ready for review yet please
-mark it by prefixing the title with `WIP: `.
+
+Every PR needs at least two reviews to get merged. During the review phase maintainers and
+contributors are likely to leave comments and request changes. Please try to address them, otherwise
+your PR might get closed without merging after a longer time of inactivity. If your PR isn't ready
+for review yet please mark it by prefixing the title with `WIP: `.
+
+### CI Pipeline
+
+The CI pipeline requires approval before being run on each MR.
+
+In order to speed up the review process the CI pipeline can be run locally using
+[act](https://github.com/nektos/act). The `fuzz` and `Cross` jobs will be skipped when using `act`
+due to caching being unsupported at this time. We do not *actively* support `act` but will merge PRs
+fixing `act` issues.
+
+### Githooks
+
+To assist devs in catching errors _before_ running CI we provide some githooks. If you do not
+already have locally configured githooks you can use the ones in this repository by running, in the
+root directory of the repository:
+```
+git config --local core.hooksPath githooks/
+```
+
+Alternatively add symlinks in your `.git/hooks` directory to any of the githooks we provide.
 
 ## Policy on Altcoins/Altchains
 
-Patches which add support for non-Bitcoin cryptocurrencies by adding constants
-to existing enums (e.g. to set the network message magic-byte sequence) are
-welcome. Anything more involved will be considered on a case-by-case basis,
-as the altcoin landscape includes projects which [frequently appear and
-disappear, and are poorly designed anyway](https://download.wpsoftware.net/bitcoin/alts.pdf)
-and keeping the codebase maintainable is a large priority.
+Since the altcoin landscape includes projects which [frequently appear and disappear, and are poorly
+designed anyway](https://download.wpsoftware.net/bitcoin/alts.pdf) we do not support any altcoins.
+Supporting Bitcoin properly is already difficult enough and we do not want to increase the
+maintenance burden and decrease API stability by adding support for other coins.
+
+Our code is public domain so by all means fork it and go wild :)
 
-In general, things that improve cross-chain compatibility (e.g. support for
-cross-chain atomic swaps) are more likely to be accepted than things which
-support only a single blockchain.
 
+## Release Notes
 
-# Release Notes
+Release notes are done per crate, see:
 
-See CHANGELOG.md
+- [bitcoin CHANGELOG](tapyrus/CHANGELOG.md)
+- [hashes CHANGELOG](hashes/CHANGELOG.md)
+- [internals CHANGELOG](internals/CHANGELOG.md)
 
 
-# Licensing
+## Licensing
 
-The code in this project is licensed under the Creative Commons CC0 1.0
-Universal license.
+The code in this project is licensed under the [Creative Commons CC0 1.0 Universal license](LICENSE).
+We use the [SPDX license list](https://spdx.org/licenses/) and [SPDX IDs](https://spdx.dev/ids/).
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000..2e161330
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,540 @@
+# Security Policy
+
+This security policy applies to the "core" crates in the rust-bitcoin ecosystem, which are
+`bitcoin`, `secp256k1`, `bitcoin_hashes` and `bitcoin-internals`. These crates deal with
+cryptography and cryptographic algorithms, and as such, are likely locations for security
+vulnerabilities to crop up.
+
+As a general rule, an issue is a security vulnerability if it could lead to:
+
+* Loss of funds
+* Loss of privacy
+* Censorship (including e.g. by attaching an incorrectly low fee to a transaction)
+* Any "ordinary" security problem, such as remote code execution or invalid memory acccess
+
+In general, use your best judgement in determining whether an issue is a security issue. If not,
+go ahead and post it to the public issue tracker.
+
+**If you believe you are aware of a security issue**, please contact Andrew Poelstra at
+`rust-bitcoin-security@wpsoftware.net`. You may GPG-encrypt this email to his public key, which
+[can be downloaded from his website here](https://wpsoftware.net/andrew/andrew.gpg) or which is
+listed in full below.
+
+# Andrew Poelstra's GPG Key
+
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=WxeH
+-----END PGP PUBLIC KEY BLOCK-----
+
diff --git a/clippy.toml b/clippy.toml
new file mode 100644
index 00000000..173999bc
--- /dev/null
+++ b/clippy.toml
@@ -0,0 +1,2 @@
+msrv = "1.56.1"
+too-many-arguments-threshold = 13
diff --git a/contrib/release.sh b/contrib/release.sh
new file mode 100755
index 00000000..9df34c9a
--- /dev/null
+++ b/contrib/release.sh
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+#
+# Check that we can publish crates in their current form if there are changes on top of the tip of
+# master that imply that we are about to do a release.
+
+set -ex
+
+main () {
+    for crate in "internals" "hashes" "tapyrus"; do
+        if release_changes $crate; then
+            echo "$crate has changes implying this is a release PR, checking if we can publish ..."
+
+            # Check if there is any mention of NEXT_RELEASE which means the
+            # next version number should be filled in.
+            if grep -qr NEXT.RELEASE ./$crate; then
+                echo Version number needs to be filled in following places:
+                grep -r NEXT.RELEASE ./$crate
+                exit 1
+            fi
+
+            # Then try to dry-run cargo publish
+            publish_dry_run $crate
+        fi
+    done
+}
+
+# Returns 0 if crate ($1) contains changes since tip of master that imply this patch set is done in
+# preparation for releasing the crate.
+release_changes() {
+    local crate=$1
+    git log --patch --reverse master.. -- $crate/Cargo.toml | grep version
+}
+
+# Do a dry run publish to crates.io using the correct package name for crate ($1).
+# We use `set -e` so this will fail the script if the dry-run fails.
+publish_dry_run() {
+    local crate=$1
+    if [ "$crate" == "hashes" ]; then
+        cargo publish -p "tapyrus_hashes" --dry-run
+    elif [ "$crate" == "internals" ]; then
+        cargo publish -p "tapyrus-internals" --dry-run
+    elif [ "$crate" == "tapyrus" ]; then
+        cargo publish -p "tapyrus" --dry-run
+    fi
+}
+
+#
+# Main script.
+#
+main $@
diff --git a/contrib/test.sh b/contrib/test.sh
index de1cb3ec..a7b1f536 100755
--- a/contrib/test.sh
+++ b/contrib/test.sh
@@ -1,49 +1,31 @@
-#!/bin/sh -ex
+#!/bin/sh
 
-FEATURES="bitcoinconsensus use-serde rand"
+set -ex
 
-if [ "$DO_COV" = true ]
-then
-    export RUSTFLAGS="-C link-dead-code"
-fi
+CRATES="tapyrus hashes internals fuzz"
+DEPS="recent minimal"
 
-
-# Use toolchain if explicitly specified
-if [ -n "$TOOLCHAIN" ]
-then
-    alias cargo="cargo +$TOOLCHAIN"
-fi
-
-# Test without any features first
-cargo test --verbose
-
-# Test each feature
-for feature in ${FEATURES}
+for dep in $DEPS
 do
-    cargo test --verbose --features="$feature"
+    cp "Cargo-$dep.lock" Cargo.lock
+    for crate in ${CRATES}
+    do
+        (
+            cd "$crate"
+            ./contrib/test.sh
+        )
+    done
+    if [ "$dep" = recent ];
+    then
+        # We always test committed dependencies but we want to warn if they could've been updated
+        cargo update
+        if diff Cargo-recent.lock Cargo.lock;
+        then
+            echo Dependencies are up to date
+        else
+            echo "::warning file=Cargo-recent.lock::Dependencies could be updated"
+        fi
+    fi
 done
 
-# Fuzz if told to
-if [ "$DO_FUZZ" = true ]
-then
-    (
-        cd fuzz
-        cargo test --verbose
-        ./travis-fuzz.sh
-    )
-fi
-
-# Bench if told to
-if [ "$DO_BENCH" = true ]
-then
-    cargo bench --features unstable
-fi
-
-# Use as dependency if told to
-if [ -n "$AS_DEPENDENCY" ]
-then
-    cargo new dep_test
-    cd dep_test
-    echo 'bitcoin = { path = "..", features = ["use-serde"] }' >> Cargo.toml
-    cargo test --verbose
-fi
+exit 0
diff --git a/contrib/update-lock-files.sh b/contrib/update-lock-files.sh
new file mode 100755
index 00000000..02ba1f7c
--- /dev/null
+++ b/contrib/update-lock-files.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+#
+# Update the minimal/recent lock file
+
+set -euo pipefail
+
+for file in Cargo-minimal.lock Cargo-recent.lock; do
+    cp --force "$file" Cargo.lock
+    cargo check
+    cp --force Cargo.lock "$file"
+done
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 4b3941da..7a9b521f 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -1,53 +1,92 @@
 [package]
-name = "bitcoin-fuzz"
+name = "tapyrus-fuzz"
+edition = "2018"
 version = "0.0.1"
-authors = ["Automatically generated"]
+authors = ["Generated by fuzz/generate-files.sh"]
 publish = false
 
 [package.metadata]
 cargo-fuzz = true
 
-[features]
-afl_fuzz = ["afl"]
-honggfuzz_fuzz = ["honggfuzz"]
-
 [dependencies]
-honggfuzz = { version = "0.5", optional = true }
-afl = { version = "0.4", optional = true }
-bitcoin = { path = "..", features = ["fuzztarget"] }
+honggfuzz = { version = "0.5.55", default-features = false }
+tapyrus = { path = "../tapyrus", features = [ "serde" ] }
+
+serde = { version = "1.0.103", features = [ "derive" ] }
+serde_json = "1.0"
+serde_cbor = "0.9"
+
+[[bin]]
+name = "tapyrus_deserialize_address"
+path = "fuzz_targets/tapyrus/deserialize_address.rs"
+
+[[bin]]
+name = "tapyrus_deserialize_amount"
+path = "fuzz_targets/tapyrus/deserialize_amount.rs"
+
+[[bin]]
+name = "tapyrus_deserialize_block"
+path = "fuzz_targets/tapyrus/deserialize_block.rs"
+
+[[bin]]
+name = "tapyrus_deserialize_prefilled_transaction"
+path = "fuzz_targets/tapyrus/deserialize_prefilled_transaction.rs"
+
+[[bin]]
+name = "tapyrus_deserialize_psbt"
+path = "fuzz_targets/tapyrus/deserialize_psbt.rs"
+
+[[bin]]
+name = "tapyrus_deserialize_script"
+path = "fuzz_targets/tapyrus/deserialize_script.rs"
 
-# Prevent this from interfering with workspaces
-[workspace]
-members = ["."]
+[[bin]]
+name = "tapyrus_deserialize_transaction"
+path = "fuzz_targets/tapyrus/deserialize_transaction.rs"
+
+[[bin]]
+name = "tapyrus_deserialize_witness"
+path = "fuzz_targets/tapyrus/deserialize_witness.rs"
 
 [[bin]]
-name = "deserialize_block"
-path = "fuzz_targets/deserialize_block.rs"
+name = "tapyrus_deser_net_msg"
+path = "fuzz_targets/tapyrus/deser_net_msg.rs"
 
 [[bin]]
-name = "deserialize_script"
-path = "fuzz_targets/deserialize_script.rs"
+name = "tapyrus_outpoint_string"
+path = "fuzz_targets/tapyrus/outpoint_string.rs"
 
 [[bin]]
-name = "deserialize_transaction"
-path = "fuzz_targets/deserialize_transaction.rs"
+name = "tapyrus_script_bytes_to_asm_fmt"
+path = "fuzz_targets/tapyrus/script_bytes_to_asm_fmt.rs"
 
 [[bin]]
-name = "deserialize_address"
-path = "fuzz_targets/deserialize_address.rs"
+name = "hashes_cbor"
+path = "fuzz_targets/hashes/cbor.rs"
 
 [[bin]]
-name = "deserialize_amount"
-path = "fuzz_targets/deserialize_amount.rs"
+name = "hashes_json"
+path = "fuzz_targets/hashes/json.rs"
 
 [[bin]]
-name = "outpoint_string"
-path = "fuzz_targets/outpoint_string.rs"
+name = "hashes_ripemd160"
+path = "fuzz_targets/hashes/ripemd160.rs"
 
 [[bin]]
-name = "deserialize_psbt"
-path = "fuzz_targets/deserialize_psbt.rs"
+name = "hashes_sha1"
+path = "fuzz_targets/hashes/sha1.rs"
 
 [[bin]]
-name = "deser_net_msg"
-path = "fuzz_targets/deser_net_msg.rs"
+name = "hashes_sha256"
+path = "fuzz_targets/hashes/sha256.rs"
+
+[[bin]]
+name = "hashes_sha512_256"
+path = "fuzz_targets/hashes/sha512_256.rs"
+
+[[bin]]
+name = "hashes_sha512"
+path = "fuzz_targets/hashes/sha512.rs"
+
+[lints.rust]
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(fuzzing)'] }
\ No newline at end of file
diff --git a/fuzz/README.md b/fuzz/README.md
new file mode 100644
index 00000000..f53a22e4
--- /dev/null
+++ b/fuzz/README.md
@@ -0,0 +1,115 @@
+# Fuzzing
+
+`bitcoin` and `bitcoin_hashes` have fuzzing harnesses setup for use with
+honggfuzz.
+
+To run the fuzz-tests as in CI -- briefly fuzzing every target -- simply
+run
+
+    ./fuzz.sh
+
+in this directory.
+
+To build honggfuzz, you must have libunwind on your system, as well as
+libopcodes and libbfd from binutils **2.38** on your system. The most
+recently-released binutils 2.39 has changed their API in a breaking way.
+
+On Nix, you can obtain these libraries by running
+
+    nix-shell -p libopcodes_2_38 -p libunwind
+
+and then run fuzz.sh as above.
+
+# 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
+
+    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
+
+    source ./fuzz-util.sh
+    listTargetNames
+
+To run each of them for an hour, run
+
+    ./cycle.sh
+
+To run a single fuzztest indefinitely, run
+
+    HFUZZ_BUILD_ARGS='--features honggfuzz_fuzz' cargo hfuzz run <target>
+
+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.
+
+# 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
+
+    ./generate-files.sh
+
+Then to test your fuzztest, run
+
+    ./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). If not, you should quickly see
+an error.
+
+# Reproducing Failures
+
+If a fuzztest fails, it will exit with a summary which looks something like
+
+```
+...
+ fuzzTarget      : hfuzz_target/x86_64-unknown-linux-gnu/release/hashes_sha256 
+CRASH:
+DESCRIPTION: 
+ORIG_FNAME: 00000000000000000000000000000000.00000000.honggfuzz.cov
+FUZZ_FNAME: hfuzz_workspace/hashes_sha256/SIGABRT.PC.7ffff7c8abc7.STACK.18826d9b64.CODE.-6.ADDR.0.INSTR.mov____%eax,%ebp.fuzz
+...
+=====================================================================
+fff400610004
+```
+
+The final line is a hex-encoded version of the input that caused the crash. You
+can test this directly by editing the `duplicate_crash` test to copy/paste the
+hex output into the call to `extend_vec_from_hex`. Then run the test with
+
+    cargo test
+
+Note that if you set your `RUSTFLAGS` while fuzzing (see above) you must make
+sure they are set the same way when running `cargo test`.
+
diff --git a/fuzz/contrib/test.sh b/fuzz/contrib/test.sh
new file mode 100755
index 00000000..fd34b23c
--- /dev/null
+++ b/fuzz/contrib/test.sh
@@ -0,0 +1,44 @@
+#!/bin/sh
+
+set -ex
+
+FEATURES=""
+
+cargo --version
+rustc --version
+
+# Make all cargo invocations verbose
+export CARGO_TERM_VERBOSE=true
+
+# Pin dependencies as required if we are using MSRV toolchain.
+if cargo --version | grep "1\.41"; then
+    # 1.0.157 uses syn 2.0 which requires edition 2021
+    cargo update -p serde --precise 1.0.156
+    # 1.0.108 uses `matches!` macro so does not work with Rust 1.41.1, bad `syn` no biscuit.
+    cargo update -p syn --precise 1.0.107
+    # Half 1.8 uses edition 2021 features
+    cargo update -p half --precise 1.7.1
+fi
+
+if [ "$DO_LINT" = true ]
+then
+    cargo clippy --all-features --all-targets -- -D warnings
+fi
+
+# Defaults / sanity checks
+cargo build
+cargo test
+
+# Address Sanitizer
+if [ "$DO_ASAN" = true ]; then
+    cargo clean
+    CC='clang -fsanitize=address -fno-omit-frame-pointer'                                        \
+    RUSTFLAGS='-Zsanitizer=address -Clinker=clang -Cforce-frame-pointers=yes'                    \
+    ASAN_OPTIONS='detect_leaks=1 detect_invalid_pointer_pairs=1 detect_stack_use_after_return=1' \
+    cargo test --lib --no-default-features --features="$FEATURES" -Zbuild-std --target x86_64-unknown-linux-gnu
+    cargo clean
+    CC='clang -fsanitize=memory -fno-omit-frame-pointer'                                         \
+    RUSTFLAGS='-Zsanitizer=memory -Zsanitizer-memory-track-origins -Cforce-frame-pointers=yes'   \
+    cargo test --lib --no-default-features --features="$FEATURES" -Zbuild-std --target x86_64-unknown-linux-gnu
+fi
+
diff --git a/fuzz/cycle.sh b/fuzz/cycle.sh
new file mode 100755
index 00000000..0b59827a
--- /dev/null
+++ b/fuzz/cycle.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+# Continuosly cycle over fuzz targets running each for 1 hour.
+# It uses chrt SCHED_IDLE so that other process takes priority.
+#
+# For hfuzz options see https://github.com/google/honggfuzz/blob/master/docs/USAGE.md
+
+set -e
+REPO_DIR=$(git rev-parse --show-toplevel)
+# shellcheck source=./fuzz-util.sh
+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
+    HFUZZ_RUN_ARGS='--run_time 3600' chrt -i 0 cargo hfuzz run "$targetName"
+    # minimize the corpus
+    HFUZZ_RUN_ARGS="-i hfuzz_workspace/$targetName/input/ -P -M" chrt -i 0 cargo hfuzz run "$targetName"
+  done
+done
+
diff --git a/fuzz/fuzz-util.sh b/fuzz/fuzz-util.sh
new file mode 100755
index 00000000..759d41c4
--- /dev/null
+++ b/fuzz/fuzz-util.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+
+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'
+}
+
+targetFileToHFuzzInputArg() {
+  baseName=$(basename "$1")
+  dirName="${baseName%.*}"
+  if [ -d "hfuzz_input/$dirName" ]; then
+    echo "HFUZZ_INPUT_ARGS=\"-f hfuzz_input/$FILE/input\""
+  fi
+}
+
+listTargetNames() {
+  for target in $(listTargetFiles); do
+    targetFileToName "$target"
+  done
+}
+
+# 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 output some report, and dumps it in hex
+checkReport() {
+  reportFile="hfuzz_workspace/$1/HONGGFUZZ.REPORT.TXT"
+  if [ -f "$reportFile" ]; then
+    cat "$reportFile"
+    for CASE in "hfuzz_workspace/$1/SIG"*; do
+      xxd -p -c10000 < "$CASE"
+    done
+    exit 1
+  fi
+}
diff --git a/fuzz/fuzz.sh b/fuzz/fuzz.sh
new file mode 100755
index 00000000..5fc65ae6
--- /dev/null
+++ b/fuzz/fuzz.sh
@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -ex
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+
+# shellcheck source=./fuzz-util.sh
+source "$REPO_DIR/fuzz/fuzz-util.sh"
+
+# Check that input files are correct Windows file names
+checkWindowsFiles
+
+if [ "$1" == "" ]; then
+  targetFiles="$(listTargetFiles)"
+else
+  targetFiles=fuzz_targets/"$1".rs
+fi
+
+cargo --version
+rustc --version
+
+# Testing
+cargo install --force honggfuzz --no-default-features
+for targetFile in $targetFiles; do
+  targetName=$(targetFileToName "$targetFile")
+  echo "Fuzzing target $targetName ($targetFile)"
+  if [ -d "hfuzz_input/$targetName" ]; then
+    HFUZZ_INPUT_ARGS="-f hfuzz_input/$targetName/input\""
+  else
+    HFUZZ_INPUT_ARGS=""
+  fi
+  HFUZZ_RUN_ARGS="--run_time 30 --exit_upon_crash -v $HFUZZ_INPUT_ARGS" cargo hfuzz run "$targetName"
+
+  checkReport "$targetName"
+done
diff --git a/fuzz/fuzz_targets/deserialize_psbt.rs b/fuzz/fuzz_targets/deserialize_psbt.rs
deleted file mode 100644
index d19563b1..00000000
--- a/fuzz/fuzz_targets/deserialize_psbt.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-extern crate bitcoin;
-
-fn do_test(data: &[u8]) {
-    let psbt: Result<bitcoin::util::psbt::PartiallySignedTransaction, _> = bitcoin::consensus::encode::deserialize(data);
-    match psbt {
-        Err(_) => {},
-        Ok(psbt) => {
-            let ser = bitcoin::consensus::encode::serialize(&psbt);
-            let deser: bitcoin::util::psbt::PartiallySignedTransaction  = bitcoin::consensus::encode::deserialize(&ser).unwrap();
-            // Since the fuzz data could order psbt fields differently, we compare to our deser/ser instead of data
-            assert_eq!(ser, bitcoin::consensus::encode::serialize(&deser));
-        }
-    }
-}
-
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    fuzz!(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
-fn main() {
-    loop {
-        fuzz!(|data| {
-            do_test(data);
-        });
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
-        let mut b = 0;
-        for (idx, c) in hex.as_bytes().iter().enumerate() {
-            b <<= 4;
-            match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
-                _ => panic!("Bad hex"),
-            }
-            if (idx & 1) == 1 {
-                out.push(b);
-                b = 0;
-            }
-        }
-    }
-
-    #[test]
-    fn duplicate_crash() {
-        let mut a = Vec::new();
-        extend_vec_from_hex("00", &mut a);
-        super::do_test(&a);
-    }
-}
diff --git a/fuzz/fuzz_targets/deserialize_transaction.rs b/fuzz/fuzz_targets/deserialize_transaction.rs
deleted file mode 100644
index b0cd7ab5..00000000
--- a/fuzz/fuzz_targets/deserialize_transaction.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-extern crate bitcoin;
-
-fn do_test(data: &[u8]) {
-    let tx_result: Result<bitcoin::blockdata::transaction::Transaction, _> = bitcoin::consensus::encode::deserialize(data);
-    match tx_result {
-        Err(_) => {},
-        Ok(mut tx) => {
-            let ser = bitcoin::consensus::encode::serialize(&tx);
-            assert_eq!(&ser[..], data);
-            let len = ser.len();
-            let calculated_weight = tx.get_weight();
-            for input in &mut tx.input {
-                input.witness = vec![];
-            }
-            let no_witness_len = bitcoin::consensus::encode::serialize(&tx).len();
-            // For 0-input transactions, `no_witness_len` will be incorrect because
-            // we serialize as segwit even after "stripping the witnesses". We need
-            // to drop two bytes (i.e. eight weight)
-            if tx.input.is_empty() {
-                assert_eq!(no_witness_len * 3 + len - 8, calculated_weight);
-            } else {
-                assert_eq!(no_witness_len * 3 + len, calculated_weight);
-            }
-        },
-    }
-}
-
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    fuzz!(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
-fn main() {
-    loop {
-        fuzz!(|data| {
-            do_test(data);
-        });
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
-        let mut b = 0;
-        for (idx, c) in hex.as_bytes().iter().enumerate() {
-            b <<= 4;
-            match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
-                _ => panic!("Bad hex"),
-            }
-            if (idx & 1) == 1 {
-                out.push(b);
-                b = 0;
-            }
-        }
-    }
-
-    #[test]
-    fn duplicate_crash() {
-        let mut a = Vec::new();
-        extend_vec_from_hex("000700000001000000010000", &mut a);
-        super::do_test(&a);
-    }
-}
diff --git a/fuzz/fuzz_targets/hashes/cbor.rs b/fuzz/fuzz_targets/hashes/cbor.rs
new file mode 100644
index 00000000..e680f96c
--- /dev/null
+++ b/fuzz/fuzz_targets/hashes/cbor.rs
@@ -0,0 +1,56 @@
+use honggfuzz::fuzz;
+use serde::{Deserialize, Serialize};
+use tapyrus::hashes::{ripemd160, sha1, sha256d, sha512, Hmac};
+
+#[derive(Deserialize, Serialize)]
+struct Hmacs {
+    sha1: Hmac<sha1::Hash>,
+    sha512: Hmac<sha512::Hash>,
+}
+
+#[derive(Deserialize, Serialize)]
+struct Main {
+    hmacs: Hmacs,
+    ripemd: ripemd160::Hash,
+    sha2d: sha256d::Hash,
+}
+
+fn do_test(data: &[u8]) {
+    if let Ok(m) = serde_cbor::from_slice::<Main>(data) {
+        let vec = serde_cbor::to_vec(&m).unwrap();
+        assert_eq!(data, &vec[..]);
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|d| { do_test(d) });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/hashes/json.rs b/fuzz/fuzz_targets/hashes/json.rs
new file mode 100644
index 00000000..9a153e06
--- /dev/null
+++ b/fuzz/fuzz_targets/hashes/json.rs
@@ -0,0 +1,56 @@
+use honggfuzz::fuzz;
+use serde::{Deserialize, Serialize};
+use tapyrus::hashes::{ripemd160, sha1, sha256d, sha512, Hmac};
+
+#[derive(Deserialize, Serialize)]
+struct Hmacs {
+    sha1: Hmac<sha1::Hash>,
+    sha512: Hmac<sha512::Hash>,
+}
+
+#[derive(Deserialize, Serialize)]
+struct Main {
+    hmacs: Hmacs,
+    ripemd: ripemd160::Hash,
+    sha2d: sha256d::Hash,
+}
+
+fn do_test(data: &[u8]) {
+    if let Ok(m) = serde_json::from_slice::<Main>(data) {
+        let vec = serde_json::to_vec(&m).unwrap();
+        assert_eq!(data, &vec[..]);
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|d| { do_test(d) });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/hashes/ripemd160.rs b/fuzz/fuzz_targets/hashes/ripemd160.rs
new file mode 100644
index 00000000..2fb5a193
--- /dev/null
+++ b/fuzz/fuzz_targets/hashes/ripemd160.rs
@@ -0,0 +1,44 @@
+use honggfuzz::fuzz;
+use tapyrus::hashes::{ripemd160, Hash, HashEngine};
+
+fn do_test(data: &[u8]) {
+    let mut engine = ripemd160::Hash::engine();
+    engine.input(data);
+    let eng_hash = ripemd160::Hash::from_engine(engine);
+
+    let hash = ripemd160::Hash::hash(data);
+    assert_eq!(&hash[..], &eng_hash[..]);
+}
+
+fn main() {
+    loop {
+        fuzz!(|d| { do_test(d) });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/hashes/sha1.rs b/fuzz/fuzz_targets/hashes/sha1.rs
new file mode 100644
index 00000000..6db171e0
--- /dev/null
+++ b/fuzz/fuzz_targets/hashes/sha1.rs
@@ -0,0 +1,44 @@
+use honggfuzz::fuzz;
+use tapyrus::hashes::{sha1, Hash, HashEngine};
+
+fn do_test(data: &[u8]) {
+    let mut engine = sha1::Hash::engine();
+    engine.input(data);
+    let eng_hash = sha1::Hash::from_engine(engine);
+
+    let hash = sha1::Hash::hash(data);
+    assert_eq!(&hash[..], &eng_hash[..]);
+}
+
+fn main() {
+    loop {
+        fuzz!(|d| { do_test(d) });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/hashes/sha256.rs b/fuzz/fuzz_targets/hashes/sha256.rs
new file mode 100644
index 00000000..eb3002a6
--- /dev/null
+++ b/fuzz/fuzz_targets/hashes/sha256.rs
@@ -0,0 +1,44 @@
+use honggfuzz::fuzz;
+use tapyrus::hashes::{sha256, Hash, HashEngine};
+
+fn do_test(data: &[u8]) {
+    let mut engine = sha256::Hash::engine();
+    engine.input(data);
+    let eng_hash = sha256::Hash::from_engine(engine);
+
+    let hash = sha256::Hash::hash(data);
+    assert_eq!(&hash[..], &eng_hash[..]);
+}
+
+fn main() {
+    loop {
+        fuzz!(|d| { do_test(d) });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("fff400610004", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/hashes/sha512.rs b/fuzz/fuzz_targets/hashes/sha512.rs
new file mode 100644
index 00000000..6da43cbe
--- /dev/null
+++ b/fuzz/fuzz_targets/hashes/sha512.rs
@@ -0,0 +1,44 @@
+use honggfuzz::fuzz;
+use tapyrus::hashes::{sha512, Hash, HashEngine};
+
+fn do_test(data: &[u8]) {
+    let mut engine = sha512::Hash::engine();
+    engine.input(data);
+    let eng_hash = sha512::Hash::from_engine(engine);
+
+    let hash = sha512::Hash::hash(data);
+    assert_eq!(&hash[..], &eng_hash[..]);
+}
+
+fn main() {
+    loop {
+        fuzz!(|d| { do_test(d) });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/hashes/sha512_256.rs b/fuzz/fuzz_targets/hashes/sha512_256.rs
new file mode 100644
index 00000000..3344da96
--- /dev/null
+++ b/fuzz/fuzz_targets/hashes/sha512_256.rs
@@ -0,0 +1,44 @@
+use honggfuzz::fuzz;
+use tapyrus::hashes::{sha512_256, Hash, HashEngine};
+
+fn do_test(data: &[u8]) {
+    let mut engine = sha512_256::Hash::engine();
+    engine.input(data);
+    let eng_hash = sha512_256::Hash::from_engine(engine);
+
+    let hash = sha512_256::Hash::hash(data);
+    assert_eq!(&hash[..], &eng_hash[..]);
+}
+
+fn main() {
+    loop {
+        fuzz!(|d| { do_test(d) });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/deserialize_block.rs b/fuzz/fuzz_targets/tapyrus/deser_net_msg.rs
similarity index 54%
rename from fuzz/fuzz_targets/deserialize_block.rs
rename to fuzz/fuzz_targets/tapyrus/deser_net_msg.rs
index 3e2b7a1b..5f55167a 100644
--- a/fuzz/fuzz_targets/deserialize_block.rs
+++ b/fuzz/fuzz_targets/tapyrus/deser_net_msg.rs
@@ -1,21 +1,10 @@
-extern crate bitcoin;
+use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
-    let _: Result<bitcoin::blockdata::block::Block, _>= bitcoin::consensus::encode::deserialize(data);
+    let _: Result<tapyrus::p2p::message::RawNetworkMessage, _> =
+        tapyrus::consensus::encode::deserialize(data);
 }
 
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    fuzz!(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -24,16 +13,16 @@ fn main() {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, fuzzing))]
 mod tests {
     fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
         let mut b = 0;
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                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_address.rs b/fuzz/fuzz_targets/tapyrus/deserialize_address.rs
similarity index 60%
rename from fuzz/fuzz_targets/deserialize_address.rs
rename to fuzz/fuzz_targets/tapyrus/deserialize_address.rs
index 4a26a20c..435b2b7b 100644
--- a/fuzz/fuzz_targets/deserialize_address.rs
+++ b/fuzz/fuzz_targets/tapyrus/deserialize_address.rs
@@ -1,26 +1,16 @@
-extern crate bitcoin;
 use std::str::FromStr;
+
+use honggfuzz::fuzz;
+
 fn do_test(data: &[u8]) {
     let data_str = String::from_utf8_lossy(data);
-    let addr = match bitcoin::util::address::Address::from_str(&data_str) {
-        Ok(addr) => addr,
+    let addr = match tapyrus::address::Address::from_str(&data_str) {
+        Ok(addr) => addr.assume_checked(),
         Err(_) => return,
     };
     assert_eq!(addr.to_string(), data_str);
 }
 
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    fuzz!(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -29,16 +19,16 @@ fn main() {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, fuzzing))]
 mod tests {
     fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
         let mut b = 0;
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                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_amount.rs b/fuzz/fuzz_targets/tapyrus/deserialize_amount.rs
similarity index 57%
rename from fuzz/fuzz_targets/deserialize_amount.rs
rename to fuzz/fuzz_targets/tapyrus/deserialize_amount.rs
index 6c396da4..8d28119c 100644
--- a/fuzz/fuzz_targets/deserialize_amount.rs
+++ b/fuzz/fuzz_targets/tapyrus/deserialize_amount.rs
@@ -1,43 +1,33 @@
-extern crate bitcoin;
 use std::str::FromStr;
+
+use honggfuzz::fuzz;
+
 fn do_test(data: &[u8]) {
     let data_str = String::from_utf8_lossy(data);
 
     // signed
-    let samt = match bitcoin::util::amount::SignedAmount::from_str(&data_str) {
+    let samt = match tapyrus::amount::SignedAmount::from_str(&data_str) {
         Ok(amt) => amt,
         Err(_) => return,
     };
-    let samt_roundtrip = match bitcoin::util::amount::SignedAmount::from_str(&samt.to_string()) {
+    let samt_roundtrip = match tapyrus::amount::SignedAmount::from_str(&samt.to_string()) {
         Ok(amt) => amt,
         Err(_) => return,
     };
     assert_eq!(samt, samt_roundtrip);
 
     // unsigned
-    let amt = match bitcoin::util::amount::Amount::from_str(&data_str) {
+    let amt = match tapyrus::amount::Amount::from_str(&data_str) {
         Ok(amt) => amt,
         Err(_) => return,
     };
-    let amt_roundtrip = match bitcoin::util::amount::Amount::from_str(&amt.to_string()) {
+    let amt_roundtrip = match tapyrus::amount::Amount::from_str(&amt.to_string()) {
         Ok(amt) => amt,
         Err(_) => return,
     };
     assert_eq!(amt, amt_roundtrip);
 }
 
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    fuzz!(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -46,16 +36,16 @@ fn main() {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, fuzzing))]
 mod tests {
     fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
         let mut b = 0;
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                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/deser_net_msg.rs b/fuzz/fuzz_targets/tapyrus/deserialize_block.rs
similarity index 54%
rename from fuzz/fuzz_targets/deser_net_msg.rs
rename to fuzz/fuzz_targets/tapyrus/deserialize_block.rs
index e2c1a0a7..313a4759 100644
--- a/fuzz/fuzz_targets/deser_net_msg.rs
+++ b/fuzz/fuzz_targets/tapyrus/deserialize_block.rs
@@ -1,21 +1,10 @@
-extern crate bitcoin;
+use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
-    let _: Result<bitcoin::network::message::RawNetworkMessage, _> = bitcoin::consensus::encode::deserialize(data);
+    let _: Result<tapyrus::blockdata::block::Block, _> =
+        tapyrus::consensus::encode::deserialize(data);
 }
 
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    fuzz!(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -24,16 +13,16 @@ fn main() {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, fuzzing))]
 mod tests {
     fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
         let mut b = 0;
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                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/tapyrus/deserialize_prefilled_transaction.rs b/fuzz/fuzz_targets/tapyrus/deserialize_prefilled_transaction.rs
new file mode 100644
index 00000000..02c66243
--- /dev/null
+++ b/fuzz/fuzz_targets/tapyrus/deserialize_prefilled_transaction.rs
@@ -0,0 +1,50 @@
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    // We already fuzz Transactions in `./deserialize_transaction.rs`.
+    let tx_result: Result<tapyrus::bip152::PrefilledTransaction, _> =
+        tapyrus::consensus::encode::deserialize(data);
+
+    match tx_result {
+        Err(_) => {}
+        Ok(tx) => {
+            let ser = tapyrus::consensus::encode::serialize(&tx);
+            assert_eq!(&ser[..], data);
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/tapyrus/deserialize_psbt.rs b/fuzz/fuzz_targets/tapyrus/deserialize_psbt.rs
new file mode 100644
index 00000000..760191e0
--- /dev/null
+++ b/fuzz/fuzz_targets/tapyrus/deserialize_psbt.rs
@@ -0,0 +1,49 @@
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let psbt: Result<tapyrus::psbt::Psbt, _> = tapyrus::psbt::Psbt::deserialize(data);
+    match psbt {
+        Err(_) => {}
+        Ok(psbt) => {
+            let ser = tapyrus::psbt::Psbt::serialize(&psbt);
+            let deser = tapyrus::psbt::Psbt::deserialize(&ser).unwrap();
+            // Since the fuzz data could order psbt fields differently, we compare to our deser/ser instead of data
+            assert_eq!(ser, tapyrus::psbt::Psbt::serialize(&deser));
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/deserialize_script.rs b/fuzz/fuzz_targets/tapyrus/deserialize_script.rs
similarity index 61%
rename from fuzz/fuzz_targets/deserialize_script.rs
rename to fuzz/fuzz_targets/tapyrus/deserialize_script.rs
index e7c36de0..973f1542 100644
--- a/fuzz/fuzz_targets/deserialize_script.rs
+++ b/fuzz/fuzz_targets/tapyrus/deserialize_script.rs
@@ -1,27 +1,29 @@
-extern crate bitcoin;
-
-use bitcoin::util::address::Address;
-use bitcoin::network::constants::Network;
-use bitcoin::blockdata::script;
-use bitcoin::consensus::encode;
+use honggfuzz::fuzz;
+use tapyrus::address::Address;
+use tapyrus::blockdata::script;
+use tapyrus::consensus::encode;
+use tapyrus::Network;
 
 fn do_test(data: &[u8]) {
-    let s: Result<script::Script, _> = encode::deserialize(data);
+    let s: Result<script::ScriptBuf, _> = encode::deserialize(data);
     if let Ok(script) = s {
-        let _: Vec<script::Instruction> = script.iter(false).collect();
-        let enforce_min: Vec<script::Instruction> = script.iter(true).collect();
+        let _: Result<Vec<script::Instruction>, script::Error> = script.instructions().collect();
 
         let mut b = script::Builder::new();
-        for ins in enforce_min {
-            match ins {
-                script::Instruction::Error(_) => return,
-                script::Instruction::Op(op) => { b = b.push_opcode(op); }
+        for ins in script.instructions_minimal() {
+            if ins.is_err() {
+                return;
+            }
+            match ins.ok().unwrap() {
+                script::Instruction::Op(op) => {
+                    b = b.push_opcode(op);
+                }
                 script::Instruction::PushBytes(bytes) => {
                     // Any one-byte pushes, except -0, which can be interpreted as numbers, should be
                     // reserialized as numbers. (For -1 through 16, this will use special ops; for
                     // others it'll just reserialize them as pushes.)
                     if bytes.len() == 1 && bytes[0] != 0x80 && bytes[0] != 0x00 {
-                        if let Ok(num) = script::read_scriptint(bytes) {
+                        if let Ok(num) = script::read_scriptint(bytes.as_bytes()) {
                             b = b.push_int(num);
                         } else {
                             b = b.push_slice(bytes);
@@ -36,24 +38,12 @@ fn do_test(data: &[u8]) {
         assert_eq!(data, &encode::serialize(&script)[..]);
 
         // Check if valid address and if that address roundtrips.
-        if let Some(addr) = Address::from_script(&script, Network::Bitcoin) {
+        if let Ok(addr) = Address::from_script(&script, Network::Prod) {
             assert_eq!(addr.script_pubkey(), script);
         }
     }
 }
 
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    fuzz!(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -62,16 +52,16 @@ fn main() {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, fuzzing))]
 mod tests {
     fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
         let mut b = 0;
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                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/tapyrus/deserialize_transaction.rs b/fuzz/fuzz_targets/tapyrus/deserialize_transaction.rs
new file mode 100644
index 00000000..064fcc22
--- /dev/null
+++ b/fuzz/fuzz_targets/tapyrus/deserialize_transaction.rs
@@ -0,0 +1,55 @@
+use honggfuzz::fuzz;
+
+fn do_test(data: &[u8]) {
+    let tx_result: Result<tapyrus::blockdata::transaction::Transaction, _> =
+        tapyrus::consensus::encode::deserialize(data);
+    match tx_result {
+        Err(_) => {}
+        Ok(mut tx) => {
+            let ser = tapyrus::consensus::encode::serialize(&tx);
+            assert_eq!(&ser[..], data);
+            let len = ser.len();
+            let calculated_weight = tx.weight().to_wu() as usize;
+            for input in &mut tx.input {
+                input.witness = tapyrus::blockdata::witness::Witness::default();
+            }
+            let no_witness_len = tapyrus::consensus::encode::serialize(&tx).len();
+            assert_eq!(no_witness_len * 3 + len, calculated_weight);
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("000700000001000000010000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/tapyrus/deserialize_witness.rs b/fuzz/fuzz_targets/tapyrus/deserialize_witness.rs
new file mode 100644
index 00000000..92b975e7
--- /dev/null
+++ b/fuzz/fuzz_targets/tapyrus/deserialize_witness.rs
@@ -0,0 +1,46 @@
+use honggfuzz::fuzz;
+use tapyrus::blockdata::witness::Witness;
+use tapyrus::consensus::{deserialize, serialize};
+
+fn do_test(data: &[u8]) {
+    let w: Result<Witness, _> = deserialize(data);
+    if let Ok(witness) = w {
+        let serialized = serialize(&witness);
+        assert_eq!(data, &serialized[..]);
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/fuzz_targets/outpoint_string.rs b/fuzz/fuzz_targets/tapyrus/outpoint_string.rs
similarity index 65%
rename from fuzz/fuzz_targets/outpoint_string.rs
rename to fuzz/fuzz_targets/tapyrus/outpoint_string.rs
index ed2d3fee..64989354 100644
--- a/fuzz/fuzz_targets/outpoint_string.rs
+++ b/fuzz/fuzz_targets/tapyrus/outpoint_string.rs
@@ -1,21 +1,22 @@
-
-extern crate bitcoin;
-
-use bitcoin::blockdata::transaction::OutPoint;
-use bitcoin::consensus::encode;
-
 use std::str::FromStr;
 
+use honggfuzz::fuzz;
+use tapyrus::blockdata::transaction::OutPoint;
+use tapyrus::consensus::encode;
+
 fn do_test(data: &[u8]) {
-    let lowercase: Vec<u8> = data.iter().map(|c| match *c {
-        b'A' => b'a',
-        b'B' => b'b',
-        b'C' => b'c',
-        b'D' => b'd',
-        b'E' => b'e',
-        b'F' => b'f',
-        x => x
-    }).collect();
+    let lowercase: Vec<u8> = data
+        .iter()
+        .map(|c| match *c {
+            b'A' => b'a',
+            b'B' => b'b',
+            b'C' => b'c',
+            b'D' => b'd',
+            b'E' => b'e',
+            b'F' => b'f',
+            x => x,
+        })
+        .collect();
     let data_str = match String::from_utf8(lowercase) {
         Err(_) => return,
         Ok(s) => s,
@@ -33,25 +34,13 @@ fn do_test(data: &[u8]) {
                 let string = deser.to_string();
                 match OutPoint::from_str(&string) {
                     Ok(destring) => assert_eq!(destring, deser),
-                    Err(_) => panic!()
+                    Err(_) => panic!(),
                 }
             }
         }
     }
 }
 
-#[cfg(feature = "afl")]
-#[macro_use] extern crate afl;
-#[cfg(feature = "afl")]
-fn main() {
-    fuzz!(|data| {
-        do_test(&data);
-    });
-}
-
-#[cfg(feature = "honggfuzz")]
-#[macro_use] extern crate honggfuzz;
-#[cfg(feature = "honggfuzz")]
 fn main() {
     loop {
         fuzz!(|data| {
@@ -60,16 +49,16 @@ fn main() {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, fuzzing))]
 mod tests {
     fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
         let mut b = 0;
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                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/tapyrus/script_bytes_to_asm_fmt.rs b/fuzz/fuzz_targets/tapyrus/script_bytes_to_asm_fmt.rs
new file mode 100644
index 00000000..2a41b09e
--- /dev/null
+++ b/fuzz/fuzz_targets/tapyrus/script_bytes_to_asm_fmt.rs
@@ -0,0 +1,52 @@
+use std::fmt;
+
+use honggfuzz::fuzz;
+
+// faster than String, we don't need to actually produce the value, just check absence of panics
+struct NullWriter;
+
+impl fmt::Write for NullWriter {
+    fn write_str(&mut self, _s: &str) -> fmt::Result { Ok(()) }
+
+    fn write_char(&mut self, _c: char) -> fmt::Result { Ok(()) }
+}
+
+fn do_test(data: &[u8]) {
+    let mut writer = NullWriter;
+    tapyrus::Script::from_bytes(data).fmt_asm(&mut writer).unwrap();
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(all(test, fuzzing))]
+mod tests {
+    fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
+        let mut b = 0;
+        for (idx, c) in hex.as_bytes().iter().enumerate() {
+            b <<= 4;
+            match *c {
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
+                _ => panic!("Bad hex"),
+            }
+            if (idx & 1) == 1 {
+                out.push(b);
+                b = 0;
+            }
+        }
+    }
+
+    #[test]
+    fn duplicate_crash() {
+        let mut a = Vec::new();
+        extend_vec_from_hex("00000", &mut a);
+        super::do_test(&a);
+    }
+}
diff --git a/fuzz/generate-files.sh b/fuzz/generate-files.sh
new file mode 100755
index 00000000..c16770ce
--- /dev/null
+++ b/fuzz/generate-files.sh
@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+
+set -e
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+
+# shellcheck source=./fuzz-util.sh
+source "$REPO_DIR/fuzz/fuzz-util.sh"
+
+# 1. Generate fuzz/Cargo.toml
+cat > "$REPO_DIR/fuzz/Cargo.toml" <<EOF
+[package]
+name = "tapyrus-fuzz"
+edition = "2018"
+version = "0.0.1"
+authors = ["Generated by fuzz/generate-files.sh"]
+publish = false
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+honggfuzz = { version = "0.5.55", default-features = false }
+tapyrus = { version = "0.5.0", features = [ "serde" ] }
+
+serde = { version = "1.0.103", features = [ "derive" ] }
+serde_json = "1.0"
+serde_cbor = "0.9"
+EOF
+
+for targetFile in $(listTargetFiles); do
+    targetName=$(targetFileToName "$targetFile")
+    cat >> "$REPO_DIR/fuzz/Cargo.toml" <<EOF
+
+[[bin]]
+name = "$targetName"
+path = "$targetFile"
+EOF
+done
+
+# 2. Generate .github/workflows/fuzz.yml
+cat > "$REPO_DIR/.github/workflows/fuzz.yml" <<EOF
+# Automatically generated by fuzz/generate-files.sh
+name: Fuzz
+
+on:
+  push:
+    branches:
+      - master
+      - 'test-ci/**'
+  pull_request:
+
+jobs:
+  fuzz:
+    if: \${{ !github.event.act }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        fuzz_target: [
+$(for name in $(listTargetNames); do echo "          $name,"; done)
+        ]
+    steps:
+      - name: Install test dependencies
+        run: sudo apt-get update -y && sudo apt-get install -y binutils-dev libunwind8-dev libcurl4-openssl-dev libelf-dev libdw-dev cmake gcc libiberty-dev
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v3
+        id: cache-fuzz
+        with:
+          path: |
+            ~/.cargo/bin
+            fuzz/target
+            target
+          key: cache-\${{ matrix.target }}-\${{ hashFiles('**/Cargo.toml','**/Cargo.lock') }}
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: '1.65.0'
+      - name: fuzz
+        run: |
+          if [[ "\${{ matrix.fuzz_target }}" =~ ^tapyrus ]]; then
+              export RUSTFLAGS='--cfg=hashes_fuzz --cfg=secp256k1_fuzz'
+          fi
+          echo "Using RUSTFLAGS \$RUSTFLAGS"
+          cd fuzz && ./fuzz.sh "\${{ matrix.fuzz_target }}"
+      - run: echo "\${{ matrix.fuzz_target }}" >executed_\${{ matrix.fuzz_target }}
+      - uses: actions/upload-artifact@v3
+        with:
+          name: executed_\${{ matrix.fuzz_target }}
+          path: executed_\${{ matrix.fuzz_target }}
+
+  verify-execution:
+    if: \${{ !github.event.act }}
+    needs: fuzz
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v3
+      - name: Display structure of downloaded files
+        run: ls -R
+      - run: find executed_* -type f -exec cat {} + | sort > executed
+      - run: source ./fuzz/fuzz-util.sh && listTargetNames | sort | diff - executed
+EOF
+
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/132dec80e89477d962a7bd0d20947063.00000077.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/132dec80e89477d962a7bd0d20947063.00000077.honggfuzz.cov
deleted file mode 100644
index e133fd44..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/132dec80e89477d962a7bd0d20947063.00000077.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/24fc2c1884453115fa0b1f2a758a8696.0000034c.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/24fc2c1884453115fa0b1f2a758a8696.0000034c.honggfuzz.cov
deleted file mode 100644
index ca7f418c..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/24fc2c1884453115fa0b1f2a758a8696.0000034c.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/2d32100000000000323d000000000000.00000002.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/2d32100000000000323d000000000000.00000002.honggfuzz.cov
deleted file mode 100644
index 852f75b9..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/2d32100000000000323d000000000000.00000002.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-'0
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/3096e01ac84d84540d122233010feba6.000004cf.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/3096e01ac84d84540d122233010feba6.000004cf.honggfuzz.cov
deleted file mode 100644
index e80229f4..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/3096e01ac84d84540d122233010feba6.000004cf.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/36413cf2bc1e6cf57d77335d0f348928.00000047.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/36413cf2bc1e6cf57d77335d0f348928.00000047.honggfuzz.cov
deleted file mode 100644
index c2538676..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/36413cf2bc1e6cf57d77335d0f348928.00000047.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/467ad0f85000000078708ab670000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/467ad0f85000000078708ab670000000.00000004.honggfuzz.cov
deleted file mode 100644
index c0648a18..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/467ad0f85000000078708ab670000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[8
u
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/51110622200000005266211140000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/51110622200000005266211140000000.00000004.honggfuzz.cov
deleted file mode 100644
index ec747fa4..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/51110622200000005266211140000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-null
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/57fd8d882850000078282d8da7800000.00000005.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/57fd8d882850000078282d8da7800000.00000005.honggfuzz.cov
deleted file mode 100644
index e22e541d..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/57fd8d882850000078282d8da7800000.00000005.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[[]]h
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/70e4556ab8a8c7dcc2338dfa4891f4ae.000000a6.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/70e4556ab8a8c7dcc2338dfa4891f4ae.000000a6.honggfuzz.cov
deleted file mode 100644
index e4dbc88c..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/70e4556ab8a8c7dcc2338dfa4891f4ae.000000a6.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"v���2-26518032317924925183�̶�*����Nkkkkkkkkk�R��0��5�� �뱝0�d�:P��
V�P��p�":9 }�� �뱝0�d�:P��
V�
V�P��p�":9 P��
V�P��p�":9 u�� �뱝0�d�:P��
V�
V�P��p�8:9 P
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/74606c62f539e4d5935525e03e92a40e.00000109.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/74606c62f539e4d5935525e03e92a40e.00000109.honggfuzz.cov
deleted file mode 100644
index a0f1e52c..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/74606c62f539e4d5935525e03e92a40e.00000109.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/77ec8eda1dccae702efb36b0adf0e18f.00000165.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/77ec8eda1dccae702efb36b0adf0e18f.00000165.honggfuzz.cov
deleted file mode 100644
index 47d68df6..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/77ec8eda1dccae702efb36b0adf0e18f.00000165.honggfuzz.cov
+++ /dev/null
@@ -1,2 +0,0 @@
-{"v�0�d�:P��
V�P��p�":9 ,"��83622040����Nkkkkkkkkk�R��v��5�� �뱝0�d�:P���V�P��p�":9 -7858362224003565858
V�P��p�":9 v3Z�r�ۦ���(
-�?����*�ef�9i"�*(��r�܇�]�1��Y�":9 u���뱝0�d�:P��
V�
V�P��p�3�̶FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/7bea4e2285010eb3cf4acb9b1203841b.0000007b.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/7bea4e2285010eb3cf4acb9b1203841b.0000007b.honggfuzz.cov
deleted file mode 100644
index 375c7326..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/7bea4e2285010eb3cf4acb9b1203841b.0000007b.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/7cd702cb9c81e396ff5433e1b716e343.0000056e.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/7cd702cb9c81e396ff5433e1b716e343.0000056e.honggfuzz.cov
deleted file mode 100644
index dec57403..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/7cd702cb9c81e396ff5433e1b716e343.0000056e.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000002_orig-0ee00000000000000ee0000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000002_orig-0ee00000000000000ee0000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 8b137891..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000002_orig-0ee00000000000000ee0000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000003_orig-108d4836be71e10731359b612fcb840b.000010b4.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000003_orig-108d4836be71e10731359b612fcb840b.000010b4.honggfuzz.cov
deleted file mode 100644
index 92fbbcf0..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000003_orig-108d4836be71e10731359b612fcb840b.000010b4.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000004_orig-123fcb7f3b8bc4bc500d63157d0d25ff.00001d58.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000004_orig-123fcb7f3b8bc4bc500d63157d0d25ff.00001d58.honggfuzz.cov
deleted file mode 100644
index d80ce6b1..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000004_orig-123fcb7f3b8bc4bc500d63157d0d25ff.00001d58.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000005_orig-12dfa93ad99f88fc4f2053d53480c3e5.00000d84.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000005_orig-12dfa93ad99f88fc4f2053d53480c3e5.00000d84.honggfuzz.cov
deleted file mode 100644
index a3731f31..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000005_orig-12dfa93ad99f88fc4f2053d53480c3e5.00000d84.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000007_orig-1e82e6b16644739bc1095df2d0075c0b.00000097.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000007_orig-1e82e6b16644739bc1095df2d0075c0b.00000097.honggfuzz.cov
deleted file mode 100644
index 0b1e19e6..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000007_orig-1e82e6b16644739bc1095df2d0075c0b.00000097.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000008_orig-1e9b9cbf5c7959604b0d1c83097d1345.00001520.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000008_orig-1e9b9cbf5c7959604b0d1c83097d1345.00001520.honggfuzz.cov
deleted file mode 100644
index 74badb19..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000008_orig-1e9b9cbf5c7959604b0d1c83097d1345.00001520.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[""7��-5
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000009_orig-20ae411d2fd000002ffd211e40800000.00000005.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000009_orig-20ae411d2fd000002ffd211e40800000.00000005.honggfuzz.cov
deleted file mode 100644
index b6b3dc08..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000009_orig-20ae411d2fd000002ffd211e40800000.00000005.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-30928
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000012_orig-288e5e0e600000002e5e0e48a0000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000012_orig-288e5e0e600000002e5e0e48a0000000.00000004.honggfuzz.cov
deleted file mode 100644
index 804f8bff..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000012_orig-288e5e0e600000002e5e0e48a0000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-2.26
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000013_orig-2a4d69685000000078792d6a70000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000013_orig-2a4d69685000000078792d6a70000000.00000004.honggfuzz.cov
deleted file mode 100644
index 890011b0..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000013_orig-2a4d69685000000078792d6a70000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[7,5
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000017_orig-334c35e4651b52f2061d4fe13e60a281.00000214.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000017_orig-334c35e4651b52f2061d4fe13e60a281.00000214.honggfuzz.cov
deleted file mode 100644
index bf291a94..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000017_orig-334c35e4651b52f2061d4fe13e60a281.00000214.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000018_orig-397e6000000000002e59500000000000.00000002.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000018_orig-397e6000000000002e59500000000000.00000002.honggfuzz.cov
deleted file mode 100644
index a9bcb243..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000018_orig-397e6000000000002e59500000000000.00000002.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-2+
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000020_orig-3cde6000000000002e5cf00000000000.00000002.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000020_orig-3cde6000000000002e5cf00000000000.00000002.honggfuzz.cov
deleted file mode 100644
index 998d1104..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000020_orig-3cde6000000000002e5cf00000000000.00000002.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-2-
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000021_orig-3cf00000000000003cf0000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000021_orig-3cf00000000000003cf0000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 3cf20d57..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000021_orig-3cf00000000000003cf0000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
--
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000023_orig-47c000000000000047c0000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000023_orig-47c000000000000047c0000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 32f64f4d..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000023_orig-47c000000000000047c0000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-t
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000024_orig-4e500000000000004e50000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000024_orig-4e500000000000004e50000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 81750b96..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000024_orig-4e500000000000004e50000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000026_orig-53cfa000000000005ff3900000000000.00000002.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000026_orig-53cfa000000000005ff3900000000000.00000002.honggfuzz.cov
deleted file mode 100644
index e0a6c666..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000026_orig-53cfa000000000005ff3900000000000.00000002.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-fo
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000027_orig-54c0ad00000000002d20d4e000000000.00000003.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000027_orig-54c0ad00000000002d20d4e000000000.00000003.honggfuzz.cov
deleted file mode 100644
index 4fc953f0..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000027_orig-54c0ad00000000002d20d4e000000000.00000003.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-08j
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000028_orig-5631cf21cf4a9e2d44df21cf21f52d69.0000000e.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000028_orig-5631cf21cf4a9e2d44df21cf21f52d69.0000000e.honggfuzz.cov
deleted file mode 100644
index 57608ac4..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000028_orig-5631cf21cf4a9e2d44df21cf21f52d69.0000000e.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000029_orig-57f82d882850000078282d8807800000.00000005.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000029_orig-57f82d882850000078282d8807800000.00000005.honggfuzz.cov
deleted file mode 100644
index f3e2f82b..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000029_orig-57f82d882850000078282d8807800000.00000005.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[[][h
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000031_orig-57fddbb82850000078287bbda7800000.00000005.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000031_orig-57fddbb82850000078287bbda7800000.00000005.honggfuzz.cov
deleted file mode 100644
index 57025ac5..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000031_orig-57fddbb82850000078287bbda7800000.00000005.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[[4]h
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000032_orig-5d2d2d5a700000002a2d2d2d70000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000032_orig-5d2d2d5a700000002a2d2d2d70000000.00000004.honggfuzz.cov
deleted file mode 100644
index e969b4b3..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000032_orig-5d2d2d5a700000002a2d2d2d70000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-5eee
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000035_orig-6d59154edc9107406929538201922082.00000248.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000035_orig-6d59154edc9107406929538201922082.00000248.honggfuzz.cov
deleted file mode 100644
index 774af0af..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000035_orig-6d59154edc9107406929538201922082.00000248.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000037_orig-705e4e493e4e5e0e6f5e0e4e493e4e4a.00000008.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000037_orig-705e4e493e4e5e0e6f5e0e4e493e4e4a.00000008.honggfuzz.cov
deleted file mode 100644
index b38d997a..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000037_orig-705e4e493e4e5e0e6f5e0e4e493e4e4a.00000008.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-2.227225
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000040_orig-761f0bedebcfac240c2affec91115bfd.00000011.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000040_orig-761f0bedebcfac240c2affec91115bfd.00000011.honggfuzz.cov
deleted file mode 100644
index 8c08ecf4..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000040_orig-761f0bedebcfac240c2affec91115bfd.00000011.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-2.322947127462735
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000041_orig-77c36463d3da4ba27232b488be74d652.00000443.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000041_orig-77c36463d3da4ba27232b488be74d652.00000443.honggfuzz.cov
deleted file mode 100644
index 48b9a17c..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000041_orig-77c36463d3da4ba27232b488be74d652.00000443.honggfuzz.cov
+++ /dev/null
@@ -1,4 +0,0 @@
-{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":9 }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||,�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000042_orig-77d7557f54289c91e217b85d989facd8.00000018.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000042_orig-77d7557f54289c91e217b85d989facd8.00000018.honggfuzz.cov
deleted file mode 100644
index a64e3821..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000042_orig-77d7557f54289c91e217b85d989facd8.00000018.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-0.3329481833294518658410
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000044_orig-78500000000000007850000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000044_orig-78500000000000007850000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 8e2f0bef..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000044_orig-78500000000000007850000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000047_orig-7dc55518500000007865551df0000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000047_orig-7dc55518500000007865551df0000000.00000004.honggfuzz.cov
deleted file mode 100644
index 93b6be2b..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000047_orig-7dc55518500000007865551df0000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[""]
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000048_orig-7eedadd9a00e3b31fcb0884b16349723.00000014.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000048_orig-7eedadd9a00e3b31fcb0884b16349723.00000014.honggfuzz.cov
deleted file mode 100644
index 635e7b69..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000048_orig-7eedadd9a00e3b31fcb0884b16349723.00000014.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
--7010909841481319489
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000049_orig-8d5ec8a00000000028ae6d5000000000.00000003.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000049_orig-8d5ec8a00000000028ae6d5000000000.00000003.honggfuzz.cov
deleted file mode 100644
index e664d1b5..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000049_orig-8d5ec8a00000000028ae6d5000000000.00000003.honggfuzz.cov
+++ /dev/null
@@ -1,2 +0,0 @@
-6
-�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000052_orig-a3a3fd51b18fec92a2a7beeffed8cae3.00000018.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000052_orig-a3a3fd51b18fec92a2a7beeffed8cae3.00000018.honggfuzz.cov
deleted file mode 100644
index e26fee6a..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000052_orig-a3a3fd51b18fec92a2a7beeffed8cae3.00000018.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000055_orig-a9f6021f1f65e0dc27de93336aabd27c.000018d9.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000055_orig-a9f6021f1f65e0dc27de93336aabd27c.000018d9.honggfuzz.cov
deleted file mode 100644
index 789cd047..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000055_orig-a9f6021f1f65e0dc27de93336aabd27c.000018d9.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000056_orig-ada1751ee6257eb5e41676e7942f2cee.0000018c.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000056_orig-ada1751ee6257eb5e41676e7942f2cee.0000018c.honggfuzz.cov
deleted file mode 100644
index ad41a6b0..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000056_orig-ada1751ee6257eb5e41676e7942f2cee.0000018c.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000057_orig-aebd22b8a4eaea84473de8f7af92b9e8.00000010.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000057_orig-aebd22b8a4eaea84473de8f7af92b9e8.00000010.honggfuzz.cov
deleted file mode 100644
index 74515b63..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000057_orig-aebd22b8a4eaea84473de8f7af92b9e8.00000010.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-2.32294718384932
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000058_orig-bb2dbbbe28500000781e1b8d4b500000.00000005.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000058_orig-bb2dbbbe28500000781e1b8d4b500000.00000005.honggfuzz.cov
deleted file mode 100644
index 75f66321..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000058_orig-bb2dbbbe28500000781e1b8d4b500000.00000005.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[{}]�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000059_orig-bfff1b9d411fec33960462c7c10fff37.00000015.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000059_orig-bfff1b9d411fec33960462c7c10fff37.00000015.honggfuzz.cov
deleted file mode 100644
index fac0d071..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000059_orig-bfff1b9d411fec33960462c7c10fff37.00000015.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
--0.89846310859469617
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000061_orig-c10ddce82b9fbc814168922cd0a8c702.00000cd9.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000061_orig-c10ddce82b9fbc814168922cd0a8c702.00000cd9.honggfuzz.cov
deleted file mode 100644
index c99f102b..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000061_orig-c10ddce82b9fbc814168922cd0a8c702.00000cd9.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[[4]]��5
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000062_orig-cba6d94806f7b566cb25b3da0ef0c600.0000111f.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000062_orig-cba6d94806f7b566cb25b3da0ef0c600.0000111f.honggfuzz.cov
deleted file mode 100644
index 91b7cf5b..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000062_orig-cba6d94806f7b566cb25b3da0ef0c600.0000111f.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000063_orig-d40f0232cbdf1d50812e29256f1fd27c.000002e7.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000063_orig-d40f0232cbdf1d50812e29256f1fd27c.000002e7.honggfuzz.cov
deleted file mode 100644
index 40c54f91..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000063_orig-d40f0232cbdf1d50812e29256f1fd27c.000002e7.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000064_orig-d706a550b181d5068db96ee44a07c478.000000b7.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000064_orig-d706a550b181d5068db96ee44a07c478.000000b7.honggfuzz.cov
deleted file mode 100644
index 115f5a52..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000064_orig-d706a550b181d5068db96ee44a07c478.000000b7.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000065_orig-d7b9d4f86a11cd25d4fef32dc4e27948.000001d6.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000065_orig-d7b9d4f86a11cd25d4fef32dc4e27948.000001d6.honggfuzz.cov
deleted file mode 100644
index 5b4000e1..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000065_orig-d7b9d4f86a11cd25d4fef32dc4e27948.000001d6.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000067_orig-db66e14c0e5000004e2c61361b600000.00000005.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000067_orig-db66e14c0e5000004e2c61361b600000.00000005.honggfuzz.cov
deleted file mode 100644
index a63c371b..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000067_orig-db66e14c0e5000004e2c61361b600000.00000005.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{\9�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000068_orig-e177cb82e1fdef491f2140a923efd3ed.000001d6.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_decimal/input/id-000068_orig-e177cb82e1fdef491f2140a923efd3ed.000001d6.honggfuzz.cov
deleted file mode 100644
index 24f5f82e..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000068_orig-e177cb82e1fdef491f2140a923efd3ed.000001d6.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000080_src-000000_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000080_src-000000_op-havoc_rep-32
deleted file mode 100644
index d6ddb445..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000080_src-000000_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000083_src-000000_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000083_src-000000_op-havoc_rep-8
deleted file mode 100644
index 52420837..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000083_src-000000_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000084_src-000000_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000084_src-000000_op-havoc_rep-4
deleted file mode 100644
index fec3dfd2..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000084_src-000000_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000086_src-000000_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000086_src-000000_op-havoc_rep-16
deleted file mode 100644
index 5eb264df..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000086_src-000000_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000090_src-000000_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000090_src-000000_op-havoc_rep-8
deleted file mode 100644
index 14c37392..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000090_src-000000_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000093_src-000000_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000093_src-000000_op-havoc_rep-128
deleted file mode 100644
index b5f49a5b..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000093_src-000000_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000097_src-000000_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000097_src-000000_op-havoc_rep-64
deleted file mode 100644
index 0ce4cb24..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000097_src-000000_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000098_src-000000_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000098_src-000000_op-havoc_rep-32
deleted file mode 100644
index 0c8f4c03..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000098_src-000000_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000099_src-000000_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000099_src-000000_op-havoc_rep-64
deleted file mode 100644
index 18194e57..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000099_src-000000_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000100_src-000000_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000100_src-000000_op-havoc_rep-16
deleted file mode 100644
index 1da1c48e..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000100_src-000000_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000104_src-000000_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000104_src-000000_op-havoc_rep-64
deleted file mode 100644
index 2514619c..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000104_src-000000_op-havoc_rep-64
+++ /dev/null
@@ -1 +0,0 @@
-"4�#@>4�\""
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000105_src-000000_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000105_src-000000_op-havoc_rep-128
deleted file mode 100644
index a12847e4..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000105_src-000000_op-havoc_rep-128
+++ /dev/null
@@ -1 +0,0 @@
-






\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000107_src-000001_op-flip1_pos-77 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000107_src-000001_op-flip1_pos-77
deleted file mode 100644
index dbaa009d..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000107_src-000001_op-flip1_pos-77
+++ /dev/null
@@ -1 +0,0 @@
-"4�#��-5�!S��57���Vg���



���������









A
ظ7i����<�����N�\u1471\u�471\u1471\u1471\u1471\u1471\u
\u\
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000112_src-000001_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000112_src-000001_op-havoc_rep-4
deleted file mode 100644
index 09f08443..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000112_src-000001_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-"4�#��-5�\u1471\u1471\u1471\u1471\u1471\u1471\u1471\u1471\u1471\u
\u\
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000114_src-000001_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000114_src-000001_op-havoc_rep-8
deleted file mode 100644
index 36de43b2..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000114_src-000001_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-"4�#��-5�!S��57���Vg���



���������



�




A
ظ7i���<����N�\u1471\u1471\\ZB471\u1471\d
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000115_src-000001_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000115_src-000001_op-havoc_rep-64
deleted file mode 100644
index e4da3fc9..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000115_src-000001_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000116_src-000001_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000116_src-000001_op-havoc_rep-128
deleted file mode 100644
index 011a33b5..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000116_src-000001_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000118_src-000001_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000118_src-000001_op-havoc_rep-64
deleted file mode 100644
index 70ed709c..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000118_src-000001_op-havoc_rep-64
+++ /dev/null
@@ -1 +0,0 @@
-[[[[HV�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000124_src-000001_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000124_src-000001_op-havoc_rep-128
deleted file mode 100644
index e8d6f4f5..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000124_src-000001_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000125_src-000006_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000125_src-000006_op-havoc_rep-128
deleted file mode 100644
index 8e39ac29..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000125_src-000006_op-havoc_rep-128
+++ /dev/null
@@ -1 +0,0 @@
-1E
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000126_src-000008_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000126_src-000008_op-havoc_rep-8
deleted file mode 100644
index 5d77a2e2..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000126_src-000008_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-[[[5d5
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000127_src-000008_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000127_src-000008_op-havoc_rep-8
deleted file mode 100644
index 70f8ae2b..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000127_src-000008_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000128_src-000008_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000128_src-000008_op-havoc_rep-4
deleted file mode 100644
index 20bfef46..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000128_src-000008_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-[["?��-
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000129_src-000008_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000129_src-000008_op-havoc_rep-8
deleted file mode 100644
index 6df3c2c7..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000129_src-000008_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-[ 

















"


\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000130_src-000008_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000130_src-000008_op-havoc_rep-128
deleted file mode 100644
index d0b81a19..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000130_src-000008_op-havoc_rep-128
+++ /dev/null
@@ -1,46 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-	�
-
-
-	�
-
-
-
-
-
-
-
-
-	�
-
-
-
-
-	
-
-	
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000132_src-000008_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000132_src-000008_op-havoc_rep-8
deleted file mode 100644
index 16ec7290..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000132_src-000008_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-[--------------------9"����@
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000133_src-000008_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000133_src-000008_op-havoc_rep-32
deleted file mode 100644
index 16f741c5..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000133_src-000008_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000135_src-000008_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000135_src-000008_op-havoc_rep-16
deleted file mode 100644
index 8643d998..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000135_src-000008_op-havoc_rep-16
+++ /dev/null
@@ -1 +0,0 @@
-nuu
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000137_src-000008_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000137_src-000008_op-havoc_rep-2
deleted file mode 100644
index 40c502d0..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000137_src-000008_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-----5
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000138_src-000008_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000138_src-000008_op-havoc_rep-2
deleted file mode 100644
index 5693cfda..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000138_src-000008_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
---5
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000139_src-000008_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000139_src-000008_op-havoc_rep-128
deleted file mode 100644
index e2017f6c..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000139_src-000008_op-havoc_rep-128
+++ /dev/null
@@ -1 +0,0 @@
-                         
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000141_src-000008_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000141_src-000008_op-havoc_rep-2
deleted file mode 100644
index 43bdfe7e..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000141_src-000008_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
---------------------------------[""7��-F
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000142_src-000010_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000142_src-000010_op-havoc_rep-32
deleted file mode 100644
index c7d525fc..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000142_src-000010_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000143_src-000010_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000143_src-000010_op-havoc_rep-128
deleted file mode 100644
index 3f3a1afb..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000143_src-000010_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000145_src-000011_op-flip4_pos-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000145_src-000011_op-flip4_pos-4
deleted file mode 100644
index 334c7a67..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000145_src-000011_op-flip4_pos-4
+++ /dev/null
@@ -1 +0,0 @@
-2.7E,K�F�83
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000146_src-000011_op-int8_pos-5_val-+32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000146_src-000011_op-int8_pos-5_val-+32
deleted file mode 100644
index 58bc77c3..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000146_src-000011_op-int8_pos-5_val-+32
+++ /dev/null
@@ -1 +0,0 @@
-2.7E+ �F�83
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000147_src-000013_op-arith8_pos-3_val--21 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000147_src-000013_op-arith8_pos-3_val--21
deleted file mode 100644
index 0b2f985d..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000147_src-000013_op-arith8_pos-3_val--21
+++ /dev/null
@@ -1 +0,0 @@
-[7, 
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000149_src-000016_op-flip1_pos-79 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000149_src-000016_op-flip1_pos-79
deleted file mode 100644
index f41001f2..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000149_src-000016_op-flip1_pos-79 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000150_src-000018_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000150_src-000018_op-havoc_rep-64
deleted file mode 100644
index 05ab0776..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000150_src-000018_op-havoc_rep-64
+++ /dev/null
@@ -1 +0,0 @@
-


0
�


�








�







�












M��


















�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000152_src-000028_op-flip1_pos-5 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000152_src-000028_op-flip1_pos-5
deleted file mode 100644
index f58a2661..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000152_src-000028_op-flip1_pos-5 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000153_src-000028_op-flip1_pos-7 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000153_src-000028_op-flip1_pos-7
deleted file mode 100644
index 002d6cbf..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000153_src-000028_op-flip1_pos-7 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000155_src-000028_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000155_src-000028_op-havoc_rep-4
deleted file mode 100644
index c7f042f6..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000155_src-000028_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000157_src-000028_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000157_src-000028_op-havoc_rep-2
deleted file mode 100644
index a14ea541..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000157_src-000028_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000158_src-000028_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000158_src-000028_op-havoc_rep-2
deleted file mode 100644
index 5e63c5a6..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000158_src-000028_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000160_src-000030_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000160_src-000030_op-havoc_rep-8
deleted file mode 100644
index 3b3c2479..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000160_src-000030_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-[[[]]�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000161_src-000036_op-flip1_pos-12 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000161_src-000036_op-flip1_pos-12
deleted file mode 100644
index 60302fc7..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000161_src-000036_op-flip1_pos-12
+++ /dev/null
@@ -1 +0,0 @@
--7010909849.01319480
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000163_src-000039_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000163_src-000039_op-havoc_rep-64
deleted file mode 100644
index 18732492..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000163_src-000039_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000165_src-000043_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000165_src-000043_op-havoc_rep-8
deleted file mode 100644
index 0fb0e76e..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000165_src-000043_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-{"v�0�d�
��P��p�":9 ,"��8362��p�":9 ,"���22040����Nkk�k�뱝0�d�:P���V�P��p�":9 -7
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000168_src-000060_op-arith8_pos-544_val-+18 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000168_src-000060_op-arith8_pos-544_val-+18
deleted file mode 100644
index 74519565..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000168_src-000060_op-arith8_pos-544_val-+18
+++ /dev/null
@@ -1,2 +0,0 @@
-{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�n�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2�b#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":9 ,"��83622040����Nkikkkkkkk�R��n�~X���j�o��P��p�":9 ,"��83622040��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":9 ,"��83622040����Nkikkkkkkk�R��n�~X���j�o��P��p�":9 ,"��83622040����Nkkkkkkkkk�R��v��5�� �뱝0�d�:P���V�P��p�":9 }kkk
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000171_src-000060_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000171_src-000060_op-havoc_rep-16
deleted file mode 100644
index 9d248a93..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000171_src-000060_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000172_src-000060_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000172_src-000060_op-havoc_rep-128
deleted file mode 100644
index 6cc03186..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000172_src-000060_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000175_src-000061_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000175_src-000061_op-havoc_rep-4
deleted file mode 100644
index e1eb3d2c..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000175_src-000061_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-[[[[4]]]��54]<�5
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000176_src-000061_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000176_src-000061_op-havoc_rep-2
deleted file mode 100644
index c8ce1e27..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000176_src-000061_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-[[[4]]��#[4]]��#
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000177_src-000062_op-arith8_pos-167_val--35 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000177_src-000062_op-arith8_pos-167_val--35
deleted file mode 100644
index 4fb7fddc..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000177_src-000062_op-arith8_pos-167_val--35 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000178_src-000062_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000178_src-000062_op-havoc_rep-32
deleted file mode 100644
index fc0c1970..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000178_src-000062_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000180_src-000065_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000180_src-000065_op-havoc_rep-4
deleted file mode 100644
index cbb1d4ce..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000180_src-000065_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000181_src-000070_op-flip1_pos-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000181_src-000070_op-flip1_pos-2
deleted file mode 100644
index 1b7b7133..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000181_src-000070_op-flip1_pos-2
+++ /dev/null
@@ -1,4 +0,0 @@
-{"��0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":9 ,"��83622040����Nkikkkkkkk�R��n�~X���j�o��P��p�":9}�Zd#
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000187_src-000070_op-flip1_pos-686 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000187_src-000070_op-flip1_pos-686
deleted file mode 100644
index 7f8fc72d..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000187_src-000070_op-flip1_pos-686
+++ /dev/null
@@ -1,4 +0,0 @@
-{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":9 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?a0�G�l�w#�g�:���N�ҐI^��Y��O��n�~X���j�o��P��p�":� ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":9 ,"��83622040����Nkikkkkkkk�R��n�~X���j�o��P��p�":9}�Zd#
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000189_src-000070_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000189_src-000070_op-havoc_rep-32
deleted file mode 100644
index 92c974f8..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000189_src-000070_op-havoc_rep-32
+++ /dev/null
@@ -1,3 +0,0 @@
-{"v�0�d�:P��
V�h
Pu_I�B����AƿX�{?�Y��O��n�~X���j�o��P��p111111111111111111111111�ѬTO'2�E�O���	d���G@w��Y�WZ$�Y(1�=y�=#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k���
��.�b���~��40����Nkkkk�kkkk�R��v��5x� �뱝08673586266809954039-P��p�":{"v�0�d�:P��
V�h
PWZ$�Y(1�=y�=#i�x��*,�Du_I�B����AƿX�{?a0�G�l�w#�g�:R��v��5I^��Y����836220t��Q�
-
����TO'2�E�O���	d���@@w��ڢ���bY'�Y(1�=y�#i�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-��q�o�k�����.b���~��40����Nkkkkkkkkk�R��v
����TO'2�E�O���	d�0�d�:P��dV�g�Pu_I�B�O��n�~X���a�����L-;�w#�g�:���^�ҐIq��Y��O��n�~X���j�o��P��p�"99 ,"��836220t��Q�
-
����TO'2�E�O���	d���@@w��Y�WZ$�Y(1�=y�=#e�x��*,�D��ڢ���bY'E�č�2}#�'�Ja�����L-;r]��q�o�k�����.�b���~��40����Nkkkkkkkkk�R��v��5�� �뱝08673586266809954039-P��p�":9 G"��83622040����Nkikkkkkkk�R��T�mX���j�o��P��p�":9}�Zd#
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000190_src-000070_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000190_src-000070_op-havoc_rep-64
deleted file mode 100644
index 788c2695..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000190_src-000070_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000193_src-000070_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000193_src-000070_op-havoc_rep-32
deleted file mode 100644
index ccc22dad..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000193_src-000070_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000194_src-000070_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000194_src-000070_op-havoc_rep-32
deleted file mode 100644
index 6a2d83df..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000194_src-000070_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000195_src-000070_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000195_src-000070_op-havoc_rep-64
deleted file mode 100644
index a71635c2..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000195_src-000070_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000196_src-000102_op-flip1_pos-52 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000196_src-000102_op-flip1_pos-52
deleted file mode 100644
index 2392a355..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000196_src-000102_op-flip1_pos-52 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000197_src-000102_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000197_src-000102_op-havoc_rep-16
deleted file mode 100644
index c1f389b7..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000197_src-000102_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000199_src-000104_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000199_src-000104_op-havoc_rep-4
deleted file mode 100644
index f22acca2..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000199_src-000104_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-"<�#>4�\"@>4�\"\""
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000200_src-000110_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000200_src-000110_op-havoc_rep-2
deleted file mode 100644
index 0e439e61..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000200_src-000110_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-"4U1\u1471\u1471\u1471\u1471\u1471\u1471\u1471#



��������

�N�\u1471\u1471?u1471\u1471\u1471\u1471\u
\u\
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000203_src-000114_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000203_src-000114_op-havoc_rep-32
deleted file mode 100644
index d062943f..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000203_src-000114_op-havoc_rep-32
+++ /dev/null
@@ -1 +0,0 @@
-"\u
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000204_src-000114_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000204_src-000114_op-havoc_rep-4
deleted file mode 100644
index 30a08576..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000204_src-000114_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-"i���<����N�\u1471\u1471\\Z4�#��-5�)S��57���Vg
���������



�




A
ظ7i���<����N�\u1471\u1471\\ZB47N\u1471\d
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000205_src-000149_op-arith8_pos-210_val--6 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000205_src-000149_op-arith8_pos-210_val--6
deleted file mode 100644
index a893376f..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000205_src-000149_op-arith8_pos-210_val--6 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000206_src-000149_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000206_src-000149_op-havoc_rep-32
deleted file mode 100644
index 8937e859..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000206_src-000149_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000207_src-000151_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000207_src-000151_op-havoc_rep-2
deleted file mode 100644
index e9c625b8..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000207_src-000151_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-[7.3,7..
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000208_src-000172_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000208_src-000172_op-havoc_rep-8
deleted file mode 100644
index 3ad291c9..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000208_src-000172_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000209_src-000172_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000209_src-000172_op-havoc_rep-8
deleted file mode 100644
index 881c3d74..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000209_src-000172_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000210_src-000180_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000210_src-000180_op-havoc_rep-4
deleted file mode 100644
index 7f88af8d..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000210_src-000180_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000211_src-000180_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000211_src-000180_op-havoc_rep-16
deleted file mode 100644
index d49733e0..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000211_src-000180_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000212_src-000018_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000212_src-000018_op-havoc_rep-8
deleted file mode 100644
index 22123993..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000212_src-000018_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[w[[[[[[[[[[[[[����[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[+[+[
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000214_src-000025_op-arith8_pos-5_val--9 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000214_src-000025_op-arith8_pos-5_val--9
deleted file mode 100644
index 3f05825e..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000214_src-000025_op-arith8_pos-5_val--9
+++ /dev/null
@@ -1 +0,0 @@
--10.0089898414813184
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000215_src-000067_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000215_src-000067_op-havoc_rep-4
deleted file mode 100644
index d817d8a2..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000215_src-000067_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-{                                                                                                             ,
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000217_src-000095_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000217_src-000095_op-havoc_rep-16
deleted file mode 100644
index 9b3150c8..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000217_src-000095_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000223_src-000095_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000223_src-000095_op-havoc_rep-128
deleted file mode 100644
index e4bcfffa..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000223_src-000095_op-havoc_rep-128
+++ /dev/null
@@ -1 +0,0 @@
-































































\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000224_src-000121_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000224_src-000121_op-havoc_rep-4
deleted file mode 100644
index 758198ce..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000224_src-000121_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000226_src-000121_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000226_src-000121_op-havoc_rep-64
deleted file mode 100644
index e5682522..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000226_src-000121_op-havoc_rep-64
+++ /dev/null
@@ -1 +0,0 @@
-

































































































































7Y
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000227_src-000121_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000227_src-000121_op-havoc_rep-16
deleted file mode 100644
index e69de29b..00000000
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000228_src-000227_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000228_src-000227_op-havoc_rep-4
deleted file mode 100644
index 3bd5e62a..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000228_src-000227_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-"4�#��-���\\\\\\\\\\\\�\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\1\u1471�au41wu
\u\
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000229_src-000227_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000229_src-000227_op-havoc_rep-8
deleted file mode 100644
index 4fc68d24..00000000
--- a/fuzz/hfuzz_input/deserialize_decimal/input/id-000229_src-000227_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
---------------------------------------------------------------------------------------------------------------------------------"�#��--b\
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000230_src-000015_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000230_src-000015_op-havoc_rep-128
deleted file mode 100644
index 2a3a092c..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000230_src-000015_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_decimal/input/id-000231_src-000015_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_decimal/input/id-000231_src-000015_op-havoc_rep-16
deleted file mode 100644
index 49334343..00000000
Binary files a/fuzz/hfuzz_input/deserialize_decimal/input/id-000231_src-000015_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/091c677536b4cdd0e0933edcb2f53213.00001d71.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/091c677536b4cdd0e0933edcb2f53213.00001d71.honggfuzz.cov
deleted file mode 100644
index e9dc8e0a..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/091c677536b4cdd0e0933edcb2f53213.00001d71.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/0ee00000000000000ee0000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/0ee00000000000000ee0000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 8b137891..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/0ee00000000000000ee0000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/19d007141504156035041504277019d0.00000007.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/19d007141504156035041504277019d0.00000007.honggfuzz.cov
deleted file mode 100644
index 5b75d83f..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/19d007141504156035041504277019d0.00000007.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/2d897328aaf93f1998dd6bca1836848d.00000441.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/2d897328aaf93f1998dd6bca1836848d.00000441.honggfuzz.cov
deleted file mode 100644
index 385601a9..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/2d897328aaf93f1998dd6bca1836848d.00000441.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/3e1e013000000000210e1e2000000000.00000003.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/3e1e013000000000210e1e2000000000.00000003.honggfuzz.cov
deleted file mode 100644
index 78d83348..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/3e1e013000000000210e1e2000000000.00000003.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-9..
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/4da14ef30de3322fc98aef037a303e0d.00000018.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/4da14ef30de3322fc98aef037a303e0d.00000018.honggfuzz.cov
deleted file mode 100644
index 6b2f926d..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/4da14ef30de3322fc98aef037a303e0d.00000018.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-0.6607817016591206817018
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/598a5e032ede3ed1662401c66f5611e0.0000049c.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/598a5e032ede3ed1662401c66f5611e0.0000049c.honggfuzz.cov
deleted file mode 100644
index 228534aa..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/598a5e032ede3ed1662401c66f5611e0.0000049c.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/7c75552e500000004e65551c40000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/7c75552e500000004e65551c40000000.00000004.honggfuzz.cov
deleted file mode 100644
index b20c53d8..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/7c75552e500000004e65551c40000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{""\
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/7d8828500000000078282df000000000.00000003.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/7d8828500000000078282df000000000.00000003.honggfuzz.cov
deleted file mode 100644
index 8e493586..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/7d8828500000000078282df000000000.00000003.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[[]
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/8b3e1a5bccf16edc5fc472cc6a059ac8.00000b21.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/8b3e1a5bccf16edc5fc472cc6a059ac8.00000b21.honggfuzz.cov
deleted file mode 100644
index 0f100ab9..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/8b3e1a5bccf16edc5fc472cc6a059ac8.00000b21.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/bfa25b5017821f0f58530174be1fff90.000001c9.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/bfa25b5017821f0f58530174be1fff90.000001c9.honggfuzz.cov
deleted file mode 100644
index 0ff40951..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/bfa25b5017821f0f58530174be1fff90.000001c9.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/d6cfbe4b90ca21e2b1092f4ff8a52983.00000092.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/d6cfbe4b90ca21e2b1092f4ff8a52983.00000092.honggfuzz.cov
deleted file mode 100644
index 2a5a74f8..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/d6cfbe4b90ca21e2b1092f4ff8a52983.00000092.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/ecfae34af81663d62f734894509973be.0000001e.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/ecfae34af81663d62f734894509973be.0000001e.honggfuzz.cov
deleted file mode 100644
index b750fcbc..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/ecfae34af81663d62f734894509973be.0000001e.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":-3,"":3,"":-3,"":3,S
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/ee6ca66fbfb43256b2b02562b261e566.00000473.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/ee6ca66fbfb43256b2b02562b261e566.00000473.honggfuzz.cov
deleted file mode 100644
index 083654a5..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/ee6ca66fbfb43256b2b02562b261e566.00000473.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000001_orig-003cdbfcf00000003cdbfcf000000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000001_orig-003cdbfcf00000003cdbfcf000000000.00000004.honggfuzz.cov
deleted file mode 100644
index 4a167fc3..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000001_orig-003cdbfcf00000003cdbfcf000000000.00000004.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000002_orig-004bbe1bbe5000004e1bbe1bf0000000.00000005.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000002_orig-004bbe1bbe5000004e1bbe1bf0000000.00000005.honggfuzz.cov
deleted file mode 100644
index afcb0c48..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000002_orig-004bbe1bbe5000004e1bbe1bf0000000.00000005.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{}{}
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000003_orig-007d8dde1828500078287e1d8df00000.00000006.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000003_orig-007d8dde1828500078287e1d8df00000.00000006.honggfuzz.cov
deleted file mode 100644
index b78de4c3..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000003_orig-007d8dde1828500078287e1d8df00000.00000006.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000005_orig-0ac5552e500000004e65556af0000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000005_orig-0ac5552e500000004e65556af0000000.00000004.honggfuzz.cov
deleted file mode 100644
index 3550ddb7..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000005_orig-0ac5552e500000004e65556af0000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{""
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000006_orig-0adbc000000000002bcaf00000000000.00000002.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000006_orig-0adbc000000000002bcaf00000000000.00000002.honggfuzz.cov
deleted file mode 100644
index be162472..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000006_orig-0adbc000000000002bcaf00000000000.00000002.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-4
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000009_orig-134ec2407d3c5889df6cf9e04424cff3.000008d7.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000009_orig-134ec2407d3c5889df6cf9e04424cff3.000008d7.honggfuzz.cov
deleted file mode 100644
index cbb65b8f..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000009_orig-134ec2407d3c5889df6cf9e04424cff3.000008d7.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[[]]�326
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000011_orig-20a0be0130000000210e00a080000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000011_orig-20a0be0130000000210e00a080000000.00000004.honggfuzz.cov
deleted file mode 100644
index d477568d..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000011_orig-20a0be0130000000210e00a080000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-9.88
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000012_orig-20be013000000000210e008000000000.00000003.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000012_orig-20be013000000000210e008000000000.00000003.honggfuzz.cov
deleted file mode 100644
index 5a00ea9c..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000012_orig-20be013000000000210e008000000000.00000003.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-9.8
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000014_orig-23d5552e500000004e655543e0000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000014_orig-23d5552e500000004e655543e0000000.00000004.honggfuzz.cov
deleted file mode 100644
index 17d04514..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000014_orig-23d5552e500000004e655543e0000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"":
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000015_orig-2bb8500000000000787bc00000000000.00000002.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000015_orig-2bb8500000000000787bc00000000000.00000002.honggfuzz.cov
deleted file mode 100644
index 57efe083..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000015_orig-2bb8500000000000787bc00000000000.00000002.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[4
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000016_orig-2bfd69685000000078792d6bc0000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000016_orig-2bfd69685000000078792d6bc0000000.00000004.honggfuzz.cov
deleted file mode 100644
index 8703a157..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000016_orig-2bfd69685000000078792d6bc0000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[7,4
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000017_orig-2c9c9d2c8e013000210e0c9d2c9cb000.00000006.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000017_orig-2c9c9d2c8e013000210e0c9d2c9cb000.00000006.honggfuzz.cov
deleted file mode 100644
index f20a46ab..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000017_orig-2c9c9d2c8e013000210e0c9d2c9cb000.00000006.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-9.1011
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000018_orig-2d2bebebc00000002bebebed00000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000018_orig-2d2bebebc00000002bebebed00000000.00000004.honggfuzz.cov
deleted file mode 100644
index a569be7e..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000018_orig-2d2bebebc00000002bebebed00000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-4440
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000020_orig-2e4177c00000000047e11e6000000000.00000003.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000020_orig-2e4177c00000000047e11e6000000000.00000003.honggfuzz.cov
deleted file mode 100644
index 3bf14bc8..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000020_orig-2e4177c00000000047e11e6000000000.00000003.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-t92
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000021_orig-2e494d4cf00000003cad593e60000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000021_orig-2e494d4cf00000003cad593e60000000.00000004.honggfuzz.cov
deleted file mode 100644
index 206cc257..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000021_orig-2e494d4cf00000003cad593e60000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
--e72
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000022_orig-32100000000000003210000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000022_orig-32100000000000003210000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index ad2823b4..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000022_orig-32100000000000003210000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-'
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000023_orig-36000000000000003600000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000023_orig-36000000000000003600000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 0519ecba..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000023_orig-36000000000000003600000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
- 
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000025_orig-393b5bebc00000002bebab4950000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000025_orig-393b5bebc00000002bebab4950000000.00000004.honggfuzz.cov
deleted file mode 100644
index 61ff7db5..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000025_orig-393b5bebc00000002bebab4950000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-44E+
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000027_orig-44772822d5bcd735bd3496d55c266f39.00001e09.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000027_orig-44772822d5bcd735bd3496d55c266f39.00001e09.honggfuzz.cov
deleted file mode 100644
index 0a5c28ef..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000027_orig-44772822d5bcd735bd3496d55c266f39.00001e09.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000028_orig-4a301bea76c496cbe93fc11d316243a8.00000025.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000028_orig-4a301bea76c496cbe93fc11d316243a8.00000025.honggfuzz.cov
deleted file mode 100644
index 924623b4..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000028_orig-4a301bea76c496cbe93fc11d316243a8.00000025.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":{"":-3,"":{"":-3,"":-39}z�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000029_orig-4e500000000000004e50000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000029_orig-4e500000000000004e50000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 81750b96..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000029_orig-4e500000000000004e50000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000031_orig-531aecc7a327406fbc818647b2747231.00000332.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000031_orig-531aecc7a327406fbc818647b2747231.00000332.honggfuzz.cov
deleted file mode 100644
index 58200562..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000031_orig-531aecc7a327406fbc818647b2747231.00000332.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000033_orig-5fa00000000000005fa0000000000000.00000001.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000033_orig-5fa00000000000005fa0000000000000.00000001.honggfuzz.cov
deleted file mode 100644
index 4d1ae35b..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000033_orig-5fa00000000000005fa0000000000000.00000001.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-f
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000034_orig-6618a9cb08e58ca994025c6b5884b728.000002a6.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000034_orig-6618a9cb08e58ca994025c6b5884b728.000002a6.honggfuzz.cov
deleted file mode 100644
index dd38eefa..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000034_orig-6618a9cb08e58ca994025c6b5884b728.000002a6.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000035_orig-6b1f7658418934df57e359338f3d17b4.0000075c.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000035_orig-6b1f7658418934df57e359338f3d17b4.0000075c.honggfuzz.cov
deleted file mode 100644
index f1759044..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000035_orig-6b1f7658418934df57e359338f3d17b4.0000075c.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":{"":-3,"":{"":-3,"":-39}}}1L�2
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000037_orig-6b6848a2730c22267bf9d90037a40bfe.00000441.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000037_orig-6b6848a2730c22267bf9d90037a40bfe.00000441.honggfuzz.cov
deleted file mode 100644
index e8cdef7b..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000037_orig-6b6848a2730c22267bf9d90037a40bfe.00000441.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000042_orig-7c834de7a99556aff16ff256ddf39c78.0000009a.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000042_orig-7c834de7a99556aff16ff256ddf39c78.0000009a.honggfuzz.cov
deleted file mode 100644
index 80ffdd2a..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000042_orig-7c834de7a99556aff16ff256ddf39c78.0000009a.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"":""p�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000045_orig-7dde18285000000078287e1df0000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000045_orig-7dde18285000000078287e1df0000000.00000004.honggfuzz.cov
deleted file mode 100644
index 7cd359c2..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000045_orig-7dde18285000000078287e1df0000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[[2]
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000049_orig-8d5edcf0000000003cfe6d5000000000.00000003.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000049_orig-8d5edcf0000000003cfe6d5000000000.00000003.honggfuzz.cov
deleted file mode 100644
index 9c3a6bc1..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000049_orig-8d5edcf0000000003cfe6d5000000000.00000003.honggfuzz.cov
+++ /dev/null
@@ -1,2 +0,0 @@
--
-�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000052_orig-93dbf628a000000028962b53f0000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000052_orig-93dbf628a000000028962b53f0000000.00000004.honggfuzz.cov
deleted file mode 100644
index 5f6f4ce9..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000052_orig-93dbf628a000000028962b53f0000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-6 4�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000054_orig-9e2ff69a90c666a7063d85e22473fb79.00000012.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000054_orig-9e2ff69a90c666a7063d85e22473fb79.00000012.honggfuzz.cov
deleted file mode 100644
index 25402ed0..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000054_orig-9e2ff69a90c666a7063d85e22473fb79.00000012.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"":{}}:��}}
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000056_orig-a8f294d39b025d6f3e7b21a5d442ed75.0000000d.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000056_orig-a8f294d39b025d6f3e7b21a5d442ed75.0000000d.honggfuzz.cov
deleted file mode 100644
index 3de3f0ec..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000056_orig-a8f294d39b025d6f3e7b21a5d442ed75.0000000d.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":-39
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000057_orig-a8f73f40773f1bb509a83cddc7672957.00000015.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000057_orig-a8f73f40773f1bb509a83cddc7672957.00000015.honggfuzz.cov
deleted file mode 100644
index d0f7bbff..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000057_orig-a8f73f40773f1bb509a83cddc7672957.00000015.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
--3521667332658478285,
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000058_orig-b033c968500000007879335010000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000058_orig-b033c968500000007879335010000000.00000004.honggfuzz.cov
deleted file mode 100644
index 1cb727e1..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000058_orig-b033c968500000007879335010000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-[7:�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000059_orig-b3644d6846422333e6651c8ae420b443.00000012.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000059_orig-b3644d6846422333e6651c8ae420b443.00000012.honggfuzz.cov
deleted file mode 100644
index 37a05fa8..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000059_orig-b3644d6846422333e6651c8ae420b443.00000012.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000064_orig-c4cf70f203705977ad13bc992ac28e5e.0000159e.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000064_orig-c4cf70f203705977ad13bc992ac28e5e.0000159e.honggfuzz.cov
deleted file mode 100644
index 996e6a9b..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000064_orig-c4cf70f203705977ad13bc992ac28e5e.0000159e.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":-39}z�S[
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000065_orig-ced1987ddea38cce8a3955f7dc3f6600.00001895.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000065_orig-ced1987ddea38cce8a3955f7dc3f6600.00001895.honggfuzz.cov
deleted file mode 100644
index 2aeac383..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000065_orig-ced1987ddea38cce8a3955f7dc3f6600.00001895.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-9.660739332658478285,�\n
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000069_orig-e05663d17cebb565f03a6cbab766ff92.00000014.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000069_orig-e05663d17cebb565f03a6cbab766ff92.00000014.honggfuzz.cov
deleted file mode 100644
index 6e97d15f..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000069_orig-e05663d17cebb565f03a6cbab766ff92.00000014.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000070_orig-e28c4e864c2dbaea77f8c3c28daaeedd.00000047.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000070_orig-e28c4e864c2dbaea77f8c3c28daaeedd.00000047.honggfuzz.cov
deleted file mode 100644
index 4e165140..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000070_orig-e28c4e864c2dbaea77f8c3c28daaeedd.00000047.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000071_orig-ec2fb20e1a37aadffb3f2b5914bf3678.00000048.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000071_orig-ec2fb20e1a37aadffb3f2b5914bf3678.00000048.honggfuzz.cov
deleted file mode 100644
index 1441ff5d..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000071_orig-ec2fb20e1a37aadffb3f2b5914bf3678.00000048.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000074_orig-f49e0b5a700000002a1b5e94b0000000.00000004.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000074_orig-f49e0b5a700000002a1b5e94b0000000.00000004.honggfuzz.cov
deleted file mode 100644
index 7c81cee5..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000074_orig-f49e0b5a700000002a1b5e94b0000000.00000004.honggfuzz.cov
+++ /dev/null
@@ -1 +0,0 @@
-5E2�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000075_orig-f6546e628a7644857fe5143a8a438bb4.00000141.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000075_orig-f6546e628a7644857fe5143a8a438bb4.00000141.honggfuzz.cov
deleted file mode 100644
index 842ef770..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000075_orig-f6546e628a7644857fe5143a8a438bb4.00000141.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000076_orig-fce0f4557885f35c7f2568ce9c36c826.00000dcc.honggfuzz.cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000076_orig-fce0f4557885f35c7f2568ce9c36c826.00000dcc.honggfuzz.cov
deleted file mode 100644
index 87283e5a..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000076_orig-fce0f4557885f35c7f2568ce9c36c826.00000dcc.honggfuzz.cov and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000078_src-000000_op-arith8_pos-3_val-+34 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000078_src-000000_op-arith8_pos-3_val-+34
deleted file mode 100644
index 2d201497..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000078_src-000000_op-arith8_pos-3_val-+34
+++ /dev/null
@@ -1 +0,0 @@
-"N"
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000079_src-000000_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000079_src-000000_op-havoc_rep-2
deleted file mode 100644
index a311f3a9..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000079_src-000000_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-"NN�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000080_src-000000_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000080_src-000000_op-havoc_rep-16
deleted file mode 100644
index 708a8853..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000080_src-000000_op-havoc_rep-16
+++ /dev/null
@@ -1 +0,0 @@
-"P5@555%5
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000082_src-000000_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000082_src-000000_op-havoc_rep-64
deleted file mode 100644
index 991aa1a5..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000082_src-000000_op-havoc_rep-64
+++ /dev/null
@@ -1 +0,0 @@
-    
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000083_src-000000_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000083_src-000000_op-havoc_rep-32
deleted file mode 100644
index 0aff809b..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000083_src-000000_op-havoc_rep-32
+++ /dev/null
@@ -1 +0,0 @@
-9.
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000086_src-000000_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000086_src-000000_op-havoc_rep-16
deleted file mode 100644
index 5ed6c9d1..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000086_src-000000_op-havoc_rep-16
+++ /dev/null
@@ -1 +0,0 @@
-

\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000088_src-000000_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000088_src-000000_op-havoc_rep-128
deleted file mode 100644
index 0597d13d..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000088_src-000000_op-havoc_rep-128
+++ /dev/null
@@ -1 +0,0 @@
-














\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000090_src-000000_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000090_src-000000_op-havoc_rep-8
deleted file mode 100644
index 34cefe37..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000090_src-000000_op-havoc_rep-8
+++ /dev/null
@@ -1,6 +0,0 @@
-
-
-
-
-
-"
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000091_src-000000_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000091_src-000000_op-havoc_rep-4
deleted file mode 100644
index ecdaac08..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000091_src-000000_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000094_src-000000_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000094_src-000000_op-havoc_rep-2
deleted file mode 100644
index 8e35157e..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000094_src-000000_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000095_src-000000_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000095_src-000000_op-havoc_rep-8
deleted file mode 100644
index 8e6472d5..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000095_src-000000_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-[[[[[[[[[[[
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000096_src-000000_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000096_src-000000_op-havoc_rep-128
deleted file mode 100644
index b0fcb7b4..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000096_src-000000_op-havoc_rep-128
+++ /dev/null
@@ -1 +0,0 @@
-





























�














\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000097_src-000000_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000097_src-000000_op-havoc_rep-128
deleted file mode 100644
index af756f67..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000097_src-000000_op-havoc_rep-128
+++ /dev/null
@@ -1 +0,0 @@
-66666666666666666666666666666666
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000098_src-000000_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000098_src-000000_op-havoc_rep-32
deleted file mode 100644
index b28b04f6..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000098_src-000000_op-havoc_rep-32
+++ /dev/null
@@ -1,3 +0,0 @@
-
-
-
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000099_src-000000_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000099_src-000000_op-havoc_rep-16
deleted file mode 100644
index 16b8c2c7..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000099_src-000000_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000100_src-000000_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000100_src-000000_op-havoc_rep-128
deleted file mode 100644
index 1aa5bb46..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000100_src-000000_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000101_src-000000_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000101_src-000000_op-havoc_rep-64
deleted file mode 100644
index 1f240327..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000101_src-000000_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000103_src-000000_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000103_src-000000_op-havoc_rep-16
deleted file mode 100644
index 92971a2f..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000103_src-000000_op-havoc_rep-16
+++ /dev/null
@@ -1 +0,0 @@
-[[[[[[[
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000105_src-000000_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000105_src-000000_op-havoc_rep-128
deleted file mode 100644
index 7141e096..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000105_src-000000_op-havoc_rep-128
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000106_src-000000_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000106_src-000000_op-havoc_rep-16
deleted file mode 100644
index ef939988..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000106_src-000000_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000112_src-000003_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000112_src-000003_op-havoc_rep-4
deleted file mode 100644
index d8555012..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000112_src-000003_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000113_src-000003_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000113_src-000003_op-havoc_rep-2
deleted file mode 100644
index ab475a04..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000113_src-000003_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000116_src-000003_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000116_src-000003_op-havoc_rep-8
deleted file mode 100644
index e976d76f..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000116_src-000003_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000117_src-000003_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000117_src-000003_op-havoc_rep-128
deleted file mode 100644
index a6cd9e56..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000117_src-000003_op-havoc_rep-128
+++ /dev/null
@@ -1 +0,0 @@
-nuu�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000121_src-000007_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000121_src-000007_op-havoc_rep-2
deleted file mode 100644
index 3747b796..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000121_src-000007_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-9.4660739
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000122_src-000007_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000122_src-000007_op-havoc_rep-2
deleted file mode 100644
index cafa222b..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000122_src-000007_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-9.663333333333307,9
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000123_src-000007_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000123_src-000007_op-havoc_rep-8
deleted file mode 100644
index 0952686a..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000123_src-000007_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-9eee��
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000124_src-000011_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000124_src-000011_op-havoc_rep-16
deleted file mode 100644
index e8f4dd31..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000124_src-000011_op-havoc_rep-16
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000125_src-000013_op-flip1_pos-1 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000125_src-000013_op-flip1_pos-1
deleted file mode 100644
index 34411686..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000125_src-000013_op-flip1_pos-1 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000130_src-000013_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000130_src-000013_op-havoc_rep-32
deleted file mode 100644
index bb262726..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000130_src-000013_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000131_src-000013_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000131_src-000013_op-havoc_rep-8
deleted file mode 100644
index 72938110..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000131_src-000013_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000134_src-000013_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000134_src-000013_op-havoc_rep-2
deleted file mode 100644
index 3f69021b..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000134_src-000013_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000135_src-000014_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000135_src-000014_op-havoc_rep-2
deleted file mode 100644
index ec3a7ee7..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000135_src-000014_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-{"":{1":
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000136_src-000016_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000136_src-000016_op-havoc_rep-2
deleted file mode 100644
index 75d1370d..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000136_src-000016_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-[777,7,4
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000137_src-000019_op-arith8_pos-249_val--14 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000137_src-000019_op-arith8_pos-249_val--14
deleted file mode 100644
index 7c8880bc..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000137_src-000019_op-arith8_pos-249_val--14 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000138_src-000019_op-arith8_pos-697_val-+10 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000138_src-000019_op-arith8_pos-697_val-+10
deleted file mode 100644
index 4a66b7f2..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000138_src-000019_op-arith8_pos-697_val-+10 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000139_src-000025_op-arith8_pos-0_val--7 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000139_src-000025_op-arith8_pos-0_val--7
deleted file mode 100644
index 0f414922..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000139_src-000025_op-arith8_pos-0_val--7
+++ /dev/null
@@ -1 +0,0 @@
--4E+
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000140_src-000025_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000140_src-000025_op-havoc_rep-4
deleted file mode 100644
index 0ec527f3..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000140_src-000025_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-44E++4H+
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000143_src-000031_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000143_src-000031_op-havoc_rep-128
deleted file mode 100644
index 608a7b7a..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000143_src-000031_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000144_src-000031_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000144_src-000031_op-havoc_rep-128
deleted file mode 100644
index 994527c6..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000144_src-000031_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000153_src-000035_op-flip1_pos-35 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000153_src-000035_op-flip1_pos-35
deleted file mode 100644
index e3c5084a..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000153_src-000035_op-flip1_pos-35
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":{"":-3,"":{"":-3,"":-39}}�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000156_src-000035_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000156_src-000035_op-havoc_rep-2
deleted file mode 100644
index c7e6b5bb..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000156_src-000035_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":-3,"":-39}1L�2
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000158_src-000035_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000158_src-000035_op-havoc_rep-2
deleted file mode 100644
index 42242393..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000158_src-000035_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":{"":-3,"":{"":-3,"":{"":-B,"":"":{"":-B,"":-39}}}1L�2
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000159_src-000035_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000159_src-000035_op-havoc_rep-32
deleted file mode 100644
index 3951e677..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000159_src-000035_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000160_src-000035_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000160_src-000035_op-havoc_rep-4
deleted file mode 100644
index f3dde8b5..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000160_src-000035_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
---------2
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000161_src-000037_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000161_src-000037_op-havoc_rep-8
deleted file mode 100644
index b19064f3..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000161_src-000037_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000162_src-000037_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000162_src-000037_op-havoc_rep-64
deleted file mode 100644
index 860312b7..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000162_src-000037_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000163_src-000037_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000163_src-000037_op-havoc_rep-128
deleted file mode 100644
index 118ea208..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000163_src-000037_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000164_src-000046_op-flip1_pos-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000164_src-000046_op-flip1_pos-2
deleted file mode 100644
index e8f68db6..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000164_src-000046_op-flip1_pos-2
+++ /dev/null
@@ -1 +0,0 @@
-[7.4,7,4,6
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000167_src-000047_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000167_src-000047_op-havoc_rep-2
deleted file mode 100644
index 9e8d5b08..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000167_src-000047_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000168_src-000047_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000168_src-000047_op-havoc_rep-8
deleted file mode 100644
index dacbc3c1..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000168_src-000047_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000169_src-000047_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000169_src-000047_op-havoc_rep-8
deleted file mode 100644
index 99a2ce5d..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000169_src-000047_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000174_src-000053_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000174_src-000053_op-havoc_rep-2
deleted file mode 100644
index 9bc9dc68..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000174_src-000053_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000175_src-000057_op-arith8_pos-3_val--4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000175_src-000057_op-arith8_pos-3_val--4
deleted file mode 100644
index 84fa52ce..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000175_src-000057_op-arith8_pos-3_val--4
+++ /dev/null
@@ -1 +0,0 @@
--35.1667332658478285,
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000177_src-000062_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000177_src-000062_op-havoc_rep-8
deleted file mode 100644
index f41972df..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000177_src-000062_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000178_src-000062_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000178_src-000062_op-havoc_rep-4
deleted file mode 100644
index fb709cfd..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000178_src-000062_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-"N317720572651764
�D��\u4265\"N72651764
�D��\u4265\e4e4
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000179_src-000118_op-flip2_pos-3 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000179_src-000118_op-flip2_pos-3
deleted file mode 100644
index a654abb7..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000179_src-000118_op-flip2_pos-3
+++ /dev/null
@@ -1 +0,0 @@
-9.000739
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000180_src-000129_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000180_src-000129_op-havoc_rep-2
deleted file mode 100644
index 99d225d5..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000180_src-000129_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-"�
\t
\t�%��
\t
\t��
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000182_src-000130_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000182_src-000130_op-havoc_rep-2
deleted file mode 100644
index da8c9afb..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000182_src-000130_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000183_src-000130_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000183_src-000130_op-havoc_rep-16
deleted file mode 100644
index a3b5ab00..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000183_src-000130_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000185_src-000168_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000185_src-000168_op-havoc_rep-4
deleted file mode 100644
index c10dadc8..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000185_src-000168_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000186_src-000170_op-flip1_pos-64 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000186_src-000170_op-flip1_pos-64
deleted file mode 100644
index 30875ca1..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000186_src-000170_op-flip1_pos-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000188_src-000170_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000188_src-000170_op-havoc_rep-4
deleted file mode 100644
index f517cbb5..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000188_src-000170_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000189_src-000171_op-flip1_pos-95 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000189_src-000171_op-flip1_pos-95
deleted file mode 100644
index d515290a..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000189_src-000171_op-flip1_pos-95 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000190_src-000178_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000190_src-000178_op-havoc_rep-8
deleted file mode 100644
index 0f999b1f..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000190_src-000178_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000191_src-000178_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000191_src-000178_op-havoc_rep-8
deleted file mode 100644
index d9934821..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000191_src-000178_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-"N305726��\u4265\"N726\"N72665\"N7�D��\u454665\"N7�D��\u4565\e4
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000192_src-000178_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000192_src-000178_op-havoc_rep-16
deleted file mode 100644
index ae376f11..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000192_src-000178_op-havoc_rep-16
+++ /dev/null
@@ -1 +0,0 @@
-"N'3131720&6>\"
776>\"
77�0<65\"N76D��P6 \e
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000195_src-000021_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000195_src-000021_op-havoc_rep-8
deleted file mode 100644
index 336ce216..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000195_src-000021_op-havoc_rep-8
+++ /dev/null
@@ -1 +0,0 @@
-----------------------------------------��--
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000198_src-000111_op-flip2_pos-27 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000198_src-000111_op-flip2_pos-27
deleted file mode 100644
index 170f2036..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000198_src-000111_op-flip2_pos-27
+++ /dev/null
@@ -1 +0,0 @@
----------------------------0
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000200_src-000113_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000200_src-000113_op-havoc_rep-2
deleted file mode 100644
index 07e9d0a8..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000200_src-000113_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000201_src-000114_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000201_src-000114_op-havoc_rep-2
deleted file mode 100644
index a67ce703..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000201_src-000114_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-[[[]]]]]
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000202_src-000116_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000202_src-000116_op-havoc_rep-16
deleted file mode 100644
index 320c0d1c..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000202_src-000116_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000204_src-000143_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000204_src-000143_op-havoc_rep-128
deleted file mode 100644
index 61ea6f89..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000204_src-000143_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000205_src-000157_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000205_src-000157_op-havoc_rep-2
deleted file mode 100644
index 1d3030a5..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000205_src-000157_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-{"":-3,"":{"":-3,"":{"":-3,"":
-3,"":
339}},"":
339}r}1L�2}1L�2
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000206_src-000159_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000206_src-000159_op-havoc_rep-2
deleted file mode 100644
index a3f8ee24..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000206_src-000159_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000208_src-000163_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000208_src-000163_op-havoc_rep-16
deleted file mode 100644
index 5c4a5df7..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000208_src-000163_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000210_src-000171_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000210_src-000171_op-havoc_rep-4
deleted file mode 100644
index 54b60f6d..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000210_src-000171_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000211_src-000180_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000211_src-000180_op-havoc_rep-4
deleted file mode 100644
index 0217032c..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000211_src-000180_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000212_src-000193_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000212_src-000193_op-havoc_rep-4
deleted file mode 100644
index 31ef4408..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000212_src-000193_op-havoc_rep-4 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000216_src-000201_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000216_src-000201_op-havoc_rep-2
deleted file mode 100644
index 3b9f6dba..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000216_src-000201_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-[[[[]]]u
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000218_src-000201_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000218_src-000201_op-havoc_rep-2
deleted file mode 100644
index b1a91ca9..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000218_src-000201_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-[[[[[[]]]]
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000221_src-000211_op-havoc_rep-8 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000221_src-000211_op-havoc_rep-8
deleted file mode 100644
index cec86934..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000221_src-000211_op-havoc_rep-8 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000222_src-000212_op-havoc_rep-16 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000222_src-000212_op-havoc_rep-16
deleted file mode 100644
index 8e9624c2..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000222_src-000212_op-havoc_rep-16 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000224_src-000214_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000224_src-000214_op-havoc_rep-2
deleted file mode 100644
index f46de6da..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000224_src-000214_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000225_src-000219_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000225_src-000219_op-havoc_rep-128
deleted file mode 100644
index 83ff2376..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000225_src-000219_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000226_src-000220_op-flip1_pos-445 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000226_src-000220_op-flip1_pos-445
deleted file mode 100644
index bcc7a374..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000226_src-000220_op-flip1_pos-445 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000228_src-000005_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000228_src-000005_op-havoc_rep-4
deleted file mode 100644
index fa9d9adc..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000228_src-000005_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-








































































































































































































































�






















































































































































































































































































































































































\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000231_src-000029_op-havoc_rep-64 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000231_src-000029_op-havoc_rep-64
deleted file mode 100644
index 5a1b771a..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000231_src-000029_op-havoc_rep-64 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000232_src-000055_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000232_src-000055_op-havoc_rep-128
deleted file mode 100644
index 2ab95678..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000232_src-000055_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000233_src-000144_op-havoc_rep-128 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000233_src-000144_op-havoc_rep-128
deleted file mode 100644
index ca8becaa..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000233_src-000144_op-havoc_rep-128 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000234_src-000144_op-havoc_rep-32 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000234_src-000144_op-havoc_rep-32
deleted file mode 100644
index 4a079f5c..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000234_src-000144_op-havoc_rep-32 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000236_src-000203_op-havoc_rep-2_+cov b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000236_src-000203_op-havoc_rep-2_+cov
deleted file mode 100644
index 45171232..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000236_src-000203_op-havoc_rep-2_+cov
+++ /dev/null
@@ -1 +0,0 @@
-null�
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000239_src-000154_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000239_src-000154_op-havoc_rep-4
deleted file mode 100644
index e69de29b..00000000
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000240_src-000154_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000240_src-000154_op-havoc_rep-4
deleted file mode 100644
index d6e34ca2..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000240_src-000154_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-{"���{":-3,"":{"":-3,"":{"���{":-3,"":{"{":-3,"":{"":-3,"":{"���{":-3,"":{"":-3,"":{"":-3,"":-3,"":{"":-3,#":{"":-3,"":-39}}}1L""{"":-3,"":-3,"":{"":-3,"":{"":-3,""<-39}}}1L"":-3,"":{"":-3,"":-3,"":{"":-3,#":{"":-3,"":-39}}}1L""{"":-3,"":-3,"":{"":-3,"":{"":-3,"":-39}}}1L""
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000241_src-000165_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000241_src-000165_op-havoc_rep-2
deleted file mode 100644
index a43b63db..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000241_src-000165_op-havoc_rep-2
+++ /dev/null
@@ -1 +0,0 @@
-[7,4,7,[7,4,77,4,7,[7,4,7
@,
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000242_src-000165_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000242_src-000165_op-havoc_rep-4
deleted file mode 100644
index 9c3a1d52..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000242_src-000165_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-[7,4]7,[774��,@,
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000243_src-000165_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000243_src-000165_op-havoc_rep-4
deleted file mode 100644
index 68a89c87..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000243_src-000165_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-[7,437,[7E47,437,[7E4,?,@,,7,@,
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000244_src-000165_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000244_src-000165_op-havoc_rep-4
deleted file mode 100644
index 1e3b2760..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000244_src-000165_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-[7,4,4,7,[7,4,74,4,7,[7,4,7,�,4,7,@,[7,47,@,
\ No newline at end of file
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000245_src-000173_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000245_src-000173_op-havoc_rep-2
deleted file mode 100644
index ff91b19b..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000245_src-000173_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000246_src-000185_op-havoc_rep-2 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000246_src-000185_op-havoc_rep-2
deleted file mode 100644
index 040d0100..00000000
Binary files a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000246_src-000185_op-havoc_rep-2 and /dev/null differ
diff --git a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000247_src-000191_op-havoc_rep-4 b/fuzz/hfuzz_input/deserialize_udecimal/input/id-000247_src-000191_op-havoc_rep-4
deleted file mode 100644
index 98c1328a..00000000
--- a/fuzz/hfuzz_input/deserialize_udecimal/input/id-000247_src-000191_op-havoc_rep-4
+++ /dev/null
@@ -1 +0,0 @@
-"�305726��\u4265\"N726\"N72665\"N7�?����\u4265\"N726\"N72665\"N7�D��\u454665\"N7�D��\\u45 665\"N7�D��\u4565\e4
\ No newline at end of file
diff --git a/fuzz/travis-fuzz.sh b/fuzz/travis-fuzz.sh
deleted file mode 100755
index 8f699815..00000000
--- a/fuzz/travis-fuzz.sh
+++ /dev/null
@@ -1,28 +0,0 @@
-#!/bin/bash
-set -e
-
-# Check that input files are correct Windows file names
-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
-	exit 2
-fi
-
-# Testing
-cargo install --force honggfuzz
-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="--run_time 30 --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/githooks/pre-commit b/githooks/pre-commit
new file mode 100755
index 00000000..5bb2c486
--- /dev/null
+++ b/githooks/pre-commit
@@ -0,0 +1,52 @@
+#!/bin/sh
+#
+# Verify what is about to be committed. Called by "git commit" with no
+# arguments. The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=$(git hash-object -t tree /dev/null)
+fi
+
+# If you want to allow non-ASCII filenames set this variable to true.
+allownonascii=$(git config --bool hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ASCII filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	cat <<\EOF
+Error: Attempt to add a non-ASCII file name.
+
+This can cause problems if you want to work with people on other platforms.
+
+To be portable it is advisable to rename the file.
+
+If you know what you are doing you can disable this check using:
+
+  git config hooks.allownonascii true
+EOF
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+git diff-index --check --cached $against -- || exit 1
+
+# Check that code lints cleanly.
+cargo clippy --all-features -- -D warnings || exit 1
+
+# Check that there are no formatting issues.
+cargo +nightly fmt --check || exit 1
diff --git a/hashes/CHANGELOG.md b/hashes/CHANGELOG.md
new file mode 100644
index 00000000..44d52f9c
--- /dev/null
+++ b/hashes/CHANGELOG.md
@@ -0,0 +1,194 @@
+# 0.13.0 - 2023-06-29
+
+The main improvement in this version is removal of the `hex` module in favour of the new
+[`hex-conservative`](https://crates.io/crates/hex-conservative) crate (which we wrote). We also
+bumped the Minimum Supported Rust Version across the `rust-bitcoin` ecosystem to v1.48
+
+* Bump MSRV to 1.48.0 [#1729](https://github.com/rust-bitcoin/rust-bitcoin/pull/1729).
+* Depend on new `hex-conservative` crate and remove `hex` module [#1883](https://github.com/rust-bitcoin/rust-bitcoin/pull/1833).
+* Make `sha256t_hash_newtype!` evocative of the output [#1773](https://github.com/rust-bitcoin/rust-bitcoin/pull/1773).
+* Implement computing SHA256 in const context [#1769](https://github.com/rust-bitcoin/rust-bitcoin/pull/1769).
+* Add `from_bytes_ref` and `from_bytes_mut` to all hash types [#1761](https://github.com/rust-bitcoin/rust-bitcoin/pull/1761).
+* Rename `crate::Error` to `crate::FromSliceError` [#1873](https://github.com/rust-bitcoin/rust-bitcoin/pull/1873).
+* Add simd sha256 intrinsics for x86 machines [#1962](https://github.com/rust-bitcoin/rust-bitcoin/pull/1962).
+* Introduce the "small-hash" feature for `bitcoin_hashes` [#1990](https://github.com/rust-bitcoin/rust-bitcoin/pull/1990).
+
+# 0.12.0 - 2023-03-05
+
+0.12 is a significant release. We pulled the repository into the rust-bitcoin
+repo to improve our integration testing and to get more eyes on this crate. We
+began the process of replacing the hex functionality in this crate with a more
+performant, dedicated crate, and otherwise cleaning up the API as we look forward
+to 1.0.
+
+* [Remove `FromHex` implementation](https://github.com/rust-bitcoin/rust-bitcoin/pull/1565/commits/a308e1e2ea5c6ae419d961b8da71cc8a35a92715)
+from all hashes and implement `FromStr` instead.
+* Move crate from [original repo](https://github.com/rust-bitcoin/bitcoin_hashes) to the
+`rust-bitcoin` repository. Commit history was lost during move, for commit history see the original
+repository. Tip of bitcoin_hashes:master at time of import: 54c16249e06cc6b7870c7fc07d90f489d82647c7
+* [Remove `Deref` impls for all hashes](https://github.com/rust-bitcoin/rust-bitcoin/pull/1450)
+* [Add `AsRef` impls for all hashes from fixed-size arrays](https://github.com/rust-bitcoin/rust-bitcoin/pull/1593)
+* [Add the `sha512_256` hash](https://github.com/rust-bitcoin/rust-bitcoin/pull/1413)
+* [Remove the `ToHex` trait in favor of `DisplayHex` and `fmt::Display`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1531)
+* [Remove the now-unused `HexWriter` object](https://github.com/rust-bitcoin/rust-bitcoin/pull/1572)
+* [nostd: `alloc` feature no longer enables `core2`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1612)
+* [Rewrite `hash_newtype` macro with new syntax](https://github.com/rust-bitcoin/rust-bitcoin/pull/1659)
+* [Rename `Hash::Inner` to `Hash::Bytes`, 'Hash::*_inner` and several related conversion methods](https://github.com/rust-bitcoin/rust-bitcoin/pull/1577)
+
+
+# 0.11.0 - 2022-06-25
+
+The major change in this version is the increase of the Minimum Supported Rust Version (MSRV) from
+1.29 to 1.41.1. This is a big change because it introduces Rust Edition 2018 to the codebase along
+with all the benefits that brings. We also did a bunch of optimisations to speed up encoding and
+decoding hex strings.
+
+## Breaking changes
+
+* [Enable edition 2018 and bump MSRV to Rust 1.41.1](https://github.com/rust-bitcoin/bitcoin_hashes/pull/136)
+
+## New features/APIs
+
+* [Add `all_zeros` to `Hash` trait](https://github.com/rust-bitcoin/bitcoin_hashes/pull/148)
+* [Implement `Write` on `HmacEngine`](https://github.com/rust-bitcoin/bitcoin_hashes/pull/133)
+* [Introduce `HexWriter`](https://github.com/rust-bitcoin/bitcoin_hashes/pull/156), makes serialising hex faster
+* [Implement `Read` on `HexIterator`](https://github.com/rust-bitcoin/bitcoin_hashes/pull/135), makes deserialising hex faster
+
+## Other improvements
+
+* Use `rotate_left` [instead of custom macro](https://github.com/rust-bitcoin/bitcoin_hashes/pull/162)
+* [Enable clippy on CI](https://github.com/rust-bitcoin/bitcoin_hashes/pull/152)
+* Various docs fixes
+* [Improve feature test coverage](https://github.com/rust-bitcoin/bitcoin_hashes/pull/147)
+* [Add a disabled `rustfmt.toml`](https://github.com/rust-bitcoin/bitcoin_hashes/pull/141) to improve interaction with auto-formatting in editors
+
+
+# 0.10.0 - 2021-07-05
+
+* Increase `core2` to released version of 0.3.0
+
+# 0.9.7 - 2021-06-17
+
+* Introduce `alloc` feature and `core2` dependency for nostd support (this feature has MSRV of 1.36 rather than 1.29)
+
+# 0.9.6 - 2021-05-03
+
+* Re-export `core` as `_export::_core`. This resolves an issue when calling several exported macros with the `std` feature.
+
+# 0.9.5 - 2021-04-28
+
+* Add [`#[repr(transparent)]` to all newtype wrappers](https://github.com/rust-bitcoin/bitcoin_hashes/pull/108/)
+* Add [missing `#derive`s](https://github.com/rust-bitcoin/bitcoin_hashes/pull/110/)
+* Replace `fuzztarget` feature with [use of `cfg(fuzzing)`](https://github.com/rust-bitcoin/bitcoin_hashes/pull/111/)
+* Use [`core` rather than `std`](https://github.com/rust-bitcoin/bitcoin_hashes/pull/118/) and [fix `no_std` compilation](https://github.com/rust-bitcoin/bitcoin_hashes/pull/122/)
+
+Note that we have stopped re-exporting the `core` crate when compiling without `std`. This is technically a breaking change but it is hard to imagine what user might be affected.
+
+# 0.9.4 - 2020-10-23
+
+* Add `Hmac::from_inner_engines`
+
+# 0.9.3 - 2020-10-19
+
+* More serde macro fixes
+
+# 0.9.2 - 2020-10-18
+
+* Fix rustc 1.29.0 downstream issues with serde macros
+
+# 0.9.2 - 2020-10-16
+
+* Fix visibility issue with serde macros
+
+# 0.9.1 - 2020-10-07
+
+* Add `FromStr` impl to `sha256t::Hash`
+* Fix `Hash::engine()` implementation for hash newtypes
+* Add `sha256t_hash_newtype!` macro for creating tagged hashes
+
+# 0.9.0 - 2020-08-27
+
+* **Update MSRV to 1.29.0**
+
+# 0.8.0 - 2020-08-26
+
+* Add `as_inner` method to `Hash` trait
+* Add `n_bytes_hashed` to `HashEngine` trait
+
+# 0.7.6 - 2020-04-05
+
+* Support hash newtypes with reversed hex serialization.
+
+# 0.7.5 - 2020-04-02
+
+* Add `sha256t` module for SHA-256-based tagged hashes.
+* Add `FromStr` for hash newtypes.
+* Add `from_hash` for hash newtypes.
+
+# 0.7.3 - 2019-12-18
+
+* Add `as_hash(&self) -> <inner>` method to hash newtypes.
+
+# 0.7.2 - 2019-11-29
+
+* Make the inner variable of `sha256::Midstat` public
+* Drop the `byteorder` dependency in favor of manual endianness implementations
+(later this will be in stdlib so we can drop even that)
+* Fix the `hash_newtype` macro, which did not compile before
+
+# 0.7.1 - 2019-08-14
+
+* Add hash_newtype macro that allows third parties to create newtype structs.
+
+# 0.7.0 - 2019-07-19
+
+* Add `hex::Error` type for errors generated by the `hex` module.
+
+# 0.6.0 - 2019-07-10
+
+* Add `no_std` support, rearrange traits to not depend on `io::Write`
+
+# 0.5.0 - 2019-06-28
+
+* Fix panic when parsing hashes that contain multibyte characters
+* Add `FromStr` to all hashes which hex-parses them
+
+# 0.4.0 - 2019-06-23
+
+* [Add `from_inner` method](https://github.com/rust-bitcoin/bitcoin_hashes/pull/20) to all hashes
+* [Update `FromHex` trait](https://github.com/rust-bitcoin/bitcoin_hashes/pull/40) to require `from_byte_iter` method rather than `from_hex` be implemented
+* Make `Hmac` midstate [an actual HMAC midstate](https://github.com/rust-bitcoin/bitcoin_hashes/pull/43)
+* Allow `Display` [of truncated hashes](https://github.com/rust-bitcoin/bitcoin_hashes/pull/9)
+* Require [using a constructor for `HexIterator`](https://github.com/rust-bitcoin/bitcoin_hashes/pull/44) and then [clean up the internals](https://github.com/rust-bitcoin/bitcoin_hashes/pull/47)
+* [Strongly type `sha256::Midstate`](https://github.com/rust-bitcoin/bitcoin_hashes/pull/39) to allow independent serialization
+* Add [siphash24 module](https://github.com/rust-bitcoin/bitcoin_hashes/pull/46)
+
+# 0.3.2 - 2019-03-20
+
+* Implement the `FromHex` trait on [many more types](https://github.com/rust-bitcoin/bitcoin_hashes/pull/38)
+
+# 0.3.1 - 2019-03-04
+
+* [Fix serde serialization](https://github.com/rust-bitcoin/bitcoin_hashes/pull/36)
+
+# 0.3.0 - 2019-01-23
+
+* Bump minimum required rustc version to 1.22.0
+* Fixed serde deserialization into owned string that previously caused panics
+  when doing round-trip (de)serialization
+* `HashEngine::block_size()` and `Hash::len()` are now associated constants
+  `HashEngine::BLOCK_SIZE` and `Hash::LEN`
+* Removed `block_size()` method from `Hash` trait. It is still available as
+  `<T as Hash>::Engine::BLOCK_SIZE`
+
+# 0.2.0 - 2019-01-15
+
+* Add a constant-time comparison function
+* Simplify `io::Write::write` implementations by having them do only partial writes
+* Add fuzzing support
+* Allow `Hash`es to be borrowed as `[u8]`
+* Replace public `Hash` inners with `into_inner` method
+
+# 0.1.0 - 2018-12-08
+
+* Initial release
diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
new file mode 100644
index 00000000..8d026f80
--- /dev/null
+++ b/hashes/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "tapyrus_hashes"
+version = "0.13.0"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
+license = "MIT"
+homepage = "https://github.com/chaintope/rust-tapyrus/"
+repository = "https://github.com/chaintope/rust-tapyrus/"
+description = "Hash functions used by the rust-tapyrus eccosystem"
+categories = ["algorithms"]
+keywords = [ "crypto", "bitcoin", "hash", "digest" ]
+readme = "README.md"
+edition = "2018"
+exclude = ["tests", "contrib"]
+
+[features]
+default = ["std"]
+std = ["alloc", "hex/std"]
+alloc = ["hex/alloc"]
+serde-std = ["serde/std"]
+# If you want I/O you must enable either "std" or "core2".
+core2 = ["actual-core2", "hex/core2"]
+# Smaller (but slower) implementation of sha256, sha512 and ripemd160
+small-hash = []
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[dependencies]
+hex = { package = "hex-conservative", version = "0.1.1", default-features = false }
+
+schemars = { version = "0.8.3", optional = true }
+# Only enable this if you explicitly do not want to use "std", otherwise enable "serde-std".
+serde = { version = "1.0", default-features = false, optional = true }
+
+# Do NOT use this feature! Use the "core2" feature instead.
+actual-core2 = { package = "core2", version = "0.3.2", default-features = false, optional = true }
+
+[dev-dependencies]
+serde_test = "1.0"
+serde_json = "1.0"
+
+[lints.rust]
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(hashes_fuzz)' ] }
diff --git a/hashes/README.md b/hashes/README.md
new file mode 100644
index 00000000..433a9593
--- /dev/null
+++ b/hashes/README.md
@@ -0,0 +1,44 @@
+# Bitcoin Hashes Library
+
+This is a simple, no-dependency library which implements the hash functions
+needed by Bitcoin. These are SHA1, SHA256, SHA256d, SHA512, and RIPEMD160. As an
+ancilliary thing, it exposes hexadecimal serialization and deserialization,
+since these are needed to display hashes anway.
+
+[Documentation](https://docs.rs/bitcoin_hashes/)
+
+## Minimum Supported Rust Version (MSRV)
+
+This library should always compile with any combination of features on **Rust 1.56.1**.
+
+
+To build with the MSRV you will need to pin `serde` (if you have either the `serde` or the
+`schemars` feature enabled)
+
+```
+# serde 1.0.157 uses syn 2.0 which requires edition 2021
+cargo update -p serde --precise 1.0.156
+```
+
+before building. (And if your code is a library, your downstream users will need to run these
+commands, and so on.)
+
+## Contributions
+
+Contributions are welcome, including additional hash function implementations.
+
+### Githooks
+
+To assist devs in catching errors _before_ running CI we provide some githooks. If you do not
+already have locally configured githooks you can use the ones in this repository by running, in the
+root directory of the repository:
+```
+git config --local core.hooksPath githooks/
+```
+
+Alternatively add symlinks in your `.git/hooks` directory to any of the githooks we provide.
+
+### Running Benchmarks
+
+We use a custom Rust compiler configuration conditional to guard the bench mark code. To run the
+bench marks use: `RUSTFLAGS='--cfg=bench' cargo +nightly bench`.
diff --git a/hashes/contrib/test.sh b/hashes/contrib/test.sh
new file mode 100755
index 00000000..37160d0e
--- /dev/null
+++ b/hashes/contrib/test.sh
@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+
+set -ex
+
+FEATURES="serde serde-std std core2 alloc"
+
+cargo --version
+rustc --version
+
+# Work out if we are using a nightly toolchain.
+NIGHTLY=false
+if cargo --version | grep nightly >/dev/null; then
+    NIGHTLY=true
+fi
+
+# Pin dependencies as required if we are using MSRV toolchain.
+if cargo --version | grep "1\.48"; then
+    # 1.0.157 uses syn 2.0 which requires edition 2021
+    cargo update -p serde_json --precise 1.0.99
+    cargo update -p serde --precise 1.0.156
+fi
+
+# Make all cargo invocations verbose
+export CARGO_TERM_VERBOSE=true
+
+# Defaults / sanity checks
+cargo build
+cargo test
+
+if [ "$DO_LINT" = true ]
+then
+    cargo clippy --locked --all-features --all-targets -- -D warnings
+fi
+
+if [ "$DO_FEATURE_MATRIX" = true ]; then
+    cargo build --locked --no-default-features
+    cargo test --locked --no-default-features
+
+    # All features
+    cargo build --locked --no-default-features --features="$FEATURES"
+    cargo test --locked --no-default-features --features="$FEATURES"
+    # Single features
+    for feature in ${FEATURES}
+    do
+        cargo build --locked --no-default-features --features="$feature"
+        cargo test --locked --no-default-features --features="$feature"
+		# All combos of two features
+		for featuretwo in ${FEATURES}; do
+			cargo build --locked --no-default-features --features="$feature $featuretwo"
+			cargo test --locked --no-default-features --features="$feature $featuretwo"
+		done
+    done
+
+    # Other combos
+    cargo test --locked --no-default-features --features="std,schemars"
+fi
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+
+if [ "$DO_SCHEMARS_TESTS" = true ]; then
+    pushd "$REPO_DIR/hashes/extended_tests/schemars" > /dev/null
+    cargo test
+    popd > /dev/null
+fi
+
+# Build the docs if told to (this only works with the nightly toolchain)
+if [ "$DO_DOCSRS" = true ]; then
+    RUSTDOCFLAGS="--cfg docsrs -D warnings -D rustdoc::broken-intra-doc-links" cargo +nightly doc --all-features
+fi
+
+# Build the docs with a stable toolchain, in unison with the DO_DOCSRS command
+# above this checks that we feature guarded docs imports correctly.
+if [ "$DO_DOCS" = true ]; then
+    RUSTDOCFLAGS="-D warnings" cargo +stable doc --all-features
+fi
+
+# Webassembly stuff
+if [ "$DO_WASM" = true ]; then
+    clang --version &&
+    CARGO_TARGET_DIR=wasm cargo install --force wasm-pack &&
+    printf '\n[target.wasm32-unknown-unknown.dev-dependencies]\nwasm-bindgen-test = "0.3"\n' >> Cargo.toml &&
+    printf '\n[lib]\ncrate-type = ["cdylib", "rlib"]\n' >> Cargo.toml &&
+    CC=clang-9 wasm-pack build &&
+    CC=clang-9 wasm-pack test --node;
+fi
+
+# Address Sanitizer
+if [ "$DO_ASAN" = true ]; then
+    cargo clean
+    CC='clang -fsanitize=address -fno-omit-frame-pointer'                                        \
+    RUSTFLAGS='-Zsanitizer=address -Clinker=clang -Cforce-frame-pointers=yes'                    \
+    ASAN_OPTIONS='detect_leaks=1 detect_invalid_pointer_pairs=1 detect_stack_use_after_return=1' \
+    cargo test --lib --no-default-features --features="$FEATURES" -Zbuild-std --target x86_64-unknown-linux-gnu
+    cargo clean
+    CC='clang -fsanitize=memory -fno-omit-frame-pointer'                                         \
+    RUSTFLAGS='-Zsanitizer=memory -Zsanitizer-memory-track-origins -Cforce-frame-pointers=yes'   \
+    cargo test --lib --no-default-features --features="$FEATURES" -Zbuild-std --target x86_64-unknown-linux-gnu
+fi
+
+# Run formatter if told to.
+if [ "$DO_FMT" = true ]; then
+    if [ "$NIGHTLY" = false ]; then
+        echo "DO_FMT requires a nightly toolchain (consider using RUSTUP_TOOLCHAIN)"
+        exit 1
+    fi
+    rustup component add rustfmt
+    cargo fmt --check
+fi
+
+# Bench if told to, only works with non-stable toolchain (nightly, beta).
+if [ "$DO_BENCH" = true ]
+then
+    if [ "$NIGHTLY" = false ]
+    then
+        if [ -n "$RUSTUP_TOOLCHAIN" ]
+        then
+            echo "RUSTUP_TOOLCHAIN is set to a non-nightly toolchain but DO_BENCH requires a nightly toolchain"
+        else
+            echo "DO_BENCH requires a nightly toolchain"
+        fi
+        exit 1
+    fi
+    RUSTFLAGS='--cfg=bench' cargo bench
+fi
diff --git a/hashes/embedded/Cargo.toml b/hashes/embedded/Cargo.toml
new file mode 100644
index 00000000..ea85dc99
--- /dev/null
+++ b/hashes/embedded/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+authors = ["Riccardo Casatta <riccardo@casatta.it>"]
+edition = "2018"
+readme = "README.md"
+name = "embedded"
+version = "0.1.0"
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[features]
+alloc = ["alloc-cortex-m", "tapyrus_hashes/alloc"]
+
+[dependencies]
+cortex-m = "0.6.0"
+cortex-m-rt = "0.6.10"
+cortex-m-semihosting = "0.3.3"
+panic-halt = "0.2.0"
+alloc-cortex-m = { version = "0.4.1", optional = true }
+tapyrus_hashes = { path="../", default-features = false, features = ["core2"] }
+core2 = { version = "0.3.0", default_features = false }
+
+[[bin]]
+name = "embedded"
+test = false
+bench = false
+
+[profile.release]
+codegen-units = 1 # better optimizations
+debug = true # symbols are nice and they don't increase the size on Flash
+lto = true # better optimizations
+
+[patch.crates-io.tapyrus-internals]
+path = "../../internals"
diff --git a/hashes/embedded/README.md b/hashes/embedded/README.md
new file mode 100644
index 00000000..60e4e1a1
--- /dev/null
+++ b/hashes/embedded/README.md
@@ -0,0 +1,30 @@
+# Running
+
+To run the embedded test, first prepare your environment:
+
+```shell
+sudo ./scripts/install-deps
+rustup +nightly target add thumbv7m-none-eabi
+```
+
+Then:
+
+```shell
+source ./scripts/env.sh && cargo +nightly run --target thumbv7m-none-eabi
+```
+
+Output should be something like:
+
+```text
+hash:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad hash_check:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
+hash:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad hash_check:ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
+```
+
+## Cleanup
+
+After sourcing `scripts/env.sh` and _before_ building again using another target
+you'll want to unset `RUSTFLAGS` otherwise you'll get linker errors.
+
+```shell
+unset RUSTFLAGS
+```
diff --git a/hashes/embedded/memory.x b/hashes/embedded/memory.x
new file mode 100644
index 00000000..95de161b
--- /dev/null
+++ b/hashes/embedded/memory.x
@@ -0,0 +1,5 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 256K
+  RAM : ORIGIN = 0x20000000, LENGTH = 64K
+}
diff --git a/hashes/embedded/scripts/env.sh b/hashes/embedded/scripts/env.sh
new file mode 100644
index 00000000..125162b6
--- /dev/null
+++ b/hashes/embedded/scripts/env.sh
@@ -0,0 +1,2 @@
+export RUSTFLAGS="-C link-arg=-Tlink.x"
+export CARGO_TARGET_THUMBV7M_NONE_EABI_RUNNER="qemu-system-arm -cpu cortex-m3 -machine mps2-an385 -nographic -semihosting-config enable=on,target=native -kernel"
diff --git a/hashes/embedded/scripts/install-deps b/hashes/embedded/scripts/install-deps
new file mode 100755
index 00000000..d22806dd
--- /dev/null
+++ b/hashes/embedded/scripts/install-deps
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+apt install gcc-arm-none-eabi qemu-system-arm gdb-multiarch
diff --git a/hashes/embedded/src/main.rs b/hashes/embedded/src/main.rs
new file mode 100644
index 00000000..7c58163d
--- /dev/null
+++ b/hashes/embedded/src/main.rs
@@ -0,0 +1,63 @@
+#![cfg_attr(feature = "alloc", feature(alloc_error_handler))]
+#![no_std]
+#![no_main]
+
+#[macro_use]
+extern crate tapyrus_hashes;
+
+#[cfg(feature = "alloc")] extern crate alloc;
+#[cfg(feature = "alloc")] use alloc_cortex_m::CortexMHeap;
+#[cfg(feature = "alloc")] use alloc::string::ToString;
+
+use tapyrus_hashes::{sha256, Hash, HashEngine};
+use core2::io::Write;
+use core::str::FromStr;
+use cortex_m_rt::entry;
+use cortex_m_semihosting::{debug, hprintln};
+use panic_halt as _;
+
+hash_newtype! {
+    struct TestType(sha256::Hash);
+}
+
+// this is the allocator the application will use
+#[cfg(feature = "alloc")]
+#[global_allocator]
+static ALLOCATOR: CortexMHeap = CortexMHeap::empty();
+
+#[cfg(feature = "alloc")]
+const HEAP_SIZE: usize = 1024; // in bytes
+
+#[entry]
+fn main() -> ! {
+    #[cfg(feature = "alloc")]
+    unsafe { ALLOCATOR.init(cortex_m_rt::heap_start() as usize, HEAP_SIZE) }
+
+    let mut engine = TestType::engine();
+    engine.write_all(b"abc").unwrap();
+    check_result(engine);
+
+    let mut engine = TestType::engine();
+    engine.input(b"abc");
+    check_result(engine);
+
+    debug::exit(debug::EXIT_SUCCESS);
+    loop {}
+}
+
+fn check_result(engine: sha256::HashEngine) {
+    let hash = TestType::from_engine(engine);
+
+    let hash_check =
+        TestType::from_str("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad")
+            .unwrap();
+    hprintln!("hash:{} hash_check:{}", hash, hash_check).unwrap();
+    if hash != hash_check {
+        debug::exit(debug::EXIT_FAILURE);
+    }
+
+    #[cfg(feature = "alloc")]
+    if hash.to_string() != hash_check.to_string() {
+        debug::exit(debug::EXIT_FAILURE);
+    }
+}
diff --git a/hashes/extended_tests/schemars/Cargo.toml b/hashes/extended_tests/schemars/Cargo.toml
new file mode 100644
index 00000000..b784d016
--- /dev/null
+++ b/hashes/extended_tests/schemars/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "schemars"
+version = "0.1.0"
+authors = ["Jeremy Rubin <j@rubin.io>"]
+edition = "2018"
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[dependencies.tapyrus_hashes]
+path = "../.."
+features = ['schemars', 'serde']
+
+[dependencies]
+jsonschema-valid = "0.4.0"
+serde = { version = "1.0", default-features = false}
+schemars = "0.8.3"
+serde_test = "1.0"
+serde_json = "1.0"
+
+[patch.crates-io.tapyrus-internals]
+path = "../../../internals"
diff --git a/hashes/extended_tests/schemars/README.md b/hashes/extended_tests/schemars/README.md
new file mode 100644
index 00000000..9e0a5970
--- /dev/null
+++ b/hashes/extended_tests/schemars/README.md
@@ -0,0 +1,11 @@
+# Test crate for the schemars feature
+
+Run as usual with `cargo test`.
+
+## Minimum Supported Rust Version (MSRV)
+
+To run the tests with the MSRV you will need to pin `serde`:
+
+- `cargo update -p serde --precise 1.0.156`
+- `cargo update -p regex --precise 1.7.3`
+- `cargo update -p chrono --precise 0.4.24`
diff --git a/hashes/extended_tests/schemars/src/main.rs b/hashes/extended_tests/schemars/src/main.rs
new file mode 100644
index 00000000..b4e480ca
--- /dev/null
+++ b/hashes/extended_tests/schemars/src/main.rs
@@ -0,0 +1,191 @@
+fn main() {}
+#[cfg(test)]
+mod tests {
+    use tapyrus_hashes::*;
+
+    #[test]
+    fn hash160() {
+        static HASH_BYTES: [u8; 20] = [
+            0x13, 0x20, 0x72, 0xdf, 0x69, 0x09, 0x33, 0x83, 0x5e, 0xb8, 0xb6, 0xad, 0x0b, 0x77,
+            0xe7, 0xb6, 0xf1, 0x4a, 0xca, 0xd7,
+        ];
+
+        let hash = hash160::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(hash160::Hash);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+
+    #[test]
+    fn hmac_sha512() {
+        static HASH_BYTES: [u8; 64] = [
+            0x8b, 0x41, 0xe1, 0xb7, 0x8a, 0xd1, 0x15, 0x21, 0x11, 0x3c, 0x52, 0xff, 0x18, 0x2a,
+            0x1b, 0x8e, 0x0a, 0x19, 0x57, 0x54, 0xaa, 0x52, 0x7f, 0xcd, 0x00, 0xa4, 0x11, 0x62,
+            0x0b, 0x46, 0xf2, 0x0f, 0xff, 0xfb, 0x80, 0x88, 0xcc, 0xf8, 0x54, 0x97, 0x12, 0x1a,
+            0xd4, 0x49, 0x9e, 0x08, 0x45, 0xb8, 0x76, 0xf6, 0xdd, 0x66, 0x40, 0x08, 0x8a, 0x2f,
+            0x0b, 0x2d, 0x8a, 0x60, 0x0b, 0xdf, 0x4c, 0x0c,
+        ];
+
+        let hash = Hmac::<sha512::Hash>::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(Hmac::<sha512::Hash>);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+
+    #[test]
+    fn ripemd160() {
+        static HASH_BYTES: [u8; 20] = [
+            0x13, 0x20, 0x72, 0xdf, 0x69, 0x09, 0x33, 0x83, 0x5e, 0xb8, 0xb6, 0xad, 0x0b, 0x77,
+            0xe7, 0xb6, 0xf1, 0x4a, 0xca, 0xd7,
+        ];
+
+        let hash = ripemd160::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(ripemd160::Hash);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+
+    #[test]
+    fn sha1() {
+        static HASH_BYTES: [u8; 20] = [
+            0x13, 0x20, 0x72, 0xdf, 0x69, 0x09, 0x33, 0x83, 0x5e, 0xb8, 0xb6, 0xad, 0x0b, 0x77,
+            0xe7, 0xb6, 0xf1, 0x4a, 0xca, 0xd7,
+        ];
+
+        let hash = sha1::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(sha1::Hash);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+
+    #[test]
+    fn sha256d() {
+        static HASH_BYTES: [u8; 32] = [
+            0xef, 0x53, 0x7f, 0x25, 0xc8, 0x95, 0xbf, 0xa7, 0x82, 0x52, 0x65, 0x29, 0xa9, 0xb6,
+            0x3d, 0x97, 0xaa, 0x63, 0x15, 0x64, 0xd5, 0xd7, 0x89, 0xc2, 0xb7, 0x65, 0x44, 0x8c,
+            0x86, 0x35, 0xfb, 0x6c,
+        ];
+
+        let hash = sha256d::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(sha256d::Hash);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+
+    #[test]
+    fn sha256() {
+        static HASH_BYTES: [u8; 32] = [
+            0xef, 0x53, 0x7f, 0x25, 0xc8, 0x95, 0xbf, 0xa7, 0x82, 0x52, 0x65, 0x29, 0xa9, 0xb6,
+            0x3d, 0x97, 0xaa, 0x63, 0x15, 0x64, 0xd5, 0xd7, 0x89, 0xc2, 0xb7, 0x65, 0x44, 0x8c,
+            0x86, 0x35, 0xfb, 0x6c,
+        ];
+
+        let hash = sha256::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(sha256::Hash);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+
+    #[test]
+    fn test_hash() {
+        const TEST_MIDSTATE: [u8; 32] = [
+            156, 224, 228, 230, 124, 17, 108, 57, 56, 179, 202, 242, 195, 15, 80, 137, 211, 243,
+            147, 108, 71, 99, 110, 96, 125, 179, 62, 234, 221, 198, 240, 201,
+        ];
+
+        #[derive(
+            Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Hash, schemars::JsonSchema,
+        )]
+        pub struct TestHashTag;
+
+        impl sha256t::Tag for TestHashTag {
+            fn engine() -> sha256::HashEngine {
+                // The TapRoot TapLeaf midstate.
+                let midstate = sha256::Midstate::from_byte_array(TEST_MIDSTATE);
+                sha256::HashEngine::from_midstate(midstate, 64)
+            }
+        }
+
+        /// A hash tagged with `$name`.
+        pub type TestHash = sha256t::Hash<TestHashTag>;
+
+        sha256t_hash_newtype! {
+            struct NewTypeTag = raw(TEST_MIDSTATE, 64);
+
+            #[hash_newtype(backward)]
+            struct NewTypeHash(_);
+        }
+        static HASH_BYTES: [u8; 32] = [
+            0xef, 0x53, 0x7f, 0x25, 0xc8, 0x95, 0xbf, 0xa7, 0x82, 0x52, 0x65, 0x29, 0xa9, 0xb6,
+            0x3d, 0x97, 0xaa, 0x63, 0x15, 0x64, 0xd5, 0xd7, 0x89, 0xc2, 0xb7, 0x65, 0x44, 0x8c,
+            0x86, 0x35, 0xfb, 0x6c,
+        ];
+
+        let hash = TestHash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(TestHash);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+
+    #[test]
+    fn sha512() {
+        static HASH_BYTES: [u8; 64] = [
+            0x8b, 0x41, 0xe1, 0xb7, 0x8a, 0xd1, 0x15, 0x21, 0x11, 0x3c, 0x52, 0xff, 0x18, 0x2a,
+            0x1b, 0x8e, 0x0a, 0x19, 0x57, 0x54, 0xaa, 0x52, 0x7f, 0xcd, 0x00, 0xa4, 0x11, 0x62,
+            0x0b, 0x46, 0xf2, 0x0f, 0xff, 0xfb, 0x80, 0x88, 0xcc, 0xf8, 0x54, 0x97, 0x12, 0x1a,
+            0xd4, 0x49, 0x9e, 0x08, 0x45, 0xb8, 0x76, 0xf6, 0xdd, 0x66, 0x40, 0x08, 0x8a, 0x2f,
+            0x0b, 0x2d, 0x8a, 0x60, 0x0b, 0xdf, 0x4c, 0x0c,
+        ];
+
+        let hash = sha512::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(sha512::Hash);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+
+    #[test]
+    fn siphash24() {
+        static HASH_BYTES: [u8; 8] = [0x8b, 0x41, 0xe1, 0xb7, 0x8a, 0xd1, 0x15, 0x21];
+
+        let hash = siphash24::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let js = serde_json::from_str(&serde_json::to_string(&hash).unwrap()).unwrap();
+        let s = schemars::schema_for!(siphash24::Hash);
+        let schema = serde_json::from_str(&serde_json::to_string(&s).unwrap()).unwrap();
+        assert!(jsonschema_valid::Config::from_schema(&schema, None)
+            .unwrap()
+            .validate(&js)
+            .is_ok());
+    }
+}
diff --git a/hashes/src/cmp.rs b/hashes/src/cmp.rs
new file mode 100644
index 00000000..d84b31c0
--- /dev/null
+++ b/hashes/src/cmp.rs
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Useful comparison functions.
+
+/// Compare two slices for equality in fixed time. Panics if the slices are of non-equal length.
+///
+/// This works by XOR'ing each byte of the two inputs together and keeping an OR counter of the
+/// results.
+///
+/// Instead of doing fancy bit twiddling to try to outsmart the compiler and prevent early exits,
+/// which is not guaranteed to remain stable as compilers get ever smarter, we take the hit of
+/// writing each intermediate value to memory with a volatile write and then re-reading it with a
+/// volatile read. This should remain stable across compiler upgrades, but is much slower.
+///
+/// As of rust 1.31.0 disassembly looks completely within reason for this, see
+/// <https://godbolt.org/z/mMbGQv>.
+pub fn fixed_time_eq(a: &[u8], b: &[u8]) -> bool {
+    assert!(a.len() == b.len());
+    let count = a.len();
+    let lhs = &a[..count];
+    let rhs = &b[..count];
+
+    let mut r: u8 = 0;
+    for i in 0..count {
+        let mut rs = unsafe { core::ptr::read_volatile(&r) };
+        rs |= lhs[i] ^ rhs[i];
+        unsafe {
+            core::ptr::write_volatile(&mut r, rs);
+        }
+    }
+    {
+        let mut t = unsafe { core::ptr::read_volatile(&r) };
+        t |= t >> 4;
+        unsafe {
+            core::ptr::write_volatile(&mut r, t);
+        }
+    }
+    {
+        let mut t = unsafe { core::ptr::read_volatile(&r) };
+        t |= t >> 2;
+        unsafe {
+            core::ptr::write_volatile(&mut r, t);
+        }
+    }
+    {
+        let mut t = unsafe { core::ptr::read_volatile(&r) };
+        t |= t >> 1;
+        unsafe {
+            core::ptr::write_volatile(&mut r, t);
+        }
+    }
+    unsafe { (::core::ptr::read_volatile(&r) & 1) == 0 }
+}
+
+#[test]
+fn eq_test() {
+    assert!(fixed_time_eq(&[0b00000000], &[0b00000000]));
+    assert!(fixed_time_eq(&[0b00000001], &[0b00000001]));
+    assert!(fixed_time_eq(&[0b00000010], &[0b00000010]));
+    assert!(fixed_time_eq(&[0b00000100], &[0b00000100]));
+    assert!(fixed_time_eq(&[0b00001000], &[0b00001000]));
+    assert!(fixed_time_eq(&[0b00010000], &[0b00010000]));
+    assert!(fixed_time_eq(&[0b00100000], &[0b00100000]));
+    assert!(fixed_time_eq(&[0b01000000], &[0b01000000]));
+    assert!(fixed_time_eq(&[0b10000000], &[0b10000000]));
+    assert!(fixed_time_eq(&[0b11111111], &[0b11111111]));
+
+    assert!(!fixed_time_eq(&[0b00000001], &[0b00000000]));
+    assert!(!fixed_time_eq(&[0b00000001], &[0b11111111]));
+    assert!(!fixed_time_eq(&[0b00000010], &[0b00000000]));
+    assert!(!fixed_time_eq(&[0b00000010], &[0b11111111]));
+    assert!(!fixed_time_eq(&[0b00000100], &[0b00000000]));
+    assert!(!fixed_time_eq(&[0b00000100], &[0b11111111]));
+    assert!(!fixed_time_eq(&[0b00001000], &[0b00000000]));
+    assert!(!fixed_time_eq(&[0b00001000], &[0b11111111]));
+    assert!(!fixed_time_eq(&[0b00010000], &[0b00000000]));
+    assert!(!fixed_time_eq(&[0b00010000], &[0b11111111]));
+    assert!(!fixed_time_eq(&[0b00100000], &[0b00000000]));
+    assert!(!fixed_time_eq(&[0b00100000], &[0b11111111]));
+    assert!(!fixed_time_eq(&[0b01000000], &[0b00000000]));
+    assert!(!fixed_time_eq(&[0b01000000], &[0b11111111]));
+    assert!(!fixed_time_eq(&[0b10000000], &[0b00000000]));
+    assert!(!fixed_time_eq(&[0b10000000], &[0b11111111]));
+
+    assert!(fixed_time_eq(&[0b00000000, 0b00000000], &[0b00000000, 0b00000000]));
+    assert!(!fixed_time_eq(&[0b00000001, 0b00000000], &[0b00000000, 0b00000000]));
+    assert!(!fixed_time_eq(&[0b00000000, 0b00000001], &[0b00000000, 0b00000000]));
+    assert!(!fixed_time_eq(&[0b00000000, 0b00000000], &[0b00000001, 0b00000000]));
+    assert!(!fixed_time_eq(&[0b00000000, 0b00000000], &[0b00000001, 0b00000001]));
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::cmp::fixed_time_eq;
+    use crate::{sha256, sha512, Hash};
+
+    #[bench]
+    fn bench_32b_constant_time_cmp_ne(bh: &mut Bencher) {
+        let hash_a = sha256::Hash::hash(&[0; 1]);
+        let hash_b = sha256::Hash::hash(&[1; 1]);
+        bh.iter(|| fixed_time_eq(&hash_a[..], &hash_b[..]))
+    }
+
+    #[bench]
+    fn bench_32b_slice_cmp_ne(bh: &mut Bencher) {
+        let hash_a = sha256::Hash::hash(&[0; 1]);
+        let hash_b = sha256::Hash::hash(&[1; 1]);
+        bh.iter(|| &hash_a[..] == &hash_b[..])
+    }
+
+    #[bench]
+    fn bench_32b_constant_time_cmp_eq(bh: &mut Bencher) {
+        let hash_a = sha256::Hash::hash(&[0; 1]);
+        let hash_b = sha256::Hash::hash(&[0; 1]);
+        bh.iter(|| fixed_time_eq(&hash_a[..], &hash_b[..]))
+    }
+
+    #[bench]
+    fn bench_32b_slice_cmp_eq(bh: &mut Bencher) {
+        let hash_a = sha256::Hash::hash(&[0; 1]);
+        let hash_b = sha256::Hash::hash(&[0; 1]);
+        bh.iter(|| &hash_a[..] == &hash_b[..])
+    }
+
+    #[bench]
+    fn bench_64b_constant_time_cmp_ne(bh: &mut Bencher) {
+        let hash_a = sha512::Hash::hash(&[0; 1]);
+        let hash_b = sha512::Hash::hash(&[1; 1]);
+        bh.iter(|| fixed_time_eq(&hash_a[..], &hash_b[..]))
+    }
+
+    #[bench]
+    fn bench_64b_slice_cmp_ne(bh: &mut Bencher) {
+        let hash_a = sha512::Hash::hash(&[0; 1]);
+        let hash_b = sha512::Hash::hash(&[1; 1]);
+        bh.iter(|| &hash_a[..] == &hash_b[..])
+    }
+
+    #[bench]
+    fn bench_64b_constant_time_cmp_eq(bh: &mut Bencher) {
+        let hash_a = sha512::Hash::hash(&[0; 1]);
+        let hash_b = sha512::Hash::hash(&[0; 1]);
+        bh.iter(|| fixed_time_eq(&hash_a[..], &hash_b[..]))
+    }
+
+    #[bench]
+    fn bench_64b_slice_cmp_eq(bh: &mut Bencher) {
+        let hash_a = sha512::Hash::hash(&[0; 1]);
+        let hash_b = sha512::Hash::hash(&[0; 1]);
+        bh.iter(|| &hash_a[..] == &hash_b[..])
+    }
+}
diff --git a/hashes/src/hash160.rs b/hashes/src/hash160.rs
new file mode 100644
index 00000000..af44f477
--- /dev/null
+++ b/hashes/src/hash160.rs
@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: CC0-1.0
+//
+// This module is largely copied from the rust-crypto ripemd.rs file;
+// while rust-crypto is licensed under Apache, that file specifically
+// was written entirely by Andrew Poelstra, who is re-licensing its
+// contents here as CC0.
+
+//! HASH160 (SHA256 then RIPEMD160) implementation.
+//!
+
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::str;
+
+use crate::{ripemd160, sha256, FromSliceError};
+
+crate::internal_macros::hash_type! {
+    160,
+    false,
+    "Output of the Bitcoin HASH160 hash function. (RIPEMD160(SHA256))",
+    "crate::util::json_hex_string::len_20"
+}
+
+type HashEngine = sha256::HashEngine;
+
+fn from_engine(e: HashEngine) -> Hash {
+    use crate::Hash as _;
+
+    let sha2 = sha256::Hash::from_engine(e);
+    let rmd = ripemd160::Hash::hash(&sha2[..]);
+
+    let mut ret = [0; 20];
+    ret.copy_from_slice(&rmd[..]);
+    Hash(ret)
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test() {
+        use crate::{hash160, Hash, HashEngine};
+
+        #[derive(Clone)]
+        #[cfg(feature = "alloc")]
+        struct Test {
+            input: Vec<u8>,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
+        #[rustfmt::skip]
+        let tests = vec![
+            // Uncompressed pubkey obtained from Bitcoin key; data from validateaddress
+            Test {
+                input: vec![
+                    0x04, 0xa1, 0x49, 0xd7, 0x6c, 0x5d, 0xe2, 0x7a, 0x2d,
+                    0xdb, 0xfa, 0xa1, 0x24, 0x6c, 0x4a, 0xdc, 0xd2, 0xb6,
+                    0xf7, 0xaa, 0x29, 0x54, 0xc2, 0xe2, 0x53, 0x03, 0xf5,
+                    0x51, 0x54, 0xca, 0xad, 0x91, 0x52, 0xe4, 0xf7, 0xe4,
+                    0xb8, 0x5d, 0xf1, 0x69, 0xc1, 0x8a, 0x3c, 0x69, 0x7f,
+                    0xbb, 0x2d, 0xc4, 0xec, 0xef, 0x94, 0xac, 0x55, 0xfe,
+                    0x81, 0x64, 0xcc, 0xf9, 0x82, 0xa1, 0x38, 0x69, 0x1a,
+                    0x55, 0x19,
+                ],
+                output: vec![
+                    0xda, 0x0b, 0x34, 0x52, 0xb0, 0x6f, 0xe3, 0x41,
+                    0x62, 0x6a, 0xd0, 0x94, 0x9c, 0x18, 0x3f, 0xbd,
+                    0xa5, 0x67, 0x68, 0x26,
+                ],
+                output_str: "da0b3452b06fe341626ad0949c183fbda5676826",
+            },
+        ];
+
+        for test in tests {
+            // Hash through high-level API, check hex encoding/decoding
+            let hash = hash160::Hash::hash(&test.input[..]);
+            assert_eq!(hash, test.output_str.parse::<hash160::Hash>().expect("parse hex"));
+            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(&hash.to_string(), &test.output_str);
+
+            // Hash through engine, checking that we can input byte by byte
+            let mut engine = hash160::Hash::engine();
+            for ch in test.input {
+                engine.input(&[ch]);
+            }
+            let manual_hash = Hash::from_engine(engine);
+            assert_eq!(hash, manual_hash);
+            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn ripemd_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        use crate::{hash160, Hash};
+
+        #[rustfmt::skip]
+        static HASH_BYTES: [u8; 20] = [
+            0x13, 0x20, 0x72, 0xdf,
+            0x69, 0x09, 0x33, 0x83,
+            0x5e, 0xb8, 0xb6, 0xad,
+            0x0b, 0x77, 0xe7, 0xb6,
+            0xf1, 0x4a, 0xca, 0xd7,
+        ];
+
+        let hash = hash160::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
+        assert_tokens(&hash.readable(), &[Token::Str("132072df690933835eb8b6ad0b77e7b6f14acad7")]);
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{hash160, Hash, HashEngine};
+
+    #[bench]
+    pub fn hash160_10(bh: &mut Bencher) {
+        let mut engine = hash160::Hash::engine();
+        let bytes = [1u8; 10];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn hash160_1k(bh: &mut Bencher) {
+        let mut engine = hash160::Hash::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn hash160_64k(bh: &mut Bencher) {
+        let mut engine = hash160::Hash::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/hmac.rs b/hashes/src/hmac.rs
new file mode 100644
index 00000000..32ca96a1
--- /dev/null
+++ b/hashes/src/hmac.rs
@@ -0,0 +1,383 @@
+// SPDX-License-Identifier: CC0-1.0
+
+// This module is largely copied from the rust-crypto ripemd.rs file;
+// while rust-crypto is licensed under Apache, that file specifically
+// was written entirely by Andrew Poelstra, who is re-licensing its
+// contents here as CC0.
+
+//! Hash-based Message Authentication Code (HMAC).
+//!
+
+use core::{borrow, fmt, ops, str};
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::{FromSliceError, Hash, HashEngine};
+
+/// A hash computed from a RFC 2104 HMAC. Parameterized by the underlying hash function.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "schemars", schemars(transparent))]
+#[repr(transparent)]
+pub struct Hmac<T: Hash>(T);
+
+impl<T: Hash + str::FromStr> str::FromStr for Hmac<T> {
+    type Err = <T as str::FromStr>::Err;
+    fn from_str(s: &str) -> Result<Self, Self::Err> { Ok(Hmac(str::FromStr::from_str(s)?)) }
+}
+
+/// Pair of underlying hash midstates which represent the current state of an `HmacEngine`.
+pub struct HmacMidState<T: Hash> {
+    /// Midstate of the inner hash engine
+    pub inner: <T::Engine as HashEngine>::MidState,
+    /// Midstate of the outer hash engine
+    pub outer: <T::Engine as HashEngine>::MidState,
+}
+
+/// Pair of underyling hash engines, used for the inner and outer hash of HMAC.
+#[derive(Clone)]
+pub struct HmacEngine<T: Hash> {
+    iengine: T::Engine,
+    oengine: T::Engine,
+}
+
+impl<T: Hash> Default for HmacEngine<T> {
+    fn default() -> Self { HmacEngine::new(&[]) }
+}
+
+impl<T: Hash> HmacEngine<T> {
+    /// Constructs a new keyed HMAC from `key`.
+    ///
+    /// We only support underlying hashes whose block sizes are ≤ 128 bytes.
+    ///
+    /// # Panics
+    ///
+    /// Larger hashes will result in a panic.
+    pub fn new(key: &[u8]) -> HmacEngine<T> {
+        debug_assert!(T::Engine::BLOCK_SIZE <= 128);
+
+        let mut ipad = [0x36u8; 128];
+        let mut opad = [0x5cu8; 128];
+        let mut ret = HmacEngine { iengine: <T as Hash>::engine(), oengine: <T as Hash>::engine() };
+
+        if key.len() > T::Engine::BLOCK_SIZE {
+            let hash = <T as Hash>::hash(key);
+            for (b_i, b_h) in ipad.iter_mut().zip(&hash[..]) {
+                *b_i ^= *b_h;
+            }
+            for (b_o, b_h) in opad.iter_mut().zip(&hash[..]) {
+                *b_o ^= *b_h;
+            }
+        } else {
+            for (b_i, b_h) in ipad.iter_mut().zip(key) {
+                *b_i ^= *b_h;
+            }
+            for (b_o, b_h) in opad.iter_mut().zip(key) {
+                *b_o ^= *b_h;
+            }
+        };
+
+        HashEngine::input(&mut ret.iengine, &ipad[..T::Engine::BLOCK_SIZE]);
+        HashEngine::input(&mut ret.oengine, &opad[..T::Engine::BLOCK_SIZE]);
+        ret
+    }
+
+    /// A special constructor giving direct access to the underlying "inner" and "outer" engines.
+    pub fn from_inner_engines(iengine: T::Engine, oengine: T::Engine) -> HmacEngine<T> {
+        HmacEngine { iengine, oengine }
+    }
+}
+
+impl<T: Hash> HashEngine for HmacEngine<T> {
+    type MidState = HmacMidState<T>;
+
+    fn midstate(&self) -> Self::MidState {
+        HmacMidState { inner: self.iengine.midstate(), outer: self.oengine.midstate() }
+    }
+
+    const BLOCK_SIZE: usize = T::Engine::BLOCK_SIZE;
+
+    fn n_bytes_hashed(&self) -> usize { self.iengine.n_bytes_hashed() }
+
+    fn input(&mut self, buf: &[u8]) { self.iengine.input(buf) }
+}
+
+impl<T: Hash> fmt::Debug for Hmac<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(&self.0, f) }
+}
+
+impl<T: Hash> fmt::Display for Hmac<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+impl<T: Hash> fmt::LowerHex for Hmac<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
+}
+
+impl<T: Hash> ops::Index<usize> for Hmac<T> {
+    type Output = u8;
+    fn index(&self, index: usize) -> &u8 { &self.0[index] }
+}
+
+impl<T: Hash> ops::Index<ops::Range<usize>> for Hmac<T> {
+    type Output = [u8];
+    fn index(&self, index: ops::Range<usize>) -> &[u8] { &self.0[index] }
+}
+
+impl<T: Hash> ops::Index<ops::RangeFrom<usize>> for Hmac<T> {
+    type Output = [u8];
+    fn index(&self, index: ops::RangeFrom<usize>) -> &[u8] { &self.0[index] }
+}
+
+impl<T: Hash> ops::Index<ops::RangeTo<usize>> for Hmac<T> {
+    type Output = [u8];
+    fn index(&self, index: ops::RangeTo<usize>) -> &[u8] { &self.0[index] }
+}
+
+impl<T: Hash> ops::Index<ops::RangeFull> for Hmac<T> {
+    type Output = [u8];
+    fn index(&self, index: ops::RangeFull) -> &[u8] { &self.0[index] }
+}
+
+impl<T: Hash> borrow::Borrow<[u8]> for Hmac<T> {
+    fn borrow(&self) -> &[u8] { &self[..] }
+}
+
+impl<T: Hash> Hash for Hmac<T> {
+    type Engine = HmacEngine<T>;
+    type Bytes = T::Bytes;
+
+    fn from_engine(mut e: HmacEngine<T>) -> Hmac<T> {
+        let ihash = T::from_engine(e.iengine);
+        e.oengine.input(&ihash[..]);
+        let ohash = T::from_engine(e.oengine);
+        Hmac(ohash)
+    }
+
+    const LEN: usize = T::LEN;
+
+    fn from_slice(sl: &[u8]) -> Result<Hmac<T>, FromSliceError> { T::from_slice(sl).map(Hmac) }
+
+    fn to_byte_array(self) -> Self::Bytes { self.0.to_byte_array() }
+
+    fn as_byte_array(&self) -> &Self::Bytes { self.0.as_byte_array() }
+
+    fn from_byte_array(bytes: T::Bytes) -> Self { Hmac(T::from_byte_array(bytes)) }
+
+    fn all_zeros() -> Self {
+        let zeros = T::all_zeros();
+        Hmac(zeros)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<T: Hash + Serialize> Serialize for Hmac<T> {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        Serialize::serialize(&self.0, s)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, T: Hash + Deserialize<'de>> Deserialize<'de> for Hmac<T> {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Hmac<T>, D::Error> {
+        let bytes = Deserialize::deserialize(d)?;
+        Ok(Hmac(bytes))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test() {
+        use crate::{sha256, Hash, HashEngine, Hmac, HmacEngine};
+
+        #[derive(Clone)]
+        struct Test {
+            key: Vec<u8>,
+            input: Vec<u8>,
+            output: Vec<u8>,
+        }
+
+        #[rustfmt::skip]
+        let tests = vec![
+            // Test vectors copied from libsecp256k1
+            // Sadly the RFC2104 test vectors all use MD5 as their underlying hash function,
+            // which of course this library does not support.
+            Test {
+                key: vec![ 0x0b; 20],
+                input: vec![0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65],
+                output: vec![
+                    0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
+                    0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
+                    0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
+                    0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7,
+                ],
+            },
+            Test {
+                key: vec![ 0x4a, 0x65, 0x66, 0x65 ],
+                input: vec![
+                    0x77, 0x68, 0x61, 0x74, 0x20, 0x64, 0x6f, 0x20,
+                    0x79, 0x61, 0x20, 0x77, 0x61, 0x6e, 0x74, 0x20,
+                    0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x74, 0x68,
+                    0x69, 0x6e, 0x67, 0x3f,
+                ],
+                output: vec![
+                    0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
+                    0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
+                    0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
+                    0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43,
+                ],
+            },
+            Test {
+                key: vec![ 0xaa; 20 ],
+                input: vec![ 0xdd; 50 ],
+                output: vec![
+                    0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
+                    0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7,
+                    0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22,
+                    0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe,
+                ],
+            },
+            Test {
+                key: vec![
+                    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                    0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+                    0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
+                    0x19
+                ],
+                input: vec![ 0xcd; 50 ],
+                output: vec![
+                    0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e,
+                    0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a,
+                    0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07,
+                    0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b,
+                ],
+            },
+            Test {
+                key: vec! [ 0xaa; 131 ],
+                input: vec![
+                    0x54, 0x65, 0x73, 0x74, 0x20, 0x55, 0x73, 0x69,
+                    0x6e, 0x67, 0x20, 0x4c, 0x61, 0x72, 0x67, 0x65,
+                    0x72, 0x20, 0x54, 0x68, 0x61, 0x6e, 0x20, 0x42,
+                    0x6c, 0x6f, 0x63, 0x6b, 0x2d, 0x53, 0x69, 0x7a,
+                    0x65, 0x20, 0x4b, 0x65, 0x79, 0x20, 0x2d, 0x20,
+                    0x48, 0x61, 0x73, 0x68, 0x20, 0x4b, 0x65, 0x79,
+                    0x20, 0x46, 0x69, 0x72, 0x73, 0x74,
+                ],
+                output: vec![
+                    0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f,
+                    0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f,
+                    0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14,
+                    0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54,
+                ],
+            },
+            Test {
+                key: vec! [ 0xaa; 131 ],
+                input: vec![
+                    0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20,
+                    0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x75,
+                    0x73, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x6c,
+                    0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74, 0x68,
+                    0x61, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
+                    0x2d, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x6b, 0x65,
+                    0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x61, 0x20,
+                    0x6c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x74,
+                    0x68, 0x61, 0x6e, 0x20, 0x62, 0x6c, 0x6f, 0x63,
+                    0x6b, 0x2d, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x64,
+                    0x61, 0x74, 0x61, 0x2e, 0x20, 0x54, 0x68, 0x65,
+                    0x20, 0x6b, 0x65, 0x79, 0x20, 0x6e, 0x65, 0x65,
+                    0x64, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65,
+                    0x20, 0x68, 0x61, 0x73, 0x68, 0x65, 0x64, 0x20,
+                    0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x20, 0x62,
+                    0x65, 0x69, 0x6e, 0x67, 0x20, 0x75, 0x73, 0x65,
+                    0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65,
+                    0x20, 0x48, 0x4d, 0x41, 0x43, 0x20, 0x61, 0x6c,
+                    0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x2e,
+                ],
+                output: vec![
+                    0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb,
+                    0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44,
+                    0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93,
+                    0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2,
+                ],
+            },
+        ];
+
+        for test in tests {
+            let mut engine = HmacEngine::<sha256::Hash>::new(&test.key);
+            engine.input(&test.input);
+            let hash = Hmac::<sha256::Hash>::from_engine(engine);
+            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash.as_byte_array(), test.output.as_slice());
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn hmac_sha512_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        use crate::{sha512, Hash, Hmac};
+
+        #[rustfmt::skip]
+        static HASH_BYTES: [u8; 64] = [
+            0x8b, 0x41, 0xe1, 0xb7, 0x8a, 0xd1, 0x15, 0x21,
+            0x11, 0x3c, 0x52, 0xff, 0x18, 0x2a, 0x1b, 0x8e,
+            0x0a, 0x19, 0x57, 0x54, 0xaa, 0x52, 0x7f, 0xcd,
+            0x00, 0xa4, 0x11, 0x62, 0x0b, 0x46, 0xf2, 0x0f,
+            0xff, 0xfb, 0x80, 0x88, 0xcc, 0xf8, 0x54, 0x97,
+            0x12, 0x1a, 0xd4, 0x49, 0x9e, 0x08, 0x45, 0xb8,
+            0x76, 0xf6, 0xdd, 0x66, 0x40, 0x08, 0x8a, 0x2f,
+            0x0b, 0x2d, 0x8a, 0x60, 0x0b, 0xdf, 0x4c, 0x0c,
+        ];
+
+        let hash = Hmac::<sha512::Hash>::from_slice(&HASH_BYTES).expect("right number of bytes");
+        assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
+        assert_tokens(
+            &hash.readable(),
+            &[Token::Str(
+                "8b41e1b78ad11521113c52ff182a1b8e0a195754aa527fcd00a411620b46f20f\
+                 fffb8088ccf85497121ad4499e0845b876f6dd6640088a2f0b2d8a600bdf4c0c",
+            )],
+        );
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{sha256, Hash, HashEngine, Hmac};
+
+    #[bench]
+    pub fn hmac_sha256_10(bh: &mut Bencher) {
+        let mut engine = Hmac::<sha256::Hash>::engine();
+        let bytes = [1u8; 10];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn hmac_sha256_1k(bh: &mut Bencher) {
+        let mut engine = Hmac::<sha256::Hash>::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn hmac_sha256_64k(bh: &mut Bencher) {
+        let mut engine = Hmac::<sha256::Hash>::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/impls.rs b/hashes/src/impls.rs
new file mode 100644
index 00000000..088a7f1f
--- /dev/null
+++ b/hashes/src/impls.rs
@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! `std` / `core2` Impls.
+//!
+//! Implementations of traits defined in `std` / `core2` and not in `core`.
+//!
+
+use crate::{hmac, io, ripemd160, sha1, sha256, sha512, siphash24, HashEngine};
+
+impl io::Write for sha1::HashEngine {
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.input(buf);
+        Ok(buf.len())
+    }
+}
+
+impl io::Write for sha256::HashEngine {
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.input(buf);
+        Ok(buf.len())
+    }
+}
+
+impl io::Write for sha512::HashEngine {
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.input(buf);
+        Ok(buf.len())
+    }
+}
+
+impl io::Write for ripemd160::HashEngine {
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.input(buf);
+        Ok(buf.len())
+    }
+}
+
+impl io::Write for siphash24::HashEngine {
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.input(buf);
+        Ok(buf.len())
+    }
+}
+
+impl<T: crate::Hash> io::Write for hmac::HmacEngine<T> {
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.input(buf);
+        Ok(buf.len())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::io::Write;
+    use crate::{hash160, hmac, ripemd160, sha1, sha256, sha256d, sha512, siphash24, Hash};
+
+    macro_rules! write_test {
+        ($mod:ident, $exp_empty:expr, $exp_256:expr, $exp_64k:expr,) => {
+            #[test]
+            fn $mod() {
+                let mut engine = $mod::Hash::engine();
+                engine.write_all(&[]).unwrap();
+                assert_eq!(format!("{}", $mod::Hash::from_engine(engine)), $exp_empty);
+
+                let mut engine = $mod::Hash::engine();
+                engine.write_all(&[1; 256]).unwrap();
+                assert_eq!(format!("{}", $mod::Hash::from_engine(engine)), $exp_256);
+
+                let mut engine = $mod::Hash::engine();
+                engine.write_all(&[99; 64000]).unwrap();
+                assert_eq!(format!("{}", $mod::Hash::from_engine(engine)), $exp_64k);
+            }
+        };
+    }
+
+    write_test!(
+        sha1,
+        "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+        "ac458b067c6b021c7e9358229b636e9d1e4cb154",
+        "e4b66838f9f7b6f91e5be32a02ae78094df402e7",
+    );
+
+    write_test!(
+        sha256,
+        "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+        "2661920f2409dd6c8adeb0c44972959f232b6429afa913845d0fd95e7e768234",
+        "5c5e904f5d4fd587c7a906bf846e08a927286f388c54c39213a4884695271bbc",
+    );
+
+    write_test!(
+        sha256d,
+        "56944c5d3f98413ef45cf54545538103cc9f298e0575820ad3591376e2e0f65d",
+        "374000d830c75d10d9417e493a7652920f30efbd300e3fb092f24c28c20baf64",
+        "0050d4148ad7a0437ca0643fad5bf4614cd95d9ba21fde52370b37dcc3f03307",
+    );
+
+    write_test!(
+        sha512,
+        "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce\
+         47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
+        "57ecf739d3a7ca647639adae80a05f4f361304bfcbfa1ceba93296b096e74287\
+         45fc10c142cecdd3bb587a3dba598c072f6f78b31cc0a06a3da0105ee51f75d6",
+        "dd28f78c53f3bc9bd0c2dca9642a1ad402a70412f985c1f6e54fadb98ce9c458\
+         4761df8d04ed04bb734ba48dd2106bb9ea54524f1394cdd18e6da3166e71c3ee",
+    );
+
+    write_test!(
+        ripemd160,
+        "9c1185a5c5e9fc54612808977ee8f548b2258d31",
+        "e571a1ca5b780aa52bafdb9ec852544ffca418ba",
+        "ddd2ecce739e823629c7d46ab18918e9c4a51c75",
+    );
+
+    write_test!(
+        hash160,
+        "b472a266d0bd89c13706a4132ccfb16f7c3b9fcb",
+        "671356a1a874695ad3bc20cae440f4360835bd5a",
+        "a9608c952c8dbcc20c53803d2ca5ad31d64d9313",
+    );
+
+    write_test!(siphash24, "d70077739d4b921e", "3a3ccefde9b5b1e3", "ce456e4e4ecbc5bf",);
+
+    #[test]
+    fn hmac() {
+        let mut engine = hmac::HmacEngine::<sha256::Hash>::new(&[0xde, 0xad, 0xbe, 0xef]);
+        engine.write_all(&[]).unwrap();
+        assert_eq!(
+            format!("{}", hmac::Hmac::from_engine(engine)),
+            "bf5515149cf797955c4d3194cca42472883281951697c8375d9d9b107f384225"
+        );
+
+        let mut engine = hmac::HmacEngine::<sha256::Hash>::new(&[0xde, 0xad, 0xbe, 0xef]);
+        engine.write_all(&[1; 256]).unwrap();
+        assert_eq!(
+            format!("{}", hmac::Hmac::from_engine(engine)),
+            "59c9aca10c81c73cb4c196d94db741b6bf2050e0153d5a45f2526bff34675ac5"
+        );
+
+        let mut engine = hmac::HmacEngine::<sha256::Hash>::new(&[0xde, 0xad, 0xbe, 0xef]);
+        engine.write_all(&[99; 64000]).unwrap();
+        assert_eq!(
+            format!("{}", hmac::Hmac::from_engine(engine)),
+            "30df499717415a395379a1eaabe50038036e4abb5afc94aa55c952f4aa57be08"
+        );
+    }
+}
diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
new file mode 100644
index 00000000..32a52dbf
--- /dev/null
+++ b/hashes/src/internal_macros.rs
@@ -0,0 +1,217 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Non-public macros
+
+macro_rules! arr_newtype_fmt_impl {
+    ($ty:ident, $bytes:expr $(, $gen:ident: $gent:ident)*) => {
+        impl<$($gen: $gent),*> $crate::_export::_core::fmt::LowerHex for $ty<$($gen),*> {
+            #[inline]
+            fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
+                #[allow(unused)]
+                use crate::Hash as _;
+                let case = $crate::hex::Case::Lower;
+                if <$ty<$($gen),*>>::DISPLAY_BACKWARD {
+                    $crate::hex::fmt_hex_exact!(f, $bytes, self.0.iter().rev(), case)
+                } else {
+                    $crate::hex::fmt_hex_exact!(f, $bytes, self.0.iter(), case)
+                }
+            }
+        }
+
+        impl<$($gen: $gent),*> $crate::_export::_core::fmt::UpperHex for $ty<$($gen),*> {
+            #[inline]
+            fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
+                #[allow(unused)]
+                use crate::Hash as _;
+                let case = $crate::hex::Case::Upper;
+                if <$ty<$($gen),*>>::DISPLAY_BACKWARD {
+                    $crate::hex::fmt_hex_exact!(f, $bytes, self.0.iter().rev(), case)
+                } else {
+                    $crate::hex::fmt_hex_exact!(f, $bytes, self.0.iter(), case)
+                }
+            }
+        }
+
+        impl<$($gen: $gent),*> $crate::_export::_core::fmt::Display for $ty<$($gen),*> {
+            #[inline]
+            fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
+                $crate::_export::_core::fmt::LowerHex::fmt(self, f)
+            }
+        }
+
+        impl<$($gen: $gent),*> $crate::_export::_core::fmt::Debug for $ty<$($gen),*> {
+            #[inline]
+            fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
+                write!(f, "{:#}", self)
+            }
+        }
+    }
+}
+pub(crate) use arr_newtype_fmt_impl;
+
+/// Adds trait impls to the type called `Hash` in the current scope.
+///
+/// Implpements various conversion traits as well as the [`crate::Hash`] trait.
+/// Arguments:
+///
+/// * `$bits` - number of bits this hash type has
+/// * `$reverse` - `bool`  - `true` if the hash type should be displayed backwards, `false`
+///    otherwise.
+/// * `$gen: $gent` - generic type(s) and trait bound(s)
+///
+/// Restrictions on usage:
+///
+/// * There must be a free-standing `fn from_engine(HashEngine) -> Hash` in the scope
+/// * `fn internal_new([u8; $bits / 8]) -> Self` must exist on `Hash`
+/// * `fn internal_engine() -> HashEngine` must exist on `Hash`
+///
+/// `from_engine` obviously implements the finalization algorithm.
+/// `internal_new` is required so that types with more than one field are constructible.
+/// `internal_engine` is required to initialize the engine for given hash type.
+macro_rules! hash_trait_impls {
+    ($bits:expr, $reverse:expr $(, $gen:ident: $gent:ident)*) => {
+        impl<$($gen: $gent),*> Hash<$($gen),*> {
+            /// Displays hex forwards, regardless of how this type would display it naturally.
+            ///
+            /// This is mainly intended as an internal method and you shouldn't need it unless
+            /// you're doing something special.
+            pub fn forward_hex(&self) -> impl '_ + core::fmt::LowerHex + core::fmt::UpperHex {
+                $crate::hex::DisplayHex::as_hex(&self.0)
+            }
+
+            /// Displays hex backwards, regardless of how this type would display it naturally.
+            ///
+            /// This is mainly intended as an internal method and you shouldn't need it unless
+            /// you're doing something special.
+            pub fn backward_hex(&self) -> impl '_ + core::fmt::LowerHex + core::fmt::UpperHex {
+                $crate::hex::display::DisplayArray::<_, [u8; $bits / 8 * 2]>::new(self.0.iter().rev())
+            }
+
+            /// Zero cost conversion between a fixed length byte array shared reference and
+            /// a shared reference to this Hash type.
+            pub fn from_bytes_ref(bytes: &[u8; $bits / 8]) -> &Self {
+                // Safety: Sound because Self is #[repr(transparent)] containing [u8; $bits / 8]
+                unsafe { &*(bytes as *const _ as *const Self) }
+            }
+
+            /// Zero cost conversion between a fixed length byte array exclusive reference and
+            /// an exclusive reference to this Hash type.
+            pub fn from_bytes_mut(bytes: &mut [u8; $bits / 8]) -> &mut Self {
+                // Safety: Sound because Self is #[repr(transparent)] containing [u8; $bits / 8]
+                unsafe { &mut *(bytes as *mut _ as *mut Self) }
+            }
+        }
+
+        impl<$($gen: $gent),*> str::FromStr for Hash<$($gen),*> {
+            type Err = $crate::hex::HexToArrayError;
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                use $crate::hex::{FromHex, HexToBytesIter};
+                use $crate::Hash;
+
+                let inner: [u8; $bits / 8] = if $reverse {
+                    FromHex::from_byte_iter(HexToBytesIter::new(s)?.rev())?
+                } else {
+                    FromHex::from_byte_iter(HexToBytesIter::new(s)?)?
+                };
+                Ok(Self::from_byte_array(inner))
+            }
+        }
+
+        $crate::internal_macros::arr_newtype_fmt_impl!(Hash, $bits / 8 $(, $gen: $gent)*);
+        serde_impl!(Hash, $bits / 8 $(, $gen: $gent)*);
+        borrow_slice_impl!(Hash $(, $gen: $gent)*);
+
+        impl<$($gen: $gent),*> $crate::_export::_core::convert::AsRef<[u8; $bits / 8]> for Hash<$($gen),*> {
+            fn as_ref(&self) -> &[u8; $bits / 8] {
+                &self.0
+            }
+        }
+
+        impl<I: SliceIndex<[u8]> $(, $gen: $gent)*> Index<I> for Hash<$($gen),*> {
+            type Output = I::Output;
+
+            #[inline]
+            fn index(&self, index: I) -> &Self::Output {
+                &self.0[index]
+            }
+        }
+
+        impl<$($gen: $gent),*> crate::Hash for Hash<$($gen),*> {
+            type Engine = HashEngine;
+            type Bytes = [u8; $bits / 8];
+
+            const LEN: usize = $bits / 8;
+            const DISPLAY_BACKWARD: bool = $reverse;
+
+            fn engine() -> Self::Engine {
+                Self::internal_engine()
+            }
+
+            fn from_engine(e: HashEngine) -> Hash<$($gen),*> {
+                from_engine(e)
+            }
+
+            fn from_slice(sl: &[u8]) -> Result<Hash<$($gen),*>, FromSliceError> {
+                if sl.len() != $bits / 8 {
+                    Err(FromSliceError{expected: Self::LEN, got: sl.len()})
+                } else {
+                    let mut ret = [0; $bits / 8];
+                    ret.copy_from_slice(sl);
+                    Ok(Self::internal_new(ret))
+                }
+            }
+
+            fn to_byte_array(self) -> Self::Bytes {
+                self.0
+            }
+
+            fn as_byte_array(&self) -> &Self::Bytes {
+                &self.0
+            }
+
+            fn from_byte_array(bytes: Self::Bytes) -> Self {
+                Self::internal_new(bytes)
+            }
+
+            fn all_zeros() -> Self {
+                Hash::internal_new([0x00; $bits / 8])
+            }
+        }
+    }
+}
+pub(crate) use hash_trait_impls;
+
+/// Creates a type called `Hash` and implements standard interface for it.
+///
+/// The created type will have all standard derives, `Hash` impl and implementation of
+/// `internal_engine` returning default. The created type has a single field.
+///
+/// Arguments:
+///
+/// * `$bits` - the number of bits of the hash type
+/// * `$reverse` - `true` if the hash should be displayed backwards, `false` otherwise
+/// * `$doc` - doc string to put on the type
+/// * `$schemars` - a literal that goes into `schema_with`.
+///
+/// The `from_engine` free-standing function is still required with this macro. See the doc of
+/// [`hash_trait_impls`].
+macro_rules! hash_type {
+    ($bits:expr, $reverse:expr, $doc:literal, $schemars:literal) => {
+        #[doc = $doc]
+        #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        #[cfg_attr(feature = "schemars", derive(crate::schemars::JsonSchema))]
+        #[repr(transparent)]
+        pub struct Hash(
+            #[cfg_attr(feature = "schemars", schemars(schema_with = $schemars))] [u8; $bits / 8],
+        );
+
+        impl Hash {
+            fn internal_new(arr: [u8; $bits / 8]) -> Self { Hash(arr) }
+
+            fn internal_engine() -> HashEngine { Default::default() }
+        }
+
+        crate::internal_macros::hash_trait_impls!($bits, $reverse);
+    };
+}
+pub(crate) use hash_type;
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
new file mode 100644
index 00000000..61361bb5
--- /dev/null
+++ b/hashes/src/lib.rs
@@ -0,0 +1,270 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Rust hashes library.
+//!
+//! This is a simple, no-dependency library which implements the hash functions
+//! needed by Bitcoin. These are SHA256, SHA256d, and RIPEMD160. As an ancillary
+//! thing, it exposes hexadecimal serialization and deserialization, since these
+//! are needed to display hashes anway.
+//!
+//! ## Commonly used operations
+//!
+//! Hashing a single byte slice or a string:
+//!
+//! ```rust
+//! use tapyrus_hashes::sha256;
+//! use tapyrus_hashes::Hash;
+//!
+//! let bytes = [0u8; 5];
+//! let hash_of_bytes = sha256::Hash::hash(&bytes);
+//! let hash_of_string = sha256::Hash::hash("some string".as_bytes());
+//! ```
+//!
+//!
+//! Hashing content from a reader:
+//!
+//! ```rust
+//! use tapyrus_hashes::sha256;
+//! use tapyrus_hashes::Hash;
+//!
+//! #[cfg(std)]
+//! # fn main() -> std::io::Result<()> {
+//! let mut reader: &[u8] = b"hello"; // in real code, this could be a `File` or `TcpStream`
+//! let mut engine = sha256::HashEngine::default();
+//! std::io::copy(&mut reader, &mut engine)?;
+//! let hash = sha256::Hash::from_engine(engine);
+//! # Ok(())
+//! # }
+//!
+//! #[cfg(not(std))]
+//! # fn main() {}
+//! ```
+//!
+//!
+//! Hashing content by [`std::io::Write`] on HashEngine:
+//!
+//! ```rust
+//! use tapyrus_hashes::sha256;
+//! use tapyrus_hashes::Hash;
+//! use std::io::Write;
+//!
+//! #[cfg(std)]
+//! # fn main() -> std::io::Result<()> {
+//! let mut part1: &[u8] = b"hello";
+//! let mut part2: &[u8] = b" ";
+//! let mut part3: &[u8] = b"world";
+//! let mut engine = sha256::HashEngine::default();
+//! engine.write_all(part1)?;
+//! engine.write_all(part2)?;
+//! engine.write_all(part3)?;
+//! let hash = sha256::Hash::from_engine(engine);
+//! # Ok(())
+//! # }
+//!
+//! #[cfg(not(std))]
+//! # fn main() {}
+//! ```
+
+// Coding conventions
+#![warn(missing_docs)]
+// Experimental features we need.
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(bench, feature(test))]
+// In general, rust is absolutely horrid at supporting users doing things like,
+// for example, compiling Rust code for real environments. Disable useless lints
+// that don't do anything but annoy us and cant actually ever be resolved.
+#![allow(bare_trait_objects)]
+#![allow(ellipsis_inclusive_range_patterns)]
+#![cfg_attr(all(not(test), not(feature = "std")), no_std)]
+// Instead of littering the codebase for non-fuzzing code just globally allow.
+#![cfg_attr(hashes_fuzz, allow(dead_code, unused_imports))]
+// Exclude clippy lints we don't think are valuable
+#![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
+
+#[cfg(all(not(test), not(feature = "std"), feature = "core2"))]
+extern crate actual_core2 as core2;
+#[cfg(all(feature = "alloc", not(feature = "std")))]
+extern crate alloc;
+#[cfg(any(test, feature = "std"))]
+extern crate core;
+
+#[cfg(feature = "serde")]
+/// A generic serialization/deserialization framework.
+pub extern crate serde;
+
+#[cfg(all(test, feature = "serde"))]
+extern crate serde_test;
+#[cfg(bench)]
+extern crate test;
+
+/// Re-export the `hex-conservative` crate.
+pub extern crate hex;
+
+#[doc(hidden)]
+pub mod _export {
+    /// A re-export of core::*
+    pub mod _core {
+        pub use core::*;
+    }
+}
+
+#[cfg(feature = "schemars")]
+extern crate schemars;
+
+mod internal_macros;
+#[macro_use]
+mod util;
+#[macro_use]
+pub mod serde_macros;
+pub mod cmp;
+pub mod hash160;
+pub mod hmac;
+#[cfg(any(test, feature = "std", feature = "core2"))]
+mod impls;
+pub mod ripemd160;
+pub mod sha1;
+pub mod sha256;
+pub mod sha256d;
+pub mod sha256t;
+pub mod sha512;
+pub mod sha512_256;
+pub mod siphash24;
+
+use core::{borrow, fmt, hash, ops};
+// You get I/O if you enable "std" or "core2" (as well as during testing).
+#[cfg(any(test, feature = "std"))]
+use std::io;
+
+#[cfg(all(not(test), not(feature = "std"), feature = "core2"))]
+use core2::io;
+pub use hmac::{Hmac, HmacEngine};
+
+/// A hashing engine which bytes can be serialized into.
+pub trait HashEngine: Clone + Default {
+    /// Byte array representing the internal state of the hash engine.
+    type MidState;
+
+    /// Outputs the midstate of the hash engine. This function should not be
+    /// used directly unless you really know what you're doing.
+    fn midstate(&self) -> Self::MidState;
+
+    /// Length of the hash's internal block size, in bytes.
+    const BLOCK_SIZE: usize;
+
+    /// Add data to the hash engine.
+    fn input(&mut self, data: &[u8]);
+
+    /// Return the number of bytes already n_bytes_hashed(inputted).
+    fn n_bytes_hashed(&self) -> usize;
+}
+
+/// Trait which applies to hashes of all types.
+pub trait Hash:
+    Copy
+    + Clone
+    + PartialEq
+    + Eq
+    + PartialOrd
+    + Ord
+    + hash::Hash
+    + fmt::Debug
+    + fmt::Display
+    + fmt::LowerHex
+    + ops::Index<ops::RangeFull, Output = [u8]>
+    + ops::Index<ops::RangeFrom<usize>, Output = [u8]>
+    + ops::Index<ops::RangeTo<usize>, Output = [u8]>
+    + ops::Index<ops::Range<usize>, Output = [u8]>
+    + ops::Index<usize, Output = u8>
+    + borrow::Borrow<[u8]>
+{
+    /// A hashing engine which bytes can be serialized into. It is expected
+    /// to implement the `io::Write` trait, and to never return errors under
+    /// any conditions.
+    type Engine: HashEngine;
+
+    /// The byte array that represents the hash internally.
+    type Bytes: hex::FromHex + Copy;
+
+    /// Constructs a new engine.
+    fn engine() -> Self::Engine { Self::Engine::default() }
+
+    /// Produces a hash from the current state of a given engine.
+    fn from_engine(e: Self::Engine) -> Self;
+
+    /// Length of the hash, in bytes.
+    const LEN: usize;
+
+    /// Copies a byte slice into a hash object.
+    fn from_slice(sl: &[u8]) -> Result<Self, FromSliceError>;
+
+    /// Hashes some bytes.
+    fn hash(data: &[u8]) -> Self {
+        let mut engine = Self::engine();
+        engine.input(data);
+        Self::from_engine(engine)
+    }
+
+    /// Flag indicating whether user-visible serializations of this hash
+    /// should be backward. For some reason Satoshi decided this should be
+    /// true for `Sha256dHash`, so here we are.
+    const DISPLAY_BACKWARD: bool = false;
+
+    /// Returns the underlying byte array.
+    fn to_byte_array(self) -> Self::Bytes;
+
+    /// Returns a reference to the underlying byte array.
+    fn as_byte_array(&self) -> &Self::Bytes;
+
+    /// Constructs a hash from the underlying byte array.
+    fn from_byte_array(bytes: Self::Bytes) -> Self;
+
+    /// Returns an all zero hash.
+    ///
+    /// An all zeros hash is a made up construct because there is not a known input that can create
+    /// it, however it is used in various places in Bitcoin e.g., the Bitcoin genesis block's
+    /// previous blockhash and the coinbase transaction's outpoint txid.
+    fn all_zeros() -> Self;
+}
+
+/// Attempted to create a hash from an invalid length slice.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct FromSliceError {
+    expected: usize,
+    got: usize,
+}
+
+impl fmt::Display for FromSliceError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "invalid slice length {} (expected {})", self.got, self.expected)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for FromSliceError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{sha256d, Hash};
+
+    hash_newtype! {
+        /// A test newtype
+        struct TestNewtype(sha256d::Hash);
+
+        /// A test newtype
+        struct TestNewtype2(sha256d::Hash);
+    }
+
+    #[test]
+    fn convert_newtypes() {
+        let h1 = TestNewtype::hash(&[]);
+        let h2: TestNewtype2 = h1.to_raw_hash().into();
+        assert_eq!(&h1[..], &h2[..]);
+
+        let h = sha256d::Hash::hash(&[]);
+        let h2: TestNewtype = h.to_string().parse().unwrap();
+        assert_eq!(h2.to_raw_hash(), h);
+    }
+}
diff --git a/hashes/src/ripemd160.rs b/hashes/src/ripemd160.rs
new file mode 100644
index 00000000..d97b3bba
--- /dev/null
+++ b/hashes/src/ripemd160.rs
@@ -0,0 +1,565 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! RIPEMD160 implementation.
+//!
+
+use core::convert::TryInto;
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::{cmp, str};
+
+use crate::{FromSliceError, HashEngine as _};
+
+crate::internal_macros::hash_type! {
+    160,
+    false,
+    "Output of the RIPEMD160 hash function.",
+    "crate::util::json_hex_string::len_20"
+}
+
+#[cfg(not(hashes_fuzz))]
+fn from_engine(mut e: HashEngine) -> Hash {
+    // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
+    let data_len = e.length as u64;
+
+    let zeroes = [0; BLOCK_SIZE - 8];
+    e.input(&[0x80]);
+    if e.length % BLOCK_SIZE > zeroes.len() {
+        e.input(&zeroes);
+    }
+    let pad_length = zeroes.len() - (e.length % BLOCK_SIZE);
+    e.input(&zeroes[..pad_length]);
+    debug_assert_eq!(e.length % BLOCK_SIZE, zeroes.len());
+
+    e.input(&(8 * data_len).to_le_bytes());
+    debug_assert_eq!(e.length % BLOCK_SIZE, 0);
+
+    Hash(e.midstate())
+}
+
+#[cfg(hashes_fuzz)]
+fn from_engine(e: HashEngine) -> Hash {
+    let mut res = e.midstate();
+    res[0] ^= (e.length & 0xff) as u8;
+    Hash(res)
+}
+
+const BLOCK_SIZE: usize = 64;
+
+/// Engine to compute RIPEMD160 hash function.
+#[derive(Clone)]
+pub struct HashEngine {
+    buffer: [u8; BLOCK_SIZE],
+    h: [u32; 5],
+    length: usize,
+}
+
+impl Default for HashEngine {
+    fn default() -> Self {
+        HashEngine {
+            h: [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0],
+            length: 0,
+            buffer: [0; BLOCK_SIZE],
+        }
+    }
+}
+
+impl crate::HashEngine for HashEngine {
+    type MidState = [u8; 20];
+
+    #[cfg(not(hashes_fuzz))]
+    fn midstate(&self) -> [u8; 20] {
+        let mut ret = [0; 20];
+        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_exact_mut(4)) {
+            ret_bytes.copy_from_slice(&(*val).to_le_bytes());
+        }
+        ret
+    }
+
+    #[cfg(hashes_fuzz)]
+    fn midstate(&self) -> [u8; 20] {
+        let mut ret = [0; 20];
+        ret.copy_from_slice(&self.buffer[..20]);
+        ret
+    }
+
+    const BLOCK_SIZE: usize = 64;
+
+    fn n_bytes_hashed(&self) -> usize { self.length }
+
+    engine_input_impl!();
+}
+
+#[cfg(feature = "small-hash")]
+#[macro_use]
+mod small_hash {
+    #[rustfmt::skip]
+    pub(super) fn round(a: u32, _b: u32, c: u32, _d: u32, e: u32,
+                        x: u32, bits: u32, add: u32, round: u32,
+    ) -> (u32, u32) {
+        let a = a.wrapping_add(round).wrapping_add(x).wrapping_add(add);
+        let a = a.rotate_left(bits).wrapping_add(e);
+        let c = c.rotate_left(10);
+
+        (a, c)
+    }
+
+    macro_rules! round(
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr,
+         $x:expr, $bits:expr, $add:expr, $round:expr) => ({
+            let updates = small_hash::round($a, $b, $c, $d, $e, $x, $bits, $add, $round);
+            $a = updates.0;
+            $c = updates.1;
+        });
+    );
+}
+
+#[cfg(not(feature = "small-hash"))]
+macro_rules! round(
+    ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr,
+     $x:expr, $bits:expr, $add:expr, $round:expr) => ({
+        $a = $a.wrapping_add($round).wrapping_add($x).wrapping_add($add);
+        $a = $a.rotate_left($bits).wrapping_add($e);
+        $c = $c.rotate_left(10);
+    });
+);
+
+macro_rules! process_block(
+    ($h:expr, $data:expr,
+     $( round1: h_ordering $f0:expr, $f1:expr, $f2:expr, $f3:expr, $f4:expr;
+                data_index $data_index1:expr; roll_shift $bits1:expr; )*
+     $( round2: h_ordering $g0:expr, $g1:expr, $g2:expr, $g3:expr, $g4:expr;
+                data_index $data_index2:expr; roll_shift $bits2:expr; )*
+     $( round3: h_ordering $h0:expr, $h1:expr, $h2:expr, $h3:expr, $h4:expr;
+                data_index $data_index3:expr; roll_shift $bits3:expr; )*
+     $( round4: h_ordering $i0:expr, $i1:expr, $i2:expr, $i3:expr, $i4:expr;
+                data_index $data_index4:expr; roll_shift $bits4:expr; )*
+     $( round5: h_ordering $j0:expr, $j1:expr, $j2:expr, $j3:expr, $j4:expr;
+                data_index $data_index5:expr; roll_shift $bits5:expr; )*
+     $( par_round1: h_ordering $pj0:expr, $pj1:expr, $pj2:expr, $pj3:expr, $pj4:expr;
+                    data_index $pdata_index1:expr; roll_shift $pbits1:expr; )*
+     $( par_round2: h_ordering $pi0:expr, $pi1:expr, $pi2:expr, $pi3:expr, $pi4:expr;
+                    data_index $pdata_index2:expr; roll_shift $pbits2:expr; )*
+     $( par_round3: h_ordering $ph0:expr, $ph1:expr, $ph2:expr, $ph3:expr, $ph4:expr;
+                    data_index $pdata_index3:expr; roll_shift $pbits3:expr; )*
+     $( par_round4: h_ordering $pg0:expr, $pg1:expr, $pg2:expr, $pg3:expr, $pg4:expr;
+                    data_index $pdata_index4:expr; roll_shift $pbits4:expr; )*
+     $( par_round5: h_ordering $pf0:expr, $pf1:expr, $pf2:expr, $pf3:expr, $pf4:expr;
+                    data_index $pdata_index5:expr; roll_shift $pbits5:expr; )*
+    ) => ({
+        let mut bb = $h;
+        let mut bbb = $h;
+
+        // Round 1
+        $( round!(bb[$f0], bb[$f1], bb[$f2], bb[$f3], bb[$f4],
+                  $data[$data_index1], $bits1, 0x00000000,
+                  bb[$f1] ^ bb[$f2] ^ bb[$f3]); )*
+
+        // Round 2
+        $( round!(bb[$g0], bb[$g1], bb[$g2], bb[$g3], bb[$g4],
+                  $data[$data_index2], $bits2, 0x5a827999,
+                  (bb[$g1] & bb[$g2]) | (!bb[$g1] & bb[$g3])); )*
+
+        // Round 3
+        $( round!(bb[$h0], bb[$h1], bb[$h2], bb[$h3], bb[$h4],
+                  $data[$data_index3], $bits3, 0x6ed9eba1,
+                  (bb[$h1] | !bb[$h2]) ^ bb[$h3]); )*
+
+        // Round 4
+        $( round!(bb[$i0], bb[$i1], bb[$i2], bb[$i3], bb[$i4],
+                  $data[$data_index4], $bits4, 0x8f1bbcdc,
+                  (bb[$i1] & bb[$i3]) | (bb[$i2] & !bb[$i3])); )*
+
+        // Round 5
+        $( round!(bb[$j0], bb[$j1], bb[$j2], bb[$j3], bb[$j4],
+                  $data[$data_index5], $bits5, 0xa953fd4e,
+                  bb[$j1] ^ (bb[$j2] | !bb[$j3])); )*
+
+        // Parallel rounds: these are the same as the previous five
+        // rounds except that the constants have changed, we work
+        // with the other buffer, and they are applied in reverse
+        // order.
+
+        // Parallel Round 1
+        $( round!(bbb[$pj0], bbb[$pj1], bbb[$pj2], bbb[$pj3], bbb[$pj4],
+                  $data[$pdata_index1], $pbits1, 0x50a28be6,
+                  bbb[$pj1] ^ (bbb[$pj2] | !bbb[$pj3])); )*
+
+        // Porallel Round 2
+        $( round!(bbb[$pi0], bbb[$pi1], bbb[$pi2], bbb[$pi3], bbb[$pi4],
+                  $data[$pdata_index2], $pbits2, 0x5c4dd124,
+                  (bbb[$pi1] & bbb[$pi3]) | (bbb[$pi2] & !bbb[$pi3])); )*
+
+        // Parallel Round 3
+        $( round!(bbb[$ph0], bbb[$ph1], bbb[$ph2], bbb[$ph3], bbb[$ph4],
+                  $data[$pdata_index3], $pbits3, 0x6d703ef3,
+                  (bbb[$ph1] | !bbb[$ph2]) ^ bbb[$ph3]); )*
+
+        // Parallel Round 4
+        $( round!(bbb[$pg0], bbb[$pg1], bbb[$pg2], bbb[$pg3], bbb[$pg4],
+                  $data[$pdata_index4], $pbits4, 0x7a6d76e9,
+                  (bbb[$pg1] & bbb[$pg2]) | (!bbb[$pg1] & bbb[$pg3])); )*
+
+        // Parallel Round 5
+        $( round!(bbb[$pf0], bbb[$pf1], bbb[$pf2], bbb[$pf3], bbb[$pf4],
+                  $data[$pdata_index5], $pbits5, 0x00000000,
+                  bbb[$pf1] ^ bbb[$pf2] ^ bbb[$pf3]); )*
+
+        // Combine results
+        bbb[3] = bbb[3].wrapping_add($h[1]).wrapping_add(bb[2]);
+        $h[1]  =  $h[2].wrapping_add(bb[3]).wrapping_add(bbb[4]);
+        $h[2]  =  $h[3].wrapping_add(bb[4]).wrapping_add(bbb[0]);
+        $h[3]  =  $h[4].wrapping_add(bb[0]).wrapping_add(bbb[1]);
+        $h[4]  =  $h[0].wrapping_add(bb[1]).wrapping_add(bbb[2]);
+        $h[0]  =                                         bbb[3];
+    });
+);
+
+impl HashEngine {
+    fn process_block(&mut self) {
+        debug_assert_eq!(self.buffer.len(), BLOCK_SIZE);
+
+        let mut w = [0u32; 16];
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks_exact(4)) {
+            *w_val = u32::from_le_bytes(buff_bytes.try_into().expect("4 byte slice"))
+        }
+
+        process_block!(self.h, w,
+            // Round 1
+            round1: h_ordering 0, 1, 2, 3, 4; data_index  0; roll_shift 11;
+            round1: h_ordering 4, 0, 1, 2, 3; data_index  1; roll_shift 14;
+            round1: h_ordering 3, 4, 0, 1, 2; data_index  2; roll_shift 15;
+            round1: h_ordering 2, 3, 4, 0, 1; data_index  3; roll_shift 12;
+            round1: h_ordering 1, 2, 3, 4, 0; data_index  4; roll_shift  5;
+            round1: h_ordering 0, 1, 2, 3, 4; data_index  5; roll_shift  8;
+            round1: h_ordering 4, 0, 1, 2, 3; data_index  6; roll_shift  7;
+            round1: h_ordering 3, 4, 0, 1, 2; data_index  7; roll_shift  9;
+            round1: h_ordering 2, 3, 4, 0, 1; data_index  8; roll_shift 11;
+            round1: h_ordering 1, 2, 3, 4, 0; data_index  9; roll_shift 13;
+            round1: h_ordering 0, 1, 2, 3, 4; data_index 10; roll_shift 14;
+            round1: h_ordering 4, 0, 1, 2, 3; data_index 11; roll_shift 15;
+            round1: h_ordering 3, 4, 0, 1, 2; data_index 12; roll_shift  6;
+            round1: h_ordering 2, 3, 4, 0, 1; data_index 13; roll_shift  7;
+            round1: h_ordering 1, 2, 3, 4, 0; data_index 14; roll_shift  9;
+            round1: h_ordering 0, 1, 2, 3, 4; data_index 15; roll_shift  8;
+
+            // Round 2
+            round2: h_ordering 4, 0, 1, 2, 3; data_index  7; roll_shift  7;
+            round2: h_ordering 3, 4, 0, 1, 2; data_index  4; roll_shift  6;
+            round2: h_ordering 2, 3, 4, 0, 1; data_index 13; roll_shift  8;
+            round2: h_ordering 1, 2, 3, 4, 0; data_index  1; roll_shift 13;
+            round2: h_ordering 0, 1, 2, 3, 4; data_index 10; roll_shift 11;
+            round2: h_ordering 4, 0, 1, 2, 3; data_index  6; roll_shift  9;
+            round2: h_ordering 3, 4, 0, 1, 2; data_index 15; roll_shift  7;
+            round2: h_ordering 2, 3, 4, 0, 1; data_index  3; roll_shift 15;
+            round2: h_ordering 1, 2, 3, 4, 0; data_index 12; roll_shift  7;
+            round2: h_ordering 0, 1, 2, 3, 4; data_index  0; roll_shift 12;
+            round2: h_ordering 4, 0, 1, 2, 3; data_index  9; roll_shift 15;
+            round2: h_ordering 3, 4, 0, 1, 2; data_index  5; roll_shift  9;
+            round2: h_ordering 2, 3, 4, 0, 1; data_index  2; roll_shift 11;
+            round2: h_ordering 1, 2, 3, 4, 0; data_index 14; roll_shift  7;
+            round2: h_ordering 0, 1, 2, 3, 4; data_index 11; roll_shift 13;
+            round2: h_ordering 4, 0, 1, 2, 3; data_index  8; roll_shift 12;
+
+            // Round 3
+            round3: h_ordering 3, 4, 0, 1, 2; data_index  3; roll_shift 11;
+            round3: h_ordering 2, 3, 4, 0, 1; data_index 10; roll_shift 13;
+            round3: h_ordering 1, 2, 3, 4, 0; data_index 14; roll_shift  6;
+            round3: h_ordering 0, 1, 2, 3, 4; data_index  4; roll_shift  7;
+            round3: h_ordering 4, 0, 1, 2, 3; data_index  9; roll_shift 14;
+            round3: h_ordering 3, 4, 0, 1, 2; data_index 15; roll_shift  9;
+            round3: h_ordering 2, 3, 4, 0, 1; data_index  8; roll_shift 13;
+            round3: h_ordering 1, 2, 3, 4, 0; data_index  1; roll_shift 15;
+            round3: h_ordering 0, 1, 2, 3, 4; data_index  2; roll_shift 14;
+            round3: h_ordering 4, 0, 1, 2, 3; data_index  7; roll_shift  8;
+            round3: h_ordering 3, 4, 0, 1, 2; data_index  0; roll_shift 13;
+            round3: h_ordering 2, 3, 4, 0, 1; data_index  6; roll_shift  6;
+            round3: h_ordering 1, 2, 3, 4, 0; data_index 13; roll_shift  5;
+            round3: h_ordering 0, 1, 2, 3, 4; data_index 11; roll_shift 12;
+            round3: h_ordering 4, 0, 1, 2, 3; data_index  5; roll_shift  7;
+            round3: h_ordering 3, 4, 0, 1, 2; data_index 12; roll_shift  5;
+
+            // Round 4
+            round4: h_ordering 2, 3, 4, 0, 1; data_index  1; roll_shift 11;
+            round4: h_ordering 1, 2, 3, 4, 0; data_index  9; roll_shift 12;
+            round4: h_ordering 0, 1, 2, 3, 4; data_index 11; roll_shift 14;
+            round4: h_ordering 4, 0, 1, 2, 3; data_index 10; roll_shift 15;
+            round4: h_ordering 3, 4, 0, 1, 2; data_index  0; roll_shift 14;
+            round4: h_ordering 2, 3, 4, 0, 1; data_index  8; roll_shift 15;
+            round4: h_ordering 1, 2, 3, 4, 0; data_index 12; roll_shift  9;
+            round4: h_ordering 0, 1, 2, 3, 4; data_index  4; roll_shift  8;
+            round4: h_ordering 4, 0, 1, 2, 3; data_index 13; roll_shift  9;
+            round4: h_ordering 3, 4, 0, 1, 2; data_index  3; roll_shift 14;
+            round4: h_ordering 2, 3, 4, 0, 1; data_index  7; roll_shift  5;
+            round4: h_ordering 1, 2, 3, 4, 0; data_index 15; roll_shift  6;
+            round4: h_ordering 0, 1, 2, 3, 4; data_index 14; roll_shift  8;
+            round4: h_ordering 4, 0, 1, 2, 3; data_index  5; roll_shift  6;
+            round4: h_ordering 3, 4, 0, 1, 2; data_index  6; roll_shift  5;
+            round4: h_ordering 2, 3, 4, 0, 1; data_index  2; roll_shift 12;
+
+            // Round 5
+            round5: h_ordering 1, 2, 3, 4, 0; data_index  4; roll_shift  9;
+            round5: h_ordering 0, 1, 2, 3, 4; data_index  0; roll_shift 15;
+            round5: h_ordering 4, 0, 1, 2, 3; data_index  5; roll_shift  5;
+            round5: h_ordering 3, 4, 0, 1, 2; data_index  9; roll_shift 11;
+            round5: h_ordering 2, 3, 4, 0, 1; data_index  7; roll_shift  6;
+            round5: h_ordering 1, 2, 3, 4, 0; data_index 12; roll_shift  8;
+            round5: h_ordering 0, 1, 2, 3, 4; data_index  2; roll_shift 13;
+            round5: h_ordering 4, 0, 1, 2, 3; data_index 10; roll_shift 12;
+            round5: h_ordering 3, 4, 0, 1, 2; data_index 14; roll_shift  5;
+            round5: h_ordering 2, 3, 4, 0, 1; data_index  1; roll_shift 12;
+            round5: h_ordering 1, 2, 3, 4, 0; data_index  3; roll_shift 13;
+            round5: h_ordering 0, 1, 2, 3, 4; data_index  8; roll_shift 14;
+            round5: h_ordering 4, 0, 1, 2, 3; data_index 11; roll_shift 11;
+            round5: h_ordering 3, 4, 0, 1, 2; data_index  6; roll_shift  8;
+            round5: h_ordering 2, 3, 4, 0, 1; data_index 15; roll_shift  5;
+            round5: h_ordering 1, 2, 3, 4, 0; data_index 13; roll_shift  6;
+
+            // Porallel Round 1;
+            par_round1: h_ordering 0, 1, 2, 3, 4; data_index  5; roll_shift  8;
+            par_round1: h_ordering 4, 0, 1, 2, 3; data_index 14; roll_shift  9;
+            par_round1: h_ordering 3, 4, 0, 1, 2; data_index  7; roll_shift  9;
+            par_round1: h_ordering 2, 3, 4, 0, 1; data_index  0; roll_shift 11;
+            par_round1: h_ordering 1, 2, 3, 4, 0; data_index  9; roll_shift 13;
+            par_round1: h_ordering 0, 1, 2, 3, 4; data_index  2; roll_shift 15;
+            par_round1: h_ordering 4, 0, 1, 2, 3; data_index 11; roll_shift 15;
+            par_round1: h_ordering 3, 4, 0, 1, 2; data_index  4; roll_shift  5;
+            par_round1: h_ordering 2, 3, 4, 0, 1; data_index 13; roll_shift  7;
+            par_round1: h_ordering 1, 2, 3, 4, 0; data_index  6; roll_shift  7;
+            par_round1: h_ordering 0, 1, 2, 3, 4; data_index 15; roll_shift  8;
+            par_round1: h_ordering 4, 0, 1, 2, 3; data_index  8; roll_shift 11;
+            par_round1: h_ordering 3, 4, 0, 1, 2; data_index  1; roll_shift 14;
+            par_round1: h_ordering 2, 3, 4, 0, 1; data_index 10; roll_shift 14;
+            par_round1: h_ordering 1, 2, 3, 4, 0; data_index  3; roll_shift 12;
+            par_round1: h_ordering 0, 1, 2, 3, 4; data_index 12; roll_shift  6;
+
+            // Parallel Round 2
+            par_round2: h_ordering 4, 0, 1, 2, 3; data_index  6; roll_shift  9;
+            par_round2: h_ordering 3, 4, 0, 1, 2; data_index 11; roll_shift 13;
+            par_round2: h_ordering 2, 3, 4, 0, 1; data_index  3; roll_shift 15;
+            par_round2: h_ordering 1, 2, 3, 4, 0; data_index  7; roll_shift  7;
+            par_round2: h_ordering 0, 1, 2, 3, 4; data_index  0; roll_shift 12;
+            par_round2: h_ordering 4, 0, 1, 2, 3; data_index 13; roll_shift  8;
+            par_round2: h_ordering 3, 4, 0, 1, 2; data_index  5; roll_shift  9;
+            par_round2: h_ordering 2, 3, 4, 0, 1; data_index 10; roll_shift 11;
+            par_round2: h_ordering 1, 2, 3, 4, 0; data_index 14; roll_shift  7;
+            par_round2: h_ordering 0, 1, 2, 3, 4; data_index 15; roll_shift  7;
+            par_round2: h_ordering 4, 0, 1, 2, 3; data_index  8; roll_shift 12;
+            par_round2: h_ordering 3, 4, 0, 1, 2; data_index 12; roll_shift  7;
+            par_round2: h_ordering 2, 3, 4, 0, 1; data_index  4; roll_shift  6;
+            par_round2: h_ordering 1, 2, 3, 4, 0; data_index  9; roll_shift 15;
+            par_round2: h_ordering 0, 1, 2, 3, 4; data_index  1; roll_shift 13;
+            par_round2: h_ordering 4, 0, 1, 2, 3; data_index  2; roll_shift 11;
+
+            // Parallel Round 3
+            par_round3: h_ordering 3, 4, 0, 1, 2; data_index 15; roll_shift  9;
+            par_round3: h_ordering 2, 3, 4, 0, 1; data_index  5; roll_shift  7;
+            par_round3: h_ordering 1, 2, 3, 4, 0; data_index  1; roll_shift 15;
+            par_round3: h_ordering 0, 1, 2, 3, 4; data_index  3; roll_shift 11;
+            par_round3: h_ordering 4, 0, 1, 2, 3; data_index  7; roll_shift  8;
+            par_round3: h_ordering 3, 4, 0, 1, 2; data_index 14; roll_shift  6;
+            par_round3: h_ordering 2, 3, 4, 0, 1; data_index  6; roll_shift  6;
+            par_round3: h_ordering 1, 2, 3, 4, 0; data_index  9; roll_shift 14;
+            par_round3: h_ordering 0, 1, 2, 3, 4; data_index 11; roll_shift 12;
+            par_round3: h_ordering 4, 0, 1, 2, 3; data_index  8; roll_shift 13;
+            par_round3: h_ordering 3, 4, 0, 1, 2; data_index 12; roll_shift  5;
+            par_round3: h_ordering 2, 3, 4, 0, 1; data_index  2; roll_shift 14;
+            par_round3: h_ordering 1, 2, 3, 4, 0; data_index 10; roll_shift 13;
+            par_round3: h_ordering 0, 1, 2, 3, 4; data_index  0; roll_shift 13;
+            par_round3: h_ordering 4, 0, 1, 2, 3; data_index  4; roll_shift  7;
+            par_round3: h_ordering 3, 4, 0, 1, 2; data_index 13; roll_shift  5;
+
+            // Parallel Round 4
+            par_round4: h_ordering 2, 3, 4, 0, 1; data_index  8; roll_shift 15;
+            par_round4: h_ordering 1, 2, 3, 4, 0; data_index  6; roll_shift  5;
+            par_round4: h_ordering 0, 1, 2, 3, 4; data_index  4; roll_shift  8;
+            par_round4: h_ordering 4, 0, 1, 2, 3; data_index  1; roll_shift 11;
+            par_round4: h_ordering 3, 4, 0, 1, 2; data_index  3; roll_shift 14;
+            par_round4: h_ordering 2, 3, 4, 0, 1; data_index 11; roll_shift 14;
+            par_round4: h_ordering 1, 2, 3, 4, 0; data_index 15; roll_shift  6;
+            par_round4: h_ordering 0, 1, 2, 3, 4; data_index  0; roll_shift 14;
+            par_round4: h_ordering 4, 0, 1, 2, 3; data_index  5; roll_shift  6;
+            par_round4: h_ordering 3, 4, 0, 1, 2; data_index 12; roll_shift  9;
+            par_round4: h_ordering 2, 3, 4, 0, 1; data_index  2; roll_shift 12;
+            par_round4: h_ordering 1, 2, 3, 4, 0; data_index 13; roll_shift  9;
+            par_round4: h_ordering 0, 1, 2, 3, 4; data_index  9; roll_shift 12;
+            par_round4: h_ordering 4, 0, 1, 2, 3; data_index  7; roll_shift  5;
+            par_round4: h_ordering 3, 4, 0, 1, 2; data_index 10; roll_shift 15;
+            par_round4: h_ordering 2, 3, 4, 0, 1; data_index 14; roll_shift  8;
+
+            // Parallel Round 5
+            par_round5: h_ordering 1, 2, 3, 4, 0; data_index 12; roll_shift  8;
+            par_round5: h_ordering 0, 1, 2, 3, 4; data_index 15; roll_shift  5;
+            par_round5: h_ordering 4, 0, 1, 2, 3; data_index 10; roll_shift 12;
+            par_round5: h_ordering 3, 4, 0, 1, 2; data_index  4; roll_shift  9;
+            par_round5: h_ordering 2, 3, 4, 0, 1; data_index  1; roll_shift 12;
+            par_round5: h_ordering 1, 2, 3, 4, 0; data_index  5; roll_shift  5;
+            par_round5: h_ordering 0, 1, 2, 3, 4; data_index  8; roll_shift 14;
+            par_round5: h_ordering 4, 0, 1, 2, 3; data_index  7; roll_shift  6;
+            par_round5: h_ordering 3, 4, 0, 1, 2; data_index  6; roll_shift  8;
+            par_round5: h_ordering 2, 3, 4, 0, 1; data_index  2; roll_shift 13;
+            par_round5: h_ordering 1, 2, 3, 4, 0; data_index 13; roll_shift  6;
+            par_round5: h_ordering 0, 1, 2, 3, 4; data_index 14; roll_shift  5;
+            par_round5: h_ordering 4, 0, 1, 2, 3; data_index  0; roll_shift 15;
+            par_round5: h_ordering 3, 4, 0, 1, 2; data_index  3; roll_shift 13;
+            par_round5: h_ordering 2, 3, 4, 0, 1; data_index  9; roll_shift 11;
+            par_round5: h_ordering 1, 2, 3, 4, 0; data_index 11; roll_shift 11;
+        );
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test() {
+        use std::convert::TryFrom;
+
+        use crate::{ripemd160, Hash, HashEngine};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
+        #[rustfmt::skip]
+        let tests = vec![
+            // Test messages from FIPS 180-1
+            Test {
+                input: "abc",
+                output: vec![
+                    0x8e, 0xb2, 0x08, 0xf7,
+                    0xe0, 0x5d, 0x98, 0x7a,
+                    0x9b, 0x04, 0x4a, 0x8e,
+                    0x98, 0xc6, 0xb0, 0x87,
+                    0xf1, 0x5a, 0x0b, 0xfc,
+                ],
+                output_str: "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc"
+            },
+            Test {
+                input:
+                     "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+                output: vec![
+                    0x12, 0xa0, 0x53, 0x38,
+                    0x4a, 0x9c, 0x0c, 0x88,
+                    0xe4, 0x05, 0xa0, 0x6c,
+                    0x27, 0xdc, 0xf4, 0x9a,
+                    0xda, 0x62, 0xeb, 0x2b,
+                ],
+                output_str: "12a053384a9c0c88e405a06c27dcf49ada62eb2b"
+            },
+            // Examples from wikipedia
+            Test {
+                input: "The quick brown fox jumps over the lazy dog",
+                output: vec![
+                    0x37, 0xf3, 0x32, 0xf6,
+                    0x8d, 0xb7, 0x7b, 0xd9,
+                    0xd7, 0xed, 0xd4, 0x96,
+                    0x95, 0x71, 0xad, 0x67,
+                    0x1c, 0xf9, 0xdd, 0x3b,
+                ],
+                output_str: "37f332f68db77bd9d7edd4969571ad671cf9dd3b",
+            },
+            Test {
+                input: "The quick brown fox jumps over the lazy cog",
+                output: vec![
+                    0x13, 0x20, 0x72, 0xdf,
+                    0x69, 0x09, 0x33, 0x83,
+                    0x5e, 0xb8, 0xb6, 0xad,
+                    0x0b, 0x77, 0xe7, 0xb6,
+                    0xf1, 0x4a, 0xca, 0xd7,
+                ],
+                output_str: "132072df690933835eb8b6ad0b77e7b6f14acad7",
+            },
+        ];
+
+        for mut test in tests {
+            // Hash through high-level API, check hex encoding/decoding
+            let hash = ripemd160::Hash::hash(test.input.as_bytes());
+            assert_eq!(hash, test.output_str.parse::<ripemd160::Hash>().expect("parse hex"));
+            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(&hash.to_string(), &test.output_str);
+            assert_eq!(
+                ripemd160::Hash::from_bytes_ref(
+                    <&[u8; 20]>::try_from(&*test.output).expect("known length")
+                ),
+                &hash
+            );
+            assert_eq!(
+                ripemd160::Hash::from_bytes_mut(
+                    <&mut [u8; 20]>::try_from(&mut *test.output).expect("known length")
+                ),
+                &hash
+            );
+
+            // Hash through engine, checking that we can input byte by byte
+            let mut engine = ripemd160::Hash::engine();
+            for ch in test.input.as_bytes() {
+                engine.input(&[*ch]);
+            }
+            let manual_hash = ripemd160::Hash::from_engine(engine);
+            assert_eq!(hash, manual_hash);
+            assert_eq!(hash.as_byte_array(), test.output.as_slice());
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn ripemd_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        use crate::{ripemd160, Hash};
+
+        #[rustfmt::skip]
+        static HASH_BYTES: [u8; 20] = [
+            0x13, 0x20, 0x72, 0xdf,
+            0x69, 0x09, 0x33, 0x83,
+            0x5e, 0xb8, 0xb6, 0xad,
+            0x0b, 0x77, 0xe7, 0xb6,
+            0xf1, 0x4a, 0xca, 0xd7,
+        ];
+
+        let hash = ripemd160::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
+        assert_tokens(&hash.readable(), &[Token::Str("132072df690933835eb8b6ad0b77e7b6f14acad7")]);
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{ripemd160, Hash, HashEngine};
+
+    #[bench]
+    pub fn ripemd160_10(bh: &mut Bencher) {
+        let mut engine = ripemd160::Hash::engine();
+        let bytes = [1u8; 10];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn ripemd160_1k(bh: &mut Bencher) {
+        let mut engine = ripemd160::Hash::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn ripemd160_64k(bh: &mut Bencher) {
+        let mut engine = ripemd160::Hash::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/serde_macros.rs b/hashes/src/serde_macros.rs
new file mode 100644
index 00000000..ded28b2f
--- /dev/null
+++ b/hashes/src/serde_macros.rs
@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Macros for serde trait implementations, and supporting code.
+//!
+
+/// Functions used by serde impls of all hashes.
+#[cfg(feature = "serde")]
+pub mod serde_details {
+    use core::marker::PhantomData;
+    use core::str::FromStr;
+    use core::{fmt, ops, str};
+
+    use crate::FromSliceError;
+    struct HexVisitor<ValueT>(PhantomData<ValueT>);
+    use serde::{de, Deserializer, Serializer};
+
+    impl<'de, ValueT> de::Visitor<'de> for HexVisitor<ValueT>
+    where
+        ValueT: FromStr,
+        <ValueT as FromStr>::Err: fmt::Display,
+    {
+        type Value = ValueT;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("an ASCII hex string")
+        }
+
+        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            if let Ok(hex) = str::from_utf8(v) {
+                Self::Value::from_str(hex).map_err(E::custom)
+            } else {
+                return Err(E::invalid_value(de::Unexpected::Bytes(v), &self));
+            }
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Self::Value::from_str(v).map_err(E::custom)
+        }
+    }
+
+    struct BytesVisitor<ValueT>(PhantomData<ValueT>);
+
+    impl<'de, ValueT> de::Visitor<'de> for BytesVisitor<ValueT>
+    where
+        ValueT: SerdeHash,
+        <ValueT as FromStr>::Err: fmt::Display,
+    {
+        type Value = ValueT;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a bytestring")
+        }
+
+        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            SerdeHash::from_slice_delegated(v).map_err(|_| {
+                // from_slice only errors on incorrect length
+                E::invalid_length(v.len(), &stringify!(N))
+            })
+        }
+    }
+
+    /// Default serialization/deserialization methods.
+    pub trait SerdeHash
+    where
+        Self: Sized
+            + FromStr
+            + fmt::Display
+            + ops::Index<usize, Output = u8>
+            + ops::Index<ops::RangeFull, Output = [u8]>,
+        <Self as FromStr>::Err: fmt::Display,
+    {
+        /// Size, in bits, of the hash.
+        const N: usize;
+
+        /// Helper function to turn a deserialized slice into the correct hash type.
+        fn from_slice_delegated(sl: &[u8]) -> Result<Self, FromSliceError>;
+
+        /// Do serde serialization.
+        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[..])
+            }
+        }
+
+        /// Do serde deserialization.
+        fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+            if d.is_human_readable() {
+                d.deserialize_str(HexVisitor::<Self>(PhantomData))
+            } else {
+                d.deserialize_bytes(BytesVisitor::<Self>(PhantomData))
+            }
+        }
+    }
+}
+
+/// Implements `Serialize` and `Deserialize` for a type `$t` which
+/// represents a newtype over a byte-slice over length `$len`.
+#[macro_export]
+#[cfg(feature = "serde")]
+macro_rules! serde_impl(
+    ($t:ident, $len:expr $(, $gen:ident: $gent:ident)*) => (
+        impl<$($gen: $gent),*> $crate::serde_macros::serde_details::SerdeHash for $t<$($gen),*> {
+            const N : usize = $len;
+            fn from_slice_delegated(sl: &[u8]) -> Result<Self, $crate::FromSliceError> {
+                #[allow(unused_imports)]
+                use $crate::Hash as _;
+                $t::from_slice(sl)
+            }
+        }
+
+        impl<$($gen: $gent),*> $crate::serde::Serialize for $t<$($gen),*> {
+            fn serialize<S: $crate::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+                $crate::serde_macros::serde_details::SerdeHash::serialize(self, s)
+            }
+        }
+
+        impl<'de $(, $gen: $gent)*> $crate::serde::Deserialize<'de> for $t<$($gen),*> {
+            fn deserialize<D: $crate::serde::Deserializer<'de>>(d: D) -> Result<$t<$($gen),*>, D::Error> {
+                $crate::serde_macros::serde_details::SerdeHash::deserialize(d)
+            }
+        }
+));
+
+/// Does an "empty" serde implementation for the configuration without serde feature.
+#[macro_export]
+#[cfg(not(feature = "serde"))]
+macro_rules! serde_impl(
+        ($t:ident, $len:expr $(, $gen:ident: $gent:ident)*) => ()
+);
diff --git a/hashes/src/sha1.rs b/hashes/src/sha1.rs
new file mode 100644
index 00000000..a638ebc3
--- /dev/null
+++ b/hashes/src/sha1.rs
@@ -0,0 +1,257 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! SHA1 implementation.
+//!
+
+use core::convert::TryInto;
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::{cmp, str};
+
+use crate::{FromSliceError, HashEngine as _};
+
+crate::internal_macros::hash_type! {
+    160,
+    false,
+    "Output of the SHA1 hash function.",
+    "crate::util::json_hex_string::len_20"
+}
+
+fn from_engine(mut e: HashEngine) -> Hash {
+    // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
+    let data_len = e.length as u64;
+
+    let zeroes = [0; BLOCK_SIZE - 8];
+    e.input(&[0x80]);
+    if e.length % BLOCK_SIZE > zeroes.len() {
+        e.input(&zeroes);
+    }
+    let pad_length = zeroes.len() - (e.length % BLOCK_SIZE);
+    e.input(&zeroes[..pad_length]);
+    debug_assert_eq!(e.length % BLOCK_SIZE, zeroes.len());
+
+    e.input(&(8 * data_len).to_be_bytes());
+    debug_assert_eq!(e.length % BLOCK_SIZE, 0);
+
+    Hash(e.midstate())
+}
+
+const BLOCK_SIZE: usize = 64;
+
+/// Engine to compute SHA1 hash function.
+#[derive(Clone)]
+pub struct HashEngine {
+    buffer: [u8; BLOCK_SIZE],
+    h: [u32; 5],
+    length: usize,
+}
+
+impl Default for HashEngine {
+    fn default() -> Self {
+        HashEngine {
+            h: [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0],
+            length: 0,
+            buffer: [0; BLOCK_SIZE],
+        }
+    }
+}
+
+impl crate::HashEngine for HashEngine {
+    type MidState = [u8; 20];
+
+    #[cfg(not(hashes_fuzz))]
+    fn midstate(&self) -> [u8; 20] {
+        let mut ret = [0; 20];
+        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_exact_mut(4)) {
+            ret_bytes.copy_from_slice(&val.to_be_bytes())
+        }
+        ret
+    }
+
+    #[cfg(hashes_fuzz)]
+    fn midstate(&self) -> [u8; 20] {
+        let mut ret = [0; 20];
+        ret.copy_from_slice(&self.buffer[..20]);
+        ret
+    }
+
+    const BLOCK_SIZE: usize = 64;
+
+    fn n_bytes_hashed(&self) -> usize { self.length }
+
+    engine_input_impl!();
+}
+
+impl HashEngine {
+    // Basic unoptimized algorithm from Wikipedia
+    fn process_block(&mut self) {
+        debug_assert_eq!(self.buffer.len(), BLOCK_SIZE);
+
+        let mut w = [0u32; 80];
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks_exact(4)) {
+            *w_val = u32::from_be_bytes(buff_bytes.try_into().expect("4 bytes slice"))
+        }
+        for i in 16..80 {
+            w[i] = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]).rotate_left(1);
+        }
+
+        let mut a = self.h[0];
+        let mut b = self.h[1];
+        let mut c = self.h[2];
+        let mut d = self.h[3];
+        let mut e = self.h[4];
+
+        for (i, &wi) in w.iter().enumerate() {
+            let (f, k) = match i {
+                0...19 => ((b & c) | (!b & d), 0x5a827999),
+                20...39 => (b ^ c ^ d, 0x6ed9eba1),
+                40...59 => ((b & c) | (b & d) | (c & d), 0x8f1bbcdc),
+                60...79 => (b ^ c ^ d, 0xca62c1d6),
+                _ => unreachable!(),
+            };
+
+            let new_a =
+                a.rotate_left(5).wrapping_add(f).wrapping_add(e).wrapping_add(k).wrapping_add(wi);
+            e = d;
+            d = c;
+            c = b.rotate_left(30);
+            b = a;
+            a = new_a;
+        }
+
+        self.h[0] = self.h[0].wrapping_add(a);
+        self.h[1] = self.h[1].wrapping_add(b);
+        self.h[2] = self.h[2].wrapping_add(c);
+        self.h[3] = self.h[3].wrapping_add(d);
+        self.h[4] = self.h[4].wrapping_add(e);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test() {
+        use crate::{sha1, Hash, HashEngine};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
+        #[rustfmt::skip]
+        let tests = vec![
+            // Examples from wikipedia
+            Test {
+                input: "",
+                output: vec![
+                    0xda, 0x39, 0xa3, 0xee,
+                    0x5e, 0x6b, 0x4b, 0x0d,
+                    0x32, 0x55, 0xbf, 0xef,
+                    0x95, 0x60, 0x18, 0x90,
+                    0xaf, 0xd8, 0x07, 0x09,
+                ],
+                output_str: "da39a3ee5e6b4b0d3255bfef95601890afd80709"
+            },
+            Test {
+                input: "The quick brown fox jumps over the lazy dog",
+                output: vec![
+                    0x2f, 0xd4, 0xe1, 0xc6,
+                    0x7a, 0x2d, 0x28, 0xfc,
+                    0xed, 0x84, 0x9e, 0xe1,
+                    0xbb, 0x76, 0xe7, 0x39,
+                    0x1b, 0x93, 0xeb, 0x12,
+                ],
+                output_str: "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12",
+            },
+            Test {
+                input: "The quick brown fox jumps over the lazy cog",
+                output: vec![
+                    0xde, 0x9f, 0x2c, 0x7f,
+                    0xd2, 0x5e, 0x1b, 0x3a,
+                    0xfa, 0xd3, 0xe8, 0x5a,
+                    0x0b, 0xd1, 0x7d, 0x9b,
+                    0x10, 0x0d, 0xb4, 0xb3,
+                ],
+                output_str: "de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3",
+            },
+        ];
+
+        for test in tests {
+            // Hash through high-level API, check hex encoding/decoding
+            let hash = sha1::Hash::hash(test.input.as_bytes());
+            assert_eq!(hash, test.output_str.parse::<sha1::Hash>().expect("parse hex"));
+            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(&hash.to_string(), &test.output_str);
+
+            // Hash through engine, checking that we can input byte by byte
+            let mut engine = sha1::Hash::engine();
+            for ch in test.input.as_bytes() {
+                engine.input(&[*ch]);
+            }
+            let manual_hash = sha1::Hash::from_engine(engine);
+            assert_eq!(hash, manual_hash);
+            assert_eq!(hash.as_byte_array(), test.output.as_slice());
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn sha1_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        use crate::{sha1, Hash};
+
+        #[rustfmt::skip]
+        static HASH_BYTES: [u8; 20] = [
+            0x13, 0x20, 0x72, 0xdf,
+            0x69, 0x09, 0x33, 0x83,
+            0x5e, 0xb8, 0xb6, 0xad,
+            0x0b, 0x77, 0xe7, 0xb6,
+            0xf1, 0x4a, 0xca, 0xd7,
+        ];
+
+        let hash = sha1::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
+        assert_tokens(&hash.readable(), &[Token::Str("132072df690933835eb8b6ad0b77e7b6f14acad7")]);
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{sha1, Hash, HashEngine};
+
+    #[bench]
+    pub fn sha1_10(bh: &mut Bencher) {
+        let mut engine = sha1::Hash::engine();
+        let bytes = [1u8; 10];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha1_1k(bh: &mut Bencher) {
+        let mut engine = sha1::Hash::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha1_64k(bh: &mut Bencher) {
+        let mut engine = sha1::Hash::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/sha256.rs b/hashes/src/sha256.rs
new file mode 100644
index 00000000..3a8718d5
--- /dev/null
+++ b/hashes/src/sha256.rs
@@ -0,0 +1,1066 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! SHA256 implementation.
+//!
+
+#[cfg(target_arch = "x86")]
+use core::arch::x86::*;
+#[cfg(target_arch = "x86_64")]
+use core::arch::x86_64::*;
+use core::convert::TryInto;
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::{cmp, str};
+
+use crate::{hex, sha256d, FromSliceError, HashEngine as _};
+
+crate::internal_macros::hash_type! {
+    256,
+    false,
+    "Output of the SHA256 hash function.",
+    "crate::util::json_hex_string::len_32"
+}
+
+#[cfg(not(hashes_fuzz))]
+fn from_engine(mut e: HashEngine) -> Hash {
+    // pad buffer with a single 1-bit then all 0s, until there are exactly 8 bytes remaining
+    let data_len = e.length as u64;
+
+    let zeroes = [0; BLOCK_SIZE - 8];
+    e.input(&[0x80]);
+    if e.length % BLOCK_SIZE > zeroes.len() {
+        e.input(&zeroes);
+    }
+    let pad_length = zeroes.len() - (e.length % BLOCK_SIZE);
+    e.input(&zeroes[..pad_length]);
+    debug_assert_eq!(e.length % BLOCK_SIZE, zeroes.len());
+
+    e.input(&(8 * data_len).to_be_bytes());
+    debug_assert_eq!(e.length % BLOCK_SIZE, 0);
+
+    Hash(e.midstate().to_byte_array())
+}
+
+#[cfg(hashes_fuzz)]
+fn from_engine(e: HashEngine) -> Hash {
+    let mut hash = e.midstate().to_byte_array();
+    if hash == [0; 32] {
+        // Assume sha256 is secure and never generate 0-hashes (which represent invalid
+        // secp256k1 secret keys, causing downstream application breakage).
+        hash[0] = 1;
+    }
+    Hash(hash)
+}
+
+const BLOCK_SIZE: usize = 64;
+
+/// Engine to compute SHA256 hash function.
+#[derive(Clone)]
+pub struct HashEngine {
+    buffer: [u8; BLOCK_SIZE],
+    h: [u32; 8],
+    length: usize,
+}
+
+impl Default for HashEngine {
+    fn default() -> Self {
+        HashEngine {
+            h: [
+                0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
+                0x5be0cd19,
+            ],
+            length: 0,
+            buffer: [0; BLOCK_SIZE],
+        }
+    }
+}
+
+impl crate::HashEngine for HashEngine {
+    type MidState = Midstate;
+
+    #[cfg(not(hashes_fuzz))]
+    fn midstate(&self) -> Midstate {
+        let mut ret = [0; 32];
+        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_exact_mut(4)) {
+            ret_bytes.copy_from_slice(&val.to_be_bytes());
+        }
+        Midstate(ret)
+    }
+
+    #[cfg(hashes_fuzz)]
+    fn midstate(&self) -> Midstate {
+        let mut ret = [0; 32];
+        ret.copy_from_slice(&self.buffer[..32]);
+        Midstate(ret)
+    }
+
+    const BLOCK_SIZE: usize = 64;
+
+    fn n_bytes_hashed(&self) -> usize { self.length }
+
+    engine_input_impl!();
+}
+
+impl Hash {
+    /// Iterate the sha256 algorithm to turn a sha256 hash into a sha256d hash
+    pub fn hash_again(&self) -> sha256d::Hash {
+        crate::Hash::from_byte_array(<Self as crate::Hash>::hash(&self.0).0)
+    }
+
+    /// Computes hash from `bytes` in `const` context.
+    ///
+    /// Warning: this function is inefficient. It should be only used in `const` context.
+    pub const fn const_hash(bytes: &[u8]) -> Self { Hash(Midstate::const_hash(bytes, true).0) }
+}
+
+/// Output of the SHA256 hash function.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct Midstate(pub [u8; 32]);
+
+crate::internal_macros::arr_newtype_fmt_impl!(Midstate, 32);
+serde_impl!(Midstate, 32);
+borrow_slice_impl!(Midstate);
+
+impl<I: SliceIndex<[u8]>> Index<I> for Midstate {
+    type Output = I::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output { &self.0[index] }
+}
+
+impl str::FromStr for Midstate {
+    type Err = hex::HexToArrayError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> { hex::FromHex::from_hex(s) }
+}
+
+impl Midstate {
+    /// Length of the midstate, in bytes.
+    const LEN: usize = 32;
+
+    /// Flag indicating whether user-visible serializations of this hash
+    /// should be backward. For some reason Satoshi decided this should be
+    /// true for `Sha256dHash`, so here we are.
+    const DISPLAY_BACKWARD: bool = true;
+
+    /// Construct a new [`Midstate`] from the inner value.
+    pub const fn from_byte_array(inner: [u8; 32]) -> Self { Midstate(inner) }
+
+    /// Copies a byte slice into the [`Midstate`] object.
+    pub fn from_slice(sl: &[u8]) -> Result<Midstate, FromSliceError> {
+        if sl.len() != Self::LEN {
+            Err(FromSliceError { expected: Self::LEN, got: sl.len() })
+        } else {
+            let mut ret = [0; 32];
+            ret.copy_from_slice(sl);
+            Ok(Midstate(ret))
+        }
+    }
+
+    /// Unwraps the [`Midstate`] and returns the underlying byte array.
+    pub fn to_byte_array(self) -> [u8; 32] { self.0 }
+
+    /// Creates midstate for tagged hashes.
+    ///
+    /// Warning: this function is inefficient. It should be only used in `const` context.
+    ///
+    /// Computes non-finalized hash of `sha256(tag) || sha256(tag)` for use in
+    /// [`sha256t`](super::sha256t). It's provided for use with [`sha256t`](crate::sha256t).
+    pub const fn hash_tag(tag: &[u8]) -> Self {
+        let hash = Hash::const_hash(tag);
+        let mut buf = [0u8; 64];
+        let mut i = 0usize;
+        while i < buf.len() {
+            buf[i] = hash.0[i % hash.0.len()];
+            i += 1;
+        }
+        Self::const_hash(&buf, false)
+    }
+}
+
+impl hex::FromHex for Midstate {
+    type Err = hex::HexToArrayError;
+    fn from_byte_iter<I>(iter: I) -> Result<Self, Self::Err>
+    where
+        I: Iterator<Item = Result<u8, hex::HexToBytesError>>
+            + ExactSizeIterator
+            + DoubleEndedIterator,
+    {
+        // DISPLAY_BACKWARD is true
+        Ok(Midstate::from_byte_array(hex::FromHex::from_byte_iter(iter.rev())?))
+    }
+}
+
+#[allow(non_snake_case)]
+const fn Ch(x: u32, y: u32, z: u32) -> u32 { z ^ (x & (y ^ z)) }
+#[allow(non_snake_case)]
+const fn Maj(x: u32, y: u32, z: u32) -> u32 { (x & y) | (z & (x | y)) }
+#[allow(non_snake_case)]
+const fn Sigma0(x: u32) -> u32 { x.rotate_left(30) ^ x.rotate_left(19) ^ x.rotate_left(10) }
+#[allow(non_snake_case)]
+const fn Sigma1(x: u32) -> u32 { x.rotate_left(26) ^ x.rotate_left(21) ^ x.rotate_left(7) }
+const fn sigma0(x: u32) -> u32 { x.rotate_left(25) ^ x.rotate_left(14) ^ (x >> 3) }
+const fn sigma1(x: u32) -> u32 { x.rotate_left(15) ^ x.rotate_left(13) ^ (x >> 10) }
+
+#[cfg(feature = "small-hash")]
+#[macro_use]
+mod small_hash {
+    use super::*;
+
+    #[rustfmt::skip]
+    pub(super) const fn round(a: u32, b: u32, c: u32, d: u32, e: u32,
+                              f: u32, g: u32, h: u32, k: u32, w: u32) -> (u32, u32) {
+        let t1 =
+            h.wrapping_add(Sigma1(e)).wrapping_add(Ch(e, f, g)).wrapping_add(k).wrapping_add(w);
+        let t2 = Sigma0(a).wrapping_add(Maj(a, b, c));
+        (d.wrapping_add(t1), t1.wrapping_add(t2))
+    }
+    #[rustfmt::skip]
+    pub(super) const fn later_round(a: u32, b: u32, c: u32, d: u32, e: u32,
+                                    f: u32, g: u32, h: u32, k: u32, w: u32,
+                                    w1: u32, w2: u32, w3: u32,
+    ) -> (u32, u32, u32) {
+        let w = w.wrapping_add(sigma1(w1)).wrapping_add(w2).wrapping_add(sigma0(w3));
+        let (d, h) = round(a, b, c, d, e, f, g, h, k, w);
+        (d, h, w)
+    }
+
+    macro_rules! round(
+        // first round
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr, $f:expr, $g:expr, $h:expr, $k:expr, $w:expr) => (
+            let updates = small_hash::round($a, $b, $c, $d, $e, $f, $g, $h, $k, $w);
+            $d = updates.0;
+            $h = updates.1;
+        );
+        // later rounds we reassign $w before doing the first-round computation
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr, $f:expr, $g:expr, $h:expr, $k:expr, $w:expr, $w1:expr, $w2:expr, $w3:expr) => (
+            let updates = small_hash::later_round($a, $b, $c, $d, $e, $f, $g, $h, $k, $w, $w1, $w2, $w3);
+            $d = updates.0;
+            $h = updates.1;
+            $w = updates.2;
+        )
+    );
+}
+
+#[cfg(not(feature = "small-hash"))]
+#[macro_use]
+mod fast_hash {
+    macro_rules! round(
+        // first round
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr, $f:expr, $g:expr, $h:expr, $k:expr, $w:expr) => (
+            let t1 = $h.wrapping_add(Sigma1($e)).wrapping_add(Ch($e, $f, $g)).wrapping_add($k).wrapping_add($w);
+            let t2 = Sigma0($a).wrapping_add(Maj($a, $b, $c));
+            $d = $d.wrapping_add(t1);
+            $h = t1.wrapping_add(t2);
+        );
+        // later rounds we reassign $w before doing the first-round computation
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr, $f:expr, $g:expr, $h:expr, $k:expr, $w:expr, $w1:expr, $w2:expr, $w3:expr) => (
+            $w = $w.wrapping_add(sigma1($w1)).wrapping_add($w2).wrapping_add(sigma0($w3));
+            round!($a, $b, $c, $d, $e, $f, $g, $h, $k, $w);
+        )
+    );
+}
+
+impl Midstate {
+    #[allow(clippy::identity_op)] // more readble
+    const fn read_u32(bytes: &[u8], index: usize) -> u32 {
+        ((bytes[index + 0] as u32) << 24)
+            | ((bytes[index + 1] as u32) << 16)
+            | ((bytes[index + 2] as u32) << 8)
+            | ((bytes[index + 3] as u32) << 0)
+    }
+
+    const fn copy_w(bytes: &[u8], index: usize) -> [u32; 16] {
+        let mut w = [0u32; 16];
+        let mut i = 0;
+        while i < 16 {
+            w[i] = Self::read_u32(bytes, index + i * 4);
+            i += 1;
+        }
+        w
+    }
+
+    const fn const_hash(bytes: &[u8], finalize: bool) -> Self {
+        let mut state = [
+            0x6a09e667u32,
+            0xbb67ae85,
+            0x3c6ef372,
+            0xa54ff53a,
+            0x510e527f,
+            0x9b05688c,
+            0x1f83d9ab,
+            0x5be0cd19,
+        ];
+
+        let num_chunks = (bytes.len() + 9 + 63) / 64;
+        let mut chunk = 0;
+        #[allow(clippy::precedence)]
+        while chunk < num_chunks {
+            if !finalize && chunk + 1 == num_chunks {
+                break;
+            }
+            let mut w = if chunk * 64 + 64 <= bytes.len() {
+                Self::copy_w(bytes, chunk * 64)
+            } else {
+                let mut buf = [0; 64];
+                let mut i = 0;
+                let offset = chunk * 64;
+                while offset + i < bytes.len() {
+                    buf[i] = bytes[offset + i];
+                    i += 1;
+                }
+                if (bytes.len() % 64 <= 64 - 9) || (chunk + 2 == num_chunks) {
+                    buf[i] = 0x80;
+                }
+                #[allow(clippy::identity_op)] // more readble
+                #[allow(clippy::erasing_op)]
+                if chunk + 1 == num_chunks {
+                    let bit_len = bytes.len() as u64 * 8;
+                    buf[64 - 8] = ((bit_len >> 8 * 7) & 0xFF) as u8;
+                    buf[64 - 7] = ((bit_len >> 8 * 6) & 0xFF) as u8;
+                    buf[64 - 6] = ((bit_len >> 8 * 5) & 0xFF) as u8;
+                    buf[64 - 5] = ((bit_len >> 8 * 4) & 0xFF) as u8;
+                    buf[64 - 4] = ((bit_len >> 8 * 3) & 0xFF) as u8;
+                    buf[64 - 3] = ((bit_len >> 8 * 2) & 0xFF) as u8;
+                    buf[64 - 2] = ((bit_len >> 8 * 1) & 0xFF) as u8;
+                    buf[64 - 1] = ((bit_len >> 8 * 0) & 0xFF) as u8;
+                }
+                Self::copy_w(&buf, 0)
+            };
+            chunk += 1;
+
+            let mut a = state[0];
+            let mut b = state[1];
+            let mut c = state[2];
+            let mut d = state[3];
+            let mut e = state[4];
+            let mut f = state[5];
+            let mut g = state[6];
+            let mut h = state[7];
+
+            round!(a, b, c, d, e, f, g, h, 0x428a2f98, w[0]);
+            round!(h, a, b, c, d, e, f, g, 0x71374491, w[1]);
+            round!(g, h, a, b, c, d, e, f, 0xb5c0fbcf, w[2]);
+            round!(f, g, h, a, b, c, d, e, 0xe9b5dba5, w[3]);
+            round!(e, f, g, h, a, b, c, d, 0x3956c25b, w[4]);
+            round!(d, e, f, g, h, a, b, c, 0x59f111f1, w[5]);
+            round!(c, d, e, f, g, h, a, b, 0x923f82a4, w[6]);
+            round!(b, c, d, e, f, g, h, a, 0xab1c5ed5, w[7]);
+            round!(a, b, c, d, e, f, g, h, 0xd807aa98, w[8]);
+            round!(h, a, b, c, d, e, f, g, 0x12835b01, w[9]);
+            round!(g, h, a, b, c, d, e, f, 0x243185be, w[10]);
+            round!(f, g, h, a, b, c, d, e, 0x550c7dc3, w[11]);
+            round!(e, f, g, h, a, b, c, d, 0x72be5d74, w[12]);
+            round!(d, e, f, g, h, a, b, c, 0x80deb1fe, w[13]);
+            round!(c, d, e, f, g, h, a, b, 0x9bdc06a7, w[14]);
+            round!(b, c, d, e, f, g, h, a, 0xc19bf174, w[15]);
+
+            round!(a, b, c, d, e, f, g, h, 0xe49b69c1, w[0], w[14], w[9], w[1]);
+            round!(h, a, b, c, d, e, f, g, 0xefbe4786, w[1], w[15], w[10], w[2]);
+            round!(g, h, a, b, c, d, e, f, 0x0fc19dc6, w[2], w[0], w[11], w[3]);
+            round!(f, g, h, a, b, c, d, e, 0x240ca1cc, w[3], w[1], w[12], w[4]);
+            round!(e, f, g, h, a, b, c, d, 0x2de92c6f, w[4], w[2], w[13], w[5]);
+            round!(d, e, f, g, h, a, b, c, 0x4a7484aa, w[5], w[3], w[14], w[6]);
+            round!(c, d, e, f, g, h, a, b, 0x5cb0a9dc, w[6], w[4], w[15], w[7]);
+            round!(b, c, d, e, f, g, h, a, 0x76f988da, w[7], w[5], w[0], w[8]);
+            round!(a, b, c, d, e, f, g, h, 0x983e5152, w[8], w[6], w[1], w[9]);
+            round!(h, a, b, c, d, e, f, g, 0xa831c66d, w[9], w[7], w[2], w[10]);
+            round!(g, h, a, b, c, d, e, f, 0xb00327c8, w[10], w[8], w[3], w[11]);
+            round!(f, g, h, a, b, c, d, e, 0xbf597fc7, w[11], w[9], w[4], w[12]);
+            round!(e, f, g, h, a, b, c, d, 0xc6e00bf3, w[12], w[10], w[5], w[13]);
+            round!(d, e, f, g, h, a, b, c, 0xd5a79147, w[13], w[11], w[6], w[14]);
+            round!(c, d, e, f, g, h, a, b, 0x06ca6351, w[14], w[12], w[7], w[15]);
+            round!(b, c, d, e, f, g, h, a, 0x14292967, w[15], w[13], w[8], w[0]);
+
+            round!(a, b, c, d, e, f, g, h, 0x27b70a85, w[0], w[14], w[9], w[1]);
+            round!(h, a, b, c, d, e, f, g, 0x2e1b2138, w[1], w[15], w[10], w[2]);
+            round!(g, h, a, b, c, d, e, f, 0x4d2c6dfc, w[2], w[0], w[11], w[3]);
+            round!(f, g, h, a, b, c, d, e, 0x53380d13, w[3], w[1], w[12], w[4]);
+            round!(e, f, g, h, a, b, c, d, 0x650a7354, w[4], w[2], w[13], w[5]);
+            round!(d, e, f, g, h, a, b, c, 0x766a0abb, w[5], w[3], w[14], w[6]);
+            round!(c, d, e, f, g, h, a, b, 0x81c2c92e, w[6], w[4], w[15], w[7]);
+            round!(b, c, d, e, f, g, h, a, 0x92722c85, w[7], w[5], w[0], w[8]);
+            round!(a, b, c, d, e, f, g, h, 0xa2bfe8a1, w[8], w[6], w[1], w[9]);
+            round!(h, a, b, c, d, e, f, g, 0xa81a664b, w[9], w[7], w[2], w[10]);
+            round!(g, h, a, b, c, d, e, f, 0xc24b8b70, w[10], w[8], w[3], w[11]);
+            round!(f, g, h, a, b, c, d, e, 0xc76c51a3, w[11], w[9], w[4], w[12]);
+            round!(e, f, g, h, a, b, c, d, 0xd192e819, w[12], w[10], w[5], w[13]);
+            round!(d, e, f, g, h, a, b, c, 0xd6990624, w[13], w[11], w[6], w[14]);
+            round!(c, d, e, f, g, h, a, b, 0xf40e3585, w[14], w[12], w[7], w[15]);
+            round!(b, c, d, e, f, g, h, a, 0x106aa070, w[15], w[13], w[8], w[0]);
+
+            round!(a, b, c, d, e, f, g, h, 0x19a4c116, w[0], w[14], w[9], w[1]);
+            round!(h, a, b, c, d, e, f, g, 0x1e376c08, w[1], w[15], w[10], w[2]);
+            round!(g, h, a, b, c, d, e, f, 0x2748774c, w[2], w[0], w[11], w[3]);
+            round!(f, g, h, a, b, c, d, e, 0x34b0bcb5, w[3], w[1], w[12], w[4]);
+            round!(e, f, g, h, a, b, c, d, 0x391c0cb3, w[4], w[2], w[13], w[5]);
+            round!(d, e, f, g, h, a, b, c, 0x4ed8aa4a, w[5], w[3], w[14], w[6]);
+            round!(c, d, e, f, g, h, a, b, 0x5b9cca4f, w[6], w[4], w[15], w[7]);
+            round!(b, c, d, e, f, g, h, a, 0x682e6ff3, w[7], w[5], w[0], w[8]);
+            round!(a, b, c, d, e, f, g, h, 0x748f82ee, w[8], w[6], w[1], w[9]);
+            round!(h, a, b, c, d, e, f, g, 0x78a5636f, w[9], w[7], w[2], w[10]);
+            round!(g, h, a, b, c, d, e, f, 0x84c87814, w[10], w[8], w[3], w[11]);
+            round!(f, g, h, a, b, c, d, e, 0x8cc70208, w[11], w[9], w[4], w[12]);
+            round!(e, f, g, h, a, b, c, d, 0x90befffa, w[12], w[10], w[5], w[13]);
+            round!(d, e, f, g, h, a, b, c, 0xa4506ceb, w[13], w[11], w[6], w[14]);
+            round!(c, d, e, f, g, h, a, b, 0xbef9a3f7, w[14], w[12], w[7], w[15]);
+            round!(b, c, d, e, f, g, h, a, 0xc67178f2, w[15], w[13], w[8], w[0]);
+
+            state[0] = state[0].wrapping_add(a);
+            state[1] = state[1].wrapping_add(b);
+            state[2] = state[2].wrapping_add(c);
+            state[3] = state[3].wrapping_add(d);
+            state[4] = state[4].wrapping_add(e);
+            state[5] = state[5].wrapping_add(f);
+            state[6] = state[6].wrapping_add(g);
+            state[7] = state[7].wrapping_add(h);
+        }
+        let mut output = [0u8; 32];
+        let mut i = 0;
+        #[allow(clippy::identity_op)] // more readble
+        while i < 8 {
+            output[i * 4 + 0] = (state[i + 0] >> 24) as u8;
+            output[i * 4 + 1] = (state[i + 0] >> 16) as u8;
+            output[i * 4 + 2] = (state[i + 0] >> 8) as u8;
+            output[i * 4 + 3] = (state[i + 0] >> 0) as u8;
+            i += 1;
+        }
+        Midstate(output)
+    }
+}
+
+impl HashEngine {
+    /// Create a new [`HashEngine`] from a [`Midstate`].
+    ///
+    /// # Panics
+    ///
+    /// If `length` is not a multiple of the block size.
+    pub fn from_midstate(midstate: Midstate, length: usize) -> HashEngine {
+        assert!(length % BLOCK_SIZE == 0, "length is no multiple of the block size");
+
+        let mut ret = [0; 8];
+        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate[..].chunks_exact(4)) {
+            *ret_val = u32::from_be_bytes(midstate_bytes.try_into().expect("4 byte slice"));
+        }
+
+        HashEngine { buffer: [0; BLOCK_SIZE], h: ret, length }
+    }
+
+    fn process_block(&mut self) {
+        #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
+        {
+            if is_x86_feature_detected!("sse4.1")
+                && is_x86_feature_detected!("sha")
+                && is_x86_feature_detected!("sse2")
+                && is_x86_feature_detected!("ssse3")
+            {
+                return unsafe { self.process_block_simd_x86_intrinsics() };
+            }
+        }
+
+        // fallback implementation without using any intrinsics
+        self.software_process_block()
+    }
+
+    #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
+    #[target_feature(enable = "sha,sse2,ssse3,sse4.1")]
+    unsafe fn process_block_simd_x86_intrinsics(&mut self) {
+        // Code translated and based on from
+        // https://github.com/noloader/SHA-Intrinsics/blob/4899efc81d1af159c1fd955936c673139f35aea9/sha256-x86.c
+
+        /* sha256-x86.c - Intel SHA extensions using C intrinsics  */
+        /*   Written and place in public domain by Jeffrey Walton  */
+        /*   Based on code from Intel, and by Sean Gulley for      */
+        /*   the miTLS project.                                    */
+
+        // Variable names are also kept the same as in the original C code for easier comparison.
+        let (mut state0, mut state1);
+        let (mut msg, mut tmp);
+
+        let (mut msg0, mut msg1, mut msg2, mut msg3);
+
+        let (abef_save, cdgh_save);
+
+        #[allow(non_snake_case)]
+        let MASK: __m128i =
+            _mm_set_epi64x(0x0c0d_0e0f_0809_0a0bu64 as i64, 0x0405_0607_0001_0203u64 as i64);
+
+        let block_offset = 0;
+
+        // Load initial values
+        // CAST SAFETY: loadu_si128 documentation states that mem_addr does not
+        // need to be aligned on any particular boundary.
+        tmp = _mm_loadu_si128(self.h.as_ptr().add(0) as *const __m128i);
+        state1 = _mm_loadu_si128(self.h.as_ptr().add(4) as *const __m128i);
+
+        tmp = _mm_shuffle_epi32(tmp, 0xB1); // CDAB
+        state1 = _mm_shuffle_epi32(state1, 0x1B); // EFGH
+        state0 = _mm_alignr_epi8(tmp, state1, 8); // ABEF
+        state1 = _mm_blend_epi16(state1, tmp, 0xF0); // CDGH
+
+        // Process a single block
+        {
+            // Save current state
+            abef_save = state0;
+            cdgh_save = state1;
+
+            // Rounds 0-3
+            msg = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset) as *const __m128i);
+            msg0 = _mm_shuffle_epi8(msg, MASK);
+            msg = _mm_add_epi32(
+                msg0,
+                _mm_set_epi64x(0xE9B5DBA5B5C0FBCFu64 as i64, 0x71374491428A2F98u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+
+            // Rounds 4-7
+            msg1 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 16) as *const __m128i);
+            msg1 = _mm_shuffle_epi8(msg1, MASK);
+            msg = _mm_add_epi32(
+                msg1,
+                _mm_set_epi64x(0xAB1C5ED5923F82A4u64 as i64, 0x59F111F13956C25Bu64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg0 = _mm_sha256msg1_epu32(msg0, msg1);
+
+            // Rounds 8-11
+            msg2 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 32) as *const __m128i);
+            msg2 = _mm_shuffle_epi8(msg2, MASK);
+            msg = _mm_add_epi32(
+                msg2,
+                _mm_set_epi64x(0x550C7DC3243185BEu64 as i64, 0x12835B01D807AA98u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg1 = _mm_sha256msg1_epu32(msg1, msg2);
+
+            // Rounds 12-15
+            msg3 = _mm_loadu_si128(self.buffer.as_ptr().add(block_offset + 48) as *const __m128i);
+            msg3 = _mm_shuffle_epi8(msg3, MASK);
+            msg = _mm_add_epi32(
+                msg3,
+                _mm_set_epi64x(0xC19BF1749BDC06A7u64 as i64, 0x80DEB1FE72BE5D74u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg3, msg2, 4);
+            msg0 = _mm_add_epi32(msg0, tmp);
+            msg0 = _mm_sha256msg2_epu32(msg0, msg3);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg2 = _mm_sha256msg1_epu32(msg2, msg3);
+
+            // Rounds 16-19
+            msg = _mm_add_epi32(
+                msg0,
+                _mm_set_epi64x(0x240CA1CC0FC19DC6u64 as i64, 0xEFBE4786E49B69C1u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg0, msg3, 4);
+            msg1 = _mm_add_epi32(msg1, tmp);
+            msg1 = _mm_sha256msg2_epu32(msg1, msg0);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg3 = _mm_sha256msg1_epu32(msg3, msg0);
+
+            // Rounds 20-23
+            msg = _mm_add_epi32(
+                msg1,
+                _mm_set_epi64x(0x76F988DA5CB0A9DCu64 as i64, 0x4A7484AA2DE92C6Fu64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg1, msg0, 4);
+            msg2 = _mm_add_epi32(msg2, tmp);
+            msg2 = _mm_sha256msg2_epu32(msg2, msg1);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg0 = _mm_sha256msg1_epu32(msg0, msg1);
+
+            // Rounds 24-27
+            msg = _mm_add_epi32(
+                msg2,
+                _mm_set_epi64x(0xBF597FC7B00327C8u64 as i64, 0xA831C66D983E5152u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg2, msg1, 4);
+            msg3 = _mm_add_epi32(msg3, tmp);
+            msg3 = _mm_sha256msg2_epu32(msg3, msg2);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg1 = _mm_sha256msg1_epu32(msg1, msg2);
+
+            // Rounds 28-31
+            msg = _mm_add_epi32(
+                msg3,
+                _mm_set_epi64x(0x1429296706CA6351u64 as i64, 0xD5A79147C6E00BF3u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg3, msg2, 4);
+            msg0 = _mm_add_epi32(msg0, tmp);
+            msg0 = _mm_sha256msg2_epu32(msg0, msg3);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg2 = _mm_sha256msg1_epu32(msg2, msg3);
+
+            // Rounds 32-35
+            msg = _mm_add_epi32(
+                msg0,
+                _mm_set_epi64x(0x53380D134D2C6DFCu64 as i64, 0x2E1B213827B70A85u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg0, msg3, 4);
+            msg1 = _mm_add_epi32(msg1, tmp);
+            msg1 = _mm_sha256msg2_epu32(msg1, msg0);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg3 = _mm_sha256msg1_epu32(msg3, msg0);
+
+            // Rounds 36-39
+            msg = _mm_add_epi32(
+                msg1,
+                _mm_set_epi64x(0x92722C8581C2C92Eu64 as i64, 0x766A0ABB650A7354u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg1, msg0, 4);
+            msg2 = _mm_add_epi32(msg2, tmp);
+            msg2 = _mm_sha256msg2_epu32(msg2, msg1);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg0 = _mm_sha256msg1_epu32(msg0, msg1);
+
+            // Rounds 40-43
+            msg = _mm_add_epi32(
+                msg2,
+                _mm_set_epi64x(0xC76C51A3C24B8B70u64 as i64, 0xA81A664BA2BFE8A1u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg2, msg1, 4);
+            msg3 = _mm_add_epi32(msg3, tmp);
+            msg3 = _mm_sha256msg2_epu32(msg3, msg2);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg1 = _mm_sha256msg1_epu32(msg1, msg2);
+
+            // Rounds 44-47
+            msg = _mm_add_epi32(
+                msg3,
+                _mm_set_epi64x(0x106AA070F40E3585u64 as i64, 0xD6990624D192E819u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg3, msg2, 4);
+            msg0 = _mm_add_epi32(msg0, tmp);
+            msg0 = _mm_sha256msg2_epu32(msg0, msg3);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg2 = _mm_sha256msg1_epu32(msg2, msg3);
+
+            // Rounds 48-51
+            msg = _mm_add_epi32(
+                msg0,
+                _mm_set_epi64x(0x34B0BCB52748774Cu64 as i64, 0x1E376C0819A4C116u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg0, msg3, 4);
+            msg1 = _mm_add_epi32(msg1, tmp);
+            msg1 = _mm_sha256msg2_epu32(msg1, msg0);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+            msg3 = _mm_sha256msg1_epu32(msg3, msg0);
+
+            // Rounds 52-55
+            msg = _mm_add_epi32(
+                msg1,
+                _mm_set_epi64x(0x682E6FF35B9CCA4Fu64 as i64, 0x4ED8AA4A391C0CB3u64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg1, msg0, 4);
+            msg2 = _mm_add_epi32(msg2, tmp);
+            msg2 = _mm_sha256msg2_epu32(msg2, msg1);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+
+            // Rounds 56-59
+            msg = _mm_add_epi32(
+                msg2,
+                _mm_set_epi64x(0x8CC7020884C87814u64 as i64, 0x78A5636F748F82EEu64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            tmp = _mm_alignr_epi8(msg2, msg1, 4);
+            msg3 = _mm_add_epi32(msg3, tmp);
+            msg3 = _mm_sha256msg2_epu32(msg3, msg2);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+
+            // Rounds 60-63
+            msg = _mm_add_epi32(
+                msg3,
+                _mm_set_epi64x(0xC67178F2BEF9A3F7u64 as i64, 0xA4506CEB90BEFFFAu64 as i64),
+            );
+            state1 = _mm_sha256rnds2_epu32(state1, state0, msg);
+            msg = _mm_shuffle_epi32(msg, 0x0E);
+            state0 = _mm_sha256rnds2_epu32(state0, state1, msg);
+
+            // Combine state
+            state0 = _mm_add_epi32(state0, abef_save);
+            state1 = _mm_add_epi32(state1, cdgh_save);
+        }
+
+        tmp = _mm_shuffle_epi32(state0, 0x1B); // FEBA
+        state1 = _mm_shuffle_epi32(state1, 0xB1); // DCHG
+        state0 = _mm_blend_epi16(tmp, state1, 0xF0); // DCBA
+        state1 = _mm_alignr_epi8(state1, tmp, 8); // ABEF
+
+        // Save state
+        // CAST SAFETY: storeu_si128 documentation states that mem_addr does not
+        // need to be aligned on any particular boundary.
+        _mm_storeu_si128(self.h.as_mut_ptr().add(0) as *mut __m128i, state0);
+        _mm_storeu_si128(self.h.as_mut_ptr().add(4) as *mut __m128i, state1);
+    }
+
+    // Algorithm copied from libsecp256k1
+    fn software_process_block(&mut self) {
+        debug_assert_eq!(self.buffer.len(), BLOCK_SIZE);
+
+        let mut w = [0u32; 16];
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks_exact(4)) {
+            *w_val = u32::from_be_bytes(buff_bytes.try_into().expect("4 byte slice"));
+        }
+
+        let mut a = self.h[0];
+        let mut b = self.h[1];
+        let mut c = self.h[2];
+        let mut d = self.h[3];
+        let mut e = self.h[4];
+        let mut f = self.h[5];
+        let mut g = self.h[6];
+        let mut h = self.h[7];
+
+        round!(a, b, c, d, e, f, g, h, 0x428a2f98, w[0]);
+        round!(h, a, b, c, d, e, f, g, 0x71374491, w[1]);
+        round!(g, h, a, b, c, d, e, f, 0xb5c0fbcf, w[2]);
+        round!(f, g, h, a, b, c, d, e, 0xe9b5dba5, w[3]);
+        round!(e, f, g, h, a, b, c, d, 0x3956c25b, w[4]);
+        round!(d, e, f, g, h, a, b, c, 0x59f111f1, w[5]);
+        round!(c, d, e, f, g, h, a, b, 0x923f82a4, w[6]);
+        round!(b, c, d, e, f, g, h, a, 0xab1c5ed5, w[7]);
+        round!(a, b, c, d, e, f, g, h, 0xd807aa98, w[8]);
+        round!(h, a, b, c, d, e, f, g, 0x12835b01, w[9]);
+        round!(g, h, a, b, c, d, e, f, 0x243185be, w[10]);
+        round!(f, g, h, a, b, c, d, e, 0x550c7dc3, w[11]);
+        round!(e, f, g, h, a, b, c, d, 0x72be5d74, w[12]);
+        round!(d, e, f, g, h, a, b, c, 0x80deb1fe, w[13]);
+        round!(c, d, e, f, g, h, a, b, 0x9bdc06a7, w[14]);
+        round!(b, c, d, e, f, g, h, a, 0xc19bf174, w[15]);
+
+        round!(a, b, c, d, e, f, g, h, 0xe49b69c1, w[0], w[14], w[9], w[1]);
+        round!(h, a, b, c, d, e, f, g, 0xefbe4786, w[1], w[15], w[10], w[2]);
+        round!(g, h, a, b, c, d, e, f, 0x0fc19dc6, w[2], w[0], w[11], w[3]);
+        round!(f, g, h, a, b, c, d, e, 0x240ca1cc, w[3], w[1], w[12], w[4]);
+        round!(e, f, g, h, a, b, c, d, 0x2de92c6f, w[4], w[2], w[13], w[5]);
+        round!(d, e, f, g, h, a, b, c, 0x4a7484aa, w[5], w[3], w[14], w[6]);
+        round!(c, d, e, f, g, h, a, b, 0x5cb0a9dc, w[6], w[4], w[15], w[7]);
+        round!(b, c, d, e, f, g, h, a, 0x76f988da, w[7], w[5], w[0], w[8]);
+        round!(a, b, c, d, e, f, g, h, 0x983e5152, w[8], w[6], w[1], w[9]);
+        round!(h, a, b, c, d, e, f, g, 0xa831c66d, w[9], w[7], w[2], w[10]);
+        round!(g, h, a, b, c, d, e, f, 0xb00327c8, w[10], w[8], w[3], w[11]);
+        round!(f, g, h, a, b, c, d, e, 0xbf597fc7, w[11], w[9], w[4], w[12]);
+        round!(e, f, g, h, a, b, c, d, 0xc6e00bf3, w[12], w[10], w[5], w[13]);
+        round!(d, e, f, g, h, a, b, c, 0xd5a79147, w[13], w[11], w[6], w[14]);
+        round!(c, d, e, f, g, h, a, b, 0x06ca6351, w[14], w[12], w[7], w[15]);
+        round!(b, c, d, e, f, g, h, a, 0x14292967, w[15], w[13], w[8], w[0]);
+
+        round!(a, b, c, d, e, f, g, h, 0x27b70a85, w[0], w[14], w[9], w[1]);
+        round!(h, a, b, c, d, e, f, g, 0x2e1b2138, w[1], w[15], w[10], w[2]);
+        round!(g, h, a, b, c, d, e, f, 0x4d2c6dfc, w[2], w[0], w[11], w[3]);
+        round!(f, g, h, a, b, c, d, e, 0x53380d13, w[3], w[1], w[12], w[4]);
+        round!(e, f, g, h, a, b, c, d, 0x650a7354, w[4], w[2], w[13], w[5]);
+        round!(d, e, f, g, h, a, b, c, 0x766a0abb, w[5], w[3], w[14], w[6]);
+        round!(c, d, e, f, g, h, a, b, 0x81c2c92e, w[6], w[4], w[15], w[7]);
+        round!(b, c, d, e, f, g, h, a, 0x92722c85, w[7], w[5], w[0], w[8]);
+        round!(a, b, c, d, e, f, g, h, 0xa2bfe8a1, w[8], w[6], w[1], w[9]);
+        round!(h, a, b, c, d, e, f, g, 0xa81a664b, w[9], w[7], w[2], w[10]);
+        round!(g, h, a, b, c, d, e, f, 0xc24b8b70, w[10], w[8], w[3], w[11]);
+        round!(f, g, h, a, b, c, d, e, 0xc76c51a3, w[11], w[9], w[4], w[12]);
+        round!(e, f, g, h, a, b, c, d, 0xd192e819, w[12], w[10], w[5], w[13]);
+        round!(d, e, f, g, h, a, b, c, 0xd6990624, w[13], w[11], w[6], w[14]);
+        round!(c, d, e, f, g, h, a, b, 0xf40e3585, w[14], w[12], w[7], w[15]);
+        round!(b, c, d, e, f, g, h, a, 0x106aa070, w[15], w[13], w[8], w[0]);
+
+        round!(a, b, c, d, e, f, g, h, 0x19a4c116, w[0], w[14], w[9], w[1]);
+        round!(h, a, b, c, d, e, f, g, 0x1e376c08, w[1], w[15], w[10], w[2]);
+        round!(g, h, a, b, c, d, e, f, 0x2748774c, w[2], w[0], w[11], w[3]);
+        round!(f, g, h, a, b, c, d, e, 0x34b0bcb5, w[3], w[1], w[12], w[4]);
+        round!(e, f, g, h, a, b, c, d, 0x391c0cb3, w[4], w[2], w[13], w[5]);
+        round!(d, e, f, g, h, a, b, c, 0x4ed8aa4a, w[5], w[3], w[14], w[6]);
+        round!(c, d, e, f, g, h, a, b, 0x5b9cca4f, w[6], w[4], w[15], w[7]);
+        round!(b, c, d, e, f, g, h, a, 0x682e6ff3, w[7], w[5], w[0], w[8]);
+        round!(a, b, c, d, e, f, g, h, 0x748f82ee, w[8], w[6], w[1], w[9]);
+        round!(h, a, b, c, d, e, f, g, 0x78a5636f, w[9], w[7], w[2], w[10]);
+        round!(g, h, a, b, c, d, e, f, 0x84c87814, w[10], w[8], w[3], w[11]);
+        round!(f, g, h, a, b, c, d, e, 0x8cc70208, w[11], w[9], w[4], w[12]);
+        round!(e, f, g, h, a, b, c, d, 0x90befffa, w[12], w[10], w[5], w[13]);
+        round!(d, e, f, g, h, a, b, c, 0xa4506ceb, w[13], w[11], w[6], w[14]);
+        round!(c, d, e, f, g, h, a, b, 0xbef9a3f7, w[14], w[12], w[7], w[15]);
+        round!(b, c, d, e, f, g, h, a, 0xc67178f2, w[15], w[13], w[8], w[0]);
+
+        self.h[0] = self.h[0].wrapping_add(a);
+        self.h[1] = self.h[1].wrapping_add(b);
+        self.h[2] = self.h[2].wrapping_add(c);
+        self.h[3] = self.h[3].wrapping_add(d);
+        self.h[4] = self.h[4].wrapping_add(e);
+        self.h[5] = self.h[5].wrapping_add(f);
+        self.h[6] = self.h[6].wrapping_add(g);
+        self.h[7] = self.h[7].wrapping_add(h);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{sha256, Hash, HashEngine};
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test() {
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
+        #[rustfmt::skip]
+        let tests = vec![
+            // Examples from wikipedia
+            Test {
+                input: "",
+                output: vec![
+                    0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14,
+                    0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24,
+                    0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c,
+                    0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55,
+                ],
+                output_str: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+            },
+            Test {
+                input: "The quick brown fox jumps over the lazy dog",
+                output: vec![
+                    0xd7, 0xa8, 0xfb, 0xb3, 0x07, 0xd7, 0x80, 0x94,
+                    0x69, 0xca, 0x9a, 0xbc, 0xb0, 0x08, 0x2e, 0x4f,
+                    0x8d, 0x56, 0x51, 0xe4, 0x6d, 0x3c, 0xdb, 0x76,
+                    0x2d, 0x02, 0xd0, 0xbf, 0x37, 0xc9, 0xe5, 0x92,
+                ],
+                output_str: "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592",
+            },
+            Test {
+                input: "The quick brown fox jumps over the lazy dog.",
+                output: vec![
+                    0xef, 0x53, 0x7f, 0x25, 0xc8, 0x95, 0xbf, 0xa7,
+                    0x82, 0x52, 0x65, 0x29, 0xa9, 0xb6, 0x3d, 0x97,
+                    0xaa, 0x63, 0x15, 0x64, 0xd5, 0xd7, 0x89, 0xc2,
+                    0xb7, 0x65, 0x44, 0x8c, 0x86, 0x35, 0xfb, 0x6c,
+                ],
+                output_str: "ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c",
+            },
+        ];
+
+        for test in tests {
+            // Hash through high-level API, check hex encoding/decoding
+            let hash = sha256::Hash::hash(test.input.as_bytes());
+            assert_eq!(hash, test.output_str.parse::<sha256::Hash>().expect("parse hex"));
+            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(&hash.to_string(), &test.output_str);
+
+            // Hash through engine, checking that we can input byte by byte
+            let mut engine = sha256::Hash::engine();
+            for ch in test.input.as_bytes() {
+                engine.input(&[*ch]);
+            }
+            let manual_hash = sha256::Hash::from_engine(engine);
+            assert_eq!(hash, manual_hash);
+            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+        }
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn midstate() {
+        // Test vector obtained by doing an asset issuance on Elements
+        let mut engine = sha256::Hash::engine();
+        // sha256dhash of outpoint
+        // 73828cbc65fd68ab78dc86992b76ae50ae2bf8ceedbe8de0483172f0886219f7:0
+        engine.input(&[
+            0x9d, 0xd0, 0x1b, 0x56, 0xb1, 0x56, 0x45, 0x14,
+            0x3e, 0xad, 0x15, 0x8d, 0xec, 0x19, 0xf8, 0xce,
+            0xa9, 0x0b, 0xd0, 0xa9, 0xb2, 0xf8, 0x1d, 0x21,
+            0xff, 0xa3, 0xa4, 0xc6, 0x44, 0x81, 0xd4, 0x1c,
+        ]);
+        // 32 bytes of zeroes representing "new asset"
+        engine.input(&[0; 32]);
+        assert_eq!(
+            engine.midstate(),
+            // RPC output
+            sha256::Midstate::from_byte_array([
+                0x0b, 0xcf, 0xe0, 0xe5, 0x4e, 0x6c, 0xc7, 0xd3,
+                0x4f, 0x4f, 0x7c, 0x1d, 0xf0, 0xb0, 0xf5, 0x03,
+                0xf2, 0xf7, 0x12, 0x91, 0x2a, 0x06, 0x05, 0xb4,
+                0x14, 0xed, 0x33, 0x7f, 0x7f, 0x03, 0x2e, 0x03,
+            ])
+        );
+    }
+
+    #[test]
+    fn engine_with_state() {
+        let mut engine = sha256::Hash::engine();
+        let midstate_engine = sha256::HashEngine::from_midstate(engine.midstate(), 0);
+        // Fresh engine and engine initialized with fresh state should have same state
+        assert_eq!(engine.h, midstate_engine.h);
+
+        // Midstate changes after writing 64 bytes
+        engine.input(&[1; 63]);
+        assert_eq!(engine.h, midstate_engine.h);
+        engine.input(&[2; 1]);
+        assert_ne!(engine.h, midstate_engine.h);
+
+        // Initializing an engine with midstate from another engine should result in
+        // both engines producing the same hashes
+        let data_vec = vec![vec![3; 1], vec![4; 63], vec![5; 65], vec![6; 66]];
+        for data in data_vec {
+            let mut engine = engine.clone();
+            let mut midstate_engine =
+                sha256::HashEngine::from_midstate(engine.midstate(), engine.length);
+            assert_eq!(engine.h, midstate_engine.h);
+            assert_eq!(engine.length, midstate_engine.length);
+            engine.input(&data);
+            midstate_engine.input(&data);
+            assert_eq!(engine.h, midstate_engine.h);
+            let hash1 = sha256::Hash::from_engine(engine);
+            let hash2 = sha256::Hash::from_engine(midstate_engine);
+            assert_eq!(hash1, hash2);
+        }
+
+        // Test that a specific midstate results in a specific hash. Midstate was
+        // obtained by applying sha256 to sha256("MuSig coefficient")||sha256("MuSig
+        // coefficient").
+        #[rustfmt::skip]
+        static MIDSTATE: [u8; 32] = [
+            0x0f, 0xd0, 0x69, 0x0c, 0xfe, 0xfe, 0xae, 0x97,
+            0x99, 0x6e, 0xac, 0x7f, 0x5c, 0x30, 0xd8, 0x64,
+            0x8c, 0x4a, 0x05, 0x73, 0xac, 0xa1, 0xa2, 0x2f,
+            0x6f, 0x43, 0xb8, 0x01, 0x85, 0xce, 0x27, 0xcd,
+        ];
+        #[rustfmt::skip]
+        static HASH_EXPECTED: [u8; 32] = [
+            0x18, 0x84, 0xe4, 0x72, 0x40, 0x4e, 0xf4, 0x5a,
+            0xb4, 0x9c, 0x4e, 0xa4, 0x9a, 0xe6, 0x23, 0xa8,
+            0x88, 0x52, 0x7f, 0x7d, 0x8a, 0x06, 0x94, 0x20,
+            0x8f, 0xf1, 0xf7, 0xa9, 0xd5, 0x69, 0x09, 0x59,
+        ];
+        let midstate_engine =
+            sha256::HashEngine::from_midstate(sha256::Midstate::from_byte_array(MIDSTATE), 64);
+        let hash = sha256::Hash::from_engine(midstate_engine);
+        assert_eq!(hash, sha256::Hash(HASH_EXPECTED));
+    }
+
+    #[test]
+    fn const_hash() {
+        assert_eq!(super::Hash::hash(&[]), super::Hash::const_hash(&[]));
+
+        let mut bytes = Vec::new();
+        for i in 0..256 {
+            bytes.push(i as u8);
+            assert_eq!(
+                super::Hash::hash(&bytes),
+                super::Hash::const_hash(&bytes),
+                "hashes don't match for length {}",
+                i + 1
+            );
+        }
+    }
+
+    #[test]
+    fn const_midstate() {
+        use super::Midstate;
+
+        assert_eq!(
+            Midstate::hash_tag(b"TapLeaf"),
+            Midstate([
+                156, 224, 228, 230, 124, 17, 108, 57, 56, 179, 202, 242, 195, 15, 80, 137, 211,
+                243, 147, 108, 71, 99, 110, 96, 125, 179, 62, 234, 221, 198, 240, 201,
+            ])
+        )
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn sha256_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        #[rustfmt::skip]
+        static HASH_BYTES: [u8; 32] = [
+            0xef, 0x53, 0x7f, 0x25, 0xc8, 0x95, 0xbf, 0xa7,
+            0x82, 0x52, 0x65, 0x29, 0xa9, 0xb6, 0x3d, 0x97,
+            0xaa, 0x63, 0x15, 0x64, 0xd5, 0xd7, 0x89, 0xc2,
+            0xb7, 0x65, 0x44, 0x8c, 0x86, 0x35, 0xfb, 0x6c,
+        ];
+
+        let hash = sha256::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
+        assert_tokens(
+            &hash.readable(),
+            &[Token::Str("ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c")],
+        );
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    mod wasm_tests {
+        extern crate wasm_bindgen_test;
+        use self::wasm_bindgen_test::*;
+        use super::*;
+        #[wasm_bindgen_test]
+        fn sha256_tests() {
+            test();
+            midstate();
+            engine_with_state();
+        }
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{sha256, Hash, HashEngine};
+
+    #[bench]
+    pub fn sha256_10(bh: &mut Bencher) {
+        let mut engine = sha256::Hash::engine();
+        let bytes = [1u8; 10];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha256_1k(bh: &mut Bencher) {
+        let mut engine = sha256::Hash::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha256_64k(bh: &mut Bencher) {
+        let mut engine = sha256::Hash::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/sha256d.rs b/hashes/src/sha256d.rs
new file mode 100644
index 00000000..e7f6990b
--- /dev/null
+++ b/hashes/src/sha256d.rs
@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! SHA256d implementation (double SHA256).
+//!
+
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::str;
+
+use crate::{sha256, FromSliceError};
+
+crate::internal_macros::hash_type! {
+    256,
+    true,
+    "Output of the SHA256d hash function.",
+    "crate::util::json_hex_string::len_32"
+}
+
+type HashEngine = sha256::HashEngine;
+
+fn from_engine(e: sha256::HashEngine) -> Hash {
+    use crate::Hash as _;
+
+    let sha2 = sha256::Hash::from_engine(e);
+    let sha2d = sha256::Hash::hash(&sha2[..]);
+
+    let mut ret = [0; 32];
+    ret.copy_from_slice(&sha2d[..]);
+    Hash(ret)
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test() {
+        use crate::{sha256, sha256d, Hash, HashEngine};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
+        #[rustfmt::skip]
+        let tests = vec![
+            // Test vector copied out of rust-tapyrus
+            Test {
+                input: "",
+                output: vec![
+                    0x5d, 0xf6, 0xe0, 0xe2, 0x76, 0x13, 0x59, 0xd3,
+                    0x0a, 0x82, 0x75, 0x05, 0x8e, 0x29, 0x9f, 0xcc,
+                    0x03, 0x81, 0x53, 0x45, 0x45, 0xf5, 0x5c, 0xf4,
+                    0x3e, 0x41, 0x98, 0x3f, 0x5d, 0x4c, 0x94, 0x56,
+                ],
+                output_str: "56944c5d3f98413ef45cf54545538103cc9f298e0575820ad3591376e2e0f65d",
+            },
+        ];
+
+        for test in tests {
+            // Hash through high-level API, check hex encoding/decoding
+            let hash = sha256d::Hash::hash(test.input.as_bytes());
+            assert_eq!(hash, test.output_str.parse::<sha256d::Hash>().expect("parse hex"));
+            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(&hash.to_string(), &test.output_str);
+
+            // Hash through engine, checking that we can input byte by byte
+            let mut engine = sha256d::Hash::engine();
+            for ch in test.input.as_bytes() {
+                engine.input(&[*ch]);
+            }
+            let manual_hash = sha256d::Hash::from_engine(engine);
+            assert_eq!(hash, manual_hash);
+
+            // Hash by computing a sha256 then `hash_again`ing it
+            let sha2_hash = sha256::Hash::hash(test.input.as_bytes());
+            let sha2d_hash = sha2_hash.hash_again();
+            assert_eq!(hash, sha2d_hash);
+
+            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn sha256_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        use crate::{sha256d, Hash};
+
+        #[rustfmt::skip]
+        static HASH_BYTES: [u8; 32] = [
+            0xef, 0x53, 0x7f, 0x25, 0xc8, 0x95, 0xbf, 0xa7,
+            0x82, 0x52, 0x65, 0x29, 0xa9, 0xb6, 0x3d, 0x97,
+            0xaa, 0x63, 0x15, 0x64, 0xd5, 0xd7, 0x89, 0xc2,
+            0xb7, 0x65, 0x44, 0x8c, 0x86, 0x35, 0xfb, 0x6c,
+        ];
+
+        let hash = sha256d::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
+        assert_tokens(
+            &hash.readable(),
+            &[Token::Str("6cfb35868c4465b7c289d7d5641563aa973db6a929655282a7bf95c8257f53ef")],
+        );
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{sha256d, Hash, HashEngine};
+
+    #[bench]
+    pub fn sha256d_10(bh: &mut Bencher) {
+        let mut engine = sha256d::Hash::engine();
+        let bytes = [1u8; 10];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha256d_1k(bh: &mut Bencher) {
+        let mut engine = sha256d::Hash::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha256d_64k(bh: &mut Bencher) {
+        let mut engine = sha256d::Hash::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/sha256t.rs b/hashes/src/sha256t.rs
new file mode 100644
index 00000000..e136455b
--- /dev/null
+++ b/hashes/src/sha256t.rs
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! SHA256t implementation (tagged SHA256).
+//!
+
+use core::marker::PhantomData;
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::{cmp, str};
+
+use crate::{sha256, FromSliceError};
+
+type HashEngine = sha256::HashEngine;
+
+/// Trait representing a tag that can be used as a context for SHA256t hashes.
+pub trait Tag {
+    /// Returns a hash engine that is pre-tagged and is ready to be used for the data.
+    fn engine() -> sha256::HashEngine;
+}
+
+/// Output of the SHA256t hash function.
+#[repr(transparent)]
+pub struct Hash<T: Tag>([u8; 32], PhantomData<T>);
+
+#[cfg(feature = "schemars")]
+impl<T: Tag> schemars::JsonSchema for Hash<T> {
+    fn schema_name() -> String { "Hash".to_owned() }
+
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        crate::util::json_hex_string::len_32(gen)
+    }
+}
+
+impl<T: Tag> Hash<T> {
+    fn internal_new(arr: [u8; 32]) -> Self { Hash(arr, Default::default()) }
+
+    fn internal_engine() -> HashEngine { T::engine() }
+}
+
+impl<T: Tag> Copy for Hash<T> {}
+impl<T: Tag> Clone for Hash<T> {
+    fn clone(&self) -> Self { *self }
+}
+impl<T: Tag> PartialEq for Hash<T> {
+    fn eq(&self, other: &Hash<T>) -> bool { self.0 == other.0 }
+}
+impl<T: Tag> Eq for Hash<T> {}
+impl<T: Tag> Default for Hash<T> {
+    fn default() -> Self { Hash([0; 32], PhantomData) }
+}
+impl<T: Tag> PartialOrd for Hash<T> {
+    fn partial_cmp(&self, other: &Hash<T>) -> Option<cmp::Ordering> {
+        Some(cmp::Ord::cmp(self, other))
+    }
+}
+impl<T: Tag> Ord for Hash<T> {
+    fn cmp(&self, other: &Hash<T>) -> cmp::Ordering { cmp::Ord::cmp(&self.0, &other.0) }
+}
+impl<T: Tag> core::hash::Hash for Hash<T> {
+    fn hash<H: core::hash::Hasher>(&self, h: &mut H) { self.0.hash(h) }
+}
+
+crate::internal_macros::hash_trait_impls!(256, true, T: Tag);
+
+fn from_engine<T: Tag>(e: sha256::HashEngine) -> Hash<T> {
+    use crate::Hash as _;
+
+    Hash::from_byte_array(sha256::Hash::from_engine(e).to_byte_array())
+}
+
+/// Macro used to define a newtype tagged hash.
+///
+/// This macro creates two types:
+///
+/// * a tag struct
+/// * a hash wrapper
+///
+/// The syntax is:
+///
+/// ```
+/// # use tapyrus_hashes::sha256t_hash_newtype;
+/// sha256t_hash_newtype! {
+///     /// Optional documentation details here.
+///     /// Summary is always generated.
+///     pub struct FooTag = hash_str("foo");
+///
+///     /// A foo hash.
+///     // Direction works just like in case of hash_newtype! macro.
+///     #[hash_newtype(forward)]
+///     pub struct FooHash(_);
+/// }
+/// ```
+///
+/// The structs must be defined in this order - tag first, then hash type. `hash_str` marker
+/// says the midstate should be generated by hashing the supplied string in a way described in
+/// BIP-341. Alternatively, you can supply `hash_bytes` to hash raw bytes. If you have the midstate
+/// already pre-computed and prefer **compiler** performance to readability you may use
+/// `raw(MIDSTATE_BYTES, HASHED_BYTES_LENGHT)` instead.
+///
+/// Both visibility modifiers and attributes are optional and passed to inner structs (excluding
+/// `#[hash_newtype(...)]`). The attributes suffer same compiler performance limitations as in
+/// [`hash_newtype`] macro.
+///
+/// The macro accepts multiple inputs so you can define multiple hash newtypes in one macro call.
+/// Just make sure to enter the structs in order `Tag0`, `Hash0`, `Tag1`, `Hash1`...
+///
+/// [`hash_newtype`]: crate::hash_newtype
+#[macro_export]
+macro_rules! sha256t_hash_newtype {
+    ($($(#[$($tag_attr:tt)*])* $tag_vis:vis struct $tag:ident = $constructor:tt($($tag_value:tt)+); $(#[$($hash_attr:tt)*])* $hash_vis:vis struct $hash_name:ident($(#[$($field_attr:tt)*])* _);)+) => {
+        $(
+        $crate::sha256t_hash_newtype_tag!($tag_vis, $tag, stringify!($hash_name), $(#[$($tag_attr)*])*);
+
+        impl $crate::sha256t::Tag for $tag {
+            #[inline]
+            fn engine() -> $crate::sha256::HashEngine {
+                const MIDSTATE: ($crate::sha256::Midstate, usize) = $crate::sha256t_hash_newtype_tag_constructor!($constructor, $($tag_value)+);
+                #[allow(unused)]
+                const _LENGTH_CHECK: () = [(); 1][MIDSTATE.1 % 64];
+                $crate::sha256::HashEngine::from_midstate(MIDSTATE.0, MIDSTATE.1)
+            }
+        }
+
+        $crate::hash_newtype! {
+            $(#[$($hash_attr)*])*
+            $hash_vis struct $hash_name($(#[$($field_attr)*])* $crate::sha256t::Hash<$tag>);
+        }
+        )+
+    }
+}
+
+// Workaround macros being unavailable in attributes.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! sha256t_hash_newtype_tag {
+    ($vis:vis, $tag:ident, $name:expr, $(#[$($attr:meta)*])*) => {
+        #[doc = "The tag used for [`"]
+        #[doc = $name]
+        #[doc = "`]\n\n"]
+        $(#[$($attr)*])*
+        #[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+        $vis struct $tag;
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! sha256t_hash_newtype_tag_constructor {
+    (hash_str, $value:expr) => {
+        ($crate::sha256::Midstate::hash_tag($value.as_bytes()), 64)
+    };
+    (hash_bytes, $value:expr) => {
+        ($crate::sha256::Midstate::hash_tag($value), 64)
+    };
+    (raw, $bytes:expr, $len:expr) => {
+        ($crate::sha256::Midstate::from_byte_array($bytes), $len)
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "alloc")]
+    use crate::Hash;
+    use crate::{sha256, sha256t};
+
+    const TEST_MIDSTATE: [u8; 32] = [
+        156, 224, 228, 230, 124, 17, 108, 57, 56, 179, 202, 242, 195, 15, 80, 137, 211, 243, 147,
+        108, 71, 99, 110, 96, 125, 179, 62, 234, 221, 198, 240, 201,
+    ];
+
+    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
+    #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+    pub struct TestHashTag;
+
+    impl sha256t::Tag for TestHashTag {
+        fn engine() -> sha256::HashEngine {
+            // The TapRoot TapLeaf midstate.
+            let midstate = sha256::Midstate::from_byte_array(TEST_MIDSTATE);
+            sha256::HashEngine::from_midstate(midstate, 64)
+        }
+    }
+
+    /// A hash tagged with `$name`.
+    #[cfg(feature = "alloc")]
+    pub type TestHash = sha256t::Hash<TestHashTag>;
+
+    sha256t_hash_newtype! {
+        /// Test detailed explanation.
+        struct NewTypeTag = raw(TEST_MIDSTATE, 64);
+
+        /// A test hash.
+        #[hash_newtype(backward)]
+        struct NewTypeHash(_);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test_sha256t() {
+        assert_eq!(
+            TestHash::hash(&[0]).to_string(),
+            "29589d5122ec666ab5b4695070b6debc63881a4f85d88d93ddc90078038213ed"
+        );
+        assert_eq!(
+            NewTypeHash::hash(&[0]).to_string(),
+            "29589d5122ec666ab5b4695070b6debc63881a4f85d88d93ddc90078038213ed"
+        );
+    }
+}
diff --git a/hashes/src/sha512.rs b/hashes/src/sha512.rs
new file mode 100644
index 00000000..85a8aa4c
--- /dev/null
+++ b/hashes/src/sha512.rs
@@ -0,0 +1,453 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! SHA512 implementation.
+//!
+
+use core::convert::TryInto;
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::{cmp, str};
+
+use crate::{FromSliceError, HashEngine as _};
+
+crate::internal_macros::hash_trait_impls!(512, false);
+
+pub(crate) const BLOCK_SIZE: usize = 128;
+
+/// Engine to compute SHA512 hash function.
+#[derive(Clone)]
+pub struct HashEngine {
+    h: [u64; 8],
+    length: usize,
+    buffer: [u8; BLOCK_SIZE],
+}
+
+impl Default for HashEngine {
+    #[rustfmt::skip]
+    fn default() -> Self {
+        HashEngine {
+            h: [
+                0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
+                0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179,
+            ],
+            length: 0,
+            buffer: [0; BLOCK_SIZE],
+        }
+    }
+}
+
+impl HashEngine {
+    /// Constructs a hash engine suitable for use inside the default `sha512_256::HashEngine`.
+    #[rustfmt::skip]
+    pub(crate) fn sha512_256() -> Self {
+        HashEngine {
+            h: [
+                0x22312194fc2bf72c, 0x9f555fa3c84c64c2, 0x2393b86b6f53b151, 0x963877195940eabd,
+                0x96283ee2a88effe3, 0xbe5e1e2553863992, 0x2b0199fc2c85b8aa, 0x0eb72ddc81c52ca2,
+            ],
+            length: 0,
+            buffer: [0; BLOCK_SIZE],
+        }
+    }
+}
+
+impl crate::HashEngine for HashEngine {
+    type MidState = [u8; 64];
+
+    #[cfg(not(hashes_fuzz))]
+    fn midstate(&self) -> [u8; 64] {
+        let mut ret = [0; 64];
+        for (val, ret_bytes) in self.h.iter().zip(ret.chunks_exact_mut(8)) {
+            ret_bytes.copy_from_slice(&val.to_be_bytes());
+        }
+        ret
+    }
+
+    #[cfg(hashes_fuzz)]
+    fn midstate(&self) -> [u8; 64] {
+        let mut ret = [0; 64];
+        ret.copy_from_slice(&self.buffer[..64]);
+        ret
+    }
+
+    const BLOCK_SIZE: usize = 128;
+
+    fn n_bytes_hashed(&self) -> usize { self.length }
+
+    engine_input_impl!();
+}
+
+/// Output of the SHA512 hash function.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+#[repr(transparent)]
+pub struct Hash(
+    #[cfg_attr(
+        feature = "schemars",
+        schemars(schema_with = "crate::util::json_hex_string::len_64")
+    )]
+    [u8; 64],
+);
+
+impl Hash {
+    fn internal_new(arr: [u8; 64]) -> Self { Hash(arr) }
+
+    fn internal_engine() -> HashEngine { Default::default() }
+}
+
+#[cfg(not(hashes_fuzz))]
+pub(crate) fn from_engine(mut e: HashEngine) -> Hash {
+    // pad buffer with a single 1-bit then all 0s, until there are exactly 16 bytes remaining
+    let data_len = e.length as u64;
+
+    let zeroes = [0; BLOCK_SIZE - 16];
+    e.input(&[0x80]);
+    if e.length % BLOCK_SIZE > zeroes.len() {
+        e.input(&zeroes);
+    }
+    let pad_length = zeroes.len() - (e.length % BLOCK_SIZE);
+    e.input(&zeroes[..pad_length]);
+    debug_assert_eq!(e.length % BLOCK_SIZE, zeroes.len());
+
+    e.input(&[0; 8]);
+    e.input(&(8 * data_len).to_be_bytes());
+    debug_assert_eq!(e.length % BLOCK_SIZE, 0);
+
+    Hash(e.midstate())
+}
+
+#[cfg(hashes_fuzz)]
+pub(crate) fn from_engine(e: HashEngine) -> Hash {
+    let mut hash = e.midstate();
+    hash[0] ^= 0xff; // Make this distinct from SHA-256
+    Hash(hash)
+}
+
+#[allow(non_snake_case)]
+fn Ch(x: u64, y: u64, z: u64) -> u64 { z ^ (x & (y ^ z)) }
+#[allow(non_snake_case)]
+fn Maj(x: u64, y: u64, z: u64) -> u64 { (x & y) | (z & (x | y)) }
+#[allow(non_snake_case)]
+fn Sigma0(x: u64) -> u64 { x.rotate_left(36) ^ x.rotate_left(30) ^ x.rotate_left(25) }
+#[allow(non_snake_case)]
+fn Sigma1(x: u64) -> u64 { x.rotate_left(50) ^ x.rotate_left(46) ^ x.rotate_left(23) }
+fn sigma0(x: u64) -> u64 { x.rotate_left(63) ^ x.rotate_left(56) ^ (x >> 7) }
+fn sigma1(x: u64) -> u64 { x.rotate_left(45) ^ x.rotate_left(3) ^ (x >> 6) }
+
+#[cfg(feature = "small-hash")]
+#[macro_use]
+mod small_hash {
+    use super::*;
+
+    #[rustfmt::skip]
+    pub(super) fn round(a: u64, b: u64, c: u64, d: &mut u64, e: u64,
+                        f: u64, g: u64, h: &mut u64, k: u64, w: u64,
+    ) {
+        let t1 =
+            h.wrapping_add(Sigma1(e)).wrapping_add(Ch(e, f, g)).wrapping_add(k).wrapping_add(w);
+        let t2 = Sigma0(a).wrapping_add(Maj(a, b, c));
+        *d = d.wrapping_add(t1);
+        *h = t1.wrapping_add(t2);
+    }
+    #[rustfmt::skip]
+    pub(super) fn later_round(a: u64, b: u64, c: u64, d: &mut u64, e: u64,
+                              f: u64, g: u64, h: &mut u64, k: u64, w: u64,
+                              w1: u64, w2: u64, w3: u64,
+    ) -> u64 {
+        let w = w.wrapping_add(sigma1(w1)).wrapping_add(w2).wrapping_add(sigma0(w3));
+        round(a, b, c, d, e, f, g, h, k, w);
+        w
+    }
+
+    macro_rules! round(
+        // first round
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr, $f:expr, $g:expr, $h:expr, $k:expr, $w:expr) => (
+            small_hash::round($a, $b, $c, &mut $d, $e, $f, $g, &mut $h, $k, $w)
+        );
+        // later rounds we reassign $w before doing the first-round computation
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr, $f:expr, $g:expr, $h:expr, $k:expr, $w:expr, $w1:expr, $w2:expr, $w3:expr) => (
+            $w = small_hash::later_round($a, $b, $c, &mut $d, $e, $f, $g, &mut $h, $k, $w, $w1, $w2, $w3)
+        )
+    );
+}
+
+#[cfg(not(feature = "small-hash"))]
+#[macro_use]
+mod fast_hash {
+    macro_rules! round(
+        // first round
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr, $f:expr, $g:expr, $h:expr, $k:expr, $w:expr) => (
+            let t1 = $h.wrapping_add(Sigma1($e)).wrapping_add(Ch($e, $f, $g)).wrapping_add($k).wrapping_add($w);
+            let t2 = Sigma0($a).wrapping_add(Maj($a, $b, $c));
+            $d = $d.wrapping_add(t1);
+            $h = t1.wrapping_add(t2);
+        );
+        // later rounds we reassign $w before doing the first-round computation
+        ($a:expr, $b:expr, $c:expr, $d:expr, $e:expr, $f:expr, $g:expr, $h:expr, $k:expr, $w:expr, $w1:expr, $w2:expr, $w3:expr) => (
+            $w = $w.wrapping_add(sigma1($w1)).wrapping_add($w2).wrapping_add(sigma0($w3));
+            round!($a, $b, $c, $d, $e, $f, $g, $h, $k, $w);
+        )
+    );
+}
+
+impl HashEngine {
+    // Algorithm copied from libsecp256k1
+    pub(crate) fn process_block(&mut self) {
+        debug_assert_eq!(self.buffer.len(), BLOCK_SIZE);
+
+        let mut w = [0u64; 16];
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.chunks_exact(8)) {
+            *w_val = u64::from_be_bytes(buff_bytes.try_into().expect("8 byte slice"));
+        }
+
+        let mut a = self.h[0];
+        let mut b = self.h[1];
+        let mut c = self.h[2];
+        let mut d = self.h[3];
+        let mut e = self.h[4];
+        let mut f = self.h[5];
+        let mut g = self.h[6];
+        let mut h = self.h[7];
+
+        round!(a, b, c, d, e, f, g, h, 0x428a2f98d728ae22, w[0]);
+        round!(h, a, b, c, d, e, f, g, 0x7137449123ef65cd, w[1]);
+        round!(g, h, a, b, c, d, e, f, 0xb5c0fbcfec4d3b2f, w[2]);
+        round!(f, g, h, a, b, c, d, e, 0xe9b5dba58189dbbc, w[3]);
+        round!(e, f, g, h, a, b, c, d, 0x3956c25bf348b538, w[4]);
+        round!(d, e, f, g, h, a, b, c, 0x59f111f1b605d019, w[5]);
+        round!(c, d, e, f, g, h, a, b, 0x923f82a4af194f9b, w[6]);
+        round!(b, c, d, e, f, g, h, a, 0xab1c5ed5da6d8118, w[7]);
+        round!(a, b, c, d, e, f, g, h, 0xd807aa98a3030242, w[8]);
+        round!(h, a, b, c, d, e, f, g, 0x12835b0145706fbe, w[9]);
+        round!(g, h, a, b, c, d, e, f, 0x243185be4ee4b28c, w[10]);
+        round!(f, g, h, a, b, c, d, e, 0x550c7dc3d5ffb4e2, w[11]);
+        round!(e, f, g, h, a, b, c, d, 0x72be5d74f27b896f, w[12]);
+        round!(d, e, f, g, h, a, b, c, 0x80deb1fe3b1696b1, w[13]);
+        round!(c, d, e, f, g, h, a, b, 0x9bdc06a725c71235, w[14]);
+        round!(b, c, d, e, f, g, h, a, 0xc19bf174cf692694, w[15]);
+
+        round!(a, b, c, d, e, f, g, h, 0xe49b69c19ef14ad2, w[0], w[14], w[9], w[1]);
+        round!(h, a, b, c, d, e, f, g, 0xefbe4786384f25e3, w[1], w[15], w[10], w[2]);
+        round!(g, h, a, b, c, d, e, f, 0x0fc19dc68b8cd5b5, w[2], w[0], w[11], w[3]);
+        round!(f, g, h, a, b, c, d, e, 0x240ca1cc77ac9c65, w[3], w[1], w[12], w[4]);
+        round!(e, f, g, h, a, b, c, d, 0x2de92c6f592b0275, w[4], w[2], w[13], w[5]);
+        round!(d, e, f, g, h, a, b, c, 0x4a7484aa6ea6e483, w[5], w[3], w[14], w[6]);
+        round!(c, d, e, f, g, h, a, b, 0x5cb0a9dcbd41fbd4, w[6], w[4], w[15], w[7]);
+        round!(b, c, d, e, f, g, h, a, 0x76f988da831153b5, w[7], w[5], w[0], w[8]);
+        round!(a, b, c, d, e, f, g, h, 0x983e5152ee66dfab, w[8], w[6], w[1], w[9]);
+        round!(h, a, b, c, d, e, f, g, 0xa831c66d2db43210, w[9], w[7], w[2], w[10]);
+        round!(g, h, a, b, c, d, e, f, 0xb00327c898fb213f, w[10], w[8], w[3], w[11]);
+        round!(f, g, h, a, b, c, d, e, 0xbf597fc7beef0ee4, w[11], w[9], w[4], w[12]);
+        round!(e, f, g, h, a, b, c, d, 0xc6e00bf33da88fc2, w[12], w[10], w[5], w[13]);
+        round!(d, e, f, g, h, a, b, c, 0xd5a79147930aa725, w[13], w[11], w[6], w[14]);
+        round!(c, d, e, f, g, h, a, b, 0x06ca6351e003826f, w[14], w[12], w[7], w[15]);
+        round!(b, c, d, e, f, g, h, a, 0x142929670a0e6e70, w[15], w[13], w[8], w[0]);
+
+        round!(a, b, c, d, e, f, g, h, 0x27b70a8546d22ffc, w[0], w[14], w[9], w[1]);
+        round!(h, a, b, c, d, e, f, g, 0x2e1b21385c26c926, w[1], w[15], w[10], w[2]);
+        round!(g, h, a, b, c, d, e, f, 0x4d2c6dfc5ac42aed, w[2], w[0], w[11], w[3]);
+        round!(f, g, h, a, b, c, d, e, 0x53380d139d95b3df, w[3], w[1], w[12], w[4]);
+        round!(e, f, g, h, a, b, c, d, 0x650a73548baf63de, w[4], w[2], w[13], w[5]);
+        round!(d, e, f, g, h, a, b, c, 0x766a0abb3c77b2a8, w[5], w[3], w[14], w[6]);
+        round!(c, d, e, f, g, h, a, b, 0x81c2c92e47edaee6, w[6], w[4], w[15], w[7]);
+        round!(b, c, d, e, f, g, h, a, 0x92722c851482353b, w[7], w[5], w[0], w[8]);
+        round!(a, b, c, d, e, f, g, h, 0xa2bfe8a14cf10364, w[8], w[6], w[1], w[9]);
+        round!(h, a, b, c, d, e, f, g, 0xa81a664bbc423001, w[9], w[7], w[2], w[10]);
+        round!(g, h, a, b, c, d, e, f, 0xc24b8b70d0f89791, w[10], w[8], w[3], w[11]);
+        round!(f, g, h, a, b, c, d, e, 0xc76c51a30654be30, w[11], w[9], w[4], w[12]);
+        round!(e, f, g, h, a, b, c, d, 0xd192e819d6ef5218, w[12], w[10], w[5], w[13]);
+        round!(d, e, f, g, h, a, b, c, 0xd69906245565a910, w[13], w[11], w[6], w[14]);
+        round!(c, d, e, f, g, h, a, b, 0xf40e35855771202a, w[14], w[12], w[7], w[15]);
+        round!(b, c, d, e, f, g, h, a, 0x106aa07032bbd1b8, w[15], w[13], w[8], w[0]);
+
+        round!(a, b, c, d, e, f, g, h, 0x19a4c116b8d2d0c8, w[0], w[14], w[9], w[1]);
+        round!(h, a, b, c, d, e, f, g, 0x1e376c085141ab53, w[1], w[15], w[10], w[2]);
+        round!(g, h, a, b, c, d, e, f, 0x2748774cdf8eeb99, w[2], w[0], w[11], w[3]);
+        round!(f, g, h, a, b, c, d, e, 0x34b0bcb5e19b48a8, w[3], w[1], w[12], w[4]);
+        round!(e, f, g, h, a, b, c, d, 0x391c0cb3c5c95a63, w[4], w[2], w[13], w[5]);
+        round!(d, e, f, g, h, a, b, c, 0x4ed8aa4ae3418acb, w[5], w[3], w[14], w[6]);
+        round!(c, d, e, f, g, h, a, b, 0x5b9cca4f7763e373, w[6], w[4], w[15], w[7]);
+        round!(b, c, d, e, f, g, h, a, 0x682e6ff3d6b2b8a3, w[7], w[5], w[0], w[8]);
+        round!(a, b, c, d, e, f, g, h, 0x748f82ee5defb2fc, w[8], w[6], w[1], w[9]);
+        round!(h, a, b, c, d, e, f, g, 0x78a5636f43172f60, w[9], w[7], w[2], w[10]);
+        round!(g, h, a, b, c, d, e, f, 0x84c87814a1f0ab72, w[10], w[8], w[3], w[11]);
+        round!(f, g, h, a, b, c, d, e, 0x8cc702081a6439ec, w[11], w[9], w[4], w[12]);
+        round!(e, f, g, h, a, b, c, d, 0x90befffa23631e28, w[12], w[10], w[5], w[13]);
+        round!(d, e, f, g, h, a, b, c, 0xa4506cebde82bde9, w[13], w[11], w[6], w[14]);
+        round!(c, d, e, f, g, h, a, b, 0xbef9a3f7b2c67915, w[14], w[12], w[7], w[15]);
+        round!(b, c, d, e, f, g, h, a, 0xc67178f2e372532b, w[15], w[13], w[8], w[0]);
+
+        round!(a, b, c, d, e, f, g, h, 0xca273eceea26619c, w[0], w[14], w[9], w[1]);
+        round!(h, a, b, c, d, e, f, g, 0xd186b8c721c0c207, w[1], w[15], w[10], w[2]);
+        round!(g, h, a, b, c, d, e, f, 0xeada7dd6cde0eb1e, w[2], w[0], w[11], w[3]);
+        round!(f, g, h, a, b, c, d, e, 0xf57d4f7fee6ed178, w[3], w[1], w[12], w[4]);
+        round!(e, f, g, h, a, b, c, d, 0x06f067aa72176fba, w[4], w[2], w[13], w[5]);
+        round!(d, e, f, g, h, a, b, c, 0x0a637dc5a2c898a6, w[5], w[3], w[14], w[6]);
+        round!(c, d, e, f, g, h, a, b, 0x113f9804bef90dae, w[6], w[4], w[15], w[7]);
+        round!(b, c, d, e, f, g, h, a, 0x1b710b35131c471b, w[7], w[5], w[0], w[8]);
+        round!(a, b, c, d, e, f, g, h, 0x28db77f523047d84, w[8], w[6], w[1], w[9]);
+        round!(h, a, b, c, d, e, f, g, 0x32caab7b40c72493, w[9], w[7], w[2], w[10]);
+        round!(g, h, a, b, c, d, e, f, 0x3c9ebe0a15c9bebc, w[10], w[8], w[3], w[11]);
+        round!(f, g, h, a, b, c, d, e, 0x431d67c49c100d4c, w[11], w[9], w[4], w[12]);
+        round!(e, f, g, h, a, b, c, d, 0x4cc5d4becb3e42b6, w[12], w[10], w[5], w[13]);
+        round!(d, e, f, g, h, a, b, c, 0x597f299cfc657e2a, w[13], w[11], w[6], w[14]);
+        round!(c, d, e, f, g, h, a, b, 0x5fcb6fab3ad6faec, w[14], w[12], w[7], w[15]);
+        round!(b, c, d, e, f, g, h, a, 0x6c44198c4a475817, w[15], w[13], w[8], w[0]);
+
+        self.h[0] = self.h[0].wrapping_add(a);
+        self.h[1] = self.h[1].wrapping_add(b);
+        self.h[2] = self.h[2].wrapping_add(c);
+        self.h[3] = self.h[3].wrapping_add(d);
+        self.h[4] = self.h[4].wrapping_add(e);
+        self.h[5] = self.h[5].wrapping_add(f);
+        self.h[6] = self.h[6].wrapping_add(g);
+        self.h[7] = self.h[7].wrapping_add(h);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test() {
+        use crate::{sha512, Hash, HashEngine};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
+        #[rustfmt::skip]
+        let tests = vec![
+            // Test vectors computed with `sha512sum`
+            Test {
+                input: "",
+                output: vec![
+                    0xcf, 0x83, 0xe1, 0x35, 0x7e, 0xef, 0xb8, 0xbd,
+                    0xf1, 0x54, 0x28, 0x50, 0xd6, 0x6d, 0x80, 0x07,
+                    0xd6, 0x20, 0xe4, 0x05, 0x0b, 0x57, 0x15, 0xdc,
+                    0x83, 0xf4, 0xa9, 0x21, 0xd3, 0x6c, 0xe9, 0xce,
+                    0x47, 0xd0, 0xd1, 0x3c, 0x5d, 0x85, 0xf2, 0xb0,
+                    0xff, 0x83, 0x18, 0xd2, 0x87, 0x7e, 0xec, 0x2f,
+                    0x63, 0xb9, 0x31, 0xbd, 0x47, 0x41, 0x7a, 0x81,
+                    0xa5, 0x38, 0x32, 0x7a, 0xf9, 0x27, 0xda, 0x3e,
+                ],
+                output_str: "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"
+            },
+            Test {
+                input: "The quick brown fox jumps over the lazy dog",
+                output: vec![
+                    0x07, 0xe5, 0x47, 0xd9, 0x58, 0x6f, 0x6a, 0x73,
+                    0xf7, 0x3f, 0xba, 0xc0, 0x43, 0x5e, 0xd7, 0x69,
+                    0x51, 0x21, 0x8f, 0xb7, 0xd0, 0xc8, 0xd7, 0x88,
+                    0xa3, 0x09, 0xd7, 0x85, 0x43, 0x6b, 0xbb, 0x64,
+                    0x2e, 0x93, 0xa2, 0x52, 0xa9, 0x54, 0xf2, 0x39,
+                    0x12, 0x54, 0x7d, 0x1e, 0x8a, 0x3b, 0x5e, 0xd6,
+                    0xe1, 0xbf, 0xd7, 0x09, 0x78, 0x21, 0x23, 0x3f,
+                    0xa0, 0x53, 0x8f, 0x3d, 0xb8, 0x54, 0xfe, 0xe6,
+                ],
+                output_str: "07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6",
+            },
+            Test {
+                input: "The quick brown fox jumps over the lazy dog.",
+                output: vec![
+                    0x91, 0xea, 0x12, 0x45, 0xf2, 0x0d, 0x46, 0xae,
+                    0x9a, 0x03, 0x7a, 0x98, 0x9f, 0x54, 0xf1, 0xf7,
+                    0x90, 0xf0, 0xa4, 0x76, 0x07, 0xee, 0xb8, 0xa1,
+                    0x4d, 0x12, 0x89, 0x0c, 0xea, 0x77, 0xa1, 0xbb,
+                    0xc6, 0xc7, 0xed, 0x9c, 0xf2, 0x05, 0xe6, 0x7b,
+                    0x7f, 0x2b, 0x8f, 0xd4, 0xc7, 0xdf, 0xd3, 0xa7,
+                    0xa8, 0x61, 0x7e, 0x45, 0xf3, 0xc4, 0x63, 0xd4,
+                    0x81, 0xc7, 0xe5, 0x86, 0xc3, 0x9a, 0xc1, 0xed,
+                ],
+                output_str: "91ea1245f20d46ae9a037a989f54f1f790f0a47607eeb8a14d12890cea77a1bbc6c7ed9cf205e67b7f2b8fd4c7dfd3a7a8617e45f3c463d481c7e586c39ac1ed",
+            },
+        ];
+
+        for test in tests {
+            // Hash through high-level API, check hex encoding/decoding
+            let hash = sha512::Hash::hash(test.input.as_bytes());
+            assert_eq!(hash, test.output_str.parse::<sha512::Hash>().expect("parse hex"));
+            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(&hash.to_string(), &test.output_str);
+
+            // Hash through engine, checking that we can input byte by byte
+            let mut engine = sha512::Hash::engine();
+            for ch in test.input.as_bytes() {
+                engine.input(&[*ch]);
+            }
+            let manual_hash = sha512::Hash::from_engine(engine);
+            assert_eq!(hash, manual_hash);
+            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn sha512_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        use crate::{sha512, Hash};
+
+        #[rustfmt::skip]
+        static HASH_BYTES: [u8; 64] = [
+            0x8b, 0x41, 0xe1, 0xb7, 0x8a, 0xd1, 0x15, 0x21,
+            0x11, 0x3c, 0x52, 0xff, 0x18, 0x2a, 0x1b, 0x8e,
+            0x0a, 0x19, 0x57, 0x54, 0xaa, 0x52, 0x7f, 0xcd,
+            0x00, 0xa4, 0x11, 0x62, 0x0b, 0x46, 0xf2, 0x0f,
+            0xff, 0xfb, 0x80, 0x88, 0xcc, 0xf8, 0x54, 0x97,
+            0x12, 0x1a, 0xd4, 0x49, 0x9e, 0x08, 0x45, 0xb8,
+            0x76, 0xf6, 0xdd, 0x66, 0x40, 0x08, 0x8a, 0x2f,
+            0x0b, 0x2d, 0x8a, 0x60, 0x0b, 0xdf, 0x4c, 0x0c,
+        ];
+
+        let hash = sha512::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
+        assert_tokens(
+            &hash.readable(),
+            &[Token::Str(
+                "8b41e1b78ad11521113c52ff182a1b8e0a195754aa527fcd00a411620b46f20f\
+                 fffb8088ccf85497121ad4499e0845b876f6dd6640088a2f0b2d8a600bdf4c0c",
+            )],
+        );
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{sha512, Hash, HashEngine};
+
+    #[bench]
+    pub fn sha512_10(bh: &mut Bencher) {
+        let mut engine = sha512::Hash::engine();
+        let bytes = [1u8; 10];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha512_1k(bh: &mut Bencher) {
+        let mut engine = sha512::Hash::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha512_64k(bh: &mut Bencher) {
+        let mut engine = sha512::Hash::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/sha512_256.rs b/hashes/src/sha512_256.rs
new file mode 100644
index 00000000..27d90d68
--- /dev/null
+++ b/hashes/src/sha512_256.rs
@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! SHA512_256 implementation.
+//!
+//! SHA512/256 is a hash function that uses the sha512 alogrithm but it truncates
+//! the output to 256 bits. It has different initial constants than sha512 so it
+//! produces an entirely different hash compared to sha512. More information at
+//! <https://eprint.iacr.org/2010/548.pdf>.
+
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::str;
+
+use crate::{sha512, FromSliceError};
+
+/// Engine to compute SHA512/256 hash function.
+///
+/// SHA512/256 is a hash function that uses the sha512 alogrithm but it truncates
+/// the output to 256 bits. It has different initial constants than sha512 so it
+/// produces an entirely different hash compared to sha512. More information at
+/// <https://eprint.iacr.org/2010/548.pdf>.
+#[derive(Clone)]
+pub struct HashEngine(sha512::HashEngine);
+
+impl Default for HashEngine {
+    #[rustfmt::skip]
+    fn default() -> Self {
+        HashEngine(sha512::HashEngine::sha512_256())
+    }
+}
+
+impl crate::HashEngine for HashEngine {
+    type MidState = [u8; 64];
+
+    fn midstate(&self) -> [u8; 64] { self.0.midstate() }
+
+    const BLOCK_SIZE: usize = sha512::BLOCK_SIZE;
+
+    fn n_bytes_hashed(&self) -> usize { self.0.n_bytes_hashed() }
+
+    fn input(&mut self, inp: &[u8]) { self.0.input(inp); }
+}
+
+crate::internal_macros::hash_type! {
+    256,
+    false,
+    "Output of the SHA512/256 hash function.\n\nSHA512/256 is a hash function that uses the sha512 alogrithm but it truncates the output to 256 bits. It has different initial constants than sha512 so it produces an entirely different hash compared to sha512. More information at <https://eprint.iacr.org/2010/548.pdf>. ",
+    "crate::util::json_hex_string::len_32"
+}
+
+fn from_engine(e: HashEngine) -> Hash {
+    let mut ret = [0; 32];
+    ret.copy_from_slice(&sha512::from_engine(e.0)[..32]);
+    Hash(ret)
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test() {
+        use crate::{sha512_256, Hash, HashEngine};
+
+        #[derive(Clone)]
+        struct Test {
+            input: &'static str,
+            output: Vec<u8>,
+            output_str: &'static str,
+        }
+
+        #[rustfmt::skip]
+        let tests = vec![
+            // Examples from go sha512/256 tests.
+            Test {
+                input: "",
+                output: vec![
+                    0xc6, 0x72, 0xb8, 0xd1, 0xef, 0x56, 0xed, 0x28,
+                    0xab, 0x87, 0xc3, 0x62, 0x2c, 0x51, 0x14, 0x06,
+                    0x9b, 0xdd, 0x3a, 0xd7, 0xb8, 0xf9, 0x73, 0x74,
+                    0x98, 0xd0, 0xc0, 0x1e, 0xce, 0xf0, 0x96, 0x7a,
+                ],
+                output_str: "c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a"
+            },
+            Test {
+                input: "abcdef",
+                output: vec![
+                    0xe4, 0xfd, 0xcb, 0x11, 0xd1, 0xac, 0x14, 0xe6,
+                    0x98, 0x74, 0x3a, 0xcd, 0x88, 0x05, 0x17, 0x4c,
+                    0xea, 0x5d, 0xdc, 0x0d, 0x31, 0x2e, 0x3e, 0x47,
+                    0xf6, 0x37, 0x20, 0x32, 0x57, 0x1b, 0xad, 0x84,
+                ],
+                output_str: "e4fdcb11d1ac14e698743acd8805174cea5ddc0d312e3e47f6372032571bad84",
+            },
+            Test {
+                input: "Discard medicine more than two years old.",
+                output: vec![
+                    0x69, 0x0c, 0x8a, 0xd3, 0x91, 0x6c, 0xef, 0xd3,
+                    0xad, 0x29, 0x22, 0x6d, 0x98, 0x75, 0x96, 0x5e,
+                    0x3e, 0xe9, 0xec, 0x0d, 0x44, 0x82, 0xea, 0xcc,
+                    0x24, 0x8f, 0x2f, 0xf4, 0xaa, 0x0d, 0x8e, 0x5b,
+                ],
+                output_str: "690c8ad3916cefd3ad29226d9875965e3ee9ec0d4482eacc248f2ff4aa0d8e5b",
+            },
+            Test {
+                input: "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977",
+                output: vec![
+                    0xb5, 0xba, 0xf7, 0x47, 0xc3, 0x07, 0xf9, 0x88,
+                    0x49, 0xec, 0x88, 0x1c, 0xf0, 0xd4, 0x86, 0x05,
+                    0xae, 0x4e, 0xdd, 0x38, 0x63, 0x72, 0xae, 0xa9,
+                    0xb2, 0x6e, 0x71, 0xdb, 0x51, 0x7e, 0x65, 0x0b,
+                ],
+                output_str: "b5baf747c307f98849ec881cf0d48605ae4edd386372aea9b26e71db517e650b",
+            },
+            Test {
+                input: "The major problem is with sendmail.  -Mark Horton",
+                output: vec![
+                    0x53, 0xed, 0x5f, 0x9b, 0x5c, 0x0b, 0x67, 0x4a,
+                    0xc0, 0xf3, 0x42, 0x5d, 0x9f, 0x9a, 0x5d, 0x46,
+                    0x26, 0x55, 0xb0, 0x7c, 0xc9, 0x0f, 0x5d, 0x0f,
+                    0x69, 0x2e, 0xec, 0x09, 0x38, 0x84, 0xa6, 0x07,
+                ],
+                output_str: "53ed5f9b5c0b674ac0f3425d9f9a5d462655b07cc90f5d0f692eec093884a607",
+            },
+        ];
+
+        for test in tests {
+            // Hash through high-level API, check hex encoding/decoding
+            let hash = sha512_256::Hash::hash(test.input.as_bytes());
+            assert_eq!(hash, test.output_str.parse::<sha512_256::Hash>().expect("parse hex"));
+            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(&hash.to_string(), &test.output_str);
+
+            // Hash through engine, checking that we can input byte by byte
+            let mut engine = sha512_256::Hash::engine();
+            for ch in test.input.as_bytes() {
+                engine.0.input(&[*ch]);
+            }
+            let manual_hash = sha512_256::Hash::from_engine(engine);
+            assert_eq!(hash, manual_hash);
+            assert_eq!(hash.to_byte_array()[..].as_ref(), test.output.as_slice());
+        }
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{sha512_256, Hash, HashEngine};
+
+    #[bench]
+    pub fn sha512_256_10(bh: &mut Bencher) {
+        let mut engine = sha512_256::Hash::engine();
+        let bytes = [1u8; 10];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha512_256_1k(bh: &mut Bencher) {
+        let mut engine = sha512_256::Hash::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn sha512_256_64k(bh: &mut Bencher) {
+        let mut engine = sha512_256::Hash::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/siphash24.rs b/hashes/src/siphash24.rs
new file mode 100644
index 00000000..86981afe
--- /dev/null
+++ b/hashes/src/siphash24.rs
@@ -0,0 +1,387 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! SipHash 2-4 implementation.
+//!
+
+use core::ops::Index;
+use core::slice::SliceIndex;
+use core::{cmp, mem, ptr, str};
+
+use crate::{FromSliceError, Hash as _, HashEngine as _};
+
+crate::internal_macros::hash_type! {
+    64,
+    false,
+    "Output of the SipHash24 hash function.",
+    "crate::util::json_hex_string::len_8"
+}
+
+#[cfg(not(hashes_fuzz))]
+fn from_engine(e: HashEngine) -> Hash { Hash::from_u64(Hash::from_engine_to_u64(e)) }
+
+#[cfg(hashes_fuzz)]
+fn from_engine(e: HashEngine) -> Hash {
+    let state = e.midstate();
+    Hash::from_u64(state.v0 ^ state.v1 ^ state.v2 ^ state.v3)
+}
+
+macro_rules! compress {
+    ($state:expr) => {{
+        compress!($state.v0, $state.v1, $state.v2, $state.v3)
+    }};
+    ($v0:expr, $v1:expr, $v2:expr, $v3:expr) => {{
+        $v0 = $v0.wrapping_add($v1);
+        $v1 = $v1.rotate_left(13);
+        $v1 ^= $v0;
+        $v0 = $v0.rotate_left(32);
+        $v2 = $v2.wrapping_add($v3);
+        $v3 = $v3.rotate_left(16);
+        $v3 ^= $v2;
+        $v0 = $v0.wrapping_add($v3);
+        $v3 = $v3.rotate_left(21);
+        $v3 ^= $v0;
+        $v2 = $v2.wrapping_add($v1);
+        $v1 = $v1.rotate_left(17);
+        $v1 ^= $v2;
+        $v2 = $v2.rotate_left(32);
+    }};
+}
+
+/// Load an integer of the desired type from a byte stream, in LE order. Uses
+/// `copy_nonoverlapping` to let the compiler generate the most efficient way
+/// to load it from a possibly unaligned address.
+///
+/// Unsafe because: unchecked indexing at `i..i+size_of(int_ty)`.
+macro_rules! load_int_le {
+    ($buf:expr, $i:expr, $int_ty:ident) => {{
+        debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len());
+        let mut data = 0 as $int_ty;
+        ptr::copy_nonoverlapping(
+            $buf.get_unchecked($i),
+            &mut data as *mut _ as *mut u8,
+            mem::size_of::<$int_ty>(),
+        );
+        data.to_le()
+    }};
+}
+
+/// Internal state of the [`HashEngine`].
+#[derive(Debug, Clone)]
+pub struct State {
+    // v0, v2 and v1, v3 show up in pairs in the algorithm,
+    // and simd implementations of SipHash will use vectors
+    // of v02 and v13. By placing them in this order in the struct,
+    // the compiler can pick up on just a few simd optimizations by itself.
+    v0: u64,
+    v2: u64,
+    v1: u64,
+    v3: u64,
+}
+
+/// Engine to compute the SipHash24 hash function.
+#[derive(Debug, Clone)]
+pub struct HashEngine {
+    k0: u64,
+    k1: u64,
+    length: usize, // how many bytes we've processed
+    state: State,  // hash State
+    tail: u64,     // unprocessed bytes le
+    ntail: usize,  // how many bytes in tail are valid
+}
+
+impl HashEngine {
+    /// Creates a new SipHash24 engine with keys.
+    pub fn with_keys(k0: u64, k1: u64) -> HashEngine {
+        HashEngine {
+            k0,
+            k1,
+            length: 0,
+            state: State {
+                v0: k0 ^ 0x736f6d6570736575,
+                v1: k1 ^ 0x646f72616e646f6d,
+                v2: k0 ^ 0x6c7967656e657261,
+                v3: k1 ^ 0x7465646279746573,
+            },
+            tail: 0,
+            ntail: 0,
+        }
+    }
+
+    /// Creates a new SipHash24 engine.
+    pub fn new() -> HashEngine { HashEngine::with_keys(0, 0) }
+
+    /// Retrieves the keys of this engine.
+    pub fn keys(&self) -> (u64, u64) { (self.k0, self.k1) }
+
+    #[inline]
+    fn c_rounds(state: &mut State) {
+        compress!(state);
+        compress!(state);
+    }
+
+    #[inline]
+    fn d_rounds(state: &mut State) {
+        compress!(state);
+        compress!(state);
+        compress!(state);
+        compress!(state);
+    }
+}
+
+impl Default for HashEngine {
+    fn default() -> Self { HashEngine::new() }
+}
+
+impl crate::HashEngine for HashEngine {
+    type MidState = State;
+
+    fn midstate(&self) -> State { self.state.clone() }
+
+    const BLOCK_SIZE: usize = 8;
+
+    #[inline]
+    fn input(&mut self, msg: &[u8]) {
+        let length = msg.len();
+        self.length += length;
+
+        let mut needed = 0;
+
+        if self.ntail != 0 {
+            needed = 8 - self.ntail;
+            self.tail |= unsafe { u8to64_le(msg, 0, cmp::min(length, needed)) } << (8 * self.ntail);
+            if length < needed {
+                self.ntail += length;
+                return;
+            } else {
+                self.state.v3 ^= self.tail;
+                HashEngine::c_rounds(&mut self.state);
+                self.state.v0 ^= self.tail;
+                self.ntail = 0;
+            }
+        }
+
+        // Buffered tail is now flushed, process new input.
+        let len = length - needed;
+        let left = len & 0x7;
+
+        let mut i = needed;
+        while i < len - left {
+            let mi = unsafe { load_int_le!(msg, i, u64) };
+
+            self.state.v3 ^= mi;
+            HashEngine::c_rounds(&mut self.state);
+            self.state.v0 ^= mi;
+
+            i += 8;
+        }
+
+        self.tail = unsafe { u8to64_le(msg, i, left) };
+        self.ntail = left;
+    }
+
+    fn n_bytes_hashed(&self) -> usize { self.length }
+}
+
+impl Hash {
+    /// Hashes the given data with an engine with the provided keys.
+    pub fn hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> Hash {
+        let mut engine = HashEngine::with_keys(k0, k1);
+        engine.input(data);
+        Hash::from_engine(engine)
+    }
+
+    /// Hashes the given data directly to u64 with an engine with the provided keys.
+    pub fn hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64 {
+        let mut engine = HashEngine::with_keys(k0, k1);
+        engine.input(data);
+        Hash::from_engine_to_u64(engine)
+    }
+
+    /// Produces a hash as `u64` from the current state of a given engine.
+    #[inline]
+    pub fn from_engine_to_u64(e: HashEngine) -> u64 {
+        let mut state = e.state;
+
+        let b: u64 = ((e.length as u64 & 0xff) << 56) | e.tail;
+
+        state.v3 ^= b;
+        HashEngine::c_rounds(&mut state);
+        state.v0 ^= b;
+
+        state.v2 ^= 0xff;
+        HashEngine::d_rounds(&mut state);
+
+        state.v0 ^ state.v1 ^ state.v2 ^ state.v3
+    }
+
+    /// Returns the (little endian) 64-bit integer representation of the hash value.
+    pub fn as_u64(&self) -> u64 { u64::from_le_bytes(self.0) }
+
+    /// Creates a hash from its (little endian) 64-bit integer representation.
+    pub fn from_u64(hash: u64) -> Hash { Hash(hash.to_le_bytes()) }
+}
+
+/// Load an u64 using up to 7 bytes of a byte slice.
+///
+/// Unsafe because: unchecked indexing at `start..start+len`.
+#[inline]
+unsafe fn u8to64_le(buf: &[u8], start: usize, len: usize) -> u64 {
+    debug_assert!(len < 8);
+    let mut i = 0; // current byte index (from LSB) in the output u64
+    let mut out = 0;
+    if i + 3 < len {
+        out = u64::from(load_int_le!(buf, start + i, u32));
+        i += 4;
+    }
+    if i + 1 < len {
+        out |= u64::from(load_int_le!(buf, start + i, u16)) << (i * 8);
+        i += 2
+    }
+    if i < len {
+        out |= u64::from(*buf.get_unchecked(start + i)) << (i * 8);
+        i += 1;
+    }
+    debug_assert_eq!(i, len);
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_siphash_2_4() {
+        #[rustfmt::skip]
+        let vecs: [[u8; 8]; 64] = [
+            [0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72],
+            [0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74],
+            [0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d],
+            [0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85],
+            [0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf],
+            [0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18],
+            [0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb],
+            [0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab],
+            [0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93],
+            [0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e],
+            [0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a],
+            [0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4],
+            [0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75],
+            [0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14],
+            [0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7],
+            [0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1],
+            [0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f],
+            [0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69],
+            [0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b],
+            [0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb],
+            [0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe],
+            [0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0],
+            [0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93],
+            [0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8],
+            [0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8],
+            [0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc],
+            [0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17],
+            [0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f],
+            [0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde],
+            [0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6],
+            [0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad],
+            [0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32],
+            [0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71],
+            [0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7],
+            [0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12],
+            [0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15],
+            [0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31],
+            [0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02],
+            [0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca],
+            [0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a],
+            [0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e],
+            [0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad],
+            [0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18],
+            [0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4],
+            [0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9],
+            [0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9],
+            [0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb],
+            [0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0],
+            [0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6],
+            [0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7],
+            [0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee],
+            [0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1],
+            [0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a],
+            [0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81],
+            [0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f],
+            [0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24],
+            [0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7],
+            [0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea],
+            [0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60],
+            [0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66],
+            [0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c],
+            [0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f],
+            [0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5],
+            [0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95],
+        ];
+
+        let k0 = 0x_07_06_05_04_03_02_01_00;
+        let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
+        let mut vin = [0u8; 64];
+        let mut state_inc = HashEngine::with_keys(k0, k1);
+
+        for i in 0..64 {
+            vin[i] = i as u8;
+            let vec = Hash::from_slice(&vecs[i][..]).unwrap();
+            let out = Hash::hash_with_keys(k0, k1, &vin[0..i]);
+            assert_eq!(vec, out, "vec #{}", i);
+
+            let inc = Hash::from_engine(state_inc.clone());
+            assert_eq!(vec, inc, "vec #{}", i);
+            state_inc.input(&[i as u8]);
+        }
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::Bencher;
+
+    use crate::{siphash24, Hash, HashEngine};
+
+    #[bench]
+    pub fn siphash24_1ki(bh: &mut Bencher) {
+        let mut engine = siphash24::Hash::engine();
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn siphash24_64ki(bh: &mut Bencher) {
+        let mut engine = siphash24::Hash::engine();
+        let bytes = [1u8; 65536];
+        bh.iter(|| {
+            engine.input(&bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn siphash24_1ki_hash(bh: &mut Bencher) {
+        let k0 = 0x_07_06_05_04_03_02_01_00;
+        let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            let _ = siphash24::Hash::hash_with_keys(k0, k1, &bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+
+    #[bench]
+    pub fn siphash24_1ki_hash_u64(bh: &mut Bencher) {
+        let k0 = 0x_07_06_05_04_03_02_01_00;
+        let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08;
+        let bytes = [1u8; 1024];
+        bh.iter(|| {
+            let _ = siphash24::Hash::hash_to_u64_with_keys(k0, k1, &bytes);
+        });
+        bh.bytes = bytes.len() as u64;
+    }
+}
diff --git a/hashes/src/util.rs b/hashes/src/util.rs
new file mode 100644
index 00000000..6282897d
--- /dev/null
+++ b/hashes/src/util.rs
@@ -0,0 +1,486 @@
+// SPDX-License-Identifier: CC0-1.0
+
+#[macro_export]
+/// Adds hexadecimal formatting implementation of a trait `$imp` to a given type `$ty`.
+macro_rules! hex_fmt_impl(
+    ($reverse:expr, $ty:ident) => (
+        $crate::hex_fmt_impl!($reverse, $ty, );
+    );
+    ($reverse:expr, $ty:ident, $($gen:ident: $gent:ident),*) => (
+        impl<$($gen: $gent),*> $crate::_export::_core::fmt::LowerHex for $ty<$($gen),*> {
+            #[inline]
+            fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
+                if $reverse {
+                    $crate::_export::_core::fmt::LowerHex::fmt(&self.0.backward_hex(), f)
+                } else {
+                    $crate::_export::_core::fmt::LowerHex::fmt(&self.0.forward_hex(), f)
+                }
+            }
+        }
+
+        impl<$($gen: $gent),*> $crate::_export::_core::fmt::UpperHex for $ty<$($gen),*> {
+            #[inline]
+            fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
+                if $reverse {
+                    $crate::_export::_core::fmt::UpperHex::fmt(&self.0.backward_hex(), f)
+                } else {
+                    $crate::_export::_core::fmt::UpperHex::fmt(&self.0.forward_hex(), f)
+                }
+            }
+        }
+
+        impl<$($gen: $gent),*> $crate::_export::_core::fmt::Display for $ty<$($gen),*> {
+            #[inline]
+            fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
+                $crate::_export::_core::fmt::LowerHex::fmt(&self, f)
+            }
+        }
+
+        impl<$($gen: $gent),*> $crate::_export::_core::fmt::Debug for $ty<$($gen),*> {
+            #[inline]
+            fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
+                write!(f, "{:#}", self)
+            }
+        }
+    );
+);
+
+/// Adds slicing traits implementations to a given type `$ty`
+#[macro_export]
+macro_rules! borrow_slice_impl(
+    ($ty:ident) => (
+        $crate::borrow_slice_impl!($ty, );
+    );
+    ($ty:ident, $($gen:ident: $gent:ident),*) => (
+        impl<$($gen: $gent),*> $crate::_export::_core::borrow::Borrow<[u8]> for $ty<$($gen),*>  {
+            fn borrow(&self) -> &[u8] {
+                &self[..]
+            }
+        }
+
+        impl<$($gen: $gent),*> $crate::_export::_core::convert::AsRef<[u8]> for $ty<$($gen),*>  {
+            fn as_ref(&self) -> &[u8] {
+                &self[..]
+            }
+        }
+    )
+);
+
+macro_rules! engine_input_impl(
+    () => (
+        #[cfg(not(hashes_fuzz))]
+        fn input(&mut self, mut inp: &[u8]) {
+            while !inp.is_empty() {
+                let buf_idx = self.length % <Self as crate::HashEngine>::BLOCK_SIZE;
+                let rem_len = <Self as crate::HashEngine>::BLOCK_SIZE - buf_idx;
+                let write_len = cmp::min(rem_len, inp.len());
+
+                self.buffer[buf_idx..buf_idx + write_len]
+                    .copy_from_slice(&inp[..write_len]);
+                self.length += write_len;
+                if self.length % <Self as crate::HashEngine>::BLOCK_SIZE == 0 {
+                    self.process_block();
+                }
+                inp = &inp[write_len..];
+            }
+        }
+
+        #[cfg(hashes_fuzz)]
+        fn input(&mut self, inp: &[u8]) {
+            for c in inp {
+                self.buffer[0] ^= *c;
+            }
+            self.length += inp.len();
+        }
+    )
+);
+
+/// Creates a new newtype around a [`Hash`] type.
+///
+/// The syntax is similar to the usual tuple struct syntax:
+///
+/// ```
+/// # use tapyrus_hashes::{hash_newtype, sha256};
+/// hash_newtype! {
+///     /// Hash of `Foo`.
+///     pub struct MyNewtype(pub sha256::Hash);
+/// }
+/// ```
+///
+/// You can use any valid visibility specifier in place of `pub` or you can omit either or both, if
+/// you want the type or its field to be private.
+///
+/// Whether the hash is reversed or not when displaying depends on the inner type. However you can
+/// override it like this:
+///
+/// ```
+/// # use tapyrus_hashes::{hash_newtype, sha256};
+/// hash_newtype! {
+///     #[hash_newtype(backward)]
+///     struct MyNewtype(sha256::Hash);
+/// }
+/// ```
+///
+/// This will display the hash backwards regardless of what the inner type does. Use `forward`
+/// instead of `backward` to force displaying forward.
+///
+/// You can add arbitrary doc comments or other attributes to the struct or it's field. Note that
+/// the macro already derives [`Copy`], [`Clone`], [`Eq`], [`PartialEq`],
+/// [`Hash`](core::hash::Hash), [`Ord`], [`PartialOrd`]. With the `serde` feature on, this also adds
+/// `Serialize` and `Deserialize` implementations.
+///
+/// You can also define multiple newtypes within one macro call:
+///
+/// ```
+/// # use tapyrus_hashes::{hash_newtype, sha256, hash160};
+///
+/// hash_newtype! {
+///     /// My custom type 1
+///     pub struct Newtype1(sha256::Hash);
+///
+///     /// My custom type 2
+///     struct Newtype2(hash160::Hash);
+/// }
+/// ```
+///
+/// Note: the macro is internally recursive. If you use too many attributes (> 256 tokens) you may
+/// hit recursion limit. If you have so many attributes for a good reason, just raising the limit
+/// should be OK. Note however that attribute-processing part has to use [TT muncher] which has
+/// quadratic complexity, so having many attributes may blow up compile time. This should be rare.
+///
+/// [TT muncher]: https://danielkeep.github.io/tlborm/book/pat-incremental-tt-munchers.html
+///
+// Ever heard of legendary comments warning developers to not touch the code? Yep, here's another
+// one. The following code is written the way it is for some specific reasons. If you think you can
+// simplify it, I suggest spending your time elsewhere.
+//
+// If you looks at the code carefully you might ask these questions:
+//
+// * Why are attributes using `tt` and not `meta`?!
+// * Why are the macros split like that?!
+// * Why use recursion instead of `$()*`?
+//
+// None of these are here by accident. For some reason unknown to me, if you accept an argument to
+// macro with any fragment specifier other than `tt` it will **not** match any of the rules
+// requiring a specific token. Yep, I tried it, I literally got error that `hash_newtype` doesn't
+// match `hash_newtype`. So all input attributes must be `tt`.
+//
+// Originally I wanted to define a bunch of macros that would filter-out hash_type attributes. Then
+// I remembered (by seeing compiler error) that calling macros is not allowed inside attributes.
+// And no, you can't bypass it by calling a helper macro and passing "output of another macro" into
+// it. The whole macro gets passed, not the resulting value. So we have to generate the entire
+// attributes. And you can't just place an attribute-producing macro above struct - they are
+// considered separate items. This is not C.
+//
+// Thus struct is generated in a separate macro together with attributes. And since the macro needs
+// attributes as the input and I didn't want to create confusion by using `#[]` syntax *after*
+// struct, I opted to use `{}` as a separator. Yes, a separator is required because an attribute
+// may be composed of multiple token trees - that's the point of "double repetition".
+#[macro_export]
+macro_rules! hash_newtype {
+    ($($(#[$($type_attrs:tt)*])* $type_vis:vis struct $newtype:ident($(#[$field_attrs:tt])* $field_vis:vis $hash:path);)+) => {
+        $(
+        $($crate::hash_newtype_known_attrs!(#[ $($type_attrs)* ]);)*
+
+        $crate::hash_newtype_struct! {
+            $type_vis struct $newtype($(#[$field_attrs])* $field_vis $hash);
+
+            $({ $($type_attrs)* })*
+        }
+
+        $crate::hex_fmt_impl!(<$newtype as $crate::Hash>::DISPLAY_BACKWARD, $newtype);
+        $crate::serde_impl!($newtype, <$newtype as $crate::Hash>::LEN);
+        $crate::borrow_slice_impl!($newtype);
+
+        impl $newtype {
+            /// Creates this wrapper type from the inner hash type.
+            #[allow(unused)] // the user of macro may not need this
+            pub fn from_raw_hash(inner: $hash) -> $newtype {
+                $newtype(inner)
+            }
+
+            /// Returns the inner hash (sha256, sh256d etc.).
+            #[allow(unused)] // the user of macro may not need this
+            pub fn to_raw_hash(self) -> $hash {
+                self.0
+            }
+
+            /// Returns a reference to the inner hash (sha256, sh256d etc.).
+            #[allow(unused)] // the user of macro may not need this
+            pub fn as_raw_hash(&self) -> &$hash {
+                &self.0
+            }
+        }
+
+        impl $crate::_export::_core::convert::From<$hash> for $newtype {
+            fn from(inner: $hash) -> $newtype {
+                // Due to rust 1.22 we have to use this instead of simple `Self(inner)`
+                Self { 0: inner }
+            }
+        }
+
+        impl $crate::_export::_core::convert::From<$newtype> for $hash {
+            fn from(hashtype: $newtype) -> $hash {
+                hashtype.0
+            }
+        }
+
+        impl $crate::Hash for $newtype {
+            type Engine = <$hash as $crate::Hash>::Engine;
+            type Bytes = <$hash as $crate::Hash>::Bytes;
+
+            const LEN: usize = <$hash as $crate::Hash>::LEN;
+            const DISPLAY_BACKWARD: bool = $crate::hash_newtype_get_direction!($hash, $(#[$($type_attrs)*])*);
+
+            fn engine() -> Self::Engine {
+                <$hash as $crate::Hash>::engine()
+            }
+
+            fn from_engine(e: Self::Engine) -> Self {
+                Self::from(<$hash as $crate::Hash>::from_engine(e))
+            }
+
+            #[inline]
+            fn from_slice(sl: &[u8]) -> Result<$newtype, $crate::FromSliceError> {
+                Ok($newtype(<$hash as $crate::Hash>::from_slice(sl)?))
+            }
+
+            #[inline]
+            fn from_byte_array(bytes: Self::Bytes) -> Self {
+                $newtype(<$hash as $crate::Hash>::from_byte_array(bytes))
+            }
+
+            #[inline]
+            fn to_byte_array(self) -> Self::Bytes {
+                self.0.to_byte_array()
+            }
+
+            #[inline]
+            fn as_byte_array(&self) -> &Self::Bytes {
+                self.0.as_byte_array()
+            }
+
+            #[inline]
+            fn all_zeros() -> Self {
+                let zeros = <$hash>::all_zeros();
+                $newtype(zeros)
+            }
+        }
+
+        impl $crate::_export::_core::str::FromStr for $newtype {
+            type Err = $crate::hex::HexToArrayError;
+            fn from_str(s: &str) -> $crate::_export::_core::result::Result<$newtype, Self::Err> {
+                use $crate::hex::{FromHex, HexToBytesIter};
+                use $crate::Hash;
+
+                let inner: <$hash as Hash>::Bytes = if <Self as $crate::Hash>::DISPLAY_BACKWARD {
+                    FromHex::from_byte_iter(HexToBytesIter::new(s)?.rev())?
+                } else {
+                    FromHex::from_byte_iter(HexToBytesIter::new(s)?)?
+                };
+                Ok($newtype(<$hash>::from_byte_array(inner)))
+            }
+        }
+
+        impl $crate::_export::_core::convert::AsRef<[u8; <$hash as $crate::Hash>::LEN]> for $newtype {
+            fn as_ref(&self) -> &[u8; <$hash as $crate::Hash>::LEN] {
+                AsRef::<[u8; <$hash as $crate::Hash>::LEN]>::as_ref(&self.0)
+            }
+        }
+
+        impl<I: $crate::_export::_core::slice::SliceIndex<[u8]>> $crate::_export::_core::ops::Index<I> for $newtype {
+            type Output = I::Output;
+
+            #[inline]
+            fn index(&self, index: I) -> &Self::Output {
+                &self.0[index]
+            }
+        }
+        )+
+    };
+}
+
+// Generates the struct only (no impls)
+//
+// This is a separate macro to make it more readable and have a separate interface that allows for
+// two groups of type attributes: processed and not-yet-processed ones (think about it like
+// computation via recursion). The macro recursively matches unprocessed attributes, popping them
+// one at a time and either ignoring them (`hash_newtype`) or appending them to the list of
+// processed attributes to be added to the struct.
+//
+// Once the list of not-yet-processed attributes is empty the struct is generated with processed
+// attributes added.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! hash_newtype_struct {
+    ($(#[$other_attrs:meta])* $type_vis:vis struct $newtype:ident($(#[$field_attrs:meta])* $field_vis:vis $hash:path);) => {
+        $(#[$other_attrs])*
+        #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        $type_vis struct $newtype($(#[$field_attrs])* $field_vis $hash);
+    };
+    ($(#[$other_attrs:meta])* $type_vis:vis struct $newtype:ident($(#[$field_attrs:meta])* $field_vis:vis $hash:path); { hash_newtype($($ignore:tt)*) } $($type_attrs:tt)*) => {
+        $crate::hash_newtype_struct! {
+            $(#[$other_attrs])*
+            $type_vis struct $newtype($(#[$field_attrs])* $field_vis $hash);
+
+            $($type_attrs)*
+        }
+    };
+    ($(#[$other_attrs:meta])* $type_vis:vis struct $newtype:ident($(#[$field_attrs:meta])* $field_vis:vis $hash:path); { $other_attr:meta } $($type_attrs:tt)*) => {
+        $crate::hash_newtype_struct! {
+            $(#[$other_attrs])*
+            #[$other_attr]
+            $type_vis struct $newtype($(#[$field_attrs])* $field_vis $hash);
+
+            $($type_attrs)*
+        }
+    };
+}
+
+// Extracts `hash_newtype(forward)` and `hash_newtype(backward)` attributes if any and turns them
+// into bool, defaulting to `DISPLAY_BACKWARD` of the wrapped type if the attribute is omitted.
+//
+// Once an appropriate attribute is found we pass the remaining ones into another macro to detect
+// duplicates/conflicts and report an error.
+//
+// FYI, no, we can't use a helper macro to first filter all `hash_newtype` attributes. We would be
+// attempting to match on macros instead. So we must write `hashe_newtype` in each branch.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! hash_newtype_get_direction {
+    ($hash:ty, ) => { <$hash as $crate::Hash>::DISPLAY_BACKWARD };
+    ($hash:ty, #[hash_newtype(forward)] $($others:tt)*) => { { $crate::hash_newtype_forbid_direction!(forward, $($others)*); false } };
+    ($hash:ty, #[hash_newtype(backward)] $($others:tt)*) => { { $crate::hash_newtype_forbid_direction!(backward, $($others)*); true } };
+    ($hash:ty, #[$($ignore:tt)*]  $($others:tt)*) => { $crate::hash_newtype_get_direction!($hash, $($others)*) };
+}
+
+// Reports an error if any of the attributes is `hash_newtype($direction)`.
+//
+// This is used for detection of duplicates/conflicts, see the macro above.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! hash_newtype_forbid_direction {
+    ($direction:ident, ) => {};
+    ($direction:ident, #[hash_newtype(forward)] $(others:tt)*) => {
+        compile_error!(concat!("Cannot set display direction to forward: ", stringify!($direction), " was already specified"));
+    };
+    ($direction:ident, #[hash_newtype(backward)] $(others:tt)*) => {
+        compile_error!(concat!("Cannot set display direction to backward: ", stringify!($direction), " was already specified"));
+    };
+    ($direction:ident, #[$($ignore:tt)*] $(#[$others:tt])*) => {
+        $crate::hash_newtype_forbid_direction!($direction, $(#[$others])*)
+    };
+}
+
+// Checks (at compile time) that all `hash_newtype` attributes are known.
+//
+// An unknown attribute could be a typo that could cause problems - e.g. wrong display direction if
+// it's missing. To prevent this, we call this macro above. The macro produces nothing unless an
+// unknown attribute is found in which case it produces `compile_error!`.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! hash_newtype_known_attrs {
+    (#[hash_newtype(forward)]) => {};
+    (#[hash_newtype(backward)]) => {};
+    (#[hash_newtype($($unknown:tt)*)]) => { compile_error!(concat!("Unrecognized attribute ", stringify!($($unknown)*))); };
+    ($($ignore:tt)*) => {};
+}
+
+#[cfg(feature = "schemars")]
+pub mod json_hex_string {
+    use schemars::gen::SchemaGenerator;
+    use schemars::schema::{Schema, SchemaObject};
+    use schemars::JsonSchema;
+    macro_rules! define_custom_hex {
+        ($name:ident, $len:expr) => {
+            pub fn $name(gen: &mut SchemaGenerator) -> Schema {
+                let mut schema: SchemaObject = <String>::json_schema(gen).into();
+                schema.string = Some(Box::new(schemars::schema::StringValidation {
+                    max_length: Some($len * 2),
+                    min_length: Some($len * 2),
+                    pattern: Some("[0-9a-fA-F]+".to_owned()),
+                }));
+                schema.into()
+            }
+        };
+    }
+    define_custom_hex!(len_8, 8);
+    define_custom_hex!(len_20, 20);
+    define_custom_hex!(len_32, 32);
+    define_custom_hex!(len_64, 64);
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{sha256, Hash};
+
+    #[test]
+    fn hash_as_ref_array() {
+        let hash = sha256::Hash::hash(&[3, 50]);
+        let r = AsRef::<[u8; 32]>::as_ref(&hash);
+        assert_eq!(r, hash.as_byte_array());
+    }
+
+    #[test]
+    fn hash_as_ref_slice() {
+        let hash = sha256::Hash::hash(&[3, 50]);
+        let r = AsRef::<[u8]>::as_ref(&hash);
+        assert_eq!(r, hash.as_byte_array());
+    }
+
+    #[test]
+    fn hash_borrow() {
+        use core::borrow::Borrow;
+
+        let hash = sha256::Hash::hash(&[3, 50]);
+        let borrowed: &[u8] = hash.borrow();
+        assert_eq!(borrowed, hash.as_byte_array());
+    }
+
+    hash_newtype! {
+        /// Test hash.
+        struct TestHash(crate::sha256d::Hash);
+    }
+
+    #[test]
+    fn display() {
+        let want = "0000000000000000000000000000000000000000000000000000000000000000";
+        let got = format!("{}", TestHash::all_zeros());
+        assert_eq!(got, want)
+    }
+
+    #[test]
+    fn display_alternate() {
+        let want = "0x0000000000000000000000000000000000000000000000000000000000000000";
+        let got = format!("{:#}", TestHash::all_zeros());
+        assert_eq!(got, want)
+    }
+
+    #[test]
+    fn lower_hex() {
+        let want = "0000000000000000000000000000000000000000000000000000000000000000";
+        let got = format!("{:x}", TestHash::all_zeros());
+        assert_eq!(got, want)
+    }
+
+    #[test]
+    fn lower_hex_alternate() {
+        let want = "0x0000000000000000000000000000000000000000000000000000000000000000";
+        let got = format!("{:#x}", TestHash::all_zeros());
+        assert_eq!(got, want)
+    }
+
+    #[test]
+    fn inner_hash_as_ref_array() {
+        let hash = TestHash::all_zeros();
+        let r = AsRef::<[u8; 32]>::as_ref(&hash);
+        assert_eq!(r, hash.as_byte_array());
+    }
+
+    #[test]
+    fn inner_hash_as_ref_slice() {
+        let hash = TestHash::all_zeros();
+        let r = AsRef::<[u8]>::as_ref(&hash);
+        assert_eq!(r, hash.as_byte_array());
+    }
+}
diff --git a/internals/CHANGELOG.md b/internals/CHANGELOG.md
new file mode 100644
index 00000000..1003c776
--- /dev/null
+++ b/internals/CHANGELOG.md
@@ -0,0 +1,11 @@
+# 0.2.0 - 2023-06-20
+
+- [Rename crate](https://github.com/rust-bitcoin/rust-bitcoin/pull/1885) to `bitcoin-internals`
+- Add module to assist [alloc-free parse error handling](https://github.com/rust-bitcoin/rust-bitcoin/pull/1297)
+- Move various macros here.
+
+# 0.1.0 - 2023-03-08
+
+Split this crate out from the [rust-bitcoin](https://github.com/rust-bitcoin/rust-bitcoin) crate.
+For previous development history see the original
+[CHANGELOG](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/bitcoin/CHANGELOG.md) file.
diff --git a/internals/Cargo.toml b/internals/Cargo.toml
new file mode 100644
index 00000000..8de92516
--- /dev/null
+++ b/internals/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "tapyrus-internals"
+version = "0.2.0"
+authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>", "The Rust Bitcoin developers"]
+license = "MIT"
+homepage = "https://github.com/chaintope/rust-tapyrus/"
+repository = "https://github.com/chaintope/rust-tapyrus/"
+description = "Internal types and macros used by rust-tapyrus ecosystem"
+categories = ["cryptography::cryptocurrencies"]
+keywords = ["internal"]
+readme = "README.md"
+edition = "2018"
+exclude = ["tests", "contrib"]
+
+[features]
+default = []
+std = ["alloc"]
+alloc = []
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[dependencies]
+serde = { version = "1.0.103", default-features = false, optional = true }
+
+[dev-dependencies]
diff --git a/internals/README.md b/internals/README.md
new file mode 100644
index 00000000..79aa2980
--- /dev/null
+++ b/internals/README.md
@@ -0,0 +1,7 @@
+Rust Bitcoin Internals
+======================
+
+This crate is only meant to be used internally by crates in the
+[rust-bitcoin](https://github.com/rust-bitcoin) ecosystem.
+
+This crate will never be stabilized, depend on it at your own risk.
diff --git a/internals/build.rs b/internals/build.rs
new file mode 100644
index 00000000..ab1f0411
--- /dev/null
+++ b/internals/build.rs
@@ -0,0 +1,35 @@
+fn main() {
+    let rustc = std::env::var_os("RUSTC");
+    let rustc = rustc.as_ref().map(std::path::Path::new).unwrap_or_else(|| "rustc".as_ref());
+    let output = std::process::Command::new(rustc)
+        .arg("--version")
+        .output()
+        .unwrap_or_else(|error| panic!("Failed to run `{:?} --version`: {:?}", rustc, error));
+    assert!(output.status.success(), "{:?} -- version returned non-zero exit code", rustc);
+    let stdout = String::from_utf8(output.stdout).expect("rustc produced non-UTF-8 output");
+    let version_prefix = "rustc ";
+    if !stdout.starts_with(version_prefix) {
+        panic!("unexpected rustc output: {}", stdout);
+    }
+
+    let version = &stdout[version_prefix.len()..];
+    let end = version.find(&[' ', '-'] as &[_]).unwrap_or(version.len());
+    let version = &version[..end];
+    let mut version_components = version.split('.');
+    let major = version_components.next().unwrap();
+    assert_eq!(major, "1", "Unexpected Rust major version");
+    let minor = version_components
+        .next()
+        .unwrap_or("0")
+        .parse::<u64>()
+        .expect("invalid Rust minor version");
+
+    // print cfg for all interesting versions less than or equal to minor
+    // 46 adds `track_caller`
+    // 55 adds `kind()` to `ParseIntError`
+    for version in &[46, 55] {
+        if *version <= minor {
+            println!("cargo:rustc-cfg=rust_v_1_{}", version);
+        }
+    }
+}
diff --git a/internals/contrib/test.sh b/internals/contrib/test.sh
new file mode 100755
index 00000000..d4243b51
--- /dev/null
+++ b/internals/contrib/test.sh
@@ -0,0 +1,64 @@
+#!/bin/sh
+
+set -ex
+
+FEATURES="std alloc"
+
+cargo --version
+rustc --version
+
+# Work out if we are using a nightly toolchain.
+NIGHTLY=false
+if cargo --version | grep nightly >/dev/null; then
+    NIGHTLY=true
+fi
+
+# Make all cargo invocations verbose
+export CARGO_TERM_VERBOSE=true
+
+# Defaults / sanity checks
+cargo --locked build
+cargo --locked test
+
+if [ "$DO_LINT" = true ]
+then
+    cargo clippy --locked --all-features --all-targets -- -D warnings
+fi
+
+if [ "$DO_FEATURE_MATRIX" = true ]; then
+    # No features
+    cargo build --locked --no-default-features
+    cargo test --locked --no-default-features
+
+    # All features
+    cargo build --locked --no-default-features --features="$FEATURES"
+    cargo test --locked --no-default-features --features="$FEATURES"
+
+    # Single features
+    for feature in ${FEATURES}
+    do
+        cargo build --locked --no-default-features --features="$feature"
+        cargo test --locked --no-default-features --features="$feature"
+    done
+fi
+
+# Build the docs if told to (this only works with the nightly toolchain)
+if [ "$DO_DOCSRS" = true ]; then
+    RUSTDOCFLAGS="--cfg docsrs -D warnings -D rustdoc::broken-intra-doc-links" cargo +nightly doc --all-features
+fi
+
+# Build the docs with a stable toolchain, in unison with the DO_DOCSRS command
+# above this checks that we feature guarded docs imports correctly.
+if [ "$DO_DOCS" = true ]; then
+    RUSTDOCFLAGS="-D warnings" cargo +stable doc --locked --all-features
+fi
+
+# Run formatter if told to.
+if [ "$DO_FMT" = true ]; then
+    if [ "$NIGHTLY" = false ]; then
+        echo "DO_FMT requires a nightly toolchain (consider using RUSTUP_TOOLCHAIN)"
+        exit 1
+    fi
+    rustup component add rustfmt
+    cargo fmt --check
+fi
diff --git a/internals/src/error.rs b/internals/src/error.rs
new file mode 100644
index 00000000..6731ae13
--- /dev/null
+++ b/internals/src/error.rs
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! # Error
+//!
+//! Error handling macros and helpers.
+//!
+
+pub mod input_string;
+mod parse_error;
+
+pub use input_string::InputString;
+
+/// Formats error.
+///
+/// If `std` feature is OFF appends error source (delimited by `: `). We do this because
+/// `e.source()` is only available in std builds, without this macro the error source is lost for
+/// no-std builds.
+#[macro_export]
+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)
+            }
+        }
+    }
+}
diff --git a/internals/src/error/input_string.rs b/internals/src/error/input_string.rs
new file mode 100644
index 00000000..b69751c0
--- /dev/null
+++ b/internals/src/error/input_string.rs
@@ -0,0 +1,126 @@
+//! Implements the [`InputString`] type storing the parsed input.
+
+use core::fmt;
+
+use storage::Storage;
+
+/// Conditionally stores the input string in parse errors.
+///
+/// This type stores the input string of a parse function depending on whether `alloc` feature is
+/// enabled. When it is enabled, the string is stored inside as `String`. When disabled this is a
+/// zero-sized type and attempt to store a string does nothing.
+///
+/// This provides two methods to format the error strings depending on the context.
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub struct InputString(Storage);
+
+impl InputString {
+    /// Displays a message saying `failed to parse <self> as <what>`.
+    ///
+    /// This is normally used whith the `write_err!` macro.
+    pub fn display_cannot_parse<'a, T>(&'a self, what: &'a T) -> CannotParse<'a, T>
+    where
+        T: fmt::Display + ?Sized,
+    {
+        CannotParse { input: self, what }
+    }
+
+    /// Formats a message saying `<self> is not a known <what>`.
+    ///
+    /// This is normally used in leaf parse errors (with no source) when parsing an enum.
+    pub fn unknown_variant<T>(&self, what: &T, f: &mut fmt::Formatter) -> fmt::Result
+    where
+        T: fmt::Display + ?Sized,
+    {
+        storage::unknown_variant(&self.0, what, f)
+    }
+}
+
+macro_rules! impl_from {
+    ($($type:ty),+ $(,)?) => {
+        $(
+            impl From<$type> for InputString {
+                fn from(input: $type) -> Self {
+                    #[allow(clippy::useless_conversion)]
+                    InputString(input.into())
+                }
+            }
+        )+
+    }
+}
+
+impl_from!(&str);
+
+/// Displays message saying `failed to parse <input> as <what>`.
+///
+/// This is created by `display_cannot_parse` method and should be used as
+/// `write_err!("{}", self.input.display_cannot_parse("what is parsed"); self.source)` in parse
+/// error [`Display`](fmt::Display) imlementation if the error has source. If the error doesn't
+/// have a source just use regular `write!` with same formatting arguments.
+pub struct CannotParse<'a, T: fmt::Display + ?Sized> {
+    input: &'a InputString,
+    what: &'a T,
+}
+
+impl<'a, T: fmt::Display + ?Sized> fmt::Display for CannotParse<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        storage::cannot_parse(&self.input.0, &self.what, f)
+    }
+}
+
+#[cfg(not(feature = "alloc"))]
+mod storage {
+    use core::fmt;
+
+    #[derive(Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
+    pub(super) struct Storage;
+
+    impl fmt::Debug for Storage {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            f.write_str("<unknown input string - compiled without the `alloc` feature>")
+        }
+    }
+
+    impl From<&str> for Storage {
+        fn from(_value: &str) -> Self { Storage }
+    }
+
+    pub(super) fn cannot_parse<W>(_: &Storage, what: &W, f: &mut fmt::Formatter) -> fmt::Result
+    where
+        W: fmt::Display + ?Sized,
+    {
+        write!(f, "failed to parse {}", what)
+    }
+
+    pub(super) fn unknown_variant<W>(_: &Storage, what: &W, f: &mut fmt::Formatter) -> fmt::Result
+    where
+        W: fmt::Display + ?Sized,
+    {
+        write!(f, "unknown {}", what)
+    }
+}
+
+#[cfg(feature = "alloc")]
+mod storage {
+    use core::fmt;
+
+    use super::InputString;
+
+    pub(super) type Storage = alloc::string::String;
+
+    pub(super) fn cannot_parse<W>(input: &Storage, what: &W, f: &mut fmt::Formatter) -> fmt::Result
+    where
+        W: fmt::Display + ?Sized,
+    {
+        write!(f, "failed to parse '{}' as {}", input, what)
+    }
+
+    pub(super) fn unknown_variant<W>(inp: &Storage, what: &W, f: &mut fmt::Formatter) -> fmt::Result
+    where
+        W: fmt::Display + ?Sized,
+    {
+        write!(f, "'{}' is not a known {}", inp, what)
+    }
+
+    impl_from!(alloc::string::String, alloc::boxed::Box<str>, alloc::borrow::Cow<'_, str>);
+}
diff --git a/internals/src/error/parse_error.rs b/internals/src/error/parse_error.rs
new file mode 100644
index 00000000..ee501e03
--- /dev/null
+++ b/internals/src/error/parse_error.rs
@@ -0,0 +1,48 @@
+//! Contains helpers for parsing-related errors.
+
+/// Creates an error type intended for string parsing errors.
+///
+/// The resulting error type has two fields: `input` and `source`. The type of `input` is
+/// [`InputString`](super::InputString), the type of `source` is specified as the second argument
+/// to the macro.
+///
+/// The resulting type is public, conditionally implements [`std::error::Error`] and has a private
+/// `new()` method for convenience.
+///
+/// ## Parameters
+///
+/// * `name` - the name of the error type
+/// * `source` - the type of the source type
+/// * `subject` - English description of the type being parsed (e.g. "a tapyrus amount")
+/// * `derive` - list of derives to add
+#[macro_export]
+macro_rules! parse_error_type {
+    ($vis:vis $name:ident, $source:ty, $subject:expr $(, $derive:path)* $(,)?) => {
+        #[derive(Debug $(, $derive)*)]
+        $vis struct $name {
+            input: $crate::error::InputString,
+            source: $source,
+        }
+
+        impl $name {
+            /// Creates `Self`.
+            fn new<T: Into<$crate::error::InputString>>(input: T, source: $source) -> Self {
+                $name {
+                    input: input.into(),
+                    source,
+                }
+            }
+        }
+
+        impl core::fmt::Display for $name {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                $crate::error::write_err!("{}", self.input.display_cannot_parse($subject); self.source)
+            }
+        }
+
+        #[cfg(feature = "std")]
+        impl std::error::Error for $name {
+            fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.source) }
+        }
+    }
+}
diff --git a/internals/src/lib.rs b/internals/src/lib.rs
new file mode 100644
index 00000000..75192dbe
--- /dev/null
+++ b/internals/src/lib.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! # Rust Bitcoin Internal
+//!
+//! This crate is only meant to be used internally by crates in the
+//! [rust-tapyrus](https://github.com/rust-bitcoin) ecosystem.
+//!
+
+#![no_std]
+// Experimental features we need.
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+// Coding conventions
+#![warn(missing_docs)]
+// Exclude clippy lints we don't think are valuable
+#![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
+
+pub mod error;
+pub mod macros;
+mod parse;
+pub mod serde;
diff --git a/internals/src/macros.rs b/internals/src/macros.rs
new file mode 100644
index 00000000..799730f0
--- /dev/null
+++ b/internals/src/macros.rs
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Various macros used by the Rust Bitcoin ecosystem.
+//!
+
+/// Implements standard array methods for a given wrapper type.
+#[macro_export]
+macro_rules! impl_array_newtype {
+    ($thing:ident, $ty:ty, $len:literal) => {
+        impl $thing {
+            /// Converts the object to a raw pointer.
+            #[inline]
+            pub fn as_ptr(&self) -> *const $ty {
+                let &$thing(ref dat) = self;
+                dat.as_ptr()
+            }
+
+            /// Converts the object to a mutable raw pointer.
+            #[inline]
+            pub fn as_mut_ptr(&mut self) -> *mut $ty {
+                let &mut $thing(ref mut dat) = self;
+                dat.as_mut_ptr()
+            }
+
+            /// Returns the length of the object as an array.
+            #[inline]
+            pub fn len(&self) -> usize { $len }
+
+            /// Returns whether the object, as an array, is empty. Always false.
+            #[inline]
+            pub fn is_empty(&self) -> bool { false }
+        }
+
+        impl<'a> core::convert::From<[$ty; $len]> for $thing {
+            fn from(data: [$ty; $len]) -> Self { $thing(data) }
+        }
+
+        impl<'a> core::convert::From<&'a [$ty; $len]> for $thing {
+            fn from(data: &'a [$ty; $len]) -> Self { $thing(*data) }
+        }
+
+        impl<'a> core::convert::TryFrom<&'a [$ty]> for $thing {
+            type Error = core::array::TryFromSliceError;
+
+            fn try_from(data: &'a [$ty]) -> Result<Self, Self::Error> {
+                use core::convert::TryInto;
+
+                Ok($thing(data.try_into()?))
+            }
+        }
+
+        impl AsRef<[$ty; $len]> for $thing {
+            fn as_ref(&self) -> &[$ty; $len] { &self.0 }
+        }
+
+        impl AsMut<[$ty; $len]> for $thing {
+            fn as_mut(&mut self) -> &mut [$ty; $len] { &mut self.0 }
+        }
+
+        impl AsRef<[$ty]> for $thing {
+            fn as_ref(&self) -> &[$ty] { &self.0 }
+        }
+
+        impl AsMut<[$ty]> for $thing {
+            fn as_mut(&mut self) -> &mut [$ty] { &mut self.0 }
+        }
+
+        impl core::borrow::Borrow<[$ty; $len]> for $thing {
+            fn borrow(&self) -> &[$ty; $len] { &self.0 }
+        }
+
+        impl core::borrow::BorrowMut<[$ty; $len]> for $thing {
+            fn borrow_mut(&mut self) -> &mut [$ty; $len] { &mut self.0 }
+        }
+
+        // The following two are valid because `[T; N]: Borrow<[T]>`
+        impl core::borrow::Borrow<[$ty]> for $thing {
+            fn borrow(&self) -> &[$ty] { &self.0 }
+        }
+
+        impl core::borrow::BorrowMut<[$ty]> for $thing {
+            fn borrow_mut(&mut self) -> &mut [$ty] { &mut self.0 }
+        }
+
+        impl<I> core::ops::Index<I> for $thing
+        where
+            [$ty]: core::ops::Index<I>,
+        {
+            type Output = <[$ty] as core::ops::Index<I>>::Output;
+
+            #[inline]
+            fn index(&self, index: I) -> &Self::Output { &self.0[index] }
+        }
+    };
+}
+
+/// Implements `Debug` by calling through to `Display`.
+#[macro_export]
+macro_rules! debug_from_display {
+    ($thing:ident) => {
+        impl core::fmt::Debug for $thing {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
+                core::fmt::Display::fmt(self, f)
+            }
+        }
+    };
+}
+
+/// Asserts a boolean expression at compile time.
+#[macro_export]
+macro_rules! const_assert {
+    ($x:expr) => {{
+        const _: [(); 0 - !$x as usize] = [];
+    }};
+}
diff --git a/internals/src/parse.rs b/internals/src/parse.rs
new file mode 100644
index 00000000..1aed7605
--- /dev/null
+++ b/internals/src/parse.rs
@@ -0,0 +1,107 @@
+/// Support for parsing strings.
+
+// Impls a single TryFrom conversion
+#[doc(hidden)]
+#[macro_export]
+macro_rules! impl_try_from_stringly {
+    ($from:ty, $to:ty, $error:ty, $func:expr) => {
+        $(#[$attr])?
+        impl core::convert::TryFrom<$from> for $to {
+            type Error = $error;
+
+            fn try_from(s: $from) -> Result<Self, Self::Error> {
+                $func(AsRef::<str>::as_ref(s)).map_err(|source| <$error>::new(s, source))
+            }
+        }
+
+    }
+}
+
+/// Implements conversions from various string types.
+///
+/// This macro implements `FromStr` as well as `TryFrom<{stringly}` where `{stringly}` is one of
+/// these types:
+///
+/// * `&str`
+/// * `String`
+/// * `Box<str>`
+/// * `Cow<'_, str>`
+///
+/// The last three are only available with `alloc` feature turned on.
+#[macro_export]
+macro_rules! impl_parse {
+    ($type:ty, $descr:expr, $func:expr, $vis:vis $error:ident, $error_source:ty $(, $error_derive:path)*) => {
+        $crate::parse_error_type!($vis $error, $error_source, $descr $(, $error_derive)*);
+
+        impl core::str::FromStr for $type {
+            type Err = $error;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                $func(s).map_err(|source| <$error>::new(s, source))
+            }
+        }
+
+        impl_try_from_stringly!(&str);
+
+        #[cfg(feature = "alloc")]
+        impl_try_from_stringly!(alloc::string::String, $type, $error, $func);
+        #[cfg(feature = "alloc")]
+        impl_try_from_stringly!(alloc::borrow::Cow<'_, str>, $type, $error, $func);
+        #[cfg(feature = "alloc")]
+        impl_try_from_stringly!(alloc::boxed::Box<str>, $type, $error, $func);
+    }
+}
+
+/// Implements conversions from various string types as well as `serde` (de)serialization.
+///
+/// This calls `impl_parse` macro and implements serde deserialization by expecting and parsing a
+/// string and serialization by outputting a string.
+#[macro_export]
+macro_rules! impl_parse_and_serde {
+    ($type:ty, $descr:expr, $func:expr, $error:ident, $error_source:ty $(, $error_derive:path)*) => {
+        impl_parse!($type, $descr, $func, $error, $error_source $(, $error_derive)*);
+
+        // We don't use `serde_string_impl` because we want to avoid allocating input.
+        #[cfg(feature = "serde")]
+        impl<'de> $crate::serde::Deserialize<'de> for $type {
+            fn deserialize<D>(deserializer: D) -> Result<$name, D::Error>
+            where
+                D: $crate::serde::de::Deserializer<'de>,
+            {
+                use core::fmt::{self, Formatter};
+                use core::str::FromStr;
+
+                struct Visitor;
+                impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
+                    type Value = $name;
+
+                    fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                        f.write_str($descr)
+                    }
+
+                    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+                    where
+                        E: $crate::serde::de::Error,
+                    {
+                        s.parse().map_err(|error| {
+                            $crate::serde::IntoDeError::try_into_de_error(error)
+                                .unwrap_or_else(|_| E::invalid_value(Unexpected::Str(s), &self))
+                        })
+                    }
+                }
+
+                deserializer.deserialize_str(Visitor)
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl $crate::serde::Serialize for $name {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: $crate::serde::Serializer,
+            {
+                serializer.collect_str(&self)
+            }
+        }
+    }
+}
diff --git a/internals/src/serde.rs b/internals/src/serde.rs
new file mode 100644
index 00000000..de79756a
--- /dev/null
+++ b/internals/src/serde.rs
@@ -0,0 +1,64 @@
+//! Contains extensions of `serde` and internal reexports.
+
+#[cfg(feature = "serde")]
+#[doc(hidden)]
+pub use serde::{de, ser, Deserialize, Deserializer, Serialize, Serializer};
+
+/// Converts given error type to a type implementing [`de::Error`].
+///
+/// This is used in [`Deserialize`] implementations to convert specialized errors into serde
+/// errors.
+#[cfg(feature = "serde")]
+pub trait IntoDeError: Sized {
+    /// Converts to deserializer error possibly outputting vague message.
+    ///
+    /// This method is allowed to return a vague error message if the error type doesn't contain
+    /// enough information to explain the error precisely.
+    fn into_de_error<E: de::Error>(self, expected: Option<&dyn de::Expected>) -> E;
+
+    /// Converts to deserializer error without outputting vague message.
+    ///
+    /// If the error type doesn't contain enough information to explain the error precisely this
+    /// should return `Err(self)` allowing the caller to use its information instead.
+    fn try_into_de_error<E>(self, expected: Option<&dyn de::Expected>) -> Result<E, Self>
+    where
+        E: de::Error,
+    {
+        Ok(self.into_de_error(expected))
+    }
+}
+
+#[cfg(feature = "serde")]
+mod impls {
+    use super::*;
+
+    impl IntoDeError for core::convert::Infallible {
+        fn into_de_error<E: de::Error>(self, _expected: Option<&dyn de::Expected>) -> E {
+            match self {}
+        }
+    }
+
+    impl IntoDeError for core::num::ParseIntError {
+        fn into_de_error<E: de::Error>(self, expected: Option<&dyn de::Expected>) -> E {
+            self.try_into_de_error(expected).unwrap_or_else(|_| {
+                let expected = expected.unwrap_or(&"an integer");
+
+                E::custom(format_args!("invalid string, expected {}", expected))
+            })
+        }
+
+        fn try_into_de_error<E>(self, expected: Option<&dyn de::Expected>) -> Result<E, Self>
+        where
+            E: de::Error,
+        {
+            use core::num::IntErrorKind::Empty;
+
+            let expected = expected.unwrap_or(&"an integer");
+
+            match self.kind() {
+                Empty => Ok(E::invalid_value(de::Unexpected::Str(""), expected)),
+                _ => Err(self),
+            }
+        }
+    }
+}
diff --git a/justfile b/justfile
new file mode 100644
index 00000000..b52728ca
--- /dev/null
+++ b/justfile
@@ -0,0 +1,22 @@
+default:
+  @just --list
+
+# Cargo build everything.
+build:
+  cargo build --workspace --all-targets --all-features
+
+# Cargo check everything.
+check:
+  cargo check --workspace --all-targets --all-features
+
+# Lint everything.
+lint:
+  cargo clippy --workspace --all-targets --all-features -- --deny warnings
+
+# Check the formatting
+format:
+  cargo +nightly fmt --all --check
+
+# Update the recent and minimal lock files.
+update-lock-files:
+  contrib/update-lock-files.sh
diff --git a/logo/README.md b/logo/README.md
new file mode 100644
index 00000000..71a563db
--- /dev/null
+++ b/logo/README.md
@@ -0,0 +1,32 @@
+# Rust Bitcoin Logo
+
+## Files
+
+Included are:
+
+- [rust-bitcoin-inkscape.svg](./rust-bitcoin-inkscape.svg) - The Inkscape source file with the things used to make the logo in case adjustments are desired
+- [rust-bitcoin-optimized.svg](./rust-bitcoin-optimized.svg) - An optimized SVG for embedding or rendering at any size desired
+- [rust-bitcoin.png](./rust-bitcoin.png) - The PNG logo rendered at 300px used by this project
+- [rust-bitcoin-large.png](./rust-bitcoin-large.png) - A larger size 1024px x 1024px for convenience for embedding in presentations
+
+## Author
+
+Hunter Trujillo, @cryptoquick on [Twitter](https://twitter.com/cryptoquick), [GitHub](https://github.com/cryptoquick), and Telegram.
+
+## License
+
+Licensed in the public domain under [CC0 1.0 Universal Public Domain Dedication](https://creativecommons.org/publicdomain/zero/1.0/), and the author of this work rescinds all claims to copyright or coercion or acts of force from any nation state over this work for any purpose
+
+Bitcoin Logo is licensed under the CC Public Domain Dedication: <https://bitcoin.stackexchange.com/a/53422> and <https://bitcointalk.org/index.php?topic=1631.0>
+
+Rust Logo is licensed under CC-BY, which allows reuse and modifications for any purpose, as long as distributors give appropriate credit and indicate changes have been made. See here: <https://www.rust-lang.org/policies/media-guide>
+
+## Acknowledgements
+
+Acknowledgement for the runners up in this PR: https://github.com/rust-bitcoin/rust-bitcoin/pull/891#issuecomment-1074476858
+
+In particular, the Rust Bitcoin Wizard gear was an incredibly inspired piece of art. Also, the meshed gears design was beloved by some but not all.
+
+Thank you to the Rust Bitcoin maintainers and community, your timely responses and guidance was appreciated.
+
+Also, thank you to the voters on the Rust in Bitcoin Telegram group: <https://t.me/rust_in_bitcoin/321>.
diff --git a/logo/rust-bitcoin-inkscape.svg b/logo/rust-bitcoin-inkscape.svg
new file mode 100644
index 00000000..9b504a34
--- /dev/null
+++ b/logo/rust-bitcoin-inkscape.svg
@@ -0,0 +1,244 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="176.39641mm"
+   height="176.39641mm"
+   viewBox="0 0 176.39641 176.39641"
+   version="1.1"
+   id="svg5"
+   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04, custom)"
+   sodipodi:docname="rust-bitcoin-5.svg"
+   inkscape:export-filename="/home/hunter/rust-bitcoin-4.png"
+   inkscape:export-xdpi="43.198158"
+   inkscape:export-ydpi="43.198158"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview7"
+     pagecolor="#505050"
+     bordercolor="#ffffff"
+     borderopacity="1"
+     inkscape:pageshadow="0"
+     inkscape:pageopacity="0"
+     inkscape:pagecheckerboard="1"
+     inkscape:document-units="mm"
+     showgrid="false"
+     inkscape:zoom="1.5554293"
+     inkscape:cx="-412.10488"
+     inkscape:cy="109.61604"
+     inkscape:window-width="3840"
+     inkscape:window-height="2128"
+     inkscape:window-x="0"
+     inkscape:window-y="32"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="layer1"
+     fit-margin-top="0"
+     fit-margin-left="0"
+     fit-margin-right="0"
+     fit-margin-bottom="0" />
+  <defs
+     id="defs2">
+    <inkscape:path-effect
+       effect="powerclip"
+       id="path-effect9474"
+       is_visible="true"
+       lpeversion="1"
+       inverse="true"
+       flatten="false"
+       hide_clip="false"
+       message="Use fill-rule evenodd on &lt;b&gt;fill and stroke&lt;/b&gt; dialog if no flatten result after convert clip to paths." />
+    <inkscape:path-effect
+       effect="powerclip"
+       id="path-effect9474-5"
+       is_visible="true"
+       lpeversion="1"
+       inverse="true"
+       flatten="false"
+       hide_clip="false"
+       message="Use fill-rule evenodd on &lt;b&gt;fill and stroke&lt;/b&gt; dialog if no flatten result after convert clip to paths." />
+    <clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipPath9470">
+      <path
+         fill="#ffffff"
+         d="m 75.868035,44.926438 c 0.910871,-6.088692 -3.725,-9.361829 -10.06393,-11.545348 l 2.056255,-8.247905 -5.020525,-1.251199 -2.001919,8.030553 C 59.518082,31.583651 58.162497,31.273356 56.81549,30.965918 l 2.01622,-8.083461 -5.017667,-1.251199 -2.057688,8.245045 c -1.092475,-0.248812 -2.164932,-0.49476 -3.205927,-0.753581 l 0.0057,-0.02574 -6.923778,-1.728801 -1.335566,5.362282 c 0,0 3.724997,0.853675 3.646352,0.906584 2.033376,0.507629 2.400872,1.853205 2.339385,2.919939 l -2.342245,9.396148 c 0.140134,0.03575 0.321736,0.08723 0.521931,0.167304 -0.167304,-0.04147 -0.346049,-0.08723 -0.530511,-0.131556 L 40.64855,59.151495 c -0.248809,0.617736 -0.879414,1.544338 -2.300777,1.192572 0.05005,0.07293 -3.64921,-0.910873 -3.64921,-0.910873 l -2.492388,5.746935 6.533404,1.628704 c 1.215451,0.304578 2.406591,0.623456 3.579143,0.923742 l -2.077704,8.342281 5.014804,1.251199 2.057685,-8.253624 c 1.369886,0.371784 2.699732,0.71497 4.000979,1.038137 l -2.050536,8.215016 5.020527,1.251199 2.077704,-8.326551 c 8.561062,1.620126 14.998657,0.966642 17.708398,-6.776493 2.183522,-6.234546 -0.108675,-9.83085 -4.612992,-12.175953 3.280286,-0.756441 5.751224,-2.914224 6.410428,-7.371349 z M 64.397041,61.011853 c -1.551485,6.234544 -12.048689,2.864173 -15.45195,2.019078 l 2.756926,-11.052019 c 3.403264,0.849384 14.316578,2.530996 12.695024,9.032941 z m 1.552919,-16.1755 C 64.534317,50.5075 55.797373,47.626167 52.963228,46.919777 l 2.499537,-10.02389 c 2.834146,0.706389 11.961464,2.024795 10.487195,7.940466 z"
+         id="path9472"
+         style="display:none;stroke-width:1.42994" />
+      <path
+         id="lpe_path-effect9474"
+         style="stroke-width:1.42994"
+         class="powerclip"
+         d="M 2.124689,-1.3643165 H 106.06395 V 102.57236 H 2.124689 Z M 75.868035,44.926438 c 0.910871,-6.088692 -3.725,-9.361829 -10.06393,-11.545348 l 2.056255,-8.247905 -5.020525,-1.251199 -2.001919,8.030553 C 59.518082,31.583651 58.162497,31.273356 56.81549,30.965918 l 2.01622,-8.083461 -5.017667,-1.251199 -2.057688,8.245045 c -1.092475,-0.248812 -2.164932,-0.49476 -3.205927,-0.753581 l 0.0057,-0.02574 -6.923778,-1.728801 -1.335566,5.362282 c 0,0 3.724997,0.853675 3.646352,0.906584 2.033376,0.507629 2.400872,1.853205 2.339385,2.919939 l -2.342245,9.396148 c 0.140134,0.03575 0.321736,0.08723 0.521931,0.167304 -0.167304,-0.04147 -0.346049,-0.08723 -0.530511,-0.131556 L 40.64855,59.151495 c -0.248809,0.617736 -0.879414,1.544338 -2.300777,1.192572 0.05005,0.07293 -3.64921,-0.910873 -3.64921,-0.910873 l -2.492388,5.746935 6.533404,1.628704 c 1.215451,0.304578 2.406591,0.623456 3.579143,0.923742 l -2.077704,8.342281 5.014804,1.251199 2.057685,-8.253624 c 1.369886,0.371784 2.699732,0.71497 4.000979,1.038137 l -2.050536,8.215016 5.020527,1.251199 2.077704,-8.326551 c 8.561062,1.620126 14.998657,0.966642 17.708398,-6.776493 2.183522,-6.234546 -0.108675,-9.83085 -4.612992,-12.175953 3.280286,-0.756441 5.751224,-2.914224 6.410428,-7.371349 z M 64.397041,61.011853 c 1.621554,-6.501945 -9.29176,-8.183557 -12.695024,-9.032941 l -2.756926,11.052019 c 3.403261,0.845095 13.900465,4.215466 15.45195,-2.019078 z m 1.552919,-16.1755 c 1.474269,-5.915671 -7.653049,-7.234077 -10.487195,-7.940466 l -2.499537,10.02389 c 2.834145,0.70639 11.571089,3.587723 12.986732,-2.083424 z" />
+    </clipPath>
+    <clipPath
+       clipPathUnits="userSpaceOnUse"
+       id="clipath_lpe_path-effect9474-5">
+      <path
+         fill="#ffffff"
+         d="m 75.868035,44.926438 c 0.910871,-6.088692 -3.725,-9.361829 -10.06393,-11.545348 l 2.056255,-8.247905 -5.020525,-1.251199 -2.001919,8.030553 C 59.518082,31.583651 58.162497,31.273356 56.81549,30.965918 l 2.01622,-8.083461 -5.017667,-1.251199 -2.057688,8.245045 c -1.092475,-0.248812 -2.164932,-0.49476 -3.205927,-0.753581 l 0.0057,-0.02574 -6.923778,-1.728801 -1.335566,5.362282 c 0,0 3.724997,0.853675 3.646352,0.906584 2.033376,0.507629 2.400872,1.853205 2.339385,2.919939 l -2.342245,9.396148 c 0.140134,0.03575 0.321736,0.08723 0.521931,0.167304 -0.167304,-0.04147 -0.346049,-0.08723 -0.530511,-0.131556 L 40.64855,59.151495 c -0.248809,0.617736 -0.879414,1.544338 -2.300777,1.192572 0.05005,0.07293 -3.64921,-0.910873 -3.64921,-0.910873 l -2.492388,5.746935 6.533404,1.628704 c 1.215451,0.304578 2.406591,0.623456 3.579143,0.923742 l -2.077704,8.342281 5.014804,1.251199 2.057685,-8.253624 c 1.369886,0.371784 2.699732,0.71497 4.000979,1.038137 l -2.050536,8.215016 5.020527,1.251199 2.077704,-8.326551 c 8.561062,1.620126 14.998657,0.966642 17.708398,-6.776493 2.183522,-6.234546 -0.108675,-9.83085 -4.612992,-12.175953 3.280286,-0.756441 5.751224,-2.914224 6.410428,-7.371349 z M 64.397041,61.011853 c -1.551485,6.234544 -12.048689,2.864173 -15.45195,2.019078 l 2.756926,-11.052019 c 3.403264,0.849384 14.316578,2.530996 12.695024,9.032941 z m 1.552919,-16.1755 C 64.534317,50.5075 55.797373,47.626167 52.963228,46.919777 l 2.499537,-10.02389 c 2.834146,0.706389 11.961464,2.024795 10.487195,7.940466 z"
+         id="path112"
+         style="display:block;stroke-width:1.42994" />
+    </clipPath>
+  </defs>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(73.402031,228.93883)">
+    <rect
+       style="fill:#ffffff;stroke-width:0.264583"
+       id="rect221"
+       width="176.39641"
+       height="176.39641"
+       x="168.18069"
+       y="-348.05383" />
+    <path
+       id="path75-2-1"
+       clip-path="none"
+       style="fill:#f7931a;fill-opacity:1;stroke-width:0.913143"
+       d="m -215.99589,1.4687934 c -0.45197,0 -0.90419,0.218357 -1.17408,0.654223 l -2.48409,4.013192 c -0.39083,0.03197 -0.78135,0.07129 -1.16944,0.114205 l -3.21685,-3.451469 c -0.69914,-0.752383 -1.94674,-0.503621 -2.30374,0.459403 l -1.64745,4.409033 c -0.38169,0.109574 -0.76026,0.225457 -1.13739,0.344165 l -3.82044,-2.749185 c -0.833,-0.596823 -2.0035,-0.112829 -2.17093,0.898136 l -0.75758,4.6488106 c -0.35065,0.181714 -0.69726,0.368805 -1.04334,0.559656 l -4.28656,-1.9538856 c -0.43506,-0.199122 -0.94218,-0.158117 -1.33946,0.108521 -0.39812,0.264813 -0.63114,0.7187336 -0.61288,1.1963086 l 0.16433,4.717025 c -0.30499,0.243815 -0.60729,0.493144 -0.90588,0.745174 l -4.59404,-1.082621 c -0.46592,-0.109049 -0.95518,0.03001 -1.29398,0.367936 -0.33901,0.338153 -0.47826,0.828032 -0.36793,1.293978 l 1.0821,4.594551 c -0.25172,0.29806 -0.49932,0.599233 -0.74311,0.903821 l -4.71702,-0.163814 c -1.02634,-0.03748 -1.73288,1.019566 -1.30535,1.953369 l 1.95389,4.287077 c -0.19148,0.345262 -0.37747,0.692829 -0.55914,1.043347 l -4.64778,0.756544 c -1.01251,0.165473 -1.49795,1.337696 -0.89865,2.170409 l 2.74918,3.818371 c -0.11962,0.377132 -0.2351,0.756227 -0.34468,1.137915 l -4.40955,1.648478 c -0.96328,0.357611 -1.21089,1.605206 -0.45733,2.303735 l 3.4494,3.216341 c -0.043,0.388083 -0.0813,0.778489 -0.11421,1.168406 l -4.01215,2.484085 c -0.87394,0.53857 -0.87394,1.80857 0,2.347143 l 4.01215,2.484088 c 0.0328,0.390824 0.0713,0.780833 0.11421,1.168921 l -3.4494,3.216859 c -0.75013,0.69931 -0.50313,1.94371 0.45733,2.30322 l 4.40955,1.64796 c 0.10958,0.38169 0.22506,0.76078 0.34468,1.13791 l -2.74918,3.81992 c -0.60085,0.8326 -0.11453,2.006121 0.89917,2.169381 l 4.64726,0.75603 c 0.18171,0.35247 0.36737,0.69933 0.55914,1.04541 l -1.95389,4.28553 c -0.19892,0.4354 -0.15793,0.94281 0.10852,1.34049 0.26664,0.39904 0.72108,0.63205 1.19683,0.61288 l 4.71496,-0.16537 c 0.24563,0.30682 0.49315,0.60729 0.74517,0.90589 l -1.0821,4.59558 c -0.10958,0.46571 0.0283,0.95263 0.36793,1.2914 0.33695,0.3406 0.82737,0.47649 1.29398,0.3669 l 4.59404,-1.0821 c 0.29859,0.25385 0.60089,0.50072 0.90588,0.74362 l -0.16433,4.71806 c -0.0375,1.02589 1.01907,1.73195 1.95234,1.30431 l 4.28656,-1.95337 c 0.34517,0.19177 0.69179,0.37795 1.04334,0.55966 l 0.75758,4.64571 c 0.16632,1.01173 1.33732,1.49768 2.17093,0.90072 l 3.81889,-2.75125 c 0.37762,0.12059 0.75708,0.23559 1.13791,0.34571 l 1.64796,4.40749 c 0.16711,0.44744 0.55396,0.7784 1.02423,0.86971 0.46894,0.0946 0.95392,-0.0614 1.27899,-0.41238 l 3.21634,-3.4494 c 0.38809,0.0448 0.77913,0.0821 1.16996,0.11679 l 2.48408,4.01267 c 0.54041,0.87065 1.80674,0.87065 2.34715,0 l 2.48408,-4.01267 c 0.39011,-0.0339 0.77984,-0.0727 1.16892,-0.11679 l 3.21583,3.4494 c 0.32599,0.35065 0.81055,0.50734 1.27899,0.41238 0.46952,-0.0924 0.85712,-0.42132 1.02423,-0.86971 l 1.64796,-4.40749 c 0.38083,-0.11012 0.76026,-0.22512 1.13791,-0.34571 l 3.81992,2.75125 c 0.8332,0.59843 2.00524,0.1118 2.1699,-0.90072 l 0.75758,-4.64571 c 0.35064,-0.18171 0.69726,-0.37063 1.04334,-0.55966 l 4.28656,1.95337 c 0.93327,0.42764 1.9899,-0.27842 1.95234,-1.30431 l -0.16433,-4.71806 c 0.30498,-0.24381 0.60716,-0.48977 0.90485,-0.74362 l 4.59403,1.0821 c 0.46553,0.11133 0.95536,-0.0276 1.29295,-0.3669 0.33968,-0.33877 0.47751,-0.82569 0.36794,-1.2914 l -1.08211,-4.59558 c 0.25203,-0.2986 0.50073,-0.59907 0.74363,-0.90589 l 4.71702,0.16537 c 0.47823,0.0179 0.93145,-0.2143 1.19631,-0.61288 0.26664,-0.39813 0.30747,-0.90492 0.10749,-1.34049 l -1.95286,-4.28553 c 0.19086,-0.34608 0.37783,-0.69294 0.55863,-1.04541 l 4.64777,-0.75603 c 1.01332,-0.16383 1.49943,-1.337081 0.89866,-2.169381 l -2.74919,-3.81992 c 0.11871,-0.37713 0.2342,-0.75622 0.34468,-1.13791 l 4.40852,-1.64796 c 0.44836,-0.16802 0.77839,-0.55448 0.86971,-1.02475 0.0946,-0.46894 -0.0614,-0.95339 -0.41238,-1.27847 l -3.44836,-3.216859 c 0.042,-0.388088 0.0804,-0.779012 0.1142,-1.168921 l 4.01216,-2.484088 c 0.8741,-0.538321 0.87485,-1.808321 0.001,-2.347143 l -4.01216,-2.484085 c -0.0339,-0.390007 -0.072,-0.779217 -0.1142,-1.168406 l 3.44836,-3.216341 c 0.35066,-0.326908 0.50735,-0.811061 0.41238,-1.279506 -0.092,-0.469681 -0.42163,-0.857412 -0.87023,-1.024229 l -4.408,-1.648478 c -0.11066,-0.380579 -0.22523,-0.76 -0.34468,-1.137915 l 2.74918,-3.818371 c 0.60055,-0.832565 0.11465,-2.00592 -0.89865,-2.170409 l -4.64778,-0.756544 c -0.18101,-0.350701 -0.36709,-0.698274 -0.55862,-1.043347 l 1.95337,-4.287077 c 0.19992,-0.435117 0.15885,-0.943405 -0.108,-1.341003 -0.26474,-0.398723 -0.71804,-0.630516 -1.19631,-0.612366 l -4.71702,0.163814 c -0.24363,-0.30522 -0.49208,-0.606405 -0.74518,-0.903821 l 1.08365,-4.594551 c 0.23673,-0.999313 -0.66144,-1.898085 -1.66087,-1.661914 l -4.59404,1.082621 c -0.29826,-0.25283 -0.60028,-0.501278 -0.90589,-0.745174 l 0.16537,-4.717025 c 0.0383,-1.0262926 -1.01869,-1.7326696 -1.95234,-1.3048296 l -4.28656,1.9538856 c -0.34557,-0.190722 -0.69313,-0.377218 -1.04325,-0.559656 l -0.75757,-4.6488106 c -0.1658,-1.011754 -1.33731,-1.496423 -2.1699,-0.898136 l -3.82149,2.749185 c -0.37701,-0.120103 -0.75611,-0.234779 -1.13637,-0.344165 l -1.64796,-4.409033 c -0.35618,-0.963989 -1.60447,-1.212992 -2.30322,-0.459403 l -3.21582,3.451469 c -0.38808,-0.04294 -0.779,-0.08224 -1.16892,-0.114205 l -2.48409,-4.013192 c -0.2699,-0.435866 -0.72108,-0.654223 -1.17305,-0.654223 z m 6.98046,9.4717726 c 0.94063,-0.01085 1.86684,0.437 2.42156,1.270723 0.86822,1.300983 0.50506,3.049906 -0.81184,3.908805 -3.15982,1.948799 -6.20745,-2.623644 -3.14296,-4.715474 0.47354,-0.307667 1.00556,-0.457967 1.53324,-0.464054 z m -6.98407,3.566707 h 5.3e-4 c 0.19398,0.0013 0.38794,0.0042 0.58187,0.0088 0.002,0.0032 0.005,0.0066 0.007,0.0098 1.10678,1.617736 1.9191,2.860637 2.45567,3.700549 0.001,0.0021 0.005,0.0072 0.006,0.0093 0.005,0.0075 0.009,0.01375 0.0134,0.02119 0.51987,0.814861 0.78393,1.256254 0.78393,1.256254 0.0967,0.147358 0.20617,0.281502 0.32556,0.402042 10e-4,0.0012 0.002,0.0024 0.004,0.0036 0.001,0.0011 0.002,0.0021 0.003,0.0031 0.11993,0.120188 0.24961,0.226527 0.38758,0.318844 0.13915,0.09311 0.28652,0.171875 0.43924,0.235644 0.1506,0.06288 0.30644,0.110791 0.46561,0.144177 0.005,9.79e-4 0.009,0.0016 0.0139,0.0026 0.15922,0.03249 0.32167,0.05064 0.48472,0.05271 0.16533,0.0021 0.33158,-0.0117 0.4961,-0.04186 h 5.3e-4 c 0.16453,-0.03019 0.32733,-0.07711 0.48627,-0.14056 h 5.3e-4 c 0.15908,-0.06354 0.31382,-0.144 0.46251,-0.241845 l 4.99349,-3.286621 0.15555,-0.10232 c 9.70557,3.765959 17.28006,11.21695 20.52071,21.110341 -0.29522,0.444712 -0.57381,0.828567 -0.82889,1.205093 -3.76785,5.353534 -3.90416,5.531963 -3.90416,5.531963 -0.10279,0.145307 -0.18849,0.297382 -0.25735,0.454235 -0.0688,0.156855 -0.12084,0.318566 -0.15658,0.482142 -0.0357,0.163576 -0.0549,0.329073 -0.0584,0.494543 -0.004,0.16547 0.009,0.330981 0.0367,0.493509 0.028,0.162544 0.0716,0.322188 0.13023,0.476975 0.0586,0.154786 0.13227,0.304276 0.22065,0.446484 0.17677,0.284414 0.4124,0.538999 0.70332,0.744141 l 4.88601,3.444234 0.75654,0.5333 c -0.89849,10.285428 -6.3243,19.638629 -14.80681,25.524559 -0.002,-7.9e-4 -0.004,-0.002 -0.006,-0.003 -2.17765,-0.9069 -3.58835,-1.5381 -4.46277,-1.94665 -0.0258,-0.0121 -0.0433,-0.0209 -0.0682,-0.0326 -0.80078,-0.37639 -1.15445,-0.56689 -1.15445,-0.56689 -0.16252,-0.0726 -0.32833,-0.12677 -0.49558,-0.16382 -0.16724,-0.037 -0.33593,-0.0572 -0.50333,-0.0605 -0.1674,-0.003 -0.33362,0.01 -0.49661,0.0388 -0.16229,0.0286 -0.321,0.0731 -0.47439,0.13178 -0.002,5.3e-4 -0.004,7.9e-4 -0.005,0.002 -0.15291,0.0589 -0.30025,0.13211 -0.43976,0.21911 -0.14045,0.0876 -0.27302,0.18899 -0.39533,0.30334 -0.12108,0.11319 -0.23187,0.23952 -0.33073,0.37724 -0.002,0.003 -0.004,0.006 -0.006,0.009 -0.0983,0.13811 -0.18476,0.28768 -0.25631,0.44855 l -2.4288,5.46271 -0.48472,1.09038 c -2.55818,0.59071 -5.17507,0.88958 -7.80056,0.8909 -7.36743,-0.009 -14.54147,-2.35861 -20.48609,-6.7107 6e-5,-8e-4 -5e-5,-0.002 0,-0.003 0.005,-0.0853 0.008,-0.17288 0.007,-0.26407 l -0.093,-6.77013 c -0.002,-0.17797 -0.0224,-0.35146 -0.0589,-0.51883 -0.0363,-0.1666 -0.0888,-0.32684 -0.15554,-0.47956 -3.7e-4,-7.9e-4 -6.6e-4,-0.002 -0.001,-0.003 -4e-4,-0.001 -0.001,-0.002 -0.002,-0.003 -0.067,-0.15217 -0.14804,-0.29704 -0.24185,-0.43201 -0.0945,-0.13591 -0.2017,-0.26219 -0.31987,-0.37724 -0.11818,-0.11505 -0.24712,-0.21876 -0.38551,-0.30954 -0.13839,-0.0908 -0.28623,-0.16841 -0.44132,-0.23151 -0.15509,-0.0631 -0.31747,-0.11166 -0.48576,-0.14366 -0.16828,-0.032 -0.34241,-0.0475 -0.52038,-0.045 l -5.97741,0.0853 -0.18449,0.003 c -3.51745,-5.547081 -5.39056,-11.97777 -5.40225,-18.546157 0.011,-3.604783 0.58282,-7.185908 1.69499,-10.614855 0.0118,-0.003 0.005,-0.0011 0.0171,-0.0041 4.45781,-1.139848 5.20498,-1.30166 6.47299,-1.616956 0.16006,-0.0398 0.31487,-0.09685 0.4625,-0.168981 0.29526,-0.144262 0.56166,-0.348676 0.78497,-0.595313 0.11165,-0.123317 0.21266,-0.257286 0.30075,-0.399457 0.0881,-0.142174 0.16344,-0.292534 0.22428,-0.449069 0.0608,-0.156533 0.10708,-0.318839 0.13694,-0.485241 0.0299,-0.166404 0.0436,-0.336717 0.0388,-0.508497 -0.005,-0.171781 -0.0281,-0.345133 -0.0713,-0.517798 l -1.45213,-5.798552 -0.33435,-1.335319 c 6.59946,-7.770258 16.27821,-12.250469 26.4728,-12.254032 z m -31.19758,14.948957 c 1.19189,-0.0032 2.30664,0.734645 2.71456,1.908929 1.11834,3.507685 -4.13158,5.271532 -5.41414,1.819011 -0.50897,-1.473642 0.29002,-3.075504 1.78387,-3.576011 0.30347,-0.10214 0.61189,-0.151114 0.91571,-0.151929 z m 66.48586,13.194543 c 0.52608,-0.0019 1.08531,0.15579 1.64125,0.524 1.28946,0.896958 1.59723,2.656469 0.68678,3.927927 -0.90918,1.273461 -2.69192,1.579428 -3.98374,0.684194 -2.45596,-1.795719 -0.74593,-5.127763 1.65571,-5.136121 z m -62.02928,28.155393 c 3.72595,0.0343 3.80312,5.5067 0.0796,5.64358 -1.57744,0.0223 -2.87369,-1.2224 -2.8944,-2.77916 -0.0229,-1.55763 1.23651,-2.83933 2.81482,-2.86442 z m 41.35302,8.30233 c 1.83932,-0.0174 3.69784,1.70666 2.75591,3.93361 -0.64087,1.42265 -2.33004,2.06253 -3.77083,1.42834 -1.4425,-0.63258 -2.09338,-2.29871 -1.45469,-3.72329 0.54787,-1.14257 1.50617,-1.62955 2.46961,-1.63866 z" />
+    <path
+       d="m 330.35323,103.34875 -3.43386,-3.20864 c 0.0431,-0.387493 0.0819,-0.775439 0.11661,-1.16377 l 3.99498,-2.468047 c 0.40626,-0.250837 0.65408,-0.692851 0.65274,-1.168861 0.002,-0.476654 -0.24439,-0.91995 -0.64995,-1.170402 l -3.98304,-2.469807 c -0.0338,-0.393278 -0.0722,-0.78615 -0.11511,-1.178538 l 3.43038,-3.192943 c 0.74901,-0.695882 0.50362,-1.936751 -0.45388,-2.295158 l -4.39169,-1.645388 c -0.10834,-0.377825 -0.22238,-0.75399 -0.34209,-1.128368 l 2.74413,-3.805825 c 0.28015,-0.385928 0.33938,-0.889796 0.15637,-1.330171 -0.18074,-0.441071 -0.57808,-0.756233 -1.04871,-0.831828 l -4.63906,-0.759999 c -0.17838,-0.345626 -0.36217,-0.688428 -0.55132,-1.028278 l 1.95524,-4.275996 c 0.42618,-0.929761 -0.27572,-1.982815 -1.29789,-1.947182 l -4.69793,0.16119 c -0.24195,-0.305117 -0.48839,-0.606638 -0.73926,-0.904464 l 1.08194,-4.574749 c 0.23765,-0.994839 -0.65672,-1.891005 -1.65204,-1.655344 l -4.56736,1.07202 c -0.30038,-0.253716 -0.60377,-0.503847 -0.91011,-0.75034 l 0.16698,-4.688012 c 0.0355,-1.020452 -1.0137,-1.722733 -1.94356,-1.300903 l -4.26869,1.939465 c -0.34476,-0.190867 -0.6922,-0.376843 -1.04222,-0.557874 l -0.74937,-4.627208 c -0.15973,-1.010961 -1.33001,-1.497602 -2.15947,-0.897983 l -3.81429,2.7425 c -0.37062,-0.117656 -0.74465,-0.232255 -1.1192,-0.339553 l -1.64253,-4.404105 c -0.35707,-0.956701 -1.59553,-1.204158 -2.29282,-0.458127 l -3.20882,3.434753 c -0.38792,-0.04504 -0.77726,-0.08297 -1.16466,-0.116785 l -2.46839,-3.997846 c -0.53598,-0.871204 -1.80215,-0.87163 -2.33872,-7.88e-4 l -2.46998,3.983948 c -0.39415,0.03254 -0.786,0.07202 -1.17748,0.114357 l -3.19471,-3.430729 c -0.69707,-0.745408 -1.93434,-0.500672 -2.29513,0.453981 l -1.64736,4.392221 c -0.3779,0.109052 -0.7533,0.224153 -1.12855,0.342999 l -3.80474,-2.744858 c -0.38603,-0.279364 -0.88946,-0.338163 -1.32948,-0.155279 -0.44048,0.180924 -0.75646,0.578713 -0.83181,1.048682 l -0.76,4.639077 c -0.34544,0.178593 -0.68928,0.363072 -1.03006,0.550934 l -4.27528,-1.954108 c -0.43375,-0.197423 -0.93867,-0.157008 -1.33549,0.106895 -0.39707,0.264093 -0.6287,0.715278 -0.61188,1.191857 l 0.16012,4.698663 c -0.30401,0.241969 -0.60481,0.487933 -0.90233,0.737829 l -4.57493,-1.081052 c -0.99503,-0.236884 -1.89084,0.657514 -1.65552,1.652913 l 1.07184,4.568295 c -0.25437,0.299821 -0.50451,0.603212 -0.75034,0.910083 l -4.68686,-0.168569 c -1.02113,-0.03598 -1.72387,1.014266 -1.30108,1.944454 l 1.94,4.266009 c -0.19042,0.344962 -0.37762,0.692429 -0.55912,1.043823 l -4.62721,0.749381 c -1.01053,0.161283 -1.49597,1.331489 -0.89634,2.160727 l 2.74072,3.813911 c -0.11767,0.370643 -0.23137,0.744838 -0.33955,1.119215 l -4.40322,1.642717 c -0.9586,0.35544 -1.20653,1.596286 -0.45813,2.292803 l 3.43387,3.208639 c -0.0442,0.388096 -0.0828,0.776383 -0.11661,1.163759 l -3.99606,2.468767 c -0.86905,0.536592 -0.87045,1.799864 -0.003,2.33838 l 3.98395,2.469979 c 0.0325,0.39415 0.0718,0.786871 0.11507,1.178541 l -3.43014,3.19384 c -0.74926,0.69589 -0.50308,1.93715 0.45506,2.2944 l 4.39079,1.64522 c 0.10869,0.37969 0.22289,0.75492 0.34264,1.13034 l -2.74468,3.80384 c -0.27923,0.38641 -0.33807,0.88999 -0.15545,1.33036 0.18253,0.44174 0.58031,0.7577 1.04868,0.83183 l 4.63747,0.75874 c 0.18002,0.34758 0.36307,0.68928 0.55094,1.03007 l -1.9536,4.27725 c -0.19789,0.43342 -0.1582,0.93565 0.10743,1.33278 0.26261,0.39841 0.71495,0.62697 1.19205,0.61101 l 4.69776,-0.1603 c 0.24208,0.30618 0.48915,0.60595 0.73961,0.90269 l -1.08123,4.57582 c -0.23687,0.99458 0.6573,1.88996 1.6522,1.65444 l 4.56722,-1.07113 c 0.29967,0.25462 0.60221,0.50428 0.9101,0.75033 l -0.16644,4.68536 c -0.035,1.02053 1.01349,1.72318 1.9441,1.30285 l 4.26636,-1.94177 c 0.34529,0.19146 0.6932,0.37815 1.04365,0.56001 l 0.74972,4.62543 c 0.0759,0.46958 0.38932,0.86884 0.83079,1.04981 0.4395,0.18395 0.94308,0.12576 1.32905,-0.15358 l 3.81482,-2.74055 c 0.37029,0.11942 0.74465,0.23231 1.11958,0.34242 l 1.6427,4.40319 c 0.35788,0.95573 1.59513,1.20295 2.2928,0.45813 l 3.20865,-3.43386 c 0.38759,0.0431 0.77573,0.0811 1.16431,0.11393 l 2.46786,3.99589 c 0.24994,0.40607 0.69197,0.65388 1.16797,0.65256 0.47656,0.001 0.9197,-0.24465 1.17041,-0.64995 l 2.46961,-3.98217 c 0.39342,-0.0332 0.78636,-0.0719 1.17872,-0.11592 l 3.1935,3.43234 c 0.69689,0.74706 1.93616,0.50089 2.29462,-0.45581 l 1.6468,-4.38956 c 0.37792,-0.10903 0.75369,-0.22589 1.12855,-0.34299 l 3.80493,2.74396 c 0.828,0.59976 1.9976,0.11674 2.16112,-0.8925 l 0.76016,-4.63998 c 0.34544,-0.17858 0.68856,-0.35951 1.02881,-0.54934 l 4.27546,1.95325 c 0.43293,0.19956 0.93852,0.15932 1.33443,-0.1062 0.39785,-0.26456 0.62747,-0.71297 0.61134,-1.18919 l -0.16,-4.69954 c 0.30442,-0.24243 0.60559,-0.48735 0.90269,-0.73962 l 4.57474,1.08194 c 0.46353,0.11087 0.95136,-0.0274 1.28781,-0.36495 0.33812,-0.33679 0.47715,-0.82372 0.36683,-1.28812 l -1.07129,-4.56634 c 0.25392,-0.30075 0.50444,-0.6031 0.74978,-0.91206 l 4.68679,0.16859 c 1.02158,0.0377 1.72522,-1.0135 1.3009,-1.94356 l -1.93984,-4.2669 c 0.18956,-0.34515 0.37672,-0.69261 0.55914,-1.04382 l 4.62629,-0.74955 c 0.47066,-0.0767 0.86888,-0.38934 1.04982,-0.83079 0.18394,-0.43951 0.12575,-0.94308 -0.15357,-1.32905 l -2.73966,-3.81463 c 0.11672,-0.37083 0.23042,-0.74504 0.33955,-1.11923 l 4.40321,-1.6427 c 0.95871,-0.35515 1.20701,-1.59594 0.4588,-2.29268 z m -32.72191,27.26637 c -1.43287,-0.62366 -2.08974,-2.2901 -1.46781,-3.72371 0.61779,-1.43428 2.28274,-2.09442 3.71553,-1.47317 1.43326,0.622 2.09133,2.28779 1.47013,3.7214 -0.61994,1.43336 -2.28374,2.09365 -3.71785,1.47548 z m 9.9811,-9.9162 c -1.22578,1.11685 -2.52956,2.14497 -3.90144,3.07655 l -5.61174,-2.43171 c -1.30719,-0.56581 -2.82546,0.0365 -3.38933,1.34449 l -2.68843,6.21429 c -4.8239,1.12122 -9.83209,1.19543 -14.68708,0.2176 -4.96722,-0.98599 -9.6583,-3.04768 -13.74365,-6.04023 l -0.0931,-6.77007 c -0.018,-1.42379 -1.18795,-2.56279 -2.61172,-2.54264 l -5.97745,0.0854 c -0.84612,-1.30929 -1.60299,-2.67414 -2.26547,-4.08526 m 5.11212,12.73912 c -1.56172,0.0224 -2.84541,-1.22644 -2.86591,-2.78819 -0.0227,-1.56262 1.22435,-2.84844 2.78693,-2.8736 3.68884,0.0344 3.76542,5.52446 0.079,5.66179 z m -2.00755,-45.013569 c 0.34101,1.524829 -0.6174,3.037738 -2.14175,3.380877 -1.52409,0.341521 -3.03605,-0.618678 -3.37499,-2.14335 -0.34102,-1.524829 0.61739,-3.037739 2.14175,-3.380878 1.52409,-0.341521 3.03605,0.618679 3.37499,2.143351 z m -4.79157,7.058092 6.50067,-1.4601 c 1.38979,-0.312575 2.26355,-1.692039 1.95221,-3.082112 l -0.67419,-3.026324 c 5.75171,-2.852317 28.85231,11.498845 -9.27656,20.815729 -0.25657,-3.217608 -0.0647,-6.455261 0.57004,-9.620053 0.2475,-1.238695 0.55903,-2.449775 0.92783,-3.62714 z M 263.28072,67.15245 c 0,0 13.4354,-7.051282 21.24437,-6.95996 l 3.37344,5.330493 c 0.76116,1.203295 2.35468,1.559932 3.55613,0.795875 l 5.68824,-3.61356 c 9.63457,3.862422 16.86195,11.78439 20.03691,21.306035 l -4.74469,6.730806 c -0.81996,1.164312 -0.5432,2.772569 0.61878,3.595819 l 5.73564,4.053424 c -0.22365,2.093258 -0.57129,3.988648 -1.11144,5.938608 M 289.55606,57.236849 c 1.31792,-0.83755 3.06541,-0.446421 3.90054,0.873032 0.83564,1.320855 0.4436,3.068937 -0.87609,3.906418 -1.31793,0.83835 -3.06618,0.446634 -3.90038,-0.873927 -0.83453,-1.320719 -0.44272,-3.06771 0.87592,-3.905524 z m 27.22657,32.591547 c 0.89868,-1.276909 2.66309,-1.582063 3.93842,-0.681149 1.27546,0.90256 1.57891,2.667607 0.67812,3.944317 -0.8985,1.277833 -2.66378,1.583375 -3.9395,0.681869 -1.27416,-0.903808 -1.57694,-2.668112 -0.67702,-3.945027 z"
+       id="path11918"
+       style="fill:#ffffff;fill-opacity:1;stroke-width:0.909418"
+       inkscape:export-filename="/home/hunter/omoc-rust.png"
+       inkscape:export-xdpi="96"
+       inkscape:export-ydpi="96"
+       sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccscccccccccccsccccssccc" />
+    <path
+       d="m 300.72838,-60.57878 -3.43386,-3.20864 c 0.0431,-0.387492 0.0819,-0.775438 0.11661,-1.163769 l 3.99498,-2.468047 c 0.40626,-0.250837 0.65408,-0.692851 0.65274,-1.168861 0.002,-0.476654 -0.24439,-0.91995 -0.64995,-1.170402 l -3.98304,-2.469807 c -0.0338,-0.393278 -0.0722,-0.78615 -0.11511,-1.178538 l 3.43038,-3.192943 c 0.74901,-0.695882 0.50362,-1.936751 -0.45388,-2.295158 l -4.39169,-1.645388 c -0.10834,-0.377825 -0.22238,-0.75399 -0.34209,-1.128368 l 2.74413,-3.805825 c 0.28015,-0.385928 0.33938,-0.889796 0.15637,-1.330171 -0.18074,-0.441071 -0.57808,-0.756233 -1.04871,-0.831828 l -4.63906,-0.759999 c -0.17838,-0.345626 -0.36217,-0.688428 -0.55132,-1.028278 l 1.95524,-4.275996 c 0.42618,-0.929761 -0.27572,-1.982815 -1.29789,-1.947182 l -4.69793,0.16119 c -0.24195,-0.305117 -0.48839,-0.606638 -0.73926,-0.904464 l 1.08194,-4.574746 c 0.23765,-0.99484 -0.65672,-1.89101 -1.65204,-1.65535 l -4.56737,1.07202 c -0.30038,-0.25371 -0.60377,-0.50384 -0.91011,-0.75034 l 0.16698,-4.68801 c 0.0355,-1.02045 -1.0137,-1.72273 -1.94356,-1.3009 l -4.26869,1.93946 c -0.34476,-0.19086 -0.6922,-0.37684 -1.04222,-0.55787 l -0.74937,-4.62721 c -0.15973,-1.01096 -1.33001,-1.4976 -2.15947,-0.89798 l -3.81429,2.7425 c -0.37062,-0.11766 -0.74465,-0.23226 -1.1192,-0.33955 l -1.64253,-4.40411 c -0.35707,-0.9567 -1.59553,-1.20416 -2.29282,-0.45813 l -3.20882,3.43476 c -0.38792,-0.045 -0.77726,-0.083 -1.16466,-0.11679 l -2.46839,-3.99784 c -0.53598,-0.87121 -1.80215,-0.87163 -2.33872,-7.9e-4 l -2.46998,3.98395 c -0.39415,0.0325 -0.786,0.072 -1.17748,0.11435 l -3.19471,-3.43073 c -0.69707,-0.7454 -1.93434,-0.50067 -2.29513,0.45399 l -1.64736,4.39222 c -0.3779,0.10905 -0.7533,0.22415 -1.12855,0.343 l -3.80474,-2.74486 c -0.38603,-0.27937 -0.88946,-0.33817 -1.32948,-0.15528 -0.44048,0.18092 -0.75646,0.57871 -0.83181,1.04868 l -0.76,4.63908 c -0.34544,0.17859 -0.68928,0.36307 -1.03006,0.55093 l -4.27528,-1.95411 c -0.43375,-0.19742 -0.93867,-0.157 -1.33549,0.1069 -0.39707,0.26409 -0.6287,0.71528 -0.61188,1.19185 l 0.16012,4.69867 c -0.30401,0.24197 -0.60481,0.48793 -0.90233,0.73783 l -4.57493,-1.08106 c -0.99503,-0.23688 -1.89084,0.65752 -1.65552,1.65292 l 1.07184,4.568292 c -0.25437,0.299821 -0.50451,0.603212 -0.75034,0.910083 l -4.68686,-0.168569 c -1.02113,-0.03598 -1.72387,1.014266 -1.30108,1.944454 l 1.94,4.266009 c -0.19042,0.344962 -0.37762,0.692429 -0.55912,1.043823 l -4.62721,0.749381 c -1.01053,0.161283 -1.49597,1.331489 -0.89634,2.160727 l 2.74072,3.813911 c -0.11767,0.370643 -0.23137,0.744838 -0.33955,1.119215 l -4.40322,1.642717 c -0.9586,0.35544 -1.20653,1.596286 -0.45813,2.292803 l 3.43387,3.208639 c -0.0442,0.388096 -0.0828,0.776383 -0.11661,1.163759 l -3.99606,2.468767 c -0.86905,0.536592 -0.87045,1.799864 -0.003,2.33838 l 3.98395,2.469979 c 0.0325,0.39415 0.0718,0.786871 0.11507,1.17854 l -3.43014,3.193844 c -0.74926,0.695888 -0.50308,1.937152 0.45506,2.294403 l 4.39079,1.645216 c 0.10869,0.379692 0.22289,0.754921 0.34264,1.130341 l -2.74468,3.803844 c -0.27923,0.386404 -0.33807,0.889983 -0.15545,1.330355 0.18253,0.441742 0.58031,0.757706 1.04868,0.831834 l 4.63747,0.758737 c 0.18002,0.34758 0.36307,0.689278 0.55094,1.030075 l -1.9536,4.277243 c -0.19789,0.43342 -0.1582,0.93565 0.10743,1.332787 0.26261,0.398402 0.71495,0.626967 1.19205,0.611003 l 4.69776,-0.1603 c 0.24208,0.306184 0.48915,0.60595 0.73961,0.902689 l -1.08123,4.575826 c -0.23687,0.994577 0.6573,1.889962 1.6522,1.654443 l 4.56722,-1.071137 c 0.29967,0.254625 0.60221,0.504277 0.9101,0.750336 l -0.16644,4.685347 c -0.035,1.02053 1.01349,1.723184 1.9441,1.302854 l 4.26636,-1.941762 c 0.34529,0.19146 0.6932,0.378148 1.04365,0.560009 l 0.74972,4.625418 c 0.0759,0.469593 0.38932,0.868854 0.83079,1.049817 0.4395,0.18394 0.94308,0.125751 1.32905,-0.153576 l 3.81482,-2.74056 c 0.37029,0.11943 0.74465,0.232322 1.11958,0.342429 l 1.6427,4.403192 c 0.35788,0.955732 1.59513,1.202949 2.2928,0.458126 l 3.20865,-3.433859 c 0.38759,0.04306 0.77573,0.08105 1.16431,0.113935 l 2.46786,3.995884 c 0.24994,0.406075 0.69197,0.653885 1.16797,0.652561 0.47656,0.0014 0.9197,-0.244651 1.17041,-0.649944 l 2.46961,-3.982174 c 0.39342,-0.03322 0.78636,-0.07186 1.17872,-0.115916 l 3.1935,3.432334 c 0.69689,0.747064 1.93616,0.500892 2.29462,-0.455811 l 1.6468,-4.389556 c 0.37792,-0.109033 0.75369,-0.225892 1.12855,-0.342992 l 3.80493,2.743959 c 0.828,0.599765 1.9976,0.116742 2.16112,-0.892499 l 0.76016,-4.63998 c 0.34544,-0.178583 0.68856,-0.359504 1.02881,-0.549334 l 4.27546,1.953241 c 0.43293,0.199561 0.93852,0.159325 1.33443,-0.106196 0.39785,-0.264564 0.62747,-0.712975 0.61134,-1.189188 l -0.16,-4.699539 c 0.30442,-0.242435 0.60559,-0.487357 0.90269,-0.739621 l 4.57474,1.081939 c 0.46353,0.110871 0.95136,-0.02737 1.28781,-0.364949 0.33812,-0.336789 0.47715,-0.823722 0.36683,-1.28812 l -1.07129,-4.566346 c 0.25392,-0.300746 0.50444,-0.603092 0.74978,-0.912058 l 4.68679,0.16859 c 1.02158,0.03774 1.72522,-1.013496 1.3009,-1.943561 l -1.93984,-4.266894 c 0.18956,-0.345152 0.37672,-0.692618 0.55914,-1.043823 l 4.62629,-0.749553 c 0.47066,-0.07669 0.86888,-0.38934 1.04982,-0.830787 0.18394,-0.439506 0.12575,-0.943079 -0.15357,-1.329053 l -2.73966,-3.814627 c 0.11672,-0.370832 0.23042,-0.745036 0.33955,-1.119233 l 4.40321,-1.642696 c 0.95871,-0.355155 1.20701,-1.595942 0.4588,-2.292679 z m -32.72192,27.266373 c -1.43287,-0.623655 -2.08974,-2.290097 -1.46781,-3.723713 0.61779,-1.434279 2.28274,-2.094413 3.71553,-1.473164 1.43326,0.622 2.09133,2.287792 1.47013,3.721404 -0.61994,1.433351 -2.28374,2.09365 -3.71785,1.475473 z m 9.9811,-9.916195 c -1.22578,1.116851 -2.52956,2.144968 -3.90144,3.076548 l -5.61174,-2.431713 c -1.30719,-0.565811 -2.82546,0.03646 -3.38933,1.344492 l -2.68843,6.214286 c -4.8239,1.121229 -9.83209,1.195432 -14.68708,0.217609 -4.96722,-0.985995 -9.6583,-3.047688 -13.74365,-6.040235 l -0.0931,-6.770067 c -0.018,-1.423795 -1.18795,-2.562794 -2.61172,-2.542644 l -5.97745,0.08544 c -0.84612,-1.309288 -1.60299,-2.674138 -2.26547,-4.085264 m 5.11212,12.739121 c -1.56172,0.02244 -2.84541,-1.226437 -2.86591,-2.788187 -0.0227,-1.562618 1.22435,-2.848435 2.78693,-2.873599 3.68884,0.03444 3.76542,5.524463 0.079,5.661786 z m -2.00755,-45.013569 c 0.34101,1.524829 -0.6174,3.037738 -2.14175,3.380877 -1.52409,0.341521 -3.03605,-0.618678 -3.37499,-2.14335 -0.34102,-1.524829 0.61739,-3.037739 2.14175,-3.380878 1.52409,-0.341521 3.03605,0.618679 3.37499,2.143351 z m -4.79157,7.058092 6.50067,-1.4601 c 1.38979,-0.312575 2.26355,-1.692039 1.95221,-3.082112 l -0.67419,-3.026324 c 5.75171,-2.852317 28.85231,11.498845 -9.27656,20.815729 -0.25657,-3.217608 -0.0647,-6.455261 0.57004,-9.620053 0.2475,-1.238695 0.55903,-2.449775 0.92783,-3.62714 z m 12.32471,-17.398533 c 0,0 13.4354,-7.051281 21.24437,-6.959961 l 3.37344,5.330494 c 0.76116,1.203295 2.35468,1.559932 3.55613,0.795875 l 5.68824,-3.613559 c 9.63457,3.862421 16.86195,11.784389 20.03692,21.306034 l -4.7447,6.730806 c -0.81996,1.164312 -0.5432,2.772569 0.61878,3.595819 l 5.73565,4.053424 c -0.22365,2.093257 -0.57129,3.988652 -1.11144,5.938607 m -28.12205,-47.09318 c 1.31792,-0.83755 3.06541,-0.44642 3.90054,0.87303 0.83564,1.32086 0.4436,3.06894 -0.87609,3.90642 -1.31793,0.83835 -3.06618,0.44663 -3.90038,-0.87393 -0.83453,-1.32072 -0.44272,-3.06771 0.87592,-3.90552 z m 27.22658,32.591547 c 0.89868,-1.276909 2.66309,-1.582063 3.93842,-0.681149 1.27546,0.90256 1.57891,2.667607 0.67812,3.944317 -0.8985,1.277833 -2.66378,1.583375 -3.9395,0.681869 -1.27416,-0.903808 -1.57694,-2.668112 -0.67702,-3.945027 z"
+       id="path6469"
+       style="fill:#f5680f;fill-opacity:1;stroke-width:0.909418"
+       inkscape:export-filename="/home/hunter/omoc-rust.png"
+       inkscape:export-xdpi="96"
+       inkscape:export-ydpi="96"
+       sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccscccccccccccsccccssccc" />
+    <path
+       d="m -2.9005959,70.119893 -3.433859,-3.20864 c 0.04305,-0.387492 0.08192,-0.775438 0.116608,-1.163769 l 3.9949815,-2.468047 c 0.40626,-0.250837 0.65408,-0.692851 0.65274,-1.168861 0.002,-0.476654 -0.24439,-0.91995 -0.64995,-1.170402 l -3.9830445,-2.469807 c -0.03381,-0.393278 -0.07218,-0.78615 -0.115105,-1.178538 l 3.430379,-3.192943 c 0.7490105,-0.695882 0.5036205,-1.936751 -0.453884,-2.295158 l -4.391685,-1.645388 c -0.108339,-0.377825 -0.222382,-0.75399 -0.34209,-1.128368 l 2.74413,-3.805825 c 0.28015,-0.385928 0.339381,-0.889796 0.156365,-1.330171 -0.180743,-0.441071 -0.578076,-0.756233 -1.048711,-0.831828 L -10.86278,42.302149 c -0.178375,-0.345626 -0.362171,-0.688428 -0.551319,-1.028278 l 1.9552361,-4.275996 c 0.426189,-0.929761 -0.275719,-1.982815 -1.2978851,-1.947182 l -4.697932,0.16119 c -0.241946,-0.305117 -0.488391,-0.606638 -0.739257,-0.904464 l 1.081939,-4.574749 c 0.237651,-0.994839 -0.656724,-1.891005 -1.652036,-1.655344 l -4.567377,1.07202 c -0.30038,-0.253716 -0.60377,-0.503847 -0.910106,-0.75034 l 0.166982,-4.688012 c 0.03551,-1.020452 -1.013699,-1.722732 -1.943561,-1.300903 l -4.268697,1.939465 c -0.344754,-0.190867 -0.692193,-0.376843 -1.042212,-0.557874 l -0.749373,-4.627206 c -0.159731,-1.010962 -1.330007,-1.497603 -2.159473,-0.897983 l -3.814283,2.7425 c -0.370622,-0.117656 -0.744654,-0.232256 -1.119203,-0.339553 l -1.642534,-4.404105 c -0.357063,-0.956701 -1.595527,-1.204159 -2.292813,-0.458127 l -3.208822,3.434753 c -0.387922,-0.04504 -0.777263,-0.08297 -1.16466,-0.116785 l -2.468392,-3.997847 c -0.535982,-0.871203 -1.802155,-0.871629 -2.338724,-7.87e-4 l -2.469979,3.983948 c -0.394149,0.03254 -0.786,0.07202 -1.177477,0.114356 l -3.194714,-3.430728 c -0.697064,-0.745408 -1.934336,-0.500672 -2.295123,0.453981 l -1.647361,4.39222 c -0.377901,0.109053 -0.753301,0.224154 -1.12855,0.343 l -3.804744,-2.744858 c -0.386029,-0.279364 -0.889457,-0.338163 -1.329475,-0.155279 -0.440487,0.180924 -0.756461,0.578713 -0.831813,1.048682 l -0.760003,4.639075 c -0.345434,0.178593 -0.689278,0.363072 -1.030056,0.550934 l -4.275284,-1.954108 c -0.433744,-0.197422 -0.938664,-0.157007 -1.335483,0.106895 -0.397071,0.264093 -0.628703,0.715278 -0.611881,1.191857 l 0.160118,4.698663 c -0.304007,0.241969 -0.604812,0.487933 -0.902336,0.737829 l -4.574928,-1.081052 c -0.995027,-0.236884 -1.890835,0.657514 -1.655518,1.652913 l 1.071842,4.568295 c -0.254376,0.299821 -0.504514,0.603212 -0.75034,0.910083 l -4.68686,-0.168569 c -1.021132,-0.03598 -1.723872,1.014266 -1.301077,1.944454 l 1.939998,4.266009 c -0.190421,0.344962 -0.377618,0.692429 -0.559122,1.043823 l -4.627206,0.749381 c -1.010539,0.161283 -1.495979,1.331489 -0.896339,2.160727 l 2.740714,3.813911 c -0.117668,0.370643 -0.231369,0.744838 -0.339551,1.119215 l -4.403213,1.642717 c -0.9586,0.35544 -1.20654,1.596286 -0.45813,2.292803 l 3.433867,3.208639 c -0.04418,0.388096 -0.0828,0.776383 -0.116613,1.163759 l -3.996054,2.468767 c -0.86906,0.536592 -0.87046,1.799864 -0.003,2.33838 l 3.983946,2.469979 c 0.03252,0.39415 0.07184,0.786871 0.115065,1.17854 l -3.430551,3.193844 c -0.74926,0.695888 -0.50307,1.937152 0.45506,2.294403 l 4.390792,1.645216 c 0.108688,0.379692 0.222895,0.754921 0.342647,1.130341 l -2.744679,3.803844 c -0.27924,0.386404 -0.33808,0.889983 -0.15546,1.330355 0.18253,0.441742 0.580318,0.757706 1.04868,0.831834 l 4.637476,0.758737 c 0.180023,0.34758 0.36307,0.689278 0.550942,1.030075 l -1.953599,4.277243 c -0.197899,0.43342 -0.1582,0.93565 0.10743,1.332787 0.262606,0.398402 0.714948,0.626967 1.192044,0.611003 l 4.697764,-0.1603 c 0.242081,0.306184 0.489149,0.60595 0.739609,0.902689 l -1.081229,4.575826 c -0.23687,0.994577 0.657301,1.889962 1.652199,1.654443 l 4.567221,-1.071137 c 0.299669,0.254625 0.602208,0.504277 0.910094,0.750336 l -0.166437,4.685348 c -0.035,1.02053 1.013492,1.72318 1.944099,1.30285 l 4.26636,-1.941759 c 0.34529,0.19146 0.693205,0.378149 1.043647,0.560009 l 0.749724,4.62542 c 0.07586,0.46959 0.38932,0.86885 0.830788,1.04982 0.439506,0.18394 0.943079,0.12575 1.329054,-0.15358 l 3.814818,-2.74056 c 0.370287,0.11943 0.744648,0.23232 1.119579,0.34243 l 1.642705,4.40319 c 0.357876,0.95573 1.595126,1.20295 2.292793,0.45813 l 3.20865,-3.43386 c 0.38759,0.0431 0.775729,0.081 1.164316,0.11393 l 2.467855,3.99589 c 0.249946,0.40607 0.691969,0.65388 1.16797,0.65256 0.476565,0.001 0.919704,-0.24465 1.170412,-0.64995 l 2.469614,-3.98217 c 0.393419,-0.0332 0.786361,-0.0719 1.178715,-0.11592 l 3.193499,3.43234 c 0.696897,0.74706 1.936167,0.50089 2.294623,-0.45581 l 1.646795,-4.38956 c 0.377921,-0.10903 0.753698,-0.22589 1.12855,-0.34299 l 3.804936,2.74396 c 0.828001,0.59976 1.997602,0.11674 2.161116,-0.8925 l 0.760165,-4.63998 c 0.345434,-0.17858 0.688559,-0.35951 1.02881,-0.549336 l 4.275461,1.953246 c 0.432922,0.19956 0.938516,0.15932 1.334426,-0.1062 0.397855,-0.26456 0.627474,-0.71298 0.611337,-1.18919 l -0.159995,-4.699538 c 0.304423,-0.242435 0.605586,-0.487357 0.902688,-0.739621 l 4.574743,1.081939 c 0.463532,0.110871 0.951362,-0.02737 1.28781,-0.364949 0.338115,-0.336789 0.477145,-0.823722 0.366828,-1.28812 l -1.071289,-4.566346 c 0.253915,-0.300746 0.504439,-0.603092 0.749779,-0.912058 l 4.686785,0.16859 c 1.0215891,0.03774 1.7252211,-1.013496 1.3009001,-1.943561 l -1.9398381,-4.266894 c 0.189558,-0.345152 0.376727,-0.692618 0.559138,-1.043823 l 4.6263081,-0.749553 c 0.470661,-0.07669 0.868874,-0.38934 1.049818,-0.830787 0.18394,-0.439506 0.125751,-0.943079 -0.153576,-1.329053 l -2.739659,-3.814627 c 0.116728,-0.370832 0.230419,-0.745036 0.339554,-1.119233 l 4.403212,-1.642696 c 0.9587105,-0.355155 1.2070105,-1.595942 0.4588,-2.292679 z M -35.622516,97.386266 c -1.43287,-0.623655 -2.089745,-2.290097 -1.467808,-3.723713 0.61779,-1.434279 2.282738,-2.094413 3.715523,-1.473164 1.433263,0.622 2.091333,2.287792 1.470136,3.721404 -0.619939,1.433351 -2.283739,2.09365 -3.717851,1.475473 z m 9.981093,-9.916195 c -1.225778,1.116851 -2.529554,2.144968 -3.901431,3.076548 l -5.61174,-2.431713 c -1.307193,-0.565811 -2.825464,0.03646 -3.389335,1.344492 l -2.688434,6.214286 c -4.823894,1.121229 -9.832084,1.195432 -14.687078,0.217609 -4.967221,-0.985995 -9.658295,-3.047688 -13.743651,-6.040235 l -0.09309,-6.770067 c -0.01801,-1.423795 -1.187953,-2.562794 -2.611719,-2.542644 l -5.977454,0.08544 c -0.846117,-1.309288 -1.602988,-2.674138 -2.265464,-4.085264 m 5.112118,12.739121 c -1.561723,0.02244 -2.84541,-1.226437 -2.865913,-2.788187 -0.02268,-1.562618 1.224352,-2.848435 2.786932,-2.873599 3.68884,0.03444 3.765425,5.524463 0.07898,5.661786 z"
+       id="path6936"
+       style="fill:#f5680f;fill-opacity:1;stroke-width:0.909418"
+       inkscape:export-filename="/home/hunter/omoc-rust.png"
+       inkscape:export-xdpi="96"
+       inkscape:export-ydpi="96"
+       sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" />
+    <path
+       id="path75-3"
+       clip-path="none"
+       style="fill:#f7931a;fill-opacity:1;stroke-width:0.913142"
+       d="m -48.083404,105.53909 c -0.451974,0 -0.904153,0.2182 -1.174052,0.65407 l -2.483751,4.01322 c -0.390827,0.032 -0.781758,0.0712 -1.169847,0.1141 l -3.21668,-3.45118 c -0.699134,-0.75238 -1.946408,-0.5035 -2.303411,0.45953 l -1.647772,4.4086 c -0.381697,0.10958 -0.760118,0.22567 -1.137248,0.34439 l -3.820269,-2.74927 c -0.832997,-0.59682 -2.003487,-0.11295 -2.170916,0.89802 l -0.757638,4.64888 c -0.35065,0.18172 -0.697578,0.3691 -1.043661,0.55995 l -4.286628,-1.9543 c -0.435056,-0.19912 -0.941871,-0.1578 -1.339144,0.10884 -0.398125,0.26481 -0.631318,0.71856 -0.613052,1.19613 l 0.164568,4.71724 c -0.304989,0.24381 -0.607311,0.49299 -0.905907,0.74502 l -4.594206,-1.08257 c -0.465917,-0.10905 -0.95513,0.0301 -1.293927,0.36804 -0.339015,0.33816 -0.478365,0.82799 -0.368041,1.29393 l 1.08204,4.59473 c -0.251726,0.29806 -0.499132,0.59922 -0.742917,0.90381 l -4.717236,-0.16404 c -1.02634,-0.0375 -1.732503,1.01944 -1.304969,1.95324 l 1.953773,4.28715 c -0.191479,0.34526 -0.377749,0.69314 -0.559422,1.04366 l -4.647836,0.75607 c -1.012514,0.16547 -1.497846,1.33767 -0.898546,2.17038 l 2.749268,3.81869 c -0.119625,0.37713 -0.235333,0.75609 -0.344906,1.13778 l -4.409134,1.64829 c -0.96328,0.35762 -1.210983,1.60542 -0.457422,2.30395 l 3.449071,3.21615 c -0.04295,0.38808 -0.08122,0.77887 -0.114092,1.16879 l -4.012175,2.48375 c -0.873931,0.53858 -0.873931,1.80901 0,2.34758 l 4.012175,2.48375 c 0.03285,0.39083 0.07119,0.78071 0.114092,1.1688 l -3.449071,3.2172 c -0.750129,0.69932 -0.503044,1.94338 0.457422,2.30289 l 4.409134,1.6483 c 0.109573,0.38169 0.225281,0.76064 0.344906,1.13777 l -2.749268,3.81974 c -0.60085,0.8326 -0.114626,2.00608 0.899073,2.16934 l 4.647309,0.75606 c 0.181713,0.35247 0.367656,0.69968 0.559422,1.04577 l -1.953773,4.28557 c -0.19892,0.4354 -0.158144,0.94253 0.10831,1.3402 0.266633,0.39905 0.720914,0.63222 1.196659,0.61305 l 4.715133,-0.16562 c 0.245631,0.30682 0.492996,0.60731 0.74502,0.90591 l -1.08204,4.59578 c -0.109575,0.46571 0.02836,0.95253 0.368041,1.2913 0.336945,0.3406 0.827313,0.47657 1.293927,0.36699 l 4.594206,-1.08204 c 0.298596,0.25385 0.600918,0.50054 0.905907,0.74344 l -0.164568,4.71829 c -0.03755,1.02589 1.018923,1.73155 1.952196,1.30391 l 4.286628,-1.95324 c 0.345168,0.19176 0.692104,0.37823 1.043661,0.55995 l 0.757638,4.64573 c 0.166314,1.01173 1.337308,1.4976 2.170916,0.90065 l 3.818691,-2.75137 c 0.377649,0.12059 0.756941,0.23583 1.137773,0.34596 l 1.648299,4.40703 c 0.167106,0.44744 0.553936,0.77884 1.024207,0.87015 0.468944,0.0946 0.953605,-0.0618 1.27868,-0.41273 l 3.216679,-3.44907 c 0.388082,0.0448 0.779022,0.082 1.169845,0.11672 l 2.483752,4.0127 c 0.540408,0.87064 1.80717,0.87064 2.347576,0 l 2.483754,-4.0127 c 0.390103,-0.0339 0.779712,-0.0727 1.168792,-0.11672 l 3.216155,3.44907 c 0.325994,0.35065 0.810237,0.5077 1.278681,0.41273 0.46952,-0.0924 0.857095,-0.42176 1.024206,-0.87015 l 1.648297,-4.40703 c 0.380836,-0.11013 0.760122,-0.22537 1.137775,-0.34596 l 3.819741,2.75137 c 0.833193,0.59842 2.005186,0.11187 2.169866,-0.90065 l 0.757638,-4.64573 c 0.350647,-0.18172 0.697578,-0.37093 1.043659,-0.55995 l 4.286629,1.95324 c 0.933269,0.42764 1.989752,-0.27802 1.952194,-1.30391 l -0.164564,-4.71829 c 0.304987,-0.24381 0.607165,-0.48959 0.904854,-0.74344 l 4.594205,1.08204 c 0.465525,0.11132 0.955287,-0.0277 1.292878,-0.36699 0.339686,-0.33877 0.477615,-0.82559 0.368039,-1.2913 l -1.082041,-4.59578 c 0.252033,-0.2986 0.500548,-0.59909 0.743443,-0.90591 l 4.7172384,0.16562 c 0.478224,0.0179 0.931273,-0.21447 1.196134,-0.61305 0.266642,-0.39813 0.307764,-0.90463 0.107783,-1.3402 l -1.9532474,-4.28557 c 0.190851,-0.34609 0.3780964,-0.6933 0.5588964,-1.04577 l 4.647836,-0.75606 c 1.013312,-0.16383 1.499326,-1.33705 0.898546,-2.16934 l -2.749267,-3.81974 c 0.118709,-0.37713 0.234418,-0.75608 0.344903,-1.13777 l 4.408078,-1.6483 c 0.44836,-0.16802 0.77884,-0.55447 0.87016,-1.02473 0.0946,-0.46895 -0.0618,-0.95308 -0.41273,-1.27816 l -3.448021,-3.2172 c 0.04199,-0.38809 0.08032,-0.77889 0.114093,-1.1688 l 4.01216799,-2.48375 c 0.8741,-0.53832 0.87484,-1.80875 0.001,-2.34758 l -4.01213799,-2.48375 c -0.03387,-0.39 -0.07184,-0.77961 -0.114091,-1.16879 l 3.448009,-3.21615 c 0.35066,-0.32691 0.5077,-0.81077 0.41273,-1.27921 -0.092,-0.46968 -0.42207,-0.85792 -0.87067,-1.02474 l -4.407535,-1.64829 c -0.110657,-0.38058 -0.225457,-0.75986 -0.344907,-1.13778 l 2.749267,-3.81869 c 0.600547,-0.83256 0.114748,-2.0059 -0.898546,-2.17038 l -4.647831,-0.75607 c -0.181012,-0.3507 -0.3673714,-0.69858 -0.5589014,-1.04366 l 1.9532484,-4.28715 c 0.199913,-0.43512 0.159067,-0.94312 -0.107783,-1.34072 -0.264738,-0.39872 -0.717867,-0.63067 -1.196134,-0.61252 l -4.7172354,0.16404 c -0.243628,-0.30522 -0.491926,-0.60639 -0.74502,-0.90381 l 1.083618,-4.59473 c 0.236725,-0.99931 -0.661477,-1.89814 -1.660917,-1.66197 l -4.594206,1.08257 c -0.298259,-0.25283 -0.600301,-0.50112 -0.905906,-0.74502 l 0.165617,-4.71724 c 0.03827,-1.02629 -1.018551,-1.73281 -1.952195,-1.30497 l -4.286628,1.9543 c -0.345675,-0.19072 -0.693541,-0.37751 -1.043659,-0.55995 l -0.757641,-4.64888 c -0.165799,-1.01176 -1.337281,-1.49631 -2.169864,-0.89802 l -3.82132,2.74927 c -0.377007,-0.12011 -0.755943,-0.235 -1.136195,-0.34439 l -1.6483,-4.4086 c -0.356181,-0.96399 -1.604138,-1.21312 -2.302884,-0.45953 l -3.216156,3.45118 c -0.38808,-0.0429 -0.778877,-0.0821 -1.168794,-0.1141 l -2.483751,-4.01322 c -0.269898,-0.43587 -0.721553,-0.65407 -1.173525,-0.65407 z m -0.0031,13.03865 a 34.748302,34.748302 0 0 1 34.74829,34.74834 34.748302,34.748302 0 0 1 -34.748345,34.74835 34.748302,34.748302 0 0 1 -34.748345,-34.74835 34.748302,34.748302 0 0 1 34.748345,-34.74834 z" />
+    <path
+       fill="#ffffff"
+       d="m -24.36435,147.44117 c 0.990626,-6.62181 -4.051155,-10.18154 -10.945113,-12.55625 l 2.236298,-8.97007 -5.460114,-1.36075 -2.177205,8.73369 c -1.435396,-0.35769 -2.909674,-0.69515 -4.374623,-1.02951 l 2.192757,-8.79123 -5.457006,-1.36075 -2.237856,8.96696 c -1.188131,-0.27059 -2.35449,-0.53808 -3.486633,-0.81956 l 0.0062,-0.028 -7.530013,-1.88017 -1.452507,5.83179 c 0,0 4.051153,0.92843 3.965622,0.98597 2.211415,0.55207 2.611089,2.01547 2.544218,3.1756 l -2.547329,10.21886 c 0.152404,0.0389 0.349907,0.0949 0.567631,0.18195 -0.181953,-0.0451 -0.376349,-0.0949 -0.576962,-0.14307 l -3.570613,14.31511 c -0.270595,0.67182 -0.956414,1.67956 -2.50223,1.29699 0.05443,0.0793 -3.968729,-0.99063 -3.968729,-0.99063 l -2.710618,6.25013 7.10546,1.77131 c 1.321873,0.33125 2.617308,0.67805 3.892526,1.00463 l -2.259624,9.07272 5.453893,1.36075 2.237853,-8.9763 c 1.48983,0.40434 2.936116,0.77757 4.351298,1.12903 l -2.230078,8.93431 5.460117,1.36076 2.259625,-9.05562 c 9.310656,1.76199 16.311916,1.05128 19.258918,-7.36983 2.374708,-6.78043 -0.118191,-10.69162 -5.016898,-13.24206 3.567503,-0.82267 6.254792,-3.16939 6.971715,-8.01677 z M -36.839727,164.935 c -1.68733,6.78043 -13.103653,3.11495 -16.804899,2.19586 l 2.998318,-12.01972 c 3.701248,0.92376 15.570116,2.75261 13.806581,9.82386 z m 1.688891,-17.59181 c -1.539595,6.16771 -11.041533,3.03409 -14.123831,2.26585 l 2.718393,-10.90157 c 3.082299,0.76824 13.008792,2.20208 11.405438,8.63572 z"
+       id="path9472-6"
+       style="display:block;stroke-width:1.55515" />
+    <path
+       d="m -81.724947,171.87513 c -4.549189,6.195 13.227176,22.50327 13.218894,9.16211 -0.0083,-13.34117 -0.09309,-6.77007 -0.09309,-6.77007 -0.01801,-1.42379 -1.187953,-2.56279 -2.611719,-2.54264 l -5.977454,0.0854 m 2.846657,8.65386 c -1.561723,0.0224 -2.84541,-1.22644 -2.865913,-2.78819 -0.02268,-1.56262 1.224352,-2.84843 2.786932,-2.8736 3.68884,0.0344 3.765425,5.52446 0.07898,5.66179 z"
+       id="path6835-7"
+       style="fill:#f5680f;fill-opacity:1;stroke-width:0.909418"
+       inkscape:export-filename="/home/hunter/omoc-rust.png"
+       inkscape:export-xdpi="96"
+       inkscape:export-ydpi="96"
+       sodipodi:nodetypes="czccccccc" />
+    <path
+       d="m -70.798384,128.22041 c -7.297572,-2.41217 -17.31446,19.53368 -4.628822,15.40316 12.685642,-4.13054 6.409953,-2.1806 6.409953,-2.1806 1.348539,-0.4571 2.07026,-1.92176 1.611129,-3.26961 l -1.928355,-5.65851 m -7.350645,5.38152 c -0.503903,-1.47836 0.287134,-3.08513 1.76611,-3.58724 1.479132,-0.50445 3.087364,0.28421 3.594166,1.76254 1.107198,3.51892 -4.090494,5.28828 -5.360276,1.8247 z"
+       id="path11910-5"
+       style="fill:#f5680f;fill-opacity:1;stroke-width:0.909418"
+       inkscape:export-filename="/home/hunter/omoc-rust.png"
+       inkscape:export-xdpi="96"
+       inkscape:export-ydpi="96"
+       sodipodi:nodetypes="czccccccc" />
+    <path
+       d="m -31.705762,118.47996 c 0.503169,-7.66942 -23.254431,-11.85693 -16.071905,-0.61425 7.182547,11.24268 3.719761,5.65738 3.719761,5.65738 0.780969,1.19062 2.379889,1.52159 3.569344,0.73883 l 4.993304,-3.28697 m -7.054326,-5.76448 c 1.304548,-0.85886 3.058437,-0.49646 3.915709,0.80913 0.859575,1.30515 0.499849,3.05986 -0.803931,3.92151 -3.128344,1.95504 -6.145737,-2.63211 -3.111778,-4.73064 z"
+       id="path11912-3"
+       style="fill:#f5680f;fill-opacity:1;stroke-width:0.909418"
+       inkscape:export-filename="/home/hunter/omoc-rust.png"
+       inkscape:export-xdpi="96"
+       inkscape:export-ydpi="96"
+       sodipodi:nodetypes="czccccccc" />
+    <path
+       d="m -10.459353,158.37052 c 7.3216904,-2.33795 2.5260804,-25.98027 -5.30895,-15.18217 -7.83528,10.79793 -3.90403,5.53182 -3.90403,5.53182 -0.82233,1.16245 -0.5453,2.77161 0.6184,3.59217 l 4.88605,3.44437 m 2.78363,-8.67434 c 1.27662,0.89983 1.5810904,2.6647 0.67971,3.94023 -0.90012,1.27754 -2.66479,1.58478 -3.94374,0.68668 -2.96411,-2.19608 0.2009,-6.68265 3.26401,-4.62692 z"
+       id="path11914-5"
+       style="fill:#f5680f;fill-opacity:1;stroke-width:0.909418"
+       inkscape:export-filename="/home/hunter/omoc-rust.png"
+       inkscape:export-xdpi="96"
+       inkscape:export-ydpi="96"
+       sodipodi:nodetypes="czccccccc" />
+    <path
+       d="m -41.644288,190.1789 c 3.716687,6.72751 25.975686,-2.57281 13.86043,-8.15916 -12.115267,-5.58634 -6.185242,-2.75414 -6.185242,-2.75414 -1.30014,-0.58063 -2.824732,0.004 -3.403416,1.30494 l -2.428782,5.46244 m 9.049998,1.04418 c -0.634485,1.4272 -2.306488,2.06897 -3.732921,1.43275 -1.428133,-0.63461 -2.072583,-2.30586 -1.440254,-3.735 1.577939,-3.3345 6.594204,-1.10207 5.173175,2.30225 z"
+       id="path11916-6"
+       style="fill:#f5680f;fill-opacity:1;stroke-width:0.909418"
+       inkscape:export-filename="/home/hunter/omoc-rust.png"
+       inkscape:export-xdpi="96"
+       inkscape:export-ydpi="96"
+       sodipodi:nodetypes="czccccccc" />
+    <path
+       id="path75-2"
+       clip-path="none"
+       style="fill:#f7931a;fill-opacity:1;stroke-width:0.913143"
+       d="m -139.12389,-113.79299 c -0.44345,0.0874 -0.84491,0.38908 -1.02543,0.86889 l -1.6612,4.41779 c -0.37728,0.10698 -0.75283,0.22104 -1.1253,0.33817 l -3.82352,-2.76432 c -0.83143,-0.60299 -2.00738,-0.11769 -2.17142,0.8962 l -0.76382,4.64437 c -0.35332,0.1813 -0.70234,0.36822 -1.0494,0.55759 l -4.27992,-1.95857 c -0.93267,-0.42448 -1.9875,0.27669 -1.95629,1.30095 l 0.15565,4.70757 c -0.3089,0.24609 -0.61279,0.49666 -0.91544,0.75084 l -4.58346,-1.08816 c -0.46536,-0.11125 -0.95498,0.027 -1.2932,0.36547 -0.33941,0.33679 -0.48026,0.827209 -0.36998,1.292246 l 1.07331,4.596225 c -0.25209,0.298192 -0.50047,0.601261 -0.7447,0.906274 l -4.71667,-0.173882 c -0.47821,-0.0169 -0.93136,0.214126 -1.19841,0.611201 -0.26724,0.39732 -0.30912,0.904882 -0.1108,1.340704 l 1.95009,4.298602 c -0.18932,0.341114 -0.37401,0.684471 -0.55431,1.03045 l -4.65968,0.751373 c -1.01421,0.161663 -1.50303,1.335391 -0.903,2.1689 l 2.74597,3.828365 c -0.1211,0.375771 -0.23641,0.752735 -0.3468,1.13179 l -4.41378,1.640962 c -0.96141,0.358139 -1.21103,1.602101 -0.46202,2.303213 l 3.43563,3.214723 c -0.0444,0.393154 -0.0845,0.787419 -0.11815,1.183093 l -4.00758,2.470004 c -0.87595,0.537124 -0.87767,1.809047 -0.003,2.348687 l 4.00622,2.488657 c 0.0329,0.389071 0.0708,0.779517 0.11388,1.168443 l -3.45611,3.212996 c -0.75331,0.697392 -0.5082,1.9433 0.45384,2.302855 l 4.41677,1.661402 c 0.10777,0.37711 0.22094,0.752319 0.33807,1.124776 l -2.76229,3.823132 c -0.60075,0.83116 -0.11779,2.004316 0.89407,2.171323 l 4.64497,0.764221 c 0.18131,0.35331 0.36793,0.702916 0.55821,1.049798 l -1.95867,4.279415 c -0.42853,0.933059 0.27554,1.990396 1.30167,1.954563 l 4.70574,-0.156836 c 0.24644,0.310684 0.49566,0.615098 0.75074,0.917575 l -1.08837,4.582449 c -0.11092,0.465657 0.0274,0.955563 0.36568,1.294208 0.33875,0.339962 0.82969,0.480693 1.29275,0.369892 l 4.59399,-1.073928 c 0.30032,0.253523 0.60128,0.500471 0.90628,0.744696 l -0.17309,4.718096 c -0.0174,0.478104 0.21198,0.929173 0.6107,1.195877 0.39646,0.269024 0.90389,0.307513 1.34051,0.109774 l 4.2981,-1.949987 c 0.34205,0.19132 0.68638,0.375085 1.03257,0.554422 l 0.75107,4.660791 c 0.16148,1.013804 1.33472,1.50222 2.1677,0.902193 l 3.82794,-2.745357 c 0.37574,0.1214 0.75182,0.23705 1.13188,0.347345 l 1.64158,4.411552 c 0.35881,0.960475 1.60168,1.210824 2.30414,0.463947 l 3.21483,-3.437755 c 0.3938,0.0453 0.78834,0.08476 1.18327,0.119162 l 2.4691,4.005652 c 0.25047,0.406682 0.69402,0.656595 1.17306,0.655254 0.4784,0.0022 0.92405,-0.24468 1.17512,-0.651902 l 2.48867,-4.006218 c 0.38941,-0.03111 0.78029,-0.0701 1.17046,-0.111644 l 3.21309,3.456622 c 0.69856,0.749716 1.94098,0.504897 2.30284,-0.453846 l 1.66132,-4.417273 c 0.37619,-0.108666 0.75107,-0.222129 1.12428,-0.340609 l 3.82212,2.762486 c 0.38763,0.280996 0.89334,0.34104 1.33459,0.15729 0.44279,-0.181416 0.75947,-0.579105 0.83672,-1.051345 l 0.76462,-4.642956 c 0.35236,-0.181682 0.70239,-0.367885 1.04959,-0.55922 l 4.27982,1.960704 c 0.93319,0.426024 1.98901,-0.278046 1.95477,-1.303292 l -0.15506,-4.704523 c 0.3089,-0.246083 0.61244,-0.498462 0.91544,-0.750835 l 4.58337,1.087649 c 0.998345,0.239106 1.8985,-0.657935 1.66328,-1.657204 l -1.073517,-4.597241 c 0.252091,-0.298183 0.501008,-0.597928 0.743995,-0.904553 l 4.716567,0.173374 c 0.47827,0.01921 0.931994,-0.211799 1.197604,-0.609986 0.267764,-0.398059 0.308838,-0.902438 0.111281,-1.338165 l -1.950287,-4.299622 c 0.189541,-0.341688 0.375443,-0.684587 0.554424,-1.032572 l 4.659982,-0.749851 c 0.472657,-0.07491 0.872434,-0.390362 1.055226,-0.832634 0.184627,-0.442174 0.126681,-0.947294 -0.153747,-1.335975 l -2.74465,-3.827036 c 0.120332,-0.376461 0.236703,-0.752929 0.345936,-1.133706 l 4.413878,-1.640462 c 0.96252,-0.356665 1.212593,-1.601779 0.462228,-2.302196 l -3.435931,-3.216242 c 0.04354,-0.392967 0.08356,-0.787233 0.118146,-1.183092 l 4.006668,-2.469296 c 0.407411,-0.251544 0.656486,-0.694526 0.655152,-1.173569 0.0021,-0.478392 -0.244591,-0.923535 -0.651806,-1.174614 l -4.005297,-2.489371 c -0.03383,-0.388877 -0.07175,-0.779854 -0.113982,-1.168941 l 3.456115,-3.212996 c 0.753513,-0.697188 0.508727,-1.943352 -0.452866,-2.303048 l -4.416765,-1.661402 c -0.108673,-0.376095 -0.221215,-0.750612 -0.33797,-1.124277 l 2.761365,-3.82242 c 0.280831,-0.388545 0.340947,-0.893855 0.157191,-1.335101 -0.181082,-0.443026 -0.579464,-0.759702 -1.051852,-0.836621 l -4.643562,-0.765034 c -0.182162,-0.351999 -0.367934,-0.702106 -0.558205,-1.049797 l 1.958971,-4.277892 c 0.428232,-0.932974 -0.275392,-1.990228 -1.301363,-1.955687 l -4.706346,0.156432 c -0.245414,-0.309077 -0.495186,-0.614122 -0.749828,-0.915638 l 1.087557,-4.583886 c 0.111945,-0.465559 -0.02657,-0.95631 -0.365261,-1.29481 -0.336845,-0.33999 -0.826414,-0.47977 -1.292154,-0.36944 l -4.596337,1.072808 c -0.29805,-0.252358 -0.60004,-0.499808 -0.90586,-0.742668 l 0.17479,-4.71739 c 0.039,-1.02622 -1.01598,-1.73437 -1.95088,-1.3094 l -4.298,1.9505 c -0.34153,-0.19037 -0.68589,-0.37573 -1.03289,-0.55595 l -0.74985,-4.65997 c -0.16087,-1.01433 -1.3345,-1.50299 -2.16779,-0.9027 l -3.82785,2.74586 c -0.37605,-0.12024 -0.75307,-0.23609 -1.13188,-0.34733 l -1.64218,-4.41461 c -0.35829,-0.96059 -1.60143,-1.20959 -2.3026,-0.4616 l -3.21779,3.43622 c -0.39312,-0.0449 -0.78724,-0.0841 -1.18147,-0.11793 l -2.46939,-4.00717 c -0.53587,-0.87693 -1.80875,-0.87987 -2.34859,-0.005 l -2.48775,4.00814 c -0.38905,0.033 -0.78021,0.07 -1.16894,0.11399 l -3.21321,-3.45713 c -0.34908,-0.37544 -0.83397,-0.50245 -1.27743,-0.415 z m 8.68019,7.94326 c 0.92077,-0.19258 1.9161,0.0678 2.62156,0.77848 1.10342,1.10855 1.08527,2.89468 -0.0407,3.992 -2.72338,2.523017 -6.59761,-1.37385 -3.99545,-4.01874 0.40512,-0.39343 0.89805,-0.64376 1.41459,-0.75177 z m -6.1626,4.84985 5e-4,-10e-5 c 0.19052,-0.0365 0.38141,-0.0711 0.57265,-0.10369 0.002,0.003 0.007,0.006 0.009,0.009 1.39869,1.373203 2.43601,2.435573 3.12486,3.155882 0.002,0.0018 0.007,0.006 0.007,0.0076 0.006,0.0069 0.0114,0.01181 0.0172,0.0182 0.66763,0.698959 1.01205,1.080959 1.01205,1.080959 0.12336,0.125885 0.25671,0.236332 0.39716,0.331511 8.5e-4,7.03e-4 0.003,0.0016 0.004,0.0031 8.5e-4,7.03e-4 0.003,0.0016 0.003,0.0024 0.14091,0.09472 0.28869,0.173983 0.44191,0.237881 0.15453,0.06443 0.31434,0.113232 0.47652,0.146263 0.15992,0.03256 0.32208,0.04945 0.4847,0.05143 0.005,2e-5 0.009,2.66e-4 0.0142,2.23e-4 0.1625,0.0011 0.32539,-0.01258 0.48576,-0.04202 0.1626,-0.03 0.32307,-0.07559 0.47864,-0.137033 l 5.1e-4,-1.03e-4 c 0.15559,-0.06144 0.30626,-0.138938 0.44993,-0.231936 l 5.1e-4,-1.01e-4 c 0.14381,-0.09306 0.28006,-0.201962 0.40701,-0.326707 l 4.26375,-4.190142 0.13287,-0.13046 c 10.25061,1.818206 19.12288,7.66397 24.215355,16.744033 -0.203648,0.4934 -0.402765,0.923878 -0.580225,1.342624 -2.66158,5.981052 -2.76081,6.182468 -2.76081,6.182468 -0.0727,0.162451 -0.12741,0.328226 -0.16468,0.495426 -0.0368,0.167296 -0.057,0.335916 -0.0603,0.503326 -0.003,0.16739 0.01,0.333476 0.0383,0.4965 0.029,0.162914 0.0728,0.322994 0.13143,0.477099 0.059,0.154076 0.13256,0.302266 0.21999,0.442799 0.0874,0.140531 0.18862,0.272954 0.30284,0.395388 0.22842,0.244861 0.50883,0.449087 0.83392,0.5941 l 5.459782,2.434477 0.845392,0.376948 c 1.107268,10.265042 -2.407605,20.490879 -9.591904,27.905909 -0.002,-3.82e-4 -0.004,-0.0011 -0.006,-0.0015 -2.31192,-0.468705 -3.81804,-0.815228 -4.75497,-1.046989 -0.0276,-0.0069 -0.0466,-0.01213 -0.0733,-0.0188 -0.85843,-0.214435 -1.24228,-0.332954 -1.24228,-0.332954 -0.17348,-0.03986 -0.34665,-0.06088 -0.5179,-0.0649 -0.17124,-0.004 -0.34065,0.0088 -0.50553,0.03796 -0.16483,0.02942 -0.3254,0.07432 -0.47973,0.13409 -0.1537,0.05943 -0.30081,0.133792 -0.43996,0.221012 -0.002,8.37e-4 -0.004,0.0017 -0.005,0.0028 -0.13868,0.08726 -0.26905,0.187682 -0.38911,0.30001 -0.12086,0.1131 -0.23131,0.238223 -0.32922,0.374057 -0.0969,0.134462 -0.18117,0.279843 -0.25153,0.434068 -9.1e-4,0.0033 -0.003,0.0066 -0.004,0.01011 -0.0697,0.154516 -0.12565,0.317989 -0.1647,0.489655 l -1.32668,5.829261 -0.26476,1.163515 c -2.39569,1.074214 -4.90539,1.873452 -7.48107,2.382413 -7.23006,1.41614 -14.72312,0.497665 -21.39706,-2.622839 -1e-4,-7.85e-4 -4.4e-4,-0.002 -2.8e-4,-0.0029 -0.0114,-0.08464 -0.0256,-0.171156 -0.0442,-0.26043 l -1.40033,-6.62438 c -0.0363,-0.174232 -0.0899,-0.340506 -0.15811,-0.497649 -0.0678,-0.156436 -0.15033,-0.303512 -0.24535,-0.440434 -5.1e-4,-7.12e-4 -5.8e-4,-0.0017 -0.001,-0.0028 -5.6e-4,-9.04e-4 -0.002,-0.0018 -0.002,-0.0025 -0.0952,-0.136352 -0.20268,-0.262818 -0.3208,-0.377104 -0.119,-0.115065 -0.24859,-0.218232 -0.3868,-0.308269 -0.13819,-0.09003 -0.28474,-0.166846 -0.43808,-0.229153 -0.15333,-0.06232 -0.31338,-0.109887 -0.47775,-0.141811 -0.16436,-0.03192 -0.33308,-0.04817 -0.50436,-0.04702 -0.17131,0.0011 -0.34515,0.01964 -0.51927,0.05647 l -5.84811,1.239492 -0.18043,0.03861 c -4.52366,-4.762243 -7.60487,-10.709392 -8.88641,-17.151552 -0.68623,-3.538886 -0.81766,-7.162989 -0.38953,-10.742277 0.0108,-0.0053 0.005,-0.0019 0.016,-0.0072 4.15329,-1.980307 4.85506,-2.283534 6.03817,-2.83806 0.14935,-0.07 0.29019,-0.155955 0.4211,-0.255222 0.2618,-0.19864 0.48364,-0.450703 0.65503,-0.735867 0.0857,-0.142573 0.15893,-0.293539 0.21789,-0.450056 0.059,-0.156527 0.1038,-0.318622 0.13352,-0.483878 0.0293,-0.165355 0.0434,-0.333532 0.0405,-0.502571 -0.003,-0.169065 -0.0224,-0.338795 -0.0603,-0.506406 -0.0381,-0.16757 -0.0943,-0.333183 -0.17007,-0.494242 l -2.54605,-5.408769 -0.58623,-1.245471 c 4.97244,-8.899694 13.60223,-15.166851 23.60374,-17.141583 z m -27.71825,20.699241 c 1.16881,-0.23341 2.40516,0.274761 3.03244,1.348013 1.77548,3.225236 -3.0343,5.970929 -4.96024,2.831565 -0.78431,-1.347412 -0.31016,-3.073545 1.05875,-3.85345 0.27799,-0.158894 0.57112,-0.266586 0.86905,-0.326126 z m 67.782423,0.08974 c 0.515747,-0.103687 1.094937,-0.057 1.711583,0.196758 1.438572,0.6307 2.080744,2.297494 1.433328,3.721004 -0.645774,1.425225 -2.335706,2.070133 -3.776255,1.441576 -2.756826,-1.286942 -1.723357,-4.886752 0.631344,-5.359338 z m -55.414503,39.61809 c 3.66228,-0.686803 4.79615,4.667401 1.16936,5.521684 -1.54335,0.326891 -3.05582,-0.64366 -3.37715,-2.167041 -0.32365,-1.523814 0.66416,-3.024848 2.20781,-3.354645 z m 42.17797,0.149579 c 1.80124,-0.372707 3.95804,0.959427 3.4645,3.326487 -0.3537,1.519715 -1.88726,2.474143 -3.42348,2.130515 -1.53759,-0.341726 -2.49836,-1.850552 -2.14718,-3.37174 0.31662,-1.226945 1.16264,-1.890036 2.10616,-2.085262 z" />
+    <path
+       fill="#ffffff"
+       d="m -106.20282,-74.830666 c 1.08468,-7.250477 -4.43576,-11.148165 -11.98424,-13.748316 l 3.84651,-15.348598 -6.0236,-1.48989 -3.73669,15.089717 c -1.57166,-0.391637 -3.1859,-0.761146 -4.78995,-1.127239 l 1.75732,-7.09216 -6.10145,-1.108086 -1.68033,6.902721 c -1.30093,-0.29629 -2.57802,-0.589163 -3.81766,-0.897378 l 0.007,-0.03066 -8.2449,-2.058671 -1.5904,6.385465 c 0,0 4.43576,1.016562 4.34211,1.079566 2.42136,0.604494 2.85898,2.206816 2.78577,3.477088 l -2.78918,11.189027 c 0.16688,0.04258 0.38312,0.103906 0.62152,0.199235 -0.19923,-0.04938 -0.41208,-0.103918 -0.63173,-0.156665 l -3.9096,15.674171 c -0.29629,0.735614 -1.04724,1.839016 -2.7398,1.420136 0.0596,0.08683 -4.34551,-1.084679 -4.34551,-1.084679 l -2.96797,6.84351 7.78004,1.939476 c 1.44737,0.362687 2.86581,0.742413 4.26209,1.099999 l -2.2021,8.790052 4.33512,8.083678 3.81482,-15.27822 c 1.63127,0.442729 3.21487,0.851393 4.76441,1.236231 l -3.73248,15.233272 5.9021,1.579479 3.84122,-15.455629 c 10.19461,1.929261 17.86055,1.151088 21.08734,-8.069514 2.60017,-7.424168 -0.12941,-11.706681 -5.4932,-14.499257 3.9062,-0.900773 6.8486,-3.470278 7.63361,-8.777874 z m -13.65978,19.154674 c -1.84751,7.424157 -14.34769,3.41068 -18.40034,2.404334 l 3.28299,-13.160848 c 4.05264,1.011449 17.04831,3.013927 15.11735,10.756514 z m 1.84924,-19.261945 c -1.68576,6.753254 -12.0898,3.322132 -15.46473,2.480957 l 2.97647,-11.936555 c 3.37492,0.841177 14.24382,2.411155 12.48826,9.455598 z"
+       id="path9472-9"
+       style="display:block;stroke-width:1.7028"
+       sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccc" />
+    <path
+       fill="#ffffff"
+       d="m -192.31893,43.08125 c 0.99062,-6.621808 -4.05116,-10.181536 -10.94512,-12.556241 l 3.53066,-14.050071 -5.49557,-1.388202 -3.43611,13.841138 c -1.43539,-0.357685 -2.90967,-0.695149 -4.37462,-1.029506 l 2.71789,-10.844758 -4.34101,-6.005463 -3.87899,15.665201 c -1.18813,-0.270597 -2.35449,-0.53808 -3.48663,-0.819563 l 0.006,-0.028 -7.53001,-1.880172 -1.45251,5.831795 c 0,0 4.05115,0.928422 3.96562,0.985963 2.21142,0.552077 2.61109,2.01547 2.54422,3.175605 l -2.54733,10.21886 c 0.15241,0.03888 0.34991,0.09487 0.56763,0.181954 -0.18195,-0.0451 -0.37635,-0.09487 -0.57696,-0.143076 l -3.57061,14.315111 c -0.2706,0.67182 -0.95642,1.67956 -2.50223,1.29699 0.0544,0.0793 -3.96873,-0.99063 -3.96873,-0.99063 l -2.71062,6.25013 7.10546,1.77131 c 1.32187,0.33125 2.61731,0.678051 3.89253,1.004631 l -3.52921,14.12699 5.49481,1.13355 3.46652,-13.80337 c 1.48983,0.40434 2.93612,0.77757 4.3513,1.12903 l -3.69054,14.76015 5.65644,0.50026 3.52376,-14.02096 c 9.31066,1.76199 16.31192,1.05128 19.25892,-7.369831 2.37471,-6.78043 -0.11819,-10.691621 -5.0169,-13.242059 3.5675,-0.822674 6.25479,-3.169388 6.97172,-8.016772 z m -12.47538,17.493825 c -1.68733,6.78044 -13.10365,3.11496 -16.8049,2.19587 l 2.99832,-12.019717 c 3.70125,0.923755 15.57011,2.752606 13.80658,9.823847 z m 1.68889,-17.591797 c -1.53959,6.167703 -11.04153,3.034086 -14.12383,2.265845 l 2.71839,-10.901567 c 3.0823,0.768239 13.00879,2.202083 11.40544,8.635722 z"
+       id="path9472-9-2"
+       style="display:block;stroke-width:1.55515"
+       sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccc" />
+    <g
+       id="g386"
+       transform="translate(-0.56516517,-4.8764483)">
+      <path
+         id="path75"
+         clip-path="none"
+         style="fill:#f7931a;fill-opacity:1;stroke-width:0.913143"
+         d="m -21.137019,-210.57938 c -0.45197,0 -0.90419,0.21835 -1.17408,0.65422 l -2.48409,4.01319 c -0.39083,0.032 -0.78135,0.0713 -1.16944,0.11421 l -3.21685,-3.45147 c -0.69914,-0.75238 -1.94674,-0.50362 -2.30374,0.4594 l -1.64745,4.40904 c -0.38169,0.10957 -0.76026,0.22545 -1.1374,0.34416 l -3.82043,-2.74919 c -0.833,-0.59682 -2.0035,-0.11282 -2.17093,0.89814 l -0.75758,4.64881 c -0.35065,0.18172 -0.69726,0.36881 -1.04334,0.55966 l -4.286563,-1.95389 c -0.435056,-0.19912 -0.94218,-0.15812 -1.339453,0.10852 -0.398125,0.26482 -0.631149,0.71874 -0.612883,1.19631 l 0.164331,4.71703 c -0.304989,0.24381 -0.607291,0.49314 -0.905887,0.74517 l -4.594035,-1.08262 c -0.465917,-0.10905 -0.955181,0.03 -1.293978,0.36794 -0.339015,0.33815 -0.47826,0.82803 -0.367936,1.29397 l 1.082104,4.59455 c -0.251723,0.29806 -0.499322,0.59924 -0.743107,0.90383 l -4.717025,-0.16382 c -1.02634,-0.0375 -1.73288,1.01957 -1.305346,1.95337 l 1.953886,4.28708 c -0.191479,0.34526 -0.377466,0.69283 -0.559139,1.04334 l -4.647779,0.75655 c -1.012514,0.16547 -1.497953,1.33769 -0.898653,2.17041 l 2.749186,3.81837 c -0.119625,0.37713 -0.235108,0.75623 -0.344682,1.13791 l -4.409549,1.64848 c -0.963281,0.35761 -1.210897,1.60521 -0.457337,2.30374 l 3.449402,3.21634 c -0.04295,0.38808 -0.08133,0.77849 -0.114205,1.1684 l -4.012158,2.48409 c -0.873931,0.53857 -0.873931,1.80857 0,2.34714 l 4.012158,2.48409 c 0.03285,0.39082 0.07131,0.78083 0.114205,1.16892 l -3.449402,3.21686 c -0.750129,0.69931 -0.503129,1.94371 0.457337,2.30322 l 4.409549,1.64796 c 0.109574,0.38169 0.225057,0.76078 0.344682,1.13791 l -2.749186,3.81992 c -0.600851,0.8326 -0.114529,2.00612 0.89917,2.16938 l 4.647262,0.75603 c 0.181713,0.35247 0.367373,0.69933 0.559139,1.04541 l -1.953886,4.28553 c -0.19892,0.4354 -0.157934,0.94281 0.10852,1.34048 0.266633,0.39905 0.721081,0.63206 1.196826,0.61289 l 4.714958,-0.16537 c 0.245631,0.30682 0.493153,0.60729 0.745174,0.90589 l -1.082104,4.59558 c -0.109575,0.46571 0.02826,0.95263 0.367936,1.2914 0.336945,0.3406 0.827364,0.47648 1.293978,0.3669 l 4.594035,-1.0821 c 0.298596,0.25385 0.600898,0.50072 0.905887,0.74362 l -0.164331,4.71806 c -0.03755,1.02589 1.019063,1.73195 1.952336,1.30431 l 4.286563,-1.95336 c 0.34516,0.19176 0.69179,0.37794 1.04334,0.55965 l 0.75758,4.64571 c 0.16631,1.01173 1.33732,1.49768 2.17093,0.90072 l 3.81889,-2.75125 c 0.37762,0.12059 0.75708,0.23559 1.13791,0.34572 l 1.64796,4.40748 c 0.16711,0.44744 0.55396,0.7784 1.02423,0.86971 0.46894,0.0946 0.95392,-0.0614 1.27899,-0.41237 l 3.21634,-3.44941 c 0.38808,0.0448 0.77913,0.0821 1.16996,0.11679 l 2.48408,4.01268 c 0.54041,0.87064 1.80674,0.87064 2.34715,0 l 2.48408,-4.01268 c 0.39011,-0.0339 0.77984,-0.0727 1.16892,-0.11679 l 3.21583,3.44941 c 0.32599,0.35064 0.81055,0.50734 1.27899,0.41237 0.46952,-0.0924 0.85712,-0.42132 1.02423,-0.86971 l 1.6479602,-4.40748 c 0.38083,-0.11013 0.76026,-0.22513 1.13791,-0.34572 l 3.81992,2.75125 c 0.8332,0.59843 2.00525,0.1118 2.1699,-0.90072 l 0.75757,-4.64571 c 0.35064998,-0.18171 0.69726998,-0.37063 1.04334998,-0.55965 l 4.28656002,1.95336 c 0.93327,0.42764 1.9899,-0.27842 1.95234,-1.30431 l -0.16433,-4.71806 c 0.30498,-0.24381 0.60716,-0.48977 0.90485,-0.74362 l 4.5940298,1.0821 c 0.46553,0.11133 0.95536,-0.0276 1.29295,-0.3669 0.33968,-0.33877 0.47751,-0.82569 0.36794,-1.2914 l -1.08211,-4.59558 c 0.25203,-0.2986 0.50073,-0.59907 0.74362,-0.90589 l 4.71703,0.16537 c 0.47822,0.0179 0.93145,-0.2143 1.19631,-0.61289 0.26664,-0.39812 0.30747,-0.90491 0.10749,-1.34048 l -1.95286,-4.28553 c 0.19086,-0.34608 0.37783,-0.69294 0.55863,-1.04541 l 4.64777,-0.75603 c 1.01332,-0.16383 1.49944,-1.33708 0.89866,-2.16938 l -2.74919,-3.81992 c 0.11871,-0.37713 0.2342,-0.75622 0.34468,-1.13791 l 4.40852,-1.64796 c 0.44836,-0.16802 0.77839,-0.55448 0.86971,-1.02475 0.0946,-0.46894 -0.0615,-0.95339 -0.41238,-1.27847 l -3.44836,-3.21686 c 0.042,-0.38809 0.0804,-0.77901 0.1142,-1.16892 l 4.01216,-2.48409 c 0.8741,-0.53832 0.87485,-1.80832 0.001,-2.34714 l -4.01215,-2.48409 c -0.0339,-0.39 -0.072,-0.77921 -0.11421,-1.1684 l 3.44837,-3.21634 c 0.35066,-0.32691 0.50735,-0.81106 0.41238,-1.27951 -0.092,-0.46968 -0.42163,-0.85741 -0.87023,-1.02423 l -4.40801,-1.64848 c -0.11065,-0.38058 -0.22523,-0.76 -0.34468,-1.13791 l 2.74919,-3.81837 c 0.60055,-0.83257 0.11464,-2.00592 -0.89865,-2.17041 l -4.64778,-0.75655 c -0.18101,-0.3507 -0.36709,-0.69827 -0.55862,-1.04334 l 1.95337,-4.28708 c 0.19991,-0.43512 0.15884,-0.9434 -0.10801,-1.341 -0.26474,-0.39873 -0.71804,-0.63052 -1.19631,-0.61237 l -4.71702,0.16382 c -0.24363,-0.30522 -0.49208,-0.60641 -0.74518,-0.90383 l 1.08366,-4.59455 c 0.23672,-0.99931 -0.66144,-1.89808 -1.66088,-1.66191 l -4.5940398,1.08262 c -0.29826,-0.25283 -0.60028,-0.50128 -0.90588,-0.74517 l 0.16536,-4.71703 c 0.0383,-1.02629 -1.01869,-1.73267 -1.95234,-1.30483 l -4.28656002,1.95389 c -0.34567,-0.19072 -0.69323,-0.37722 -1.04333998,-0.55966 l -0.75758,-4.64881 c -0.1658,-1.01175 -1.33731,-1.49642 -2.16989,-0.89814 l -3.82147,2.74919 c -0.37701,-0.1201 -0.75612,-0.23478 -1.13637,-0.34416 l -1.6479602,-4.40904 c -0.35618,-0.96399 -1.60447,-1.21299 -2.30322,-0.4594 l -3.21582,3.45147 c -0.38808,-0.0429 -0.77901,-0.0822 -1.16892,-0.11421 l -2.48409,-4.01319 c -0.2699,-0.43587 -0.72108,-0.65422 -1.17306,-0.65422 z m 6.98046,9.47177 c 0.94063,-0.0109 1.86684,0.437 2.42155,1.27072 0.86823,1.30099 0.50506,3.04991 -0.81183,3.90881 -3.15982,1.9488 -6.20745,-2.62365 -3.14296,-4.71548 0.47354,-0.30766 1.00556,-0.45796 1.53324,-0.46405 z m -6.98407,3.56671 h 5.1e-4 c 0.13007,8.7e-4 0.26011,0.003 0.39016,0.006 l -2.93315,12.20029 c -1.18813,-0.2706 -2.35447,-0.5381 -3.48661,-0.81959 l 0.006,-0.0279 -7.53029,-1.87999 -1.45211,5.83168 c 0,0 4.05118,0.92845 3.96565,0.98599 2.21142,0.55208 2.6109,2.01538 2.54403,3.17552 l -2.54713,10.21901 c 0.15241,0.0389 0.34969,0.0948 0.56741,0.1819 -0.18195,-0.0451 -0.3761,-0.0949 -0.57671,-0.14314 l -3.57084,14.31489 c -0.2706,0.67182 -0.95637,1.67964 -2.50218,1.29707 0.0544,0.0793 -3.96875,-0.99063 -3.96875,-0.99063 l -2.710425,6.25026 7.104995,1.77147 c 1.32187,0.33125 2.61756,0.67801 3.89278,1.00459 l -3.51554,12.00599 c -1.43905,-0.76859 -2.83619,-1.62458 -4.16409,-2.59674 5e-5,-8e-4 -5e-5,-0.002 0,-0.003 0.005,-0.0852 0.008,-0.17287 0.007,-0.26406 l -0.093,-6.77013 c -0.002,-0.17798 -0.0224,-0.35147 -0.0589,-0.51884 -0.0363,-0.1666 -0.0888,-0.32684 -0.15555,-0.47955 -3.7e-4,-8e-4 -6.6e-4,-0.002 -0.001,-0.003 -4e-4,-0.001 -10e-4,-0.002 -0.002,-0.003 -0.067,-0.15218 -0.14804,-0.29705 -0.24185,-0.43202 -0.0945,-0.1359 -0.2017,-0.26218 -0.31987,-0.37723 -0.11818,-0.11506 -0.24712,-0.21876 -0.38551,-0.30955 -0.13839,-0.0908 -0.28623,-0.16841 -0.441317,-0.23151 -0.155091,-0.0631 -0.317474,-0.11166 -0.485759,-0.14366 -0.168284,-0.032 -0.34241,-0.0475 -0.520381,-0.045 l -5.977413,0.0853 -0.184485,0.003 c -3.517456,-5.54707 -5.390566,-11.97776 -5.402254,-18.54615 0.01098,-3.60478 0.582817,-7.18591 1.694987,-10.61485 0.01178,-0.003 0.0053,-0.001 0.01705,-0.004 4.457815,-1.13985 5.204977,-1.30166 6.47299,-1.61696 0.160058,-0.0398 0.314873,-0.0968 0.462504,-0.16898 0.295263,-0.14426 0.561663,-0.34867 0.784965,-0.59531 0.111651,-0.12332 0.212659,-0.25729 0.300757,-0.39946 0.0881,-0.14217 0.163441,-0.29253 0.224276,-0.44907 0.06083,-0.15653 0.10708,-0.31884 0.136942,-0.48524 0.02986,-0.1664 0.04358,-0.33671 0.03876,-0.50849 -0.0048,-0.17179 -0.0281,-0.34514 -0.07131,-0.5178 l -1.452108,-5.79913 -0.334346,-1.33532 c 6.599452,-7.77026 16.278202,-12.25047 26.472802,-12.25403 z m 15.9581902,3.86901 c 8.06501,4.07633 14.27692,10.88901 17.1291898,19.59674 -0.29521,0.44471 -0.57381,0.82857 -0.82889,1.20509 -3.7678498,5.35354 -3.9041498,5.53197 -3.9041498,5.53197 -0.10279,0.1453 -0.1885,0.29738 -0.25735,0.45423 -0.0688,0.15686 -0.12084,0.31857 -0.15658,0.48214 -0.0357,0.16358 -0.0549,0.32907 -0.0584,0.49455 -0.003,0.16547 0.009,0.33098 0.0367,0.4935 0.028,0.16255 0.0716,0.32219 0.13022,0.47698 0.0586,0.15479 0.13227,0.30427 0.22066,0.44648 0.17677,0.28442 0.41239,0.539 0.70332,0.74414 l 4.8859998,3.44424 0.75654,0.5333 c -0.89852,10.28541 -6.3243398,19.63861 -14.8068398,25.52454 -0.002,-7.9e-4 -0.004,-0.002 -0.006,-0.003 -2.17765,-0.90689 -3.58835,-1.5381 -4.46277,-1.94665 -0.0258,-0.0121 -0.0433,-0.0209 -0.0682,-0.0326 -0.80077,-0.37639 -1.15445,-0.56689 -1.15445,-0.56689 -0.16252,-0.0726 -0.32833,-0.12677 -0.49557,-0.16382 -0.16725,-0.037 -0.33593,-0.0572 -0.50333,-0.0605 -0.16741,-0.003 -0.33363,0.01 -0.49661,0.0388 -0.16229,0.0286 -0.32101,0.0731 -0.47439,0.13177 -0.002,5.3e-4 -0.004,7.6e-4 -0.005,0.002 -0.15291,0.0588 -0.30025,0.13212 -0.43977,0.21911 -0.14044,0.0876 -0.27301,0.189 -0.39532,0.30334 -0.12108,0.11319 -0.2318802,0.23953 -0.3307302,0.37724 -0.002,0.003 -0.004,0.006 -0.006,0.009 -0.0983,0.13811 -0.18477,0.28769 -0.25632,0.44856 l -2.42879,5.46271 -0.48473,1.09037 c -2.55818,0.59071 -5.17506,0.88959 -7.80055,0.89091 -0.27983,-3.3e-4 -0.55692,-0.027 -0.83613,-0.0341 l 3.30264,-12.26023 c 9.3106602,1.76198 16.3117802,1.05102 19.25878018,-7.3701 2.37471002,-6.78043 -0.11804,-10.69164 -5.01674998,-13.24208 3.56749998,-0.82267 6.25473,-3.16918 6.97166,-8.01657 h 5.2e-4 c 0.99062,-6.6218 -4.05111,-10.18163 -10.94507,-12.55633 z m -5.8492502,0.10387 -2.77451,10.44794 c -1.43539,-0.35768 -2.90946,-0.69555 -4.37441,-1.02991 l 1.67794,-7.62021 c 0.11921,0.0745 0.24098,0.14479 0.36948,0.19844 0.1506,0.0629 0.30644,0.11079 0.46561,0.14418 0.005,9.8e-4 0.009,0.002 0.0139,0.003 0.15922,0.0325 0.32167,0.0506 0.48472,0.0527 0.16533,0.002 0.33158,-0.0117 0.4961,-0.0419 h 5.2e-4 c 0.16453,-0.0302 0.32733,-0.0771 0.48627,-0.14056 h 5.2e-4 c 0.15908,-0.0635 0.31382,-0.14401 0.4625,-0.24185 z m -41.306522,10.97607 c 1.191892,-0.003 2.306642,0.73465 2.714564,1.90893 1.118338,3.50769 -4.131582,5.27154 -5.41414,1.81901 -0.508973,-1.47364 0.290013,-3.0755 1.78387,-3.57601 0.303472,-0.10214 0.611891,-0.15111 0.915706,-0.15193 z m 32.686372,4.89118 c 3.0823,0.76824 13.0088602,2.20201 11.4055102,8.63565 -1.53959,6.1677 -11.0419002,3.03425 -14.1242002,2.26601 z m 33.79949,8.30337 c 0.52608,-0.002 1.0853,0.15579 1.64124,0.524 1.28947,0.89696 1.59724,2.65647 0.68679,3.92792 -0.90918,1.27347 -2.69192,1.57943 -3.98374,0.6842 -2.45596,-1.79572 -0.74593,-5.12776 1.65571,-5.13612 z m -37.88967,8.10028 c 3.70125,0.92376 15.5699202,2.75296 13.8063902,9.82421 -1.6873302,6.78043 -13.1034102,3.11482 -16.8046602,2.19573 z m -4.77284,18.5906 c 1.48983,0.40433 2.93598,0.77715 4.35116,1.12861 l -3.47473,12.88758 c -1.57123,-0.3013 -3.11981,-0.69781 -4.63176,-1.21129 z m -19.366776,1.46451 c 3.725957,0.0343 3.803124,5.5067 0.07958,5.64358 -1.577437,0.0223 -2.873688,-1.2224 -2.894397,-2.77916 -0.02291,-1.55763 1.236512,-2.83933 2.814815,-2.86442 z m 41.3530262,8.30233 c 1.83932,-0.0174 3.69784,1.70666 2.75591,3.93361 -0.64087,1.42264 -2.33004,2.06253 -3.77083,1.42834 -1.4425,-0.63259 -2.09338,-2.29871 -1.45469,-3.72329 0.54787,-1.14257 1.50617,-1.62955 2.46961,-1.63866 z" />
+      <g
+         inkscape:label="Layer 1"
+         id="layer1-3"
+         transform="translate(-156.41293,-392.70627)">
+        <path
+           d="m 254.26362,273.57035 -4.40517,-1.63745 a 54.213298,54.213298 0 0 0 -0.3409,-1.11881 l 2.73526,-3.81701 c 0.27821,-0.38802 0.33654,-0.8914 0.15186,-1.33013 a 1.3695876,1.3695876 0 0 0 -1.0508,-0.82952 l -4.6272,-0.74403 a 51.06943,51.06943 0 0 0 -0.56038,-1.04316 l 1.9349,-4.26831 a 1.3750441,1.3750441 0 0 0 -1.30334,-1.94295 l -4.68656,0.17418 a 39.007783,39.007783 0 0 0 -0.75052,-0.90938 l 1.06547,-4.56939 a 1.3695876,1.3695876 0 0 0 -0.36834,-1.28768 1.3677688,1.3677688 0 0 0 -1.28827,-0.36342 l -4.57362,1.08652 a 37.124373,37.124373 0 0 0 -0.90501,-0.73639 l 0.15631,-4.69921 a 1.3750441,1.3750441 0 0 0 -1.94804,-1.2966 l -4.27293,1.95924 a 39.484319,39.484319 0 0 0 -1.03072,-0.5497 l -0.76466,-4.63834 a 1.3732253,1.3732253 0 0 0 -2.16237,-0.89082 l -3.80144,2.7494 a 49.537966,49.537966 0 0 0 -1.12897,-0.34164 l -1.6526,-4.39025 a 1.3759535,1.3759535 0 0 0 -2.29478,-0.4514 l -3.19153,3.43473 a 41.755143,41.755143 0 0 0 -1.1767,-0.11313 l -2.47474,-3.98099 a 1.3723159,1.3723159 0 0 0 -2.33873,0.004 l -2.46275,4.00062 c -0.38733,0.0343 -0.77664,0.0727 -1.16361,0.118 l -3.21292,-3.43092 a 1.3750441,1.3750441 0 0 0 -2.29226,0.46087 l -1.63727,4.40606 c -0.37532,0.10794 -0.7492,0.22299 -1.11971,0.34108 l -3.81844,-2.73776 a 1.3732253,1.3732253 0 0 0 -2.15838,0.90058 l -0.74385,4.6281 c -0.35116,0.18192 -0.69753,0.36936 -1.04245,0.5593 l -4.27009,-1.93454 a 1.3777724,1.3777724 0 0 0 -1.94289,1.30341 l 0.17258,4.68782 c -0.30669,0.24626 -0.60874,0.49715 -0.9092,0.75143 l -4.56867,-1.06656 a 1.370497,1.370497 0 0 0 -1.28662,0.36907 c -0.33674,0.3367 -0.47501,0.82554 -0.36342,1.28825 l 1.08652,4.57363 c -0.24993,0.29792 -0.49611,0.60066 -0.73817,0.90534 l -4.69813,-0.15555 a 1.3795912,1.3795912 0 0 0 -1.19113,0.61331 1.3732253,1.3732253 0 0 0 -0.1053,1.3356 l 1.95853,4.27402 a 44.22513,44.22513 0 0 0 -0.54828,1.02858 l -4.63817,0.76555 a 1.3741347,1.3741347 0 0 0 -0.89064,2.16324 l 2.74959,3.80236 a 41.851542,41.851542 0 0 0 -0.34165,1.12896 l -4.3898,1.65068 a 1.3759535,1.3759535 0 0 0 -0.45122,2.29567 l 3.4342,3.18885 c -0.0428,0.3917 -0.0816,0.78447 -0.11367,1.17867 l -3.98099,2.47474 a 1.3732253,1.3732253 0 0 0 0.006,2.33926 l 3.99883,2.46309 c 0.0343,0.38736 0.0736,0.77647 0.11801,1.16362 l -3.43003,3.21275 a 1.3732253,1.3732253 0 0 0 0.46087,2.29226 l 4.40518,1.63744 c 0.10879,0.37514 0.2228,0.74832 0.34089,1.11881 l -2.73598,3.81808 a 1.3750441,1.3750441 0 0 0 0.89879,2.15875 l 4.6281,0.74385 c 0.18191,0.35117 0.36953,0.69841 0.56037,1.04316 l -1.93472,4.26921 a 1.3741347,1.3741347 0 0 0 1.30414,1.94181 l 4.68567,-0.174 c 0.24661,0.30848 0.49661,0.61071 0.75179,0.91098 l -1.06674,4.56778 a 1.3732253,1.3732253 0 0 0 0.36925,1.2875 c 0.33867,0.33728 0.8275,0.47554 1.28825,0.36344 l 4.57166,-1.08707 c 0.30007,0.25135 0.60066,0.49611 0.90536,0.73818 l -0.15432,4.69974 c -0.0156,0.47621 0.2146,0.92435 0.61276,1.18844 0.39586,0.26642 0.90135,0.30301 1.33544,0.10441 l 4.27312,-1.95835 c 0.34138,0.18924 0.68489,0.37064 1.03036,0.54793 l 0.76573,4.63906 a 1.3732253,1.3732253 0 0 0 2.16217,0.88992 l 3.80164,-2.74852 c 0.37465,0.11947 0.75003,0.23324 1.12896,0.34164 l 1.65207,4.38758 a 1.3777724,1.3777724 0 0 0 2.29603,0.453 l 3.18849,-3.43596 a 42.924658,42.924658 0 0 0 1.17885,0.11455 l 2.47437,3.97921 c 0.25097,0.40408 0.69409,0.6517 1.17119,0.64855 a 1.3668594,1.3668594 0 0 0 1.16719,-0.65395 l 2.46399,-3.99903 c 0.38771,-0.0325 0.77666,-0.0726 1.16506,-0.11549 l 3.21273,3.43001 a 1.3759535,1.3759535 0 0 0 2.29225,-0.46087 l 1.63745,-4.40517 a 44.616181,44.616181 0 0 0 1.11829,-0.34357 l 3.81718,2.73616 c 0.38713,0.27838 0.89051,0.33671 1.32924,0.15204 a 1.3714065,1.3714065 0 0 0 0.82952,-1.0508 l 0.7442,-4.62632 a 42.924658,42.924658 0 0 0 1.04297,-0.56126 l 4.26959,1.93649 a 1.3759535,1.3759535 0 0 0 1.94171,-1.30491 l -0.17206,-4.68514 c 0.30673,-0.24621 0.60842,-0.49891 0.90919,-0.75142 l 4.56851,1.06565 a 1.3732253,1.3732253 0 0 0 1.65023,-1.65642 l -1.08672,-4.57452 c 0.24993,-0.29792 0.49683,-0.5971 0.73764,-0.90339 l 4.69795,0.15468 a 1.3677688,1.3677688 0 0 0 1.19043,-0.61225 c 0.26517,-0.39745 0.30424,-0.89972 0.10583,-1.33293 l -1.95872,-4.27489 c 0.18748,-0.34103 0.37099,-0.6831 0.54792,-1.03037 l 4.63834,-0.76466 a 1.3686782,1.3686782 0 0 0 1.04769,-0.83306 c 0.1822,-0.44107 0.12284,-0.94398 -0.15793,-1.32999 l -2.74833,-3.80077 c 0.1184,-0.37537 0.23306,-0.75091 0.34038,-1.13056 l 4.38973,-1.65064 a 1.3741347,1.3741347 0 0 0 0.4514,-2.29477 l -3.43438,-3.18973 c 0.0419,-0.39154 0.0807,-0.7843 0.11367,-1.17868 l 3.98009,-2.47455 c 0.40477,-0.25211 0.65171,-0.69411 0.64856,-1.17119 a 1.3668594,1.3668594 0 0 0 -0.65395,-1.16719 l -3.99813,-2.46416 c -0.0352,-0.38717 -0.0745,-0.77629 -0.118,-1.16364 l 3.43002,-3.21273 a 1.3732253,1.3732253 0 0 0 -0.46019,-2.2924 z m -19.6864,37.77068 a 2.8319361,2.8319361 0 0 1 -2.78949,-2.87041 2.822842,2.822842 0 0 1 2.8608,-2.79127 2.8301173,2.8301173 0 0 1 2.79074,2.86739 2.8301173,2.8301173 0 0 1 -2.86205,2.79429 z m -3.14124,-8.73554 a 2.5763889,2.5763889 0 0 0 -2.60939,2.54683 l -0.0859,6.77035 a 34.652567,34.652567 0 0 1 -13.46874,5.86094 34.686216,34.686216 0 0 1 -15.00985,-0.27711 l -2.69496,-6.21125 a 2.5754795,2.5754795 0 0 0 -3.38987,-1.33973 l -5.48281,2.38245 a 34.678941,34.678941 0 0 1 -3.66486,-2.89664 l 27.88146,-5.60569 c 0.31563,-0.0634 0.51455,-0.16286 0.45684,-0.44991 l -1.98293,-9.86266 c -0.0577,-0.28709 -0.2796,-0.30182 -0.59523,-0.23837 l -8.15438,1.63948 -1.25694,-6.25177 8.8195,-1.77319 c 0.8051,-0.16187 4.35079,-0.63543 6.36906,3.61266 0.62696,1.30526 2.29611,5.62538 3.11019,6.9524 0.84727,1.50123 3.62703,4.28177 5.90146,3.82449 l 13.89347,-2.79334 c 0.15781,-0.0317 0.32271,-0.0834 0.4937,-0.15121 a 34.919937,34.919937 0 0 1 -2.41443,4.34246 z m -36.77971,16.62083 a 2.8255702,2.8255702 0 0 1 -3.71906,-1.46835 2.8328456,2.8328456 0 0 1 1.46423,-3.72566 2.8319361,2.8319361 0 0 1 2.25483,5.19401 z m -19.19992,-40.76291 a 2.8319361,2.8319361 0 0 1 -0.67338,3.94512 2.8246608,2.8246608 0 0 1 -3.9403,-0.67713 2.8319361,2.8319361 0 0 1 0.67338,-3.94512 2.8246608,2.8246608 0 0 1 3.9403,0.67713 z m -1.70138,8.35949 5.43584,-3.85256 a 2.580936,2.580936 0 0 0 0.61363,-3.59639 l -1.78841,-2.53274 4.83504,-0.97211 4.38173,21.79376 -9.75478,1.96123 a 34.838089,34.838089 0 0 1 -3.18139,-9.09665 c -0.24898,-1.2384 -0.42824,-2.47599 -0.54167,-3.70454 z m 25.76904,-7.38315 -1.29154,-6.42383 11.51386,-2.3149 c 0.59468,-0.11957 4.33754,-0.15689 4.87943,2.53836 0.44994,2.23786 -2.15353,3.59615 -4.42706,4.05326 l -10.67486,2.14622 z m 43.00607,-2.63095 c 0.17137,0.85236 0.30978,1.70206 0.41565,2.5518 l -3.50035,0.70377 c -0.35038,0.0704 -0.44499,0.32882 -0.376,0.67205 l 0.32321,1.60751 c 0.76075,3.78386 -1.20734,5.03575 -3.03486,5.62117 -1.74014,0.55858 -3.90429,0.009 -4.36674,-1.03108 -2.23803,-5.69644 -4.24185,-6.60615 -7.44402,-8.23037 2.99198,-2.86772 5.91493,-6.79853 5.0502,-11.0995 -0.93375,-4.64424 -4.70571,-6.92939 -7.16424,-7.92763 -3.44824,-1.39479 -6.90015,-1.11913 -7.80956,-0.93629 l -36.20078,7.27833 c 3.80751,-6.46574 9.68017,-11.68439 16.92115,-14.60956 l 5.16714,3.61869 a 2.5736607,2.5736607 0 0 0 3.58816,-0.63607 l 3.85626,-5.52659 c 10.37888,-0.14892 20.10098,4.37583 26.70018,11.93842 l -1.78428,8.03942 a 2.5836643,2.5836643 0 0 0 1.95676,3.0796 l 6.85473,1.52991 c 0.33338,1.09529 0.61739,2.21254 0.84737,3.35644 z m -43.68306,-30.06602 a 2.8237514,2.8237514 0 0 1 3.9357,-0.6976 2.8328456,2.8328456 0 0 1 0.69705,3.9423 2.8219325,2.8219325 0 0 1 -3.9359,0.69672 2.833755,2.833755 0 0 1 -0.69686,-3.94141 z m 37.68373,19.58143 a 2.8237514,2.8237514 0 0 1 3.3717,-2.14633 2.8319361,2.8319361 0 0 1 2.14581,3.37831 2.8237514,2.8237514 0 0 1 -3.37242,2.14742 2.8346644,2.8346644 0 0 1 -2.14508,-3.37939 z"
+           id="path8380"
+           style="fill:#f5680f;fill-opacity:1;stroke-width:0.909418"
+           inkscape:export-filename="/home/hunter/omoc-rust.png"
+           inkscape:export-xdpi="96"
+           inkscape:export-ydpi="96" />
+      </g>
+    </g>
+    <path
+       id="path2280"
+       clip-path="none"
+       style="fill:#f7931a;fill-opacity:1;stroke-width:3.45125"
+       d="M -473.46875 -34.167969 C -475.39437 -34.231695 -477.33899 -33.241041 -478.31445 -31.285156 L -486.3125 -15.351562 C -487.76573 -15.094933 -489.22559 -14.823369 -490.67383 -14.525391 L -503.94727 -26.443359 C -505.38912 -27.737734 -507.25704 -28.050501 -508.89648 -27.570312 L -508.89648 -27.574219 C -510.53597 -27.094257 -511.94285 -25.820665 -512.45898 -23.953125 L -517.20898 -6.7578125 C -518.59271 -6.2266377 -519.96794 -5.6712007 -521.33008 -5.1035156 L -536.66211 -14.207031 C -539.99709 -16.193702 -544.25905 -13.966896 -544.53125 -10.09375 L -545.82422 7.6484375 C -547.09244 8.4511714 -548.34402 9.274464 -549.58594 10.105469 L -566.36328 4.1894531 C -570.0185 2.9092516 -573.74945 5.9071531 -573.2832 9.7519531 L -571.09375 27.419922 C -572.17277 28.451431 -573.23244 29.498776 -574.28516 30.558594 L -591.9082 28.023438 C -593.69781 27.763406 -595.49449 28.448687 -596.65234 29.837891 C -597.8153 31.221236 -598.17695 33.115168 -597.60352 34.828125 L -592 51.763672 C -592.84737 52.971987 -593.67867 54.198469 -594.49414 55.429688 L -612.30664 56.380859 C -614.11246 56.480261 -615.73937 57.504256 -616.60938 59.089844 C -617.47999 60.676414 -617.46512 62.600864 -616.57031 64.173828 L -607.76758 79.689453 C -608.36406 81.037951 -608.94111 82.394121 -609.50195 83.757812 L -626.78711 88.171875 C -630.5497 89.125714 -631.98964 93.711391 -629.44727 96.644531 L -617.80664 110.11914 C -618.1347 111.57483 -618.44015 113.03363 -618.72656 114.49805 L -634.7832 122.17773 C -638.28014 123.8532 -638.79637 128.61982 -635.73828 131.00391 L -621.71094 141.93555 C -621.74495 143.43054 -621.75989 144.92884 -621.75195 146.42969 L -635.99609 157.0918 C -639.11042 159.4119 -638.68513 164.20015 -635.20898 165.93359 L -619.28125 173.93555 C -619.02462 175.38889 -618.74965 176.84758 -618.45508 178.29688 L -630.37109 191.56641 C -632.96925 194.44799 -631.62065 199.05424 -627.87695 200.08008 L -610.6875 204.83008 C -610.15345 206.21286 -609.59901 207.58711 -609.03125 208.94922 L -618.12695 224.28125 C -620.10527 227.61442 -617.88696 231.86628 -614.02148 232.15039 L -596.27734 233.44531 C -595.47457 234.7135 -594.65269 235.9661 -593.81836 237.20703 L -599.73438 253.98242 C -601.02977 257.64051 -598.02028 261.38083 -594.16992 260.89648 L -576.50977 258.70312 C -575.4764 259.78864 -574.43424 260.84866 -573.37109 261.90039 L -575.9082 279.52148 C -576.1671 281.31211 -575.48062 283.10809 -574.0918 284.26758 C -572.70097 285.43194 -570.80493 285.79546 -569.09961 285.2207 L -552.17188 279.61328 C -550.95509 280.46534 -549.73903 281.29199 -548.50781 282.10742 L -547.55273 299.92773 C -547.45333 301.73325 -546.43738 303.35255 -544.8457 304.2207 C -543.26174 305.09835 -541.33985 305.07061 -539.76367 304.17773 L -524.24805 295.37305 C -522.89535 295.97671 -521.53606 296.55223 -520.17188 297.10938 L -515.75781 314.39648 C -514.80477 318.15761 -510.22219 319.59687 -507.29102 317.05469 L -493.81836 305.41797 C -492.36267 305.74717 -490.90757 306.05411 -489.43945 306.33984 L -481.75781 322.38672 C -480.08016 325.87991 -475.31565 326.40018 -472.92578 323.34961 L -461.99609 309.31445 C -460.4983 309.35225 -459.0002 309.36429 -457.50195 309.35938 L -446.84375 323.59766 C -445.76243 325.04321 -444.00784 325.83221 -442.20508 325.66406 C -440.40364 325.50872 -438.81034 324.42886 -438.00391 322.81055 L -430 306.88281 C -428.54484 306.63299 -427.08537 306.3537 -425.63086 306.06445 L -412.35938 317.98047 C -409.47461 320.56468 -404.88137 319.22038 -403.8457 315.48828 L -399.09766 298.29492 C -397.71858 297.75785 -396.34499 297.20391 -394.98047 296.63086 L -379.6543 305.72852 C -378.09951 306.65431 -376.17457 306.70686 -374.57617 305.86523 C -372.97123 305.03158 -371.91517 303.42694 -371.78516 301.62305 L -370.48828 283.88672 C -369.22376 283.08289 -367.96833 282.26228 -366.72656 281.42383 L -349.94922 287.34766 C -346.29147 288.63353 -342.5572 285.62295 -343.03516 281.77539 L -345.2207 264.11914 C -344.14172 263.08767 -343.08585 262.03555 -342.03125 260.98242 L -324.4082 263.51562 C -320.56885 264.07575 -317.48531 260.39227 -318.71094 256.71094 L -324.31641 239.77148 C -323.46904 238.56321 -322.63444 237.35017 -321.82422 236.11328 L -304.01172 235.16016 C -302.20492 235.06831 -300.5752 234.04628 -299.71094 232.45703 C -298.83855 230.86751 -298.85697 228.95574 -299.75 227.38281 L -308.55469 211.86133 C -307.95756 210.51064 -307.37357 209.15599 -306.81836 207.78516 L -289.5332 203.37695 C -287.7795 202.93403 -286.38311 201.60983 -285.8457 199.88281 C -285.30122 198.15557 -285.69077 196.27387 -286.87891 194.90625 L -298.51172 181.43555 C -298.18706 179.97752 -297.8772 178.52128 -297.5957 177.05078 L -281.54102 169.37305 C -278.03936 167.7028 -277.52098 162.92982 -280.58398 160.54883 L -294.61328 149.61328 C -294.58305 148.11931 -294.56578 146.62097 -294.57031 145.11914 L -280.33008 134.46094 C -278.88214 133.37534 -278.09552 131.623 -278.26367 129.82031 C -278.41901 128.0188 -279.49883 126.42753 -281.11719 125.62109 L -297.04102 117.61328 C -297.30105 116.161 -297.5759 114.7022 -297.86719 113.25195 L -285.95312 99.980469 C -283.35421 97.099637 -284.6993 92.493317 -288.44141 91.466797 L -305.63281 86.716797 C -306.16992 85.338139 -306.72041 83.966324 -307.28711 82.599609 L -298.19531 67.271484 C -297.27054 65.713299 -297.21636 63.789693 -298.05859 62.191406 C -298.89103 60.585409 -300.49839 59.529084 -302.30273 59.400391 L -320.04102 58.101562 C -320.84658 56.838596 -321.66544 55.585791 -322.5 54.341797 L -316.58398 37.572266 C -315.28969 33.91459 -318.29835 30.172986 -322.14844 30.652344 L -339.81055 32.84375 C -340.8396 31.763901 -341.88218 30.700558 -342.94336 29.652344 L -340.41016 12.027344 C -340.14748 10.23683 -340.83657 8.4381378 -342.22656 7.2792969 C -343.61025 6.1141441 -345.50123 5.7542415 -347.2168 6.328125 L -364.15234 11.931641 C -365.36017 11.083212 -366.58059 10.25335 -367.81445 9.4433594 L -368.76367 -8.3730469 C -368.96588 -12.249179 -373.1783 -14.554716 -376.55273 -12.636719 L -392.06641 -3.8320312 C -393.41676 -4.4323336 -394.77698 -5.0120263 -396.14453 -5.5722656 L -400.55273 -22.857422 C -401.50366 -26.620735 -406.08925 -28.060898 -409.02148 -25.517578 L -422.49414 -13.878906 C -423.95062 -14.20319 -425.40927 -14.511005 -426.87305 -14.800781 L -434.55859 -30.859375 C -436.23429 -34.35317 -440.9982 -34.866736 -443.38281 -31.8125 L -454.32422 -17.783203 C -455.81925 -17.817219 -457.31709 -17.8314 -458.8125 -17.824219 L -469.4707 -32.066406 C -470.48381 -33.430728 -471.97104 -34.118404 -473.46875 -34.167969 z M -470.9082 -1.0917969 C -468.25918 -1.2353504 -465.55783 -0.41781892 -463.38477 1.4082031 C -458.85391 5.2053055 -458.31302 11.935367 -462.17773 16.449219 C -471.56997 26.873534 -487.48034 13.523404 -478.58594 2.6816406 C -477.19496 1.0627556 -475.42514 -0.046443258 -473.51758 -0.62890625 C -472.66748 -0.8885031 -471.79121 -1.0439457 -470.9082 -1.0917969 z M -446.99023 14.9375 C -440.87068 15.46103 -434.84345 16.365645 -428.94531 17.642578 L -439.20312 59.068359 C -445.14326 57.588145 -451.24604 56.190288 -457.30859 54.806641 L -447.51758 15.558594 L -447.44531 15.474609 L -446.99023 14.9375 z M -492.94141 19.138672 C -492.93385 19.15001 -492.91381 19.16249 -492.90625 19.173828 C -487.1738 23.866603 -482.90851 27.511481 -480.07031 29.988281 C -480.06275 29.99584 -480.04297 30.010019 -480.04297 30.017578 C -480.02029 30.044035 -479.99685 30.06011 -479.97266 30.082031 C -477.43649 32.297892 -476.32598 33.324795 -476.12109 33.513672 L -480.07812 49.902344 C -484.99503 48.782508 -489.82061 47.676607 -494.50586 46.511719 L -494.48047 46.394531 L -525.64258 38.615234 L -531.65234 62.748047 C -531.65234 62.748047 -514.88823 66.589977 -515.24219 66.828125 C -506.09059 69.112812 -504.43619 75.169645 -504.71289 79.970703 L -515.25391 122.25977 C -514.62318 122.42077 -513.80729 122.65337 -512.90625 123.01367 C -513.65925 122.82696 -514.4628 122.61929 -515.29297 122.41992 L -530.07031 181.66211 C -531.19015 184.44241 -534.02675 188.61247 -540.42383 187.0293 C -540.19857 187.35736 -556.84766 182.92969 -556.84766 182.92969 L -568.06641 208.79492 L -538.66211 216.125 C -533.19173 217.49576 -527.83001 218.93168 -522.55273 220.2832 L -527.10547 238.72266 L -544.25781 244.01172 L -544.92383 244.21875 C -563.57304 227.83314 -577.19747 206.49459 -584.21484 182.68164 C -588.00284 169.59435 -589.73077 155.99768 -589.33789 142.37891 C -589.29896 142.36001 -589.32018 142.37216 -589.28125 142.3457 C -574.32188 133.47738 -571.78221 132.09756 -567.51758 129.60742 C -566.97922 129.29297 -566.47852 128.92012 -566.01953 128.50195 C -565.10175 127.66505 -564.35268 126.64151 -563.80469 125.50977 C -563.53029 124.94389 -563.30728 124.34946 -563.13867 123.74023 C -562.96973 123.13094 -562.85672 122.50713 -562.80078 121.875 C -562.74711 121.24257 -562.74957 120.60401 -562.81836 119.96875 C -562.88715 119.33337 -563.01874 118.70197 -563.21875 118.08398 C -563.41906 117.46618 -563.6873 116.86167 -564.02734 116.28125 L -575.45312 96.787109 L -578.08203 92.298828 C -562.39518 57.105908 -532.04524 30.576832 -495.07031 19.738281 L -495.0625 19.724609 L -495.06055 19.724609 C -494.35582 19.522405 -493.65018 19.326514 -492.94141 19.138672 z M -406.54883 24.558594 C -383.99984 33.728478 -364.38011 48.963644 -350.13867 69.720703 C -350.73724 71.647242 -351.3398 73.336007 -351.86523 74.972656 C -359.84741 98.392537 -360.15234 99.183594 -360.15234 99.183594 C -360.3708 99.819839 -360.52003 100.46344 -360.60352 101.10547 C -360.68478 101.74776 -360.70475 102.38824 -360.66016 103.01953 C -360.61594 103.65071 -360.50784 104.27096 -360.3457 104.875 C -360.18092 105.47833 -359.96268 106.06686 -359.68945 106.62695 C -359.41468 107.18678 -359.08791 107.71951 -358.71094 108.21875 C -358.33374 108.71795 -357.90716 109.18157 -357.43555 109.60352 C -356.49237 110.44745 -355.36685 111.12147 -354.09375 111.55664 L -332.71484 118.86133 L -329.4043 119.99219 C -321.7413 158.25446 -331.4896 197.94328 -356.00781 228.30078 C -356.01537 228.30006 -356.02174 228.29819 -356.0293 228.29883 C -364.89131 227.32171 -370.67949 226.52992 -374.28516 225.97656 C -374.39174 225.95766 -374.46518 225.94934 -374.56836 225.92969 C -377.87265 225.4148 -379.35742 225.09961 -379.35742 225.09961 C -380.02402 225.0089 -380.68217 224.98816 -381.32812 225.03125 C -381.97401 225.07585 -382.60805 225.18211 -383.21875 225.34766 C -383.82922 225.51433 -384.41801 225.73779 -384.97852 226.01562 C -385.5369 226.29153 -386.06645 226.62236 -386.56055 226.99805 C -386.56811 227.00183 -386.57435 227.00403 -386.57812 227.00781 C -387.07045 227.38388 -387.52774 227.80586 -387.94141 228.26953 C -388.35787 228.73642 -388.73045 229.24639 -389.05273 229.79102 C -389.37173 230.33017 -389.63919 230.90534 -389.85156 231.50977 C -389.85394 231.5211 -389.86341 231.53598 -389.86719 231.54883 C -390.07695 232.1542 -390.23176 232.78973 -390.32031 233.44922 L -393.33008 255.8418 L -393.92969 260.3125 C -402.58171 265.17173 -411.75731 269.03532 -421.2793 271.82812 C -436.98213 276.40529 -453.29862 277.95544 -469.39844 276.55664 L -459.34766 236.11523 C -420.81685 243.40693 -391.84223 240.46475 -379.64648 205.61523 C -369.81907 177.55538 -380.13561 161.36905 -400.4082 150.81445 C -385.64461 147.40997 -374.52361 137.69889 -371.55664 117.63867 L -371.55859 117.63867 C -367.45902 90.235283 -388.32383 75.505073 -416.85352 65.677734 L -406.54883 24.558594 z M -463.39648 81.496094 C -450.64088 84.675357 -409.56013 90.609682 -416.19531 117.23438 C -422.56669 142.75847 -461.88889 129.79059 -474.64453 126.61133 L -463.39648 81.496094 z M -334.10938 83.923828 C -333.02116 83.940893 -331.87175 84.121479 -330.66797 84.494141 C -325.03821 86.378386 -322.05358 92.4349 -324.00586 98.013672 C -325.95137 103.59834 -332.09203 106.60012 -337.72852 104.72461 C -348.54382 100.819 -345.88032 86.916561 -337.17773 84.335938 C -336.22471 84.053002 -335.19759 83.906764 -334.10938 83.923828 z M -589.05664 106.63281 C -585.74873 106.69325 -582.52346 108.24946 -580.47852 111.11914 C -572.69719 122.6549 -589.86711 134.62812 -598.18555 123.4668 C -601.59661 118.66196 -600.39895 112.00329 -595.51172 108.60156 C -594.5194 107.90878 -593.45277 107.40369 -592.35156 107.07812 C -591.27153 106.75899 -590.15928 106.61267 -589.05664 106.63281 z M -480.32227 149.38086 C -465.0052 153.20366 -415.88743 160.77182 -423.18555 190.03516 C -430.16826 218.09497 -477.41337 202.92654 -492.73047 199.12305 L -480.32227 149.38086 z M -500.07227 226.3125 C -493.90684 227.98581 -487.92098 229.52986 -482.06445 230.98438 L -492.24414 272.5293 C -495.76747 271.57851 -499.26123 270.48908 -502.71289 269.24023 C -502.71353 269.23732 -502.7171 269.2323 -502.7168 269.22852 C -502.78823 268.91406 -502.87017 268.59336 -502.9707 268.26367 L -507.18164 254.58008 L -500.07227 226.3125 z M -369.5918 238.05469 C -363.93107 238.29209 -358.43252 242.50104 -359.28711 249.87695 C -360.10103 255.71784 -365.54964 259.83292 -371.44922 259.0625 C -377.35329 258.29972 -381.48367 252.94709 -380.67969 247.10156 C -379.90564 242.37538 -376.946 239.59127 -373.46094 238.53516 C -372.21344 238.15711 -370.89812 237.9999 -369.5918 238.05469 z M -528.67188 251.8457 C -517.75398 252.073 -513.88775 268.68551 -525.99609 272.71875 C -531.69419 274.47472 -537.71712 271.3377 -539.44531 265.71289 C -541.18246 260.08718 -537.97559 254.10095 -532.27734 252.33398 C -531.00688 251.97472 -529.80131 251.82219 -528.67188 251.8457 z "
+       transform="matrix(0.26458333,0,0,0.26458333,-73.402031,-228.93883)"
+       inkscape:export-filename="/home/hunter/Pictures/omoc graphics/rust-bitcoin-5.png"
+       inkscape:export-xdpi="80.031731"
+       inkscape:export-ydpi="80.031731" />
+    <rect
+       style="fill:#729fcf;fill-opacity:1;stroke-width:0.264583"
+       id="rect20060"
+       width="9.8467264"
+       height="44.83942"
+       x="-308.26736"
+       y="-127.99509"
+       transform="rotate(13.99185)" />
+    <path
+       id="path2280-6"
+       clip-path="none"
+       style="fill:#f7931a;fill-opacity:1;stroke-width:0.913143"
+       d="m -282.61236,-109.62932 c -0.43378,0.12699 -0.80643,0.46361 -0.94299,0.95773 l -1.25646,4.54948 c -0.36611,0.14054 -0.72986,0.28796 -1.09026,0.43816 l -4.057,-2.40862 c -0.88238,-0.52564 -2.00984,0.0634 -2.08186,1.08817 l -0.34232,4.6943 c -0.33555,0.21239 -0.66631,0.42998 -0.9949,0.64985 l -4.43896,-1.56505 c -0.96711,-0.33872 -1.9545,0.45462 -1.83114,1.47189 l 0.57911,4.67441 c -0.28549,0.27292 -0.56556,0.54985 -0.84409,0.83026 l -4.66284,-0.67083 c -0.4735,-0.0688 -0.94867,0.11292 -1.25502,0.48048 -0.3077,0.36601 -0.40379,0.86711 -0.25207,1.32033 l 1.483,4.48084 c -0.2242,0.3197 -0.44426,0.64392 -0.66002,0.96968 l -4.71316,0.25166 c -0.47779,0.0263 -0.90829,0.29716 -1.13848,0.71668 -0.23035,0.41978 -0.22635,0.92905 0.0104,1.34523 l 2.32939,4.10545 c -0.15782,0.35679 -0.31083,0.71538 -0.45922,1.07619 l -4.57304,1.1681 c -0.99552,0.25237 -1.37663,1.46537 -0.70396,2.24143 l 3.0797,3.56542 c -0.0868,0.38515 -0.16764,0.77097 -0.24342,1.15843 l -4.24802,2.0319 c -0.92523,0.4433 -1.06177,1.70469 -0.25265,2.33548 l 3.71126,2.89215 c -0.009,0.39555 -0.0132,0.79183 -0.0111,1.18893 l -3.76877,2.82098 c -0.824,0.61386 -0.71113,1.88076 0.2086,2.3394 l 4.21412,2.11764 c 0.0679,0.38453 0.14074,0.76998 0.21868,1.15344 l -3.15261,3.51128 c -0.68743,0.76242 -0.33107,1.98118 0.65945,2.2526 l 4.54848,1.25677 c 0.1413,0.36586 0.28781,0.72935 0.43803,1.08974 l -2.40666,4.05643 c -0.52343,0.8819 0.0633,2.00678 1.08604,2.08195 l 4.69493,0.34267 c 0.2124,0.33554 0.42976,0.66691 0.65051,0.99524 l -1.56518,4.43847 c -0.34274,0.96787 0.45372,1.95749 1.47246,1.82934 l 4.67248,-0.58011 c 0.27341,0.28721 0.54904,0.56794 0.83033,0.84621 l -0.67112,4.66186 c -0.0685,0.47377 0.11333,0.94922 0.48079,1.256 0.36799,0.30807 0.86961,0.404 1.32081,0.25193 l 4.47856,-1.48341 c 0.32194,0.22544 0.64393,0.44428 0.96969,0.66003 l 0.25261,4.7145 c 0.0263,0.47771 0.29482,0.9063 0.71595,1.136 0.41909,0.23221 0.92792,0.22484 1.34495,-0.0114 l 4.10495,-2.32925 c 0.3579,0.15972 0.71739,0.31172 1.07833,0.45913 l 1.16788,4.57419 c 0.25216,0.99513 1.46463,1.37586 2.24017,0.70324 l 3.56505,-3.07904 c 0.38515,0.0871 0.77013,0.16837 1.15857,0.24397 l 2.03232,4.24573 c 0.44388,0.92424 1.70426,1.06161 2.33658,0.25448 l 2.89205,-3.71338 c 0.39629,0.01 0.79279,0.0134 1.1892,0.0121 l 2.81991,3.76692 c 0.2861,0.38247 0.75035,0.59142 1.22733,0.54693 0.47663,-0.0411 0.89824,-0.32694 1.11161,-0.75512 l 2.11765,-4.21411 c 0.38501,-0.0661 0.77079,-0.14011 1.15563,-0.21664 l 3.51143,3.15311 c 0.76326,0.68374 1.97857,0.32799 2.25259,-0.65946 l 1.25662,-4.54897 c 0.36488,-0.1421 0.72801,-0.28888 1.08904,-0.4405 l 4.05544,2.40692 c 0.41137,0.24495 0.92042,0.25918 1.34333,0.0365 0.42464,-0.22057 0.70421,-0.64518 0.73861,-1.12246 l 0.34323,-4.69296 c 0.33457,-0.21268 0.6664,-0.42965 0.99495,-0.65149 l 4.43905,1.56718 c 0.96778,0.34022 1.95588,-0.4561 1.82942,-1.4741 l -0.57825,-4.67142 c 0.28548,-0.27291 0.56506,-0.5516 0.84409,-0.83024 l 4.66271,0.67031 c 1.01583,0.1482 1.83151,-0.82628 1.50723,-1.8003 l -1.48329,-4.48183 c 0.2242,-0.31969 0.4451,-0.64064 0.65947,-0.9679 l 4.71301,-0.25216 c 0.47805,-0.0243 0.90912,-0.29491 1.13779,-0.7154 0.23082,-0.42056 0.22628,-0.92658 -0.01,-1.34275 l -2.32968,-4.10644 c 0.15799,-0.35737 0.31224,-0.71562 0.45914,-1.07832 l 4.57348,-1.16661 c 0.464,-0.11719 0.83373,-0.46736 0.97592,-0.9243 0.14406,-0.457 0.0409,-0.95485 -0.27346,-1.3167 l -3.07825,-3.56421 c 0.0859,-0.38577 0.16791,-0.7712 0.24239,-1.16027 l 4.24815,-2.03142 c 0.92648,-0.44192 1.06337,-1.7045 0.25295,-2.33447 l -3.7117,-2.89364 c 0.008,-0.39528 0.0123,-0.79156 0.0111,-1.18892 l 3.76793,-2.8202 c 0.3831,-0.28723 0.59125,-0.75085 0.54676,-1.22781 -0.0411,-0.47665 -0.32679,-0.89776 -0.75498,-1.11113 l -4.21325,-2.11843 c -0.0688,-0.38425 -0.14176,-0.77021 -0.21883,-1.15392 l 3.15262,-3.51128 c 0.68763,-0.76222 0.33159,-1.98127 -0.65851,-2.25287 l -4.54847,-1.25678 c -0.14211,-0.36477 -0.28794,-0.72763 -0.43788,-1.08924 l 2.40579,-4.05565 c 0.24468,-0.41227 0.25904,-0.92094 0.0362,-1.34382 -0.22025,-0.42492 -0.64554,-0.70442 -1.12294,-0.73847 l -4.69359,-0.34361 c -0.21314,-0.33416 -0.42969,-0.6661 -0.6505,-0.99524 l 1.56561,-4.43698 c 0.34245,-0.96776 -0.45357,-1.95732 -1.47224,-1.83049 l -4.67312,0.57977 c -0.27227,-0.28571 -0.5485,-0.56702 -0.82927,-0.84436 l 0.6702,-4.66324 c 0.0695,-0.47374 -0.11266,-0.95001 -0.48043,-1.25662 -0.3661,-0.30828 -0.86627,-0.40339 -1.32018,-0.25155 l -4.48101,1.48252 c -0.31957,-0.22448 -0.64263,-0.44373 -0.96909,-0.65804 l -0.25089,-4.71396 c -0.0535,-1.02556 -1.16809,-1.63579 -2.06091,-1.12832 l -4.10481,2.32975 c -0.35728,-0.15883 -0.71694,-0.31241 -1.07877,-0.46064 l -1.1666,-4.57347 c -0.2516,-0.99571 -1.46448,-1.37666 -2.2403,-0.70374 l -3.56492,3.07953 c -0.38536,-0.0858 -0.77128,-0.16728 -1.15857,-0.24395 l -2.0332,-4.24873 c -0.44336,-0.9244 -1.70388,-1.06039 -2.33481,-0.25229 l -2.89516,3.71214 c -0.39556,-0.009 -0.79162,-0.0129 -1.18728,-0.011 l -2.82035,-3.76842 c -0.61269,-0.82509 -1.88065,-0.71335 -2.33948,0.20664 l -2.11656,4.21595 c -0.3845,0.0679 -0.77073,0.14 -1.15391,0.21884 l -3.51159,-3.15361 c -0.38149,-0.34247 -0.87585,-0.42528 -1.30962,-0.29823 z m 9.36046,7.12899 c 0.89969,-0.27474 1.91443,-0.10504 2.68104,0.53914 1.19879,1.00465 1.34163,2.78515 0.31909,3.97944 -2.48503,2.7581 -6.69455,-0.7739 -4.34124,-3.64245 0.36803,-0.42833 0.8364,-0.72205 1.34111,-0.87616 z m -5.70063,5.3853 4.9e-4,-1.5e-4 c 0.18646,-0.0535 0.37345,-0.10515 0.56098,-0.15485 0.002,0.003 0.007,0.006 0.009,0.009 1.51671,1.24163 2.64551,2.20624 3.39645,2.86156 0.002,0.002 0.007,0.006 0.007,0.008 0.006,0.007 0.0124,0.0108 0.0188,0.0166 0.72789,0.63596 1.10532,0.98538 1.10532,0.98538 0.13419,0.11427 0.27695,0.21226 0.42541,0.29439 9.1e-4,6.3e-4 0.003,0.002 0.004,0.003 9.1e-4,6.2e-4 0.003,0.002 0.003,0.002 0.14886,0.0816 0.30318,0.14727 0.46154,0.1971 0.15971,0.0503 0.32326,0.0845 0.48775,0.10275 0.16221,0.018 0.32524,0.0203 0.48737,0.008 0.005,-4.3e-4 0.009,-5.5e-4 0.0142,-10e-4 0.16193,-0.0135 0.32293,-0.0419 0.48001,-0.0856 0.15923,-0.0445 0.31493,-0.10437 0.46434,-0.17959 l 5e-4,-1.5e-4 c 0.14943,-0.0752 0.29249,-0.16597 0.4272,-0.27153 l 5.1e-4,-1.4e-4 c 0.13484,-0.10566 0.26072,-0.22638 0.37591,-0.36205 l 3.86895,-4.55721 0.12057,-0.1419 c 10.37273,0.88739 19.73555,5.9101 25.62531,14.49449 -0.15837,0.50973 -0.3179,0.9564 -0.45692,1.38943 -2.11195,6.19651 -2.19263,6.40605 -2.19263,6.40605 -0.0578,0.16834 -0.0973,0.33836 -0.11939,0.50823 -0.0215,0.16994 -0.0265,0.33969 -0.0147,0.50672 0.0117,0.167 0.04,0.33122 0.0829,0.49104 0.0436,0.15963 0.10157,0.31512 0.17386,0.46331 0.0727,0.14812 0.15926,0.28909 0.259,0.42118 0.0998,0.13208 0.21244,0.25485 0.33722,0.36649 0.24955,0.22329 0.54721,0.40142 0.88405,0.51656 l 5.6569,1.93273 0.87591,0.29926 c 2.0275,10.12356 -0.55187,20.62445 -7.03898,28.65654 -0.002,-1.9e-4 -0.004,-6.3e-4 -0.006,-4.6e-4 -2.34474,-0.25853 -3.87595,-0.46796 -4.82995,-0.61437 -0.0282,-0.005 -0.0475,-0.007 -0.0748,-0.0122 -0.87426,-0.13623 -1.26722,-0.2197 -1.26722,-0.2197 -0.17637,-0.024 -0.35073,-0.0294 -0.52164,-0.018 -0.17089,0.0118 -0.33846,0.0396 -0.50004,0.0834 -0.16152,0.0441 -0.3174,0.10325 -0.4657,0.17676 -0.14774,0.073 -0.28755,0.16035 -0.41828,0.25975 -0.002,10e-4 -0.004,0.002 -0.005,0.003 -0.13026,0.0995 -0.25105,0.21117 -0.3605,0.33385 -0.11019,0.12353 -0.20892,0.25809 -0.29419,0.40219 -0.0844,0.14265 -0.15522,0.29504 -0.21141,0.45496 -6.3e-4,0.003 -0.003,0.007 -0.004,0.0104 -0.0555,0.16017 -0.0965,0.32802 -0.11993,0.50251 l -0.79614,5.92507 -0.15887,1.18262 c -2.28918,1.28567 -4.71667,2.30775 -7.23603,3.04668 -7.07309,2.06171 -14.61843,1.82199 -21.54634,-0.6846 -1.7e-4,-7.7e-4 -6.3e-4,-0.002 -5.5e-4,-0.003 -0.0189,-0.0832 -0.0409,-0.16816 -0.0675,-0.25539 l -1.9914,-6.47131 c -0.0518,-0.17024 -0.12021,-0.33101 -0.20231,-0.48137 -0.0816,-0.14969 -0.17705,-0.28874 -0.28402,-0.41654 -5.7e-4,-6.7e-4 -7.6e-4,-0.002 -0.001,-0.003 -6.4e-4,-8.4e-4 -0.002,-0.002 -0.002,-0.002 -0.10711,-0.12721 -0.22554,-0.24347 -0.35347,-0.34665 -0.12889,-0.10388 -0.26724,-0.19495 -0.413,-0.27218 -0.14574,-0.0772 -0.29861,-0.14052 -0.45694,-0.18876 -0.15833,-0.0482 -0.32201,-0.0812 -0.48859,-0.0982 -0.16657,-0.017 -0.33606,-0.018 -0.50654,-10e-4 -0.17051,0.0169 -0.34198,0.0506 -0.51207,0.10307 l -5.71267,1.76128 -0.17622,0.0547 c -4.93427,-4.33536 -8.53871,-9.98077 -10.39539,-16.28128 -1.00224,-3.46268 -1.45963,-7.06021 -1.35568,-10.66351 0.0103,-0.005 0.005,-0.002 0.0153,-0.009 3.958,-2.34641 4.6296,-2.71162 5.75795,-3.37047 0.14244,-0.0832 0.27495,-0.18148 0.39639,-0.29212 0.24283,-0.22143 0.44108,-0.49245 0.58607,-0.79189 0.0726,-0.14972 0.13185,-0.30667 0.17646,-0.46786 0.0447,-0.16121 0.0746,-0.32668 0.0894,-0.49393 0.0142,-0.16733 0.0132,-0.3361 -0.005,-0.50418 -0.0182,-0.16811 -0.0528,-0.33541 -0.10572,-0.49892 -0.053,-0.16346 -0.12393,-0.32333 -0.2139,-0.4769 l -3.02296,-5.15742 -0.69604,-1.18759 c 4.15048,-9.31146 12.1806,-16.33056 21.96355,-19.19826 z m -25.74083,23.1121 c 1.14303,-0.33775 2.42014,0.057 3.14155,1.06936 2.05881,3.05217 -2.48407,6.22 -4.68499,3.2669 -0.90251,-1.27128 -0.58578,-3.03311 0.7073,-3.93315 0.26255,-0.1833 0.54478,-0.31696 0.83614,-0.4031 z m 67.5149,-6.01692 c 0.50431,-0.14972 1.08535,-0.1554 1.72235,0.0418 1.48954,0.49854 2.27925,2.10071 1.76271,3.57676 -0.51475,1.47761 -2.13972,2.27213 -3.63104,1.7759 -2.86155,-1.03336 -2.15658,-4.71164 0.14598,-5.39443 z m -51.62015,44.44909 c 3.58552,-1.01393 5.19711,4.21636 1.66203,5.39388 -1.50762,0.4646 -3.10138,-0.36575 -3.55863,-1.85398 -0.45962,-1.48847 0.38896,-3.07239 1.89662,-3.5399 z m 42.01994,-3.65068 c 1.76036,-0.53346 4.02838,0.59896 3.75009,3.00086 -0.21535,1.5454 -1.6567,2.6341 -3.21763,2.43026 -1.56212,-0.20182 -2.65491,-1.61797 -2.44219,-3.1646 0.2048,-1.25047 0.98764,-1.98709 1.90973,-2.26652 z" />
+    <path
+       fill="#ffffff"
+       d="m -246.27505,-71.20849 c 1.08468,-7.25048 -4.43576,-11.14817 -11.98424,-13.74832 l 3.84651,-15.3486 -6.0236,-1.48989 -3.73669,15.08972 c -1.57166,-0.39164 -3.1859,-0.76115 -4.78995,-1.12724 l 2.70316,-10.83589 -7.55662,4.68948 -1.171,4.84889 c -1.30093,-0.29629 -2.57802,-0.58917 -3.81766,-0.89738 l 0.007,-0.0307 -8.2449,-2.05867 -1.5904,6.38546 c 0,0 4.43576,1.01656 4.34211,1.07957 2.42136,0.60449 2.85898,2.20681 2.78577,3.47709 l -2.78918,11.18902 c 0.16688,0.0426 0.38312,0.10391 0.62152,0.19924 -0.19923,-0.0494 -0.41208,-0.10392 -0.63173,-0.15667 l -3.9096,15.67417 c -0.29629,0.73562 -1.04724,1.83902 -2.7398,1.42014 0.0596,0.0868 -4.34551,-1.08468 -4.34551,-1.08468 l -2.96797,6.84351 7.78004,1.93948 c 1.44737,0.36268 2.86581,0.74241 4.26209,1.1 l -1.33648,5.41258 5.14426,4.69127 2.14006,-8.50834 c 1.63127,0.44273 3.21487,0.85139 4.76441,1.23623 l -3.73248,15.23327 5.9021,1.57948 3.84122,-15.45563 c 10.19461,1.92926 17.86055,1.15109 21.08734,-8.06951 2.60017,-7.42417 -0.12941,-11.70669 -5.4932,-14.49926 3.9062,-0.90077 6.8486,-3.47028 7.63361,-8.77788 z m -13.65978,19.15467 c -1.84751,7.42416 -14.34769,3.41068 -18.40034,2.40434 l 3.28299,-13.16085 c 4.05264,1.01145 17.04831,3.01392 15.11735,10.75651 z m 1.84924,-19.26194 c -1.68576,6.75325 -12.0898,3.32213 -15.46473,2.48095 l 2.97647,-11.93655 c 3.37492,0.84118 14.24382,2.41115 12.48826,9.4556 z"
+       id="path2282-2"
+       style="display:block;stroke-width:1.7028"
+       sodipodi:nodetypes="ccccccccccccccccccccccccccccccccccccccccccc" />
+  </g>
+</svg>
diff --git a/logo/rust-bitcoin-large.png b/logo/rust-bitcoin-large.png
new file mode 100644
index 00000000..f0cce340
Binary files /dev/null and b/logo/rust-bitcoin-large.png differ
diff --git a/logo/rust-bitcoin-optimized.svg b/logo/rust-bitcoin-optimized.svg
new file mode 100644
index 00000000..31cf374b
--- /dev/null
+++ b/logo/rust-bitcoin-optimized.svg
@@ -0,0 +1 @@
+<svg width="359.854" height="359.857" viewBox="0 0 95.211 95.212" xmlns="http://www.w3.org/2000/svg"><path d="m330.353 103.349-3.434-3.209c.043-.387.082-.775.117-1.164l3.995-2.468a1.37 1.37 0 0 0 .653-1.169 1.37 1.37 0 0 0-.65-1.17l-3.983-2.47a51.065 51.065 0 0 0-.115-1.178l3.43-3.193a1.375 1.375 0 0 0-.454-2.295l-4.392-1.646a39.007 39.007 0 0 0-.342-1.128l2.744-3.806c.28-.386.34-.89.157-1.33a1.368 1.368 0 0 0-1.049-.832l-4.639-.76a37.132 37.132 0 0 0-.551-1.028l1.955-4.276a1.375 1.375 0 0 0-1.298-1.947l-4.698.16a39.484 39.484 0 0 0-.74-.904l1.083-4.574a1.373 1.373 0 0 0-1.652-1.656l-4.568 1.072c-.3-.254-.603-.504-.91-.75l.167-4.688a1.376 1.376 0 0 0-1.943-1.301l-4.269 1.94c-.345-.191-.692-.377-1.042-.558l-.75-4.628a1.372 1.372 0 0 0-2.159-.898l-3.814 2.743c-.37-.118-.745-.232-1.12-.34l-1.642-4.404a1.375 1.375 0 0 0-2.293-.458l-3.209 3.435a41.082 41.082 0 0 0-1.164-.117l-2.469-3.998a1.373 1.373 0 0 0-2.338 0l-2.47 3.983a46.61 46.61 0 0 0-1.178.115l-3.195-3.431a1.378 1.378 0 0 0-2.295.454l-1.647 4.392c-.378.11-.753.224-1.129.343l-3.804-2.745a1.37 1.37 0 0 0-1.33-.155 1.37 1.37 0 0 0-.832 1.049l-.76 4.639c-.345.178-.689.363-1.03.55l-4.275-1.953a1.38 1.38 0 0 0-1.336.107 1.373 1.373 0 0 0-.611 1.191l.16 4.699c-.304.242-.605.488-.903.738l-4.575-1.081a1.374 1.374 0 0 0-1.655 1.653l1.072 4.568c-.255.3-.505.603-.75.91l-4.687-.168a1.376 1.376 0 0 0-1.301 1.944l1.94 4.266c-.19.345-.378.692-.56 1.044l-4.627.75a1.373 1.373 0 0 0-.896 2.16l2.74 3.814c-.117.37-.23.745-.339 1.12l-4.403 1.642a1.373 1.373 0 0 0-.458 2.293l3.434 3.208c-.045.388-.083.777-.117 1.164l-3.996 2.469c-.87.536-.87 1.8-.003 2.338l3.984 2.47c.032.394.072.787.115 1.179l-3.43 3.193a1.374 1.374 0 0 0 .455 2.295l4.39 1.645c.11.38.223.755.343 1.13l-2.744 3.804c-.28.387-.339.89-.156 1.33.183.442.58.758 1.049.832l4.637.76c.18.347.363.688.551 1.03l-1.953 4.277c-.198.433-.159.935.107 1.332a1.37 1.37 0 0 0 1.192.611l4.698-.16c.242.306.489.606.74.903l-1.082 4.576a1.373 1.373 0 0 0 1.652 1.654l4.568-1.071c.3.254.602.504.91.75l-.167 4.686a1.378 1.378 0 0 0 1.944 1.302l4.267-1.941c.345.191.693.378 1.043.56l.75 4.625c.076.47.39.869.83 1.05.44.184.944.126 1.33-.154l3.815-2.74c.37.12.744.232 1.12.342l1.642 4.403a1.376 1.376 0 0 0 2.293.458l3.209-3.433c.387.043.775.08 1.164.114l2.468 3.995a1.372 1.372 0 0 0 2.338.003l2.47-3.982c.393-.033.786-.072 1.178-.116l3.194 3.432c.697.747 1.936.501 2.295-.456l1.646-4.39c.378-.108.754-.225 1.129-.342l3.805 2.744c.828.6 1.997.117 2.16-.893l.761-4.64c.346-.178.689-.36 1.029-.549l4.275 1.953c.433.2.939.16 1.335-.106.398-.264.627-.713.611-1.19l-.16-4.699c.305-.242.606-.487.903-.74l4.575 1.083c.463.11.95-.028 1.287-.365a1.37 1.37 0 0 0 .367-1.288l-1.071-4.567c.254-.3.504-.603.75-.912l4.686.169a1.374 1.374 0 0 0 1.301-1.944l-1.94-4.267c.19-.345.377-.692.56-1.043l4.626-.75a1.37 1.37 0 0 0 1.05-.83c.184-.44.126-.944-.154-1.33l-2.74-3.814c.117-.371.231-.746.34-1.12l4.403-1.642a1.373 1.373 0 0 0 .46-2.293zm-32.722 27.266a2.832 2.832 0 0 1-1.467-3.724 2.823 2.823 0 0 1 3.715-1.473 2.83 2.83 0 0 1-2.248 5.197zm9.981-9.916a34.92 34.92 0 0 1-3.901 3.076l-5.612-2.431a2.576 2.576 0 0 0-3.39 1.344l-2.688 6.215a34.653 34.653 0 0 1-14.687.217 34.686 34.686 0 0 1-13.743-6.04l-.093-6.77a2.575 2.575 0 0 0-2.612-2.543l-5.978.086a34.68 34.68 0 0 1-2.265-4.086m5.112 12.74a2.826 2.826 0 0 1-2.866-2.789 2.833 2.833 0 0 1 2.787-2.873c3.689.034 3.766 5.524.08 5.661zm-2.007-45.014a2.832 2.832 0 0 1-2.142 3.38 2.825 2.825 0 0 1-3.375-2.143 2.832 2.832 0 0 1 2.142-3.38 2.825 2.825 0 0 1 3.375 2.143zm-4.792 7.058 6.5-1.46a2.58 2.58 0 0 0 1.953-3.082l-.674-3.027c5.751-2.852 28.852 11.5-9.277 20.816a34.838 34.838 0 0 1 .57-9.62 35.23 35.23 0 0 1 .928-3.627zm12.325-17.399s13.435-7.05 21.244-6.96l3.374 5.331a2.574 2.574 0 0 0 3.556.796l5.688-3.614c9.634 3.863 16.862 11.785 20.037 21.306l-4.745 6.731a2.584 2.584 0 0 0 .619 3.596l5.736 4.053a36.116 36.116 0 0 1-1.112 5.939m-28.122-47.093a2.824 2.824 0 0 1 3.9.873 2.833 2.833 0 0 1-.875 3.906 2.822 2.822 0 0 1-3.9-.874 2.834 2.834 0 0 1 .875-3.905zm27.227 32.591a2.824 2.824 0 0 1 3.938-.68 2.832 2.832 0 0 1 .678 3.944 2.824 2.824 0 0 1-3.94.681 2.835 2.835 0 0 1-.676-3.945z" style="fill:#fff;fill-opacity:1;stroke-width:.909418" transform="translate(201.733 209.108)"/><path style="fill:#f7931a;fill-opacity:1;stroke-width:.913143" d="M-158.176-209.107a1.371 1.371 0 0 0-1.282.763l-2.116 4.215c-.385.068-.77.14-1.154.219l-3.512-3.153a1.368 1.368 0 0 0-1.31-.299 1.37 1.37 0 0 0-.942.957l-1.257 4.55c-.366.14-.73.288-1.09.438l-4.057-2.409a1.38 1.38 0 0 0-2.082 1.088l-.342 4.695c-.336.212-.667.43-.995.65l-4.44-1.565a1.383 1.383 0 0 0-1.83 1.471l.58 4.675c-.286.273-.567.55-.845.83l-4.663-.67a1.376 1.376 0 0 0-1.255.48 1.375 1.375 0 0 0-.252 1.32l1.483 4.48c-.225.32-.444.645-.66.97l-4.713.253a1.385 1.385 0 0 0-1.139.716c-.23.42-.226.93.01 1.345l2.33 4.106c-.158.356-.31.715-.46 1.076l-4.572 1.168a1.38 1.38 0 0 0-.704 2.242l3.08 3.565c-.087.385-.168.77-.244 1.158l-4.248 2.032a1.381 1.381 0 0 0-.253 2.336l3.712 2.892c-.01.395-.013.792-.011 1.189l-3.77 2.821a1.379 1.379 0 0 0 .21 2.34l4.213 2.117c.068.384.141.77.219 1.153l-3.153 3.511a1.378 1.378 0 0 0 .66 2.253l4.548 1.257c.141.366.288.73.438 1.09l-2.406 4.056a1.381 1.381 0 0 0 1.086 2.082l4.695.343c.212.335.43.667.65.995l-1.565 4.439a1.38 1.38 0 0 0 1.472 1.829l4.673-.58c.273.287.55.567.83.846l-.67 4.662c-.07.474.112.949.48 1.256.368.308.87.404 1.32.252l4.48-1.484c.321.226.643.444.969.66l.253 4.715c.026.478.295.906.716 1.136.419.232.927.225 1.344-.012l4.106-2.33c.358.16.717.313 1.078.46l1.168 4.574a1.38 1.38 0 0 0 2.24.703l3.565-3.078c.385.087.77.168 1.158.243l2.033 4.246a1.384 1.384 0 0 0 2.337.255l2.891-3.714c.397.01.793.014 1.19.012l2.82 3.768c.286.382.75.59 1.227.546a1.373 1.373 0 0 0 1.111-.755l2.118-4.214c.385-.066.771-.14 1.156-.216l3.511 3.152a1.381 1.381 0 0 0 2.253-.659l1.256-4.55c.365-.141.729-.288 1.09-.44l4.055 2.408c.411.245.92.259 1.343.036.425-.22.704-.645.739-1.122l.343-4.693c.334-.213.667-.43.995-.652l4.44 1.567a1.382 1.382 0 0 0 1.829-1.474l-.579-4.671c.286-.273.565-.552.844-.83l4.663.67a1.38 1.38 0 0 0 1.507-1.8l-1.483-4.482c.224-.32.445-.641.66-.968l4.712-.252c.479-.025.91-.295 1.138-.716.231-.42.226-.926-.01-1.342l-2.33-4.107c.159-.357.313-.716.46-1.078l4.573-1.167c.464-.117.834-.467.976-.924a1.375 1.375 0 0 0-.273-1.317l-3.078-3.564c.086-.386.168-.771.242-1.16l4.248-2.032a1.38 1.38 0 0 0 .253-2.334l-3.712-2.894c.008-.395.013-.791.012-1.189l3.767-2.82c.383-.287.592-.75.547-1.228a1.373 1.373 0 0 0-.755-1.11l-4.213-2.12c-.069-.384-.142-.77-.219-1.153l3.153-3.512a1.378 1.378 0 0 0-.659-2.252l-4.548-1.257a54.531 54.531 0 0 0-.438-1.09l2.405-4.055c.245-.412.26-.921.037-1.344a1.375 1.375 0 0 0-1.123-.739l-4.694-.343a51.33 51.33 0 0 0-.65-.995l1.565-4.437a1.38 1.38 0 0 0-1.472-1.83l-4.673.579a39.1 39.1 0 0 0-.83-.844l.671-4.664c.07-.473-.113-.95-.48-1.256a1.373 1.373 0 0 0-1.32-.252l-4.482 1.483c-.32-.224-.642-.444-.969-.658l-.25-4.714a1.38 1.38 0 0 0-2.062-1.128l-4.104 2.33a39.772 39.772 0 0 0-1.08-.461l-1.166-4.574a1.38 1.38 0 0 0-2.24-.703l-3.565 3.079a50.075 50.075 0 0 0-1.158-.244l-2.034-4.249a1.382 1.382 0 0 0-2.335-.252l-2.895 3.712a43.13 43.13 0 0 0-1.187-.01l-2.82-3.77a1.363 1.363 0 0 0-1.058-.555zm.678 8.751c.7-.038 1.415.179 1.99.662a2.801 2.801 0 0 1 .32 3.98c-2.486 2.757-6.695-.775-4.342-3.643a2.866 2.866 0 0 1 2.032-.999zm6.328 4.241c1.619.139 3.214.378 4.774.716l-2.714 10.96a250.01 250.01 0 0 0-4.79-1.127l2.59-10.384.02-.023zm-12.158 1.112.009.009a142.161 142.161 0 0 1 3.396 2.861c.002.002.007.006.007.008.006.007.012.011.019.017.67.586.965.858 1.019.908l-1.047 4.336c-1.301-.296-2.578-.589-3.818-.897l.007-.03-8.245-2.06-1.59 6.386s4.436 1.017 4.342 1.08c2.422.604 2.86 2.207 2.786 3.477l-2.789 11.189c.167.042.383.104.621.2-.199-.05-.412-.105-.631-.158l-3.91 15.675c-.296.735-1.047 1.839-2.74 1.42.06.087-4.345-1.085-4.345-1.085l-2.968 6.844 7.78 1.939c1.447.363 2.866.743 4.262 1.1l-1.205 4.879-4.538 1.4-.176.054a34.75 34.75 0 0 1-10.396-16.282 34.75 34.75 0 0 1-1.355-10.663l.015-.009c3.958-2.346 4.63-2.711 5.758-3.37.142-.083.275-.182.396-.293a2.61 2.61 0 0 0 .586-.791 2.765 2.765 0 0 0 .266-.962 2.592 2.592 0 0 0-.11-1.003 2.418 2.418 0 0 0-.215-.477l-3.023-5.158-.695-1.187a34.748 34.748 0 0 1 21.963-19.199l.002-.004c.187-.053.374-.105.561-.155zm22.858 1.434c5.966 2.426 11.157 6.457 14.925 11.949-.158.51-.318.957-.457 1.39-2.112 6.196-2.192 6.405-2.192 6.405a2.595 2.595 0 0 0-.135 1.015 2.592 2.592 0 0 0 .853 1.742c.25.224.548.402.885.517l5.656 1.933.876.299a34.748 34.748 0 0 1-7.039 28.657h-.006a117.303 117.303 0 0 1-4.83-.615c-.028-.005-.048-.007-.075-.013-.874-.136-1.267-.22-1.267-.22a2.585 2.585 0 0 0-1.487.243c-.148.073-.288.16-.419.26-.002 0-.004.002-.005.003a2.59 2.59 0 0 0-.655.736 2.557 2.557 0 0 0-.21.455l-.005.01c-.055.16-.096.329-.12.503l-.796 5.925-.159 1.183a34.75 34.75 0 0 1-7.236 3.047 34.74 34.74 0 0 1-12.732 1.25l2.66-10.7c10.194 1.93 17.86 1.151 21.087-8.07 2.6-7.423-.13-11.706-5.493-14.499 3.906-.9 6.849-3.47 7.634-8.777 1.084-7.25-4.437-11.148-11.985-13.748zm-15.041 15.065c3.375.84 14.244 2.41 12.489 9.455-1.686 6.754-12.09 3.322-15.465 2.481zm34.207.642c.288.005.592.052.91.15a2.794 2.794 0 0 1 1.763 3.578 2.885 2.885 0 0 1-3.63 1.775c-2.862-1.033-2.157-4.711.145-5.394.253-.075.524-.114.812-.11zm-67.455 6.008a2.84 2.84 0 0 1 2.27 1.187c2.059 3.052-2.484 6.22-4.685 3.267-.902-1.271-.586-3.033.708-3.933a2.89 2.89 0 0 1 1.707-.52zm28.77 11.31c4.052 1.012 17.048 3.015 15.117 10.757-1.847 7.424-14.348 3.411-18.4 2.405zm-5.226 20.356c1.631.442 3.215.85 4.765 1.236l-2.694 10.992a34.734 34.734 0 0 1-2.77-.87v-.003a3.618 3.618 0 0 0-.068-.256l-1.114-3.62zm34.523 3.106c1.498.063 2.953 1.177 2.727 3.128-.216 1.546-1.657 2.635-3.218 2.43a2.81 2.81 0 0 1-2.443-3.164c.205-1.25.988-1.987 1.91-2.267.33-.1.679-.141 1.024-.127zm-42.09 3.65c2.889.06 3.912 4.455.708 5.522-1.507.464-3.101-.366-3.558-1.854-.46-1.488.389-3.072 1.896-3.54.336-.095.655-.135.954-.129z" transform="translate(201.733 209.108)"/></svg>
\ No newline at end of file
diff --git a/logo/rust-bitcoin.png b/logo/rust-bitcoin.png
new file mode 100644
index 00000000..0f59dd16
Binary files /dev/null and b/logo/rust-bitcoin.png differ
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 00000000..2c104735
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1,77 @@
+ignore = []
+hard_tabs = false
+tab_spaces = 4
+newline_style = "Auto"
+indent_style = "Block"
+
+max_width = 100 # This is 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 = "2018"
+version = "One"
+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
+hide_parse_errors = false
+error_on_line_overflow = false
+error_on_unformatted = false
+emit_mode = "Files"
+make_backup = false
diff --git a/src/blockdata/block.rs b/src/blockdata/block.rs
deleted file mode 100644
index f67e8586..00000000
--- a/src/blockdata/block.rs
+++ /dev/null
@@ -1,285 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Bitcoin Block
-//!
-//! A block is a bundle of transactions with a proof-of-work attached,
-//! which commits to an earlier block to form the blockchain. This
-//! module describes structures and functions needed to describe
-//! these blocks and the blockchain.
-//!
-
-use util;
-use util::Error::{BlockBadTarget, BlockBadProofOfWork};
-use util::hash::{BitcoinHash, bitcoin_merkle_root};
-use hashes::{Hash, HashEngine};
-use hash_types::{Wtxid, BlockHash, TxMerkleNode, WitnessMerkleNode, WitnessCommitment};
-use util::uint::Uint256;
-use consensus::encode::Encodable;
-use network::constants::Network;
-use blockdata::transaction::Transaction;
-use blockdata::constants::max_target;
-
-/// A block header, which contains all the block's information except
-/// the actual transactions
-#[derive(Copy, PartialEq, Eq, Clone, Debug)]
-pub struct BlockHeader {
-    /// The protocol version. Should always be 1.
-    pub version: u32,
-    /// Reference to the previous block in the chain
-    pub prev_blockhash: BlockHash,
-    /// The root hash of the merkle tree of transactions in the block
-    pub merkle_root: TxMerkleNode,
-    /// The timestamp of the block, as claimed by the miner
-    pub time: u32,
-    /// The target value below which the blockhash must lie, encoded as a
-    /// a float (with well-defined rounding, of course)
-    pub bits: u32,
-    /// The nonce, selected to obtain a low enough blockhash
-    pub nonce: u32,
-}
-
-/// A Bitcoin block, which is a collection of transactions with an attached
-/// proof of work.
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct Block {
-    /// The block header
-    pub header: BlockHeader,
-    /// List of transactions contained in the block
-    pub txdata: Vec<Transaction>
-}
-
-impl Block {
-    /// check if merkle root of header matches merkle root of the transaction list
-    pub fn check_merkle_root (&self) -> bool {
-        self.header.merkle_root == self.merkle_root()
-    }
-
-    /// check if witness commitment in coinbase is matching the transaction list
-    pub fn check_witness_commitment(&self) -> bool {
-
-        // witness commitment is optional if there are no transactions using SegWit in the block
-        if self.txdata.iter().all(|t| t.input.iter().all(|i| i.witness.is_empty())) {
-            return true;
-        }
-        if self.txdata.len() > 0 {
-            let coinbase = &self.txdata[0];
-            if coinbase.is_coin_base() {
-                // commitment is in the last output that starts with below magic
-                if let Some(pos) = coinbase.output.iter()
-                    .rposition(|o| {
-                        o.script_pubkey.len () >= 38 &&
-                        o.script_pubkey[0..6] == [0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed] }) {
-                    let commitment = WitnessCommitment::from_slice(&coinbase.output[pos].script_pubkey.as_bytes()[6..38]).unwrap();
-                    // witness reserved value is in coinbase input witness
-                    if coinbase.input[0].witness.len() == 1 && coinbase.input[0].witness[0].len() == 32 {
-                        let witness_root = self.witness_root();
-                        return commitment == Self::compute_witness_commitment(&witness_root, coinbase.input[0].witness[0].as_slice())
-                    }
-                }
-            }
-        }
-        false
-    }
-
-    /// Calculate the transaction merkle root.
-    pub fn merkle_root(&self) -> TxMerkleNode {
-        let hashes = self.txdata.iter().map(|obj| obj.txid().as_hash());
-        bitcoin_merkle_root(hashes).into()
-    }
-
-    /// compute witness commitment for the transaction list
-    pub fn compute_witness_commitment (witness_root: &WitnessMerkleNode, witness_reserved_value: &[u8]) -> WitnessCommitment {
-        let mut encoder = WitnessCommitment::engine();
-        witness_root.consensus_encode(&mut encoder).unwrap();
-        encoder.input(witness_reserved_value);
-        WitnessCommitment::from_engine(encoder)
-    }
-
-    /// Merkle root of transactions hashed for witness
-    pub fn witness_root(&self) -> WitnessMerkleNode {
-        let hashes = self.txdata.iter().enumerate().map(|(i, t)|
-            if i == 0 {
-                // Replace the first hash with zeroes.
-                Wtxid::default().as_hash()
-            } else {
-                t.wtxid().as_hash()
-            }
-        );
-        bitcoin_merkle_root(hashes).into()
-    }
-}
-
-impl BlockHeader {
-    /// Computes the target [0, T] that a blockhash must land in to be valid
-    pub fn target(&self) -> Uint256 {
-        // This is a floating-point "compact" encoding originally used by
-        // OpenSSL, which satoshi put into consensus code, so we're stuck
-        // with it. The exponent needs to have 3 subtracted from it, hence
-        // this goofy decoding code:
-        let (mant, expt) = {
-            let unshifted_expt = self.bits >> 24;
-            if unshifted_expt <= 3 {
-                ((self.bits & 0xFFFFFF) >> (8 * (3 - unshifted_expt as usize)), 0)
-            } else {
-                (self.bits & 0xFFFFFF, 8 * ((self.bits >> 24) - 3))
-            }
-        };
-
-        // The mantissa is signed but may not be negative
-        if mant > 0x7FFFFF {
-            Default::default()
-        } else {
-            Uint256::from_u64(mant as u64).unwrap() << (expt as usize)
-        }
-    }
-
-    /// Computes the target value in float format from Uint256 format.
-    pub fn compact_target_from_u256(value: &Uint256) -> u32 {
-        let mut size = (value.bits() + 7) / 8;
-        let mut compact = if size <= 3 {
-            (value.low_u64() << (8 * (3 - size))) as u32
-        } else {
-            let bn = *value >> (8 * (size - 3));
-            bn.low_u32()
-        };
-
-        if (compact & 0x00800000) != 0 {
-            compact >>= 8;
-            size += 1;
-        }
-
-        compact | (size << 24) as u32
-    }
-
-    /// Compute the popular "difficulty" measure for mining
-    pub fn difficulty(&self, network: Network) -> u64 {
-        (max_target(network) / self.target()).low_u64()
-    }
-
-    /// Checks that the proof-of-work for the block is valid.
-    pub fn validate_pow(&self, required_target: &Uint256) -> Result<(), util::Error> {
-        let target = &self.target();
-        if target != required_target {
-            return Err(BlockBadTarget);
-        }
-        let data: [u8; 32] = self.bitcoin_hash().into_inner();
-        let mut ret = [0u64; 4];
-        util::endian::bytes_to_u64_slice_le(&data, &mut ret);
-        let hash = &Uint256(ret);
-        if hash <= target { Ok(()) } else { Err(BlockBadProofOfWork) }
-    }
-
-    /// Returns the total work of the block
-    pub fn work(&self) -> Uint256 {
-        // 2**256 / (target + 1) == ~target / (target+1) + 1    (eqn shamelessly stolen from bitcoind)
-        let mut ret = !self.target();
-        let mut ret1 = self.target();
-        ret1.increment();
-        ret = ret / ret1;
-        ret.increment();
-        ret
-    }
-}
-
-impl BitcoinHash<BlockHash> for BlockHeader {
-    fn bitcoin_hash(&self) -> BlockHash {
-        use consensus::encode::serialize;
-        BlockHash::hash(&serialize(self))
-    }
-}
-
-impl BitcoinHash<BlockHash> for Block {
-    fn bitcoin_hash(&self) -> BlockHash {
-        self.header.bitcoin_hash()
-    }
-}
-
-impl_consensus_encoding!(BlockHeader, version, prev_blockhash, merkle_root, time, bits, nonce);
-impl_consensus_encoding!(Block, header, txdata);
-serde_struct_impl!(BlockHeader, version, prev_blockhash, merkle_root, time, bits, nonce);
-serde_struct_impl!(Block, header, txdata);
-
-#[cfg(test)]
-mod tests {
-    use hex::decode as hex_decode;
-
-    use blockdata::block::{Block, BlockHeader};
-    use consensus::encode::{deserialize, serialize};
-
-    #[test]
-    fn block_test() {
-        let some_block = hex_decode("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914cd74d6e49ffff001d323b3a7b0201000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0804ffff001d026e04ffffffff0100f2052a0100000043410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac00000000010000000321f75f3139a013f50f315b23b0c9a2b6eac31e2bec98e5891c924664889942260000000049483045022100cb2c6b346a978ab8c61b18b5e9397755cbd17d6eb2fe0083ef32e067fa6c785a02206ce44e613f31d9a6b0517e46f3db1576e9812cc98d159bfdaf759a5014081b5c01ffffffff79cda0945903627c3da1f85fc95d0b8ee3e76ae0cfdc9a65d09744b1f8fc85430000000049483045022047957cdd957cfd0becd642f6b84d82f49b6cb4c51a91f49246908af7c3cfdf4a022100e96b46621f1bffcf5ea5982f88cef651e9354f5791602369bf5a82a6cd61a62501fffffffffe09f5fe3ffbf5ee97a54eb5e5069e9da6b4856ee86fc52938c2f979b0f38e82000000004847304402204165be9a4cbab8049e1af9723b96199bfd3e85f44c6b4c0177e3962686b26073022028f638da23fc003760861ad481ead4099312c60030d4cb57820ce4d33812a5ce01ffffffff01009d966b01000000434104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac00000000").unwrap();
-        let cutoff_block = hex_decode("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914cd74d6e49ffff001d323b3a7b0201000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0804ffff001d026e04ffffffff0100f2052a0100000043410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac00000000010000000321f75f3139a013f50f315b23b0c9a2b6eac31e2bec98e5891c924664889942260000000049483045022100cb2c6b346a978ab8c61b18b5e9397755cbd17d6eb2fe0083ef32e067fa6c785a02206ce44e613f31d9a6b0517e46f3db1576e9812cc98d159bfdaf759a5014081b5c01ffffffff79cda0945903627c3da1f85fc95d0b8ee3e76ae0cfdc9a65d09744b1f8fc85430000000049483045022047957cdd957cfd0becd642f6b84d82f49b6cb4c51a91f49246908af7c3cfdf4a022100e96b46621f1bffcf5ea5982f88cef651e9354f5791602369bf5a82a6cd61a62501fffffffffe09f5fe3ffbf5ee97a54eb5e5069e9da6b4856ee86fc52938c2f979b0f38e82000000004847304402204165be9a4cbab8049e1af9723b96199bfd3e85f44c6b4c0177e3962686b26073022028f638da23fc003760861ad481ead4099312c60030d4cb57820ce4d33812a5ce01ffffffff01009d966b01000000434104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").unwrap();
-
-        let prevhash = hex_decode("4ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000").unwrap();
-        let merkle = hex_decode("bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914c").unwrap();
-
-        let decode: Result<Block, _> = deserialize(&some_block);
-        let bad_decode: Result<Block, _> = deserialize(&cutoff_block);
-
-        assert!(decode.is_ok());
-        assert!(bad_decode.is_err());
-        let real_decode = decode.unwrap();
-        assert_eq!(real_decode.header.version, 1);
-        assert_eq!(serialize(&real_decode.header.prev_blockhash), prevhash);
-        assert_eq!(real_decode.header.merkle_root, real_decode.merkle_root());
-        assert_eq!(serialize(&real_decode.header.merkle_root), merkle);
-        assert_eq!(real_decode.header.time, 1231965655);
-        assert_eq!(real_decode.header.bits, 486604799);
-        assert_eq!(real_decode.header.nonce, 2067413810);
-        // [test] TODO: check the transaction data
-
-        // should be also ok for a non-witness block as commitment is optional in that case
-        assert!(real_decode.check_witness_commitment());
-
-        assert_eq!(serialize(&real_decode), some_block);
-    }
-
-    // Check testnet block 000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b
-    #[test]
-    fn segwit_block_test() {
-        let segwit_block = hex_decode("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").unwrap();
-
-        let decode: Result<Block, _> = deserialize(&segwit_block);
-
-        let prevhash = hex_decode("2aa2f2ca794ccbd40c16e2f3333f6b8b683f9e7179b2c4d74906000000000000").unwrap();
-        let merkle = hex_decode("10bc26e70a2f672ad420a6153dd0c28b40a6002c55531bfc99bf8994a8e8f67e").unwrap();
-
-        assert!(decode.is_ok());
-        let real_decode = decode.unwrap();
-        assert_eq!(real_decode.header.version, 0x20000000);  // VERSIONBITS but no bits set
-        assert_eq!(serialize(&real_decode.header.prev_blockhash), prevhash);
-        assert_eq!(serialize(&real_decode.header.merkle_root), merkle);
-        assert_eq!(real_decode.header.merkle_root, real_decode.merkle_root());
-        assert_eq!(real_decode.header.time, 1472004949);
-        assert_eq!(real_decode.header.bits, 0x1a06d450);
-        assert_eq!(real_decode.header.nonce, 1879759182);
-        // [test] TODO: check the transaction data
-
-        assert!(real_decode.check_witness_commitment());
-
-        assert_eq!(serialize(&real_decode), segwit_block);
-    }
-
-    #[test]
-    fn compact_roundrtip_test() {
-        let some_header = hex_decode("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914cd74d6e49ffff001d323b3a7b").unwrap();
-
-        let header: BlockHeader = deserialize(&some_header).expect("Can't deserialize correct block header");
-
-        assert_eq!(header.bits, BlockHeader::compact_target_from_u256(&header.target()));
-    }
-}
-
diff --git a/src/blockdata/constants.rs b/src/blockdata/constants.rs
deleted file mode 100644
index 23622918..00000000
--- a/src/blockdata/constants.rs
+++ /dev/null
@@ -1,207 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Blockdata constants
-//!
-//! This module provides various constants relating to the blockchain and
-//! consensus code. In particular, it defines the genesis block and its
-//! single transaction
-//!
-
-use std::default::Default;
-
-use hashes::hex::FromHex;
-use hashes::sha256d;
-use blockdata::opcodes;
-use blockdata::script;
-use blockdata::transaction::{OutPoint, Transaction, TxOut, TxIn};
-use blockdata::block::{Block, BlockHeader};
-use network::constants::Network;
-use util::uint::Uint256;
-
-/// The maximum allowable sequence number
-pub const MAX_SEQUENCE: u32 = 0xFFFFFFFF;
-/// How many satoshis are in "one bitcoin"
-pub const COIN_VALUE: u64 = 100_000_000;
-/// How many seconds between blocks we expect on average
-pub const TARGET_BLOCK_SPACING: u32 = 600;
-/// How many blocks between diffchanges
-pub const DIFFCHANGE_INTERVAL: u32 = 2016;
-/// How much time on average should occur between diffchanges
-pub const DIFFCHANGE_TIMESPAN: u32 = 14 * 24 * 3600;
-/// The maximum allowed weight for a block, see BIP 141 (network rule)
-pub const MAX_BLOCK_WEIGHT: u32 = 4_000_000;
-/// The minimum transaction weight for a valid serialized transaction
-pub const MIN_TRANSACTION_WEIGHT: u32 = 4 * 60;
-
-
-/// In Bitcoind this is insanely described as ~((u256)0 >> 32)
-pub fn max_target(_: Network) -> Uint256 {
-    Uint256::from_u64(0xFFFF).unwrap() << 208
-}
-
-/// The maximum value allowed in an output (useful for sanity checking,
-/// since keeping everything below this value should prevent overflows
-/// if you are doing anything remotely sane with monetary values).
-pub fn max_money(_: Network) -> u64 {
-    21_000_000 * COIN_VALUE
-}
-
-/// Constructs and returns the coinbase (and only) transaction of the Bitcoin genesis block
-fn bitcoin_genesis_tx() -> Transaction {
-    // Base
-    let mut ret = Transaction {
-        version: 1,
-        lock_time: 0,
-        input: vec![],
-        output: vec![],
-    };
-
-    // Inputs
-    let in_script = script::Builder::new().push_scriptint(486604799)
-                                          .push_scriptint(4)
-                                          .push_slice(b"The Times 03/Jan/2009 Chancellor on brink of second bailout for banks")
-                                          .into_script();
-    ret.input.push(TxIn {
-        previous_output: OutPoint::null(),
-        script_sig: in_script,
-        sequence: MAX_SEQUENCE,
-        witness: vec![],
-    });
-
-    // Outputs
-    let out_script = script::Builder::new()
-        .push_slice(&Vec::<u8>::from_hex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f").unwrap())
-        .push_opcode(opcodes::all::OP_CHECKSIG)
-        .into_script();
-    ret.output.push(TxOut {
-        value: 50 * COIN_VALUE,
-        script_pubkey: out_script
-    });
-
-    // end
-    ret
-}
-
-/// Constructs and returns the genesis block
-pub fn genesis_block(network: Network) -> Block {
-    let txdata = vec![bitcoin_genesis_tx()];
-    let hash: sha256d::Hash = txdata[0].txid().into();
-    let merkle_root = hash.into();
-    match network {
-        Network::Bitcoin => {
-            Block {
-                header: BlockHeader {
-                    version: 1,
-                    prev_blockhash: Default::default(),
-                    merkle_root,
-                    time: 1231006505,
-                    bits: 0x1d00ffff,
-                    nonce: 2083236893
-                },
-                txdata: txdata
-            }
-        }
-        Network::Testnet => {
-            Block {
-                header: BlockHeader {
-                    version: 1,
-                    prev_blockhash: Default::default(),
-                    merkle_root,
-                    time: 1296688602,
-                    bits: 0x1d00ffff,
-                    nonce: 414098458
-                },
-                txdata: txdata
-            }
-        }
-        Network::Regtest => {
-            Block {
-                header: BlockHeader {
-                    version: 1,
-                    prev_blockhash: Default::default(),
-                    merkle_root,
-                    time: 1296688602,
-                    bits: 0x207fffff,
-                    nonce: 2
-                },
-                txdata: txdata
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::default::Default;
-    use hex::decode as hex_decode;
-
-    use network::constants::Network;
-    use consensus::encode::serialize;
-    use blockdata::constants::{genesis_block, bitcoin_genesis_tx};
-    use blockdata::constants::{MAX_SEQUENCE, COIN_VALUE};
-    use util::hash::BitcoinHash;
-
-    #[test]
-    fn bitcoin_genesis_first_transaction() {
-        let gen = bitcoin_genesis_tx();
-
-        assert_eq!(gen.version, 1);
-        assert_eq!(gen.input.len(), 1);
-        assert_eq!(gen.input[0].previous_output.txid, Default::default());
-        assert_eq!(gen.input[0].previous_output.vout, 0xFFFFFFFF);
-        assert_eq!(serialize(&gen.input[0].script_sig),
-                   hex_decode("4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73").unwrap());
-
-        assert_eq!(gen.input[0].sequence, MAX_SEQUENCE);
-        assert_eq!(gen.output.len(), 1);
-        assert_eq!(serialize(&gen.output[0].script_pubkey),
-                   hex_decode("434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac").unwrap());
-        assert_eq!(gen.output[0].value, 50 * COIN_VALUE);
-        assert_eq!(gen.lock_time, 0);
-
-        assert_eq!(format!("{:x}", gen.wtxid()),
-                   "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b".to_string());
-    }
-
-    #[test]
-    fn bitcoin_genesis_full_block() {
-        let gen = genesis_block(Network::Bitcoin);
-
-        assert_eq!(gen.header.version, 1);
-        assert_eq!(gen.header.prev_blockhash, Default::default());
-        assert_eq!(format!("{:x}", gen.header.merkle_root),
-                   "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b".to_string());
-        assert_eq!(gen.header.time, 1231006505);
-        assert_eq!(gen.header.bits, 0x1d00ffff);
-        assert_eq!(gen.header.nonce, 2083236893);
-        assert_eq!(format!("{:x}", gen.header.bitcoin_hash()),
-                   "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f".to_string());
-    }
-
-    #[test]
-    fn testnet_genesis_full_block() {
-        let gen = genesis_block(Network::Testnet);
-        assert_eq!(gen.header.version, 1);
-        assert_eq!(gen.header.prev_blockhash, Default::default());
-        assert_eq!(format!("{:x}", gen.header.merkle_root),
-                  "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b".to_string());
-        assert_eq!(gen.header.time, 1296688602);
-        assert_eq!(gen.header.bits, 0x1d00ffff);
-        assert_eq!(gen.header.nonce, 414098458);
-        assert_eq!(format!("{:x}", gen.header.bitcoin_hash()),
-                   "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943".to_string());
-    }
-}
-
diff --git a/src/blockdata/mod.rs b/src/blockdata/mod.rs
deleted file mode 100644
index 4713b89c..00000000
--- a/src/blockdata/mod.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Blockdata
-//!
-//! This module defines structures and functions for storing the blocks and
-//! transactions which make up the Bitcoin system.
-//!
-
-pub mod constants;
-pub mod opcodes;
-pub mod script;
-pub mod transaction;
-pub mod block;
-
diff --git a/src/blockdata/opcodes.rs b/src/blockdata/opcodes.rs
deleted file mode 100644
index 724b16c2..00000000
--- a/src/blockdata/opcodes.rs
+++ /dev/null
@@ -1,1097 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Opcodes
-//!
-//! Bitcoin's script uses a stack-based assembly language. This module defines
-//! all of the opcodes
-//!
-
-#![allow(non_camel_case_types)]
-
-#[cfg(feature = "serde")] use serde;
-
-use std::fmt;
-
-// Note: I am deliberately not implementing PartialOrd or Ord on the
-//       opcode enum. If you want to check ranges of opcodes, etc.,
-//       write an #[inline] helper function which casts to u8s.
-
-/// A script Opcode
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub struct All {
-    code: u8,
-}
-
-pub mod all {
-    //! Constants associated with All type
-    use super::All;
-
-    /// Push an empty array onto the stack
-    pub const OP_PUSHBYTES_0: All = All {code: 0x00};
-    /// Push the next byte as an array onto the stack
-    pub const OP_PUSHBYTES_1: All = All {code: 0x01};
-    /// Push the next 2 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_2: All = All {code: 0x02};
-    /// Push the next 2 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_3: All = All {code: 0x03};
-    /// Push the next 4 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_4: All = All {code: 0x04};
-    /// Push the next 5 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_5: All = All {code: 0x05};
-    /// Push the next 6 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_6: All = All {code: 0x06};
-    /// Push the next 7 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_7: All = All {code: 0x07};
-    /// Push the next 8 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_8: All = All {code: 0x08};
-    /// Push the next 9 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_9: All = All {code: 0x09};
-    /// Push the next 10 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_10: All = All {code: 0x0a};
-    /// Push the next 11 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_11: All = All {code: 0x0b};
-    /// Push the next 12 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_12: All = All {code: 0x0c};
-    /// Push the next 13 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_13: All = All {code: 0x0d};
-    /// Push the next 14 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_14: All = All {code: 0x0e};
-    /// Push the next 15 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_15: All = All {code: 0x0f};
-    /// Push the next 16 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_16: All = All {code: 0x10};
-    /// Push the next 17 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_17: All = All {code: 0x11};
-    /// Push the next 18 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_18: All = All {code: 0x12};
-    /// Push the next 19 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_19: All = All {code: 0x13};
-    /// Push the next 20 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_20: All = All {code: 0x14};
-    /// Push the next 21 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_21: All = All {code: 0x15};
-    /// Push the next 22 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_22: All = All {code: 0x16};
-    /// Push the next 23 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_23: All = All {code: 0x17};
-    /// Push the next 24 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_24: All = All {code: 0x18};
-    /// Push the next 25 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_25: All = All {code: 0x19};
-    /// Push the next 26 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_26: All = All {code: 0x1a};
-    /// Push the next 27 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_27: All = All {code: 0x1b};
-    /// Push the next 28 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_28: All = All {code: 0x1c};
-    /// Push the next 29 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_29: All = All {code: 0x1d};
-    /// Push the next 30 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_30: All = All {code: 0x1e};
-    /// Push the next 31 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_31: All = All {code: 0x1f};
-    /// Push the next 32 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_32: All = All {code: 0x20};
-    /// Push the next 33 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_33: All = All {code: 0x21};
-    /// Push the next 34 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_34: All = All {code: 0x22};
-    /// Push the next 35 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_35: All = All {code: 0x23};
-    /// Push the next 36 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_36: All = All {code: 0x24};
-    /// Push the next 37 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_37: All = All {code: 0x25};
-    /// Push the next 38 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_38: All = All {code: 0x26};
-    /// Push the next 39 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_39: All = All {code: 0x27};
-    /// Push the next 40 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_40: All = All {code: 0x28};
-    /// Push the next 41 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_41: All = All {code: 0x29};
-    /// Push the next 42 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_42: All = All {code: 0x2a};
-    /// Push the next 43 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_43: All = All {code: 0x2b};
-    /// Push the next 44 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_44: All = All {code: 0x2c};
-    /// Push the next 45 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_45: All = All {code: 0x2d};
-    /// Push the next 46 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_46: All = All {code: 0x2e};
-    /// Push the next 47 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_47: All = All {code: 0x2f};
-    /// Push the next 48 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_48: All = All {code: 0x30};
-    /// Push the next 49 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_49: All = All {code: 0x31};
-    /// Push the next 50 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_50: All = All {code: 0x32};
-    /// Push the next 51 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_51: All = All {code: 0x33};
-    /// Push the next 52 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_52: All = All {code: 0x34};
-    /// Push the next 53 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_53: All = All {code: 0x35};
-    /// Push the next 54 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_54: All = All {code: 0x36};
-    /// Push the next 55 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_55: All = All {code: 0x37};
-    /// Push the next 56 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_56: All = All {code: 0x38};
-    /// Push the next 57 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_57: All = All {code: 0x39};
-    /// Push the next 58 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_58: All = All {code: 0x3a};
-    /// Push the next 59 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_59: All = All {code: 0x3b};
-    /// Push the next 60 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_60: All = All {code: 0x3c};
-    /// Push the next 61 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_61: All = All {code: 0x3d};
-    /// Push the next 62 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_62: All = All {code: 0x3e};
-    /// Push the next 63 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_63: All = All {code: 0x3f};
-    /// Push the next 64 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_64: All = All {code: 0x40};
-    /// Push the next 65 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_65: All = All {code: 0x41};
-    /// Push the next 66 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_66: All = All {code: 0x42};
-    /// Push the next 67 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_67: All = All {code: 0x43};
-    /// Push the next 68 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_68: All = All {code: 0x44};
-    /// Push the next 69 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_69: All = All {code: 0x45};
-    /// Push the next 70 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_70: All = All {code: 0x46};
-    /// Push the next 71 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_71: All = All {code: 0x47};
-    /// Push the next 72 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_72: All = All {code: 0x48};
-    /// Push the next 73 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_73: All = All {code: 0x49};
-    /// Push the next 74 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_74: All = All {code: 0x4a};
-    /// Push the next 75 bytes as an array onto the stack
-    pub const OP_PUSHBYTES_75: All = All {code: 0x4b};
-    /// Read the next byte as N; push the next N bytes as an array onto the stack
-    pub const OP_PUSHDATA1: All = All {code: 0x4c};
-    /// Read the next 2 bytes as N; push the next N bytes as an array onto the stack
-    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
-    pub const OP_PUSHNUM_NEG1: All = All {code: 0x4f};
-    /// Synonym for OP_RETURN
-    pub const OP_RESERVED: All = All {code: 0x50};
-    /// Push the array [0x01] onto the stack
-    pub const OP_PUSHNUM_1: All = All {code: 0x51};
-    /// Push the array [0x02] onto the stack
-    pub const OP_PUSHNUM_2: All = All {code: 0x52};
-    /// Push the array [0x03] onto the stack
-    pub const OP_PUSHNUM_3: All = All {code: 0x53};
-    /// Push the array [0x04] onto the stack
-    pub const OP_PUSHNUM_4: All = All {code: 0x54};
-    /// Push the array [0x05] onto the stack
-    pub const OP_PUSHNUM_5: All = All {code: 0x55};
-    /// Push the array [0x06] onto the stack
-    pub const OP_PUSHNUM_6: All = All {code: 0x56};
-    /// Push the array [0x07] onto the stack
-    pub const OP_PUSHNUM_7: All = All {code: 0x57};
-    /// Push the array [0x08] onto the stack
-    pub const OP_PUSHNUM_8: All = All {code: 0x58};
-    /// Push the array [0x09] onto the stack
-    pub const OP_PUSHNUM_9: All = All {code: 0x59};
-    /// Push the array [0x0a] onto the stack
-    pub const OP_PUSHNUM_10: All = All {code: 0x5a};
-    /// Push the array [0x0b] onto the stack
-    pub const OP_PUSHNUM_11: All = All {code: 0x5b};
-    /// Push the array [0x0c] onto the stack
-    pub const OP_PUSHNUM_12: All = All {code: 0x5c};
-    /// Push the array [0x0d] onto the stack
-    pub const OP_PUSHNUM_13: All = All {code: 0x5d};
-    /// Push the array [0x0e] onto the stack
-    pub const OP_PUSHNUM_14: All = All {code: 0x5e};
-    /// Push the array [0x0f] onto the stack
-    pub const OP_PUSHNUM_15: All = All {code: 0x5f};
-    /// 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
-    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};
-    /// Pop and execute the next statements if a zero element was popped
-    pub const OP_NOTIF: All = All {code: 0x64};
-    /// Fail the script unconditionally, does not even need to be executed
-    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.
-    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};
-    /// If the top value is zero or the stack is empty, fail; otherwise, pop the stack
-    pub const OP_VERIFY: All = All {code: 0x69};
-    /// Fail the script immediately. (Must be executed.)
-    pub const OP_RETURN: All = All {code: 0x6a};
-    /// Pop one element from the main stack onto the alt stack
-    pub const OP_TOALTSTACK: All = All {code: 0x6b};
-    /// Pop one element from the alt stack onto the main stack
-    pub const OP_FROMALTSTACK: All = All {code: 0x6c};
-    /// Drops the top two stack items
-    pub const OP_2DROP: All = All {code: 0x6d};
-    /// Duplicates the top two stack items as AB -> ABAB
-    pub const OP_2DUP: All = All {code: 0x6e};
-    /// 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
-    pub const OP_2OVER: All = All {code: 0x70};
-    /// Moves the two stack items four spaces back to the front,
-    /// 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};
-    /// Duplicate the top stack element unless it is zero
-    pub const OP_IFDUP: All = All {code: 0x73};
-    /// Push the current number of stack items onto the stack
-    pub const OP_DEPTH: All = All {code: 0x74};
-    /// Drops the top stack item
-    pub const OP_DROP: All = All {code: 0x75};
-    /// Duplicates the top stack item
-    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
-    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};
-    /// Pop the top stack element as N. Move the Nth stack element to the top
-    pub const OP_ROLL: All = All {code: 0x7a};
-    /// Rotate the top three stack items, as [top next1 next2] -> [next2 top next1]
-    pub const OP_ROT: All = All {code: 0x7b};
-    /// Swap the top two stack items
-    pub const OP_SWAP: All = All {code: 0x7c};
-    /// Copy the top stack item to before the second item, as [top next] -> [top next top]
-    pub const OP_TUCK: All = All {code: 0x7d};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_CAT: All = All {code: 0x7e};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_SUBSTR: All = All {code: 0x7f};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_LEFT: All = All {code: 0x80};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_RIGHT: All = All {code: 0x81};
-    /// Pushes the length of the top stack item onto the stack
-    pub const OP_SIZE: All = All {code: 0x82};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_INVERT: All = All {code: 0x83};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_AND: All = All {code: 0x84};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_OR: All = All {code: 0x85};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_XOR: All = All {code: 0x86};
-    /// Pushes 1 if the inputs are exactly equal, 0 otherwise
-    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
-    pub const OP_RESERVED1: All = All {code: 0x89};
-    /// 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};
-    /// Decrement the top stack element in place
-    pub const OP_1SUB: All = All {code: 0x8c};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_2MUL: All = All {code: 0x8d};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_2DIV: All = All {code: 0x8e};
-    /// Multiply the top stack item by -1 in place
-    pub const OP_NEGATE: All = All {code: 0x8f};
-    /// Absolute value the top stack item in place
-    pub const OP_ABS: All = All {code: 0x90};
-    /// Map 0 to 1 and everything else to 0, in place
-    pub const OP_NOT: All = All {code: 0x91};
-    /// Map 0 to 0 and everything else to 1, in place
-    pub const OP_0NOTEQUAL: All = All {code: 0x92};
-    /// Pop two stack items and push their sum
-    pub const OP_ADD: All = All {code: 0x93};
-    /// Pop two stack items and push the second minus the top
-    pub const OP_SUB: All = All {code: 0x94};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_MUL: All = All {code: 0x95};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_DIV: All = All {code: 0x96};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_MOD: All = All {code: 0x97};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_LSHIFT: All = All {code: 0x98};
-    /// Fail the script unconditionally, does not even need to be executed
-    pub const OP_RSHIFT: All = All {code: 0x99};
-    /// Pop the top two stack items and push 1 if both are nonzero, else push 0
-    pub const OP_BOOLAND: All = All {code: 0x9a};
-    /// Pop the top two stack items and push 1 if either is nonzero, else push 0
-    pub const OP_BOOLOR: All = All {code: 0x9b};
-    /// Pop the top two stack items and push 1 if both are numerically equal, else push 0
-    pub const OP_NUMEQUAL: All = All {code: 0x9c};
-    /// Pop the top two stack items and return success if both are numerically equal, else return failure
-    pub const OP_NUMEQUALVERIFY: All = All {code: 0x9d};
-    /// Pop the top two stack items and push 0 if both are numerically equal, else push 1
-    pub const OP_NUMNOTEQUAL: All = All {code: 0x9e};
-    /// Pop the top two items; push 1 if the second is less than the top, 0 otherwise
-    pub const OP_LESSTHAN : All = All {code: 0x9f};
-    /// Pop the top two items; push 1 if the second is greater than the top, 0 otherwise
-    pub const OP_GREATERTHAN : All = All {code: 0xa0};
-    /// Pop the top two items; push 1 if the second is <= the top, 0 otherwise
-    pub const OP_LESSTHANOREQUAL : All = All {code: 0xa1};
-    /// Pop the top two items; push 1 if the second is >= the top, 0 otherwise
-    pub const OP_GREATERTHANOREQUAL : All = All {code: 0xa2};
-    /// Pop the top two items; push the smaller
-    pub const OP_MIN: All = All {code: 0xa3};
-    /// Pop the top two items; push the larger
-    pub const OP_MAX: All = All {code: 0xa4};
-    /// Pop the top three items; if the top is >= the second and < the third, push 1, otherwise push 0
-    pub const OP_WITHIN: All = All {code: 0xa5};
-    /// Pop the top stack item and push its RIPEMD160 hash
-    pub const OP_RIPEMD160: All = All {code: 0xa6};
-    /// Pop the top stack item and push its SHA1 hash
-    pub const OP_SHA1: All = All {code: 0xa7};
-    /// Pop the top stack item and push its SHA256 hash
-    pub const OP_SHA256: All = All {code: 0xa8};
-    /// Pop the top stack item and push its RIPEMD(SHA256) hash
-    pub const OP_HASH160: All = All {code: 0xa9};
-    /// Pop the top stack item and push its SHA256(SHA256) hash
-    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
-    pub const OP_CHECKSIG: All = All {code: 0xac};
-    /// 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
-    pub const OP_CHECKMULTISIG: All = All {code: 0xae};
-    /// Like the above but return success/failure
-    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
-    pub const OP_CLTV: All = All {code: 0xb1};
-    /// 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};
-    /// Does nothing
-    pub const OP_NOP5: All = All {code: 0xb4};
-    /// Does nothing
-    pub const OP_NOP6: All = All {code: 0xb5};
-    /// Does nothing
-    pub const OP_NOP7: All = All {code: 0xb6};
-    /// Does nothing
-    pub const OP_NOP8: All = All {code: 0xb7};
-    /// Does nothing
-    pub const OP_NOP9: All = All {code: 0xb8};
-    /// Does nothing
-    pub const OP_NOP10: All = All {code: 0xb9};
-    // Every other opcode acts as OP_RETURN
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_186: All = All {code: 0xba};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_187: All = All {code: 0xbb};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_188: All = All {code: 0xbc};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_189: All = All {code: 0xbd};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_190: All = All {code: 0xbe};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_191: All = All {code: 0xbf};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_192: All = All {code: 0xc0};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_193: All = All {code: 0xc1};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_194: All = All {code: 0xc2};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_195: All = All {code: 0xc3};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_196: All = All {code: 0xc4};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_197: All = All {code: 0xc5};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_198: All = All {code: 0xc6};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_199: All = All {code: 0xc7};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_200: All = All {code: 0xc8};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_201: All = All {code: 0xc9};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_202: All = All {code: 0xca};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_203: All = All {code: 0xcb};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_204: All = All {code: 0xcc};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_205: All = All {code: 0xcd};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_206: All = All {code: 0xce};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_207: All = All {code: 0xcf};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_208: All = All {code: 0xd0};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_209: All = All {code: 0xd1};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_210: All = All {code: 0xd2};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_211: All = All {code: 0xd3};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_212: All = All {code: 0xd4};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_213: All = All {code: 0xd5};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_214: All = All {code: 0xd6};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_215: All = All {code: 0xd7};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_216: All = All {code: 0xd8};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_217: All = All {code: 0xd9};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_218: All = All {code: 0xda};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_219: All = All {code: 0xdb};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_220: All = All {code: 0xdc};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_221: All = All {code: 0xdd};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_222: All = All {code: 0xde};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_223: All = All {code: 0xdf};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_224: All = All {code: 0xe0};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_225: All = All {code: 0xe1};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_226: All = All {code: 0xe2};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_227: All = All {code: 0xe3};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_228: All = All {code: 0xe4};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_229: All = All {code: 0xe5};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_230: All = All {code: 0xe6};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_231: All = All {code: 0xe7};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_232: All = All {code: 0xe8};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_233: All = All {code: 0xe9};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_234: All = All {code: 0xea};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_235: All = All {code: 0xeb};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_236: All = All {code: 0xec};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_237: All = All {code: 0xed};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_238: All = All {code: 0xee};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_239: All = All {code: 0xef};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_240: All = All {code: 0xf0};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_241: All = All {code: 0xf1};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_242: All = All {code: 0xf2};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_243: All = All {code: 0xf3};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_244: All = All {code: 0xf4};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_245: All = All {code: 0xf5};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_246: All = All {code: 0xf6};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_247: All = All {code: 0xf7};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_248: All = All {code: 0xf8};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_249: All = All {code: 0xf9};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_250: All = All {code: 0xfa};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_251: All = All {code: 0xfb};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_252: All = All {code: 0xfc};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_253: All = All {code: 0xfd};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_254: All = All {code: 0xfe};
-    /// Synonym for OP_RETURN
-    pub const OP_RETURN_255: All = All {code: 0xff};
-}
-
-impl fmt::Debug for All {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("OP_")?;
-        match *self {
-            All {code: x} if x <= 75 => write!(f, "PUSHBYTES_{}", self.code),
-            all::OP_PUSHDATA1 => write!(f, "PUSHDATA1"),
-            all::OP_PUSHDATA2 => write!(f, "PUSHDATA2"),
-            all::OP_PUSHDATA4 => write!(f, "PUSHDATA4"),
-            all::OP_PUSHNUM_NEG1 => write!(f, "PUSHNUM_NEG1"),
-            all::OP_RESERVED => write!(f, "RESERVED"),
-            All {code: x} if x >= all::OP_PUSHNUM_1.code && x <= all::OP_PUSHNUM_16.code => write!(f, "PUSHNUM_{}", x - all::OP_PUSHNUM_1.code + 1),
-            all::OP_NOP => write!(f, "NOP"),
-            all::OP_VER => write!(f, "VER"),
-            all::OP_IF => write!(f, "IF"),
-            all::OP_NOTIF => write!(f, "NOTIF"),
-            all::OP_VERIF => write!(f, "VERIF"),
-            all::OP_VERNOTIF => write!(f, "VERNOTIF"),
-            all::OP_ELSE => write!(f, "ELSE"),
-            all::OP_ENDIF => write!(f, "ENDIF"),
-            all::OP_VERIFY => write!(f, "VERIFY"),
-            all::OP_RETURN => write!(f, "RETURN"),
-            all::OP_TOALTSTACK => write!(f, "TOALTSTACK"),
-            all::OP_FROMALTSTACK => write!(f, "FROMALTSTACK"),
-            all::OP_2DROP => write!(f, "2DROP"),
-            all::OP_2DUP => write!(f, "2DUP"),
-            all::OP_3DUP => write!(f, "3DUP"),
-            all::OP_2OVER => write!(f, "2OVER"),
-            all::OP_2ROT => write!(f, "2ROT"),
-            all::OP_2SWAP => write!(f, "2SWAP"),
-            all::OP_IFDUP => write!(f, "IFDUP"),
-            all::OP_DEPTH => write!(f, "DEPTH"),
-            all::OP_DROP => write!(f, "DROP"),
-            all::OP_DUP => write!(f, "DUP"),
-            all::OP_NIP => write!(f, "NIP"),
-            all::OP_OVER => write!(f, "OVER"),
-            all::OP_PICK => write!(f, "PICK"),
-            all::OP_ROLL => write!(f, "ROLL"),
-            all::OP_ROT => write!(f, "ROT"),
-            all::OP_SWAP => write!(f, "SWAP"),
-            all::OP_TUCK => write!(f, "TUCK"),
-            all::OP_CAT => write!(f, "CAT"),
-            all::OP_SUBSTR => write!(f, "SUBSTR"),
-            all::OP_LEFT => write!(f, "LEFT"),
-            all::OP_RIGHT => write!(f, "RIGHT"),
-            all::OP_SIZE => write!(f, "SIZE"),
-            all::OP_INVERT => write!(f, "INVERT"),
-            all::OP_AND => write!(f, "AND"),
-            all::OP_OR => write!(f, "OR"),
-            all::OP_XOR => write!(f, "XOR"),
-            all::OP_EQUAL => write!(f, "EQUAL"),
-            all::OP_EQUALVERIFY => write!(f, "EQUALVERIFY"),
-            all::OP_RESERVED1 => write!(f, "RESERVED1"),
-            all::OP_RESERVED2 => write!(f, "RESERVED2"),
-            all::OP_1ADD => write!(f, "1ADD"),
-            all::OP_1SUB => write!(f, "1SUB"),
-            all::OP_2MUL => write!(f, "2MUL"),
-            all::OP_2DIV => write!(f, "2DIV"),
-            all::OP_NEGATE => write!(f, "NEGATE"),
-            all::OP_ABS => write!(f, "ABS"),
-            all::OP_NOT => write!(f, "NOT"),
-            all::OP_0NOTEQUAL => write!(f, "0NOTEQUAL"),
-            all::OP_ADD => write!(f, "ADD"),
-            all::OP_SUB => write!(f, "SUB"),
-            all::OP_MUL => write!(f, "MUL"),
-            all::OP_DIV => write!(f, "DIV"),
-            all::OP_MOD => write!(f, "MOD"),
-            all::OP_LSHIFT => write!(f, "LSHIFT"),
-            all::OP_RSHIFT => write!(f, "RSHIFT"),
-            all::OP_BOOLAND => write!(f, "BOOLAND"),
-            all::OP_BOOLOR => write!(f, "BOOLOR"),
-            all::OP_NUMEQUAL => write!(f, "NUMEQUAL"),
-            all::OP_NUMEQUALVERIFY => write!(f, "NUMEQUALVERIFY"),
-            all::OP_NUMNOTEQUAL => write!(f, "NUMNOTEQUAL"),
-            all::OP_LESSTHAN  => write!(f, "LESSTHAN"),
-            all::OP_GREATERTHAN  => write!(f, "GREATERTHAN"),
-            all::OP_LESSTHANOREQUAL  => write!(f, "LESSTHANOREQUAL"),
-            all::OP_GREATERTHANOREQUAL  => write!(f, "GREATERTHANOREQUAL"),
-            all::OP_MIN => write!(f, "MIN"),
-            all::OP_MAX => write!(f, "MAX"),
-            all::OP_WITHIN => write!(f, "WITHIN"),
-            all::OP_RIPEMD160 => write!(f, "RIPEMD160"),
-            all::OP_SHA1 => write!(f, "SHA1"),
-            all::OP_SHA256 => write!(f, "SHA256"),
-            all::OP_HASH160 => write!(f, "HASH160"),
-            all::OP_HASH256 => write!(f, "HASH256"),
-            all::OP_CODESEPARATOR => write!(f, "CODESEPARATOR"),
-            all::OP_CHECKSIG => write!(f, "CHECKSIG"),
-            all::OP_CHECKSIGVERIFY => write!(f, "CHECKSIGVERIFY"),
-            all::OP_CHECKMULTISIG => write!(f, "CHECKMULTISIG"),
-            all::OP_CHECKMULTISIGVERIFY => write!(f, "CHECKMULTISIGVERIFY"),
-            all::OP_CLTV => write!(f, "CLTV"),
-            all::OP_CSV => write!(f, "CSV"),
-            All {code: x} if x >= all::OP_NOP1.code && x <= all::OP_NOP10.code => write!(f, "NOP{}", x - all::OP_NOP1.code + 1),
-            All {code: x} => write!(f, "RETURN_{}", x),
-        }
-    }
-}
-
-impl All {
-    /// Classifies an Opcode into a broad class
-    #[inline]
-    pub fn classify(&self) -> Class {
-        // 17 opcodes
-        if *self == all::OP_VERIF || *self == all::OP_VERNOTIF ||
-           *self == all::OP_CAT || *self == all::OP_SUBSTR ||
-           *self == all::OP_LEFT || *self == all::OP_RIGHT ||
-           *self == all::OP_INVERT || *self == all::OP_AND ||
-           *self == all::OP_OR || *self == all::OP_XOR ||
-           *self == all::OP_2MUL || *self == all::OP_2DIV ||
-           *self == all::OP_MUL || *self == all::OP_DIV || *self == all::OP_MOD ||
-           *self == all::OP_LSHIFT || *self == all::OP_RSHIFT {
-            Class::IllegalOp
-        // 11 opcodes
-        } else if *self == all::OP_NOP ||
-                  (all::OP_NOP1.code <= self.code &&
-                   self.code <= all::OP_NOP10.code) {
-            Class::NoOp
-        // 75 opcodes
-        } else if *self == all::OP_RESERVED || *self == all::OP_VER || *self == all::OP_RETURN ||
-                  *self == all::OP_RESERVED1 || *self == all::OP_RESERVED2 ||
-                  self.code >= all::OP_RETURN_186.code {
-            Class::ReturnOp
-        // 1 opcode
-        } else if *self == all::OP_PUSHNUM_NEG1 {
-            Class::PushNum(-1)
-        // 16 opcodes
-        } else if all::OP_PUSHNUM_1.code <= self.code &&
-                  self.code <= all::OP_PUSHNUM_16.code {
-            Class::PushNum(1 + self.code as i32 - all::OP_PUSHNUM_1.code as i32)
-        // 76 opcodes
-        } else if self.code <= all::OP_PUSHBYTES_75.code {
-            Class::PushBytes(self.code as u32)
-        // 60 opcodes
-        } else {
-            Class::Ordinary(Ordinary::try_from_all(*self).unwrap())
-        }
-    }
-
-    /// Encode as a byte
-    #[inline]
-    pub fn into_u8(&self) -> u8 {
-        self.code
-    }
-}
-
-impl From<u8> for All {
-    #[inline]
-    fn from(b: u8) -> All {
-        All {code: b}
-    }
-}
-
-
-display_from_debug!(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
-pub static OP_NOP2: All = all::OP_CLTV;
-/// previously called OP_NOP3
-pub static OP_NOP3: All = all::OP_CSV;
-
-/// Broad categories of opcodes with similar behavior
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum Class {
-    /// Pushes the given number onto the stack
-    PushNum(i32),
-    /// Pushes the given number of bytes onto the stack
-    PushBytes(u32),
-    /// Fails the script if executed
-    ReturnOp,
-    /// Fails the script even if not executed
-    IllegalOp,
-    /// Does nothing
-    NoOp,
-    /// Any opcode not covered above
-    Ordinary(Ordinary)
-}
-
-display_from_debug!(Class);
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for Class {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
-macro_rules! ordinary_opcode {
-    ($($op:ident),*) => (
-        #[repr(u8)]
-        #[doc(hidden)]
-        #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-        pub enum Ordinary {
-            $( $op = all::$op.code ),*
-        }
-
-        impl Ordinary {
-            /// Try to create from an All
-            pub fn try_from_all(b: All) -> Option<Self> {
-                match b {
-                    $( all::$op => { Some(Ordinary::$op) } ),*
-                    _ => None,
-                }
-            }
-        }
-    );
-}
-
-// "Ordinary" opcodes -- should be 60 of these
-ordinary_opcode! {
-    // pushdata
-    OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4,
-    // control flow
-    OP_IF, OP_NOTIF, OP_ELSE, OP_ENDIF, OP_VERIFY,
-    // stack
-    OP_TOALTSTACK, OP_FROMALTSTACK,
-    OP_2DROP, OP_2DUP, OP_3DUP, OP_2OVER, OP_2ROT, OP_2SWAP,
-    OP_DROP, OP_DUP, OP_NIP, OP_OVER, OP_PICK, OP_ROLL, OP_ROT, OP_SWAP, OP_TUCK,
-    OP_IFDUP, OP_DEPTH, OP_SIZE,
-    // equality
-    OP_EQUAL, OP_EQUALVERIFY,
-    // arithmetic
-    OP_1ADD, OP_1SUB, OP_NEGATE, OP_ABS, OP_NOT, OP_0NOTEQUAL,
-    OP_ADD, OP_SUB, OP_BOOLAND, OP_BOOLOR,
-    OP_NUMEQUAL, OP_NUMEQUALVERIFY, OP_NUMNOTEQUAL, OP_LESSTHAN,
-    OP_GREATERTHAN, OP_LESSTHANOREQUAL, OP_GREATERTHANOREQUAL,
-    OP_MIN, OP_MAX, OP_WITHIN,
-    // crypto
-    OP_RIPEMD160, OP_SHA1, OP_SHA256, OP_HASH160, OP_HASH256,
-    OP_CODESEPARATOR, OP_CHECKSIG, OP_CHECKSIGVERIFY,
-    OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY
-}
-
-impl Ordinary {
-    /// Encode as a byte
-    #[inline]
-    pub fn into_u8(&self) -> u8 {
-      *self as u8
-  }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashSet;
-
-    use super::*;
-
-    macro_rules! roundtrip {
-        ($unique:expr, $op:ident) => {
-            assert_eq!(all::$op, All::from(all::$op.into_u8()));
-
-            let s1 = format!("{}", all::$op);
-            let s2 = format!("{:?}", all::$op);
-            assert_eq!(s1, s2);
-            assert_eq!(s1, stringify!($op));
-            assert!($unique.insert(s1));
-        }
-    }
-
-    #[test]
-    fn str_roundtrip() {
-        let mut unique = HashSet::new();
-        roundtrip!(unique, OP_PUSHBYTES_0);
-        roundtrip!(unique, OP_PUSHBYTES_1);
-        roundtrip!(unique, OP_PUSHBYTES_2);
-        roundtrip!(unique, OP_PUSHBYTES_3);
-        roundtrip!(unique, OP_PUSHBYTES_4);
-        roundtrip!(unique, OP_PUSHBYTES_5);
-        roundtrip!(unique, OP_PUSHBYTES_6);
-        roundtrip!(unique, OP_PUSHBYTES_7);
-        roundtrip!(unique, OP_PUSHBYTES_8);
-        roundtrip!(unique, OP_PUSHBYTES_9);
-        roundtrip!(unique, OP_PUSHBYTES_10);
-        roundtrip!(unique, OP_PUSHBYTES_11);
-        roundtrip!(unique, OP_PUSHBYTES_12);
-        roundtrip!(unique, OP_PUSHBYTES_13);
-        roundtrip!(unique, OP_PUSHBYTES_14);
-        roundtrip!(unique, OP_PUSHBYTES_15);
-        roundtrip!(unique, OP_PUSHBYTES_16);
-        roundtrip!(unique, OP_PUSHBYTES_17);
-        roundtrip!(unique, OP_PUSHBYTES_18);
-        roundtrip!(unique, OP_PUSHBYTES_19);
-        roundtrip!(unique, OP_PUSHBYTES_20);
-        roundtrip!(unique, OP_PUSHBYTES_21);
-        roundtrip!(unique, OP_PUSHBYTES_22);
-        roundtrip!(unique, OP_PUSHBYTES_23);
-        roundtrip!(unique, OP_PUSHBYTES_24);
-        roundtrip!(unique, OP_PUSHBYTES_25);
-        roundtrip!(unique, OP_PUSHBYTES_26);
-        roundtrip!(unique, OP_PUSHBYTES_27);
-        roundtrip!(unique, OP_PUSHBYTES_28);
-        roundtrip!(unique, OP_PUSHBYTES_29);
-        roundtrip!(unique, OP_PUSHBYTES_30);
-        roundtrip!(unique, OP_PUSHBYTES_31);
-        roundtrip!(unique, OP_PUSHBYTES_32);
-        roundtrip!(unique, OP_PUSHBYTES_33);
-        roundtrip!(unique, OP_PUSHBYTES_34);
-        roundtrip!(unique, OP_PUSHBYTES_35);
-        roundtrip!(unique, OP_PUSHBYTES_36);
-        roundtrip!(unique, OP_PUSHBYTES_37);
-        roundtrip!(unique, OP_PUSHBYTES_38);
-        roundtrip!(unique, OP_PUSHBYTES_39);
-        roundtrip!(unique, OP_PUSHBYTES_40);
-        roundtrip!(unique, OP_PUSHBYTES_41);
-        roundtrip!(unique, OP_PUSHBYTES_42);
-        roundtrip!(unique, OP_PUSHBYTES_43);
-        roundtrip!(unique, OP_PUSHBYTES_44);
-        roundtrip!(unique, OP_PUSHBYTES_45);
-        roundtrip!(unique, OP_PUSHBYTES_46);
-        roundtrip!(unique, OP_PUSHBYTES_47);
-        roundtrip!(unique, OP_PUSHBYTES_48);
-        roundtrip!(unique, OP_PUSHBYTES_49);
-        roundtrip!(unique, OP_PUSHBYTES_50);
-        roundtrip!(unique, OP_PUSHBYTES_51);
-        roundtrip!(unique, OP_PUSHBYTES_52);
-        roundtrip!(unique, OP_PUSHBYTES_53);
-        roundtrip!(unique, OP_PUSHBYTES_54);
-        roundtrip!(unique, OP_PUSHBYTES_55);
-        roundtrip!(unique, OP_PUSHBYTES_56);
-        roundtrip!(unique, OP_PUSHBYTES_57);
-        roundtrip!(unique, OP_PUSHBYTES_58);
-        roundtrip!(unique, OP_PUSHBYTES_59);
-        roundtrip!(unique, OP_PUSHBYTES_60);
-        roundtrip!(unique, OP_PUSHBYTES_61);
-        roundtrip!(unique, OP_PUSHBYTES_62);
-        roundtrip!(unique, OP_PUSHBYTES_63);
-        roundtrip!(unique, OP_PUSHBYTES_64);
-        roundtrip!(unique, OP_PUSHBYTES_65);
-        roundtrip!(unique, OP_PUSHBYTES_66);
-        roundtrip!(unique, OP_PUSHBYTES_67);
-        roundtrip!(unique, OP_PUSHBYTES_68);
-        roundtrip!(unique, OP_PUSHBYTES_69);
-        roundtrip!(unique, OP_PUSHBYTES_70);
-        roundtrip!(unique, OP_PUSHBYTES_71);
-        roundtrip!(unique, OP_PUSHBYTES_72);
-        roundtrip!(unique, OP_PUSHBYTES_73);
-        roundtrip!(unique, OP_PUSHBYTES_74);
-        roundtrip!(unique, OP_PUSHBYTES_75);
-        roundtrip!(unique, OP_PUSHDATA1);
-        roundtrip!(unique, OP_PUSHDATA2);
-        roundtrip!(unique, OP_PUSHDATA4);
-        roundtrip!(unique, OP_PUSHNUM_NEG1);
-        roundtrip!(unique, OP_RESERVED);
-        roundtrip!(unique, OP_PUSHNUM_1);
-        roundtrip!(unique, OP_PUSHNUM_2);
-        roundtrip!(unique, OP_PUSHNUM_3);
-        roundtrip!(unique, OP_PUSHNUM_4);
-        roundtrip!(unique, OP_PUSHNUM_5);
-        roundtrip!(unique, OP_PUSHNUM_6);
-        roundtrip!(unique, OP_PUSHNUM_7);
-        roundtrip!(unique, OP_PUSHNUM_8);
-        roundtrip!(unique, OP_PUSHNUM_9);
-        roundtrip!(unique, OP_PUSHNUM_10);
-        roundtrip!(unique, OP_PUSHNUM_11);
-        roundtrip!(unique, OP_PUSHNUM_12);
-        roundtrip!(unique, OP_PUSHNUM_13);
-        roundtrip!(unique, OP_PUSHNUM_14);
-        roundtrip!(unique, OP_PUSHNUM_15);
-        roundtrip!(unique, OP_PUSHNUM_16);
-        roundtrip!(unique, OP_NOP);
-        roundtrip!(unique, OP_VER);
-        roundtrip!(unique, OP_IF);
-        roundtrip!(unique, OP_NOTIF);
-        roundtrip!(unique, OP_VERIF);
-        roundtrip!(unique, OP_VERNOTIF);
-        roundtrip!(unique, OP_ELSE);
-        roundtrip!(unique, OP_ENDIF);
-        roundtrip!(unique, OP_VERIFY);
-        roundtrip!(unique, OP_RETURN);
-        roundtrip!(unique, OP_TOALTSTACK);
-        roundtrip!(unique, OP_FROMALTSTACK);
-        roundtrip!(unique, OP_2DROP);
-        roundtrip!(unique, OP_2DUP);
-        roundtrip!(unique, OP_3DUP);
-        roundtrip!(unique, OP_2OVER);
-        roundtrip!(unique, OP_2ROT);
-        roundtrip!(unique, OP_2SWAP);
-        roundtrip!(unique, OP_IFDUP);
-        roundtrip!(unique, OP_DEPTH);
-        roundtrip!(unique, OP_DROP);
-        roundtrip!(unique, OP_DUP);
-        roundtrip!(unique, OP_NIP);
-        roundtrip!(unique, OP_OVER);
-        roundtrip!(unique, OP_PICK);
-        roundtrip!(unique, OP_ROLL);
-        roundtrip!(unique, OP_ROT);
-        roundtrip!(unique, OP_SWAP);
-        roundtrip!(unique, OP_TUCK);
-        roundtrip!(unique, OP_CAT);
-        roundtrip!(unique, OP_SUBSTR);
-        roundtrip!(unique, OP_LEFT);
-        roundtrip!(unique, OP_RIGHT);
-        roundtrip!(unique, OP_SIZE);
-        roundtrip!(unique, OP_INVERT);
-        roundtrip!(unique, OP_AND);
-        roundtrip!(unique, OP_OR);
-        roundtrip!(unique, OP_XOR);
-        roundtrip!(unique, OP_EQUAL);
-        roundtrip!(unique, OP_EQUALVERIFY);
-        roundtrip!(unique, OP_RESERVED1);
-        roundtrip!(unique, OP_RESERVED2);
-        roundtrip!(unique, OP_1ADD);
-        roundtrip!(unique, OP_1SUB);
-        roundtrip!(unique, OP_2MUL);
-        roundtrip!(unique, OP_2DIV);
-        roundtrip!(unique, OP_NEGATE);
-        roundtrip!(unique, OP_ABS);
-        roundtrip!(unique, OP_NOT);
-        roundtrip!(unique, OP_0NOTEQUAL);
-        roundtrip!(unique, OP_ADD);
-        roundtrip!(unique, OP_SUB);
-        roundtrip!(unique, OP_MUL);
-        roundtrip!(unique, OP_DIV);
-        roundtrip!(unique, OP_MOD);
-        roundtrip!(unique, OP_LSHIFT);
-        roundtrip!(unique, OP_RSHIFT);
-        roundtrip!(unique, OP_BOOLAND);
-        roundtrip!(unique, OP_BOOLOR);
-        roundtrip!(unique, OP_NUMEQUAL);
-        roundtrip!(unique, OP_NUMEQUALVERIFY);
-        roundtrip!(unique, OP_NUMNOTEQUAL);
-        roundtrip!(unique, OP_LESSTHAN );
-        roundtrip!(unique, OP_GREATERTHAN );
-        roundtrip!(unique, OP_LESSTHANOREQUAL );
-        roundtrip!(unique, OP_GREATERTHANOREQUAL );
-        roundtrip!(unique, OP_MIN);
-        roundtrip!(unique, OP_MAX);
-        roundtrip!(unique, OP_WITHIN);
-        roundtrip!(unique, OP_RIPEMD160);
-        roundtrip!(unique, OP_SHA1);
-        roundtrip!(unique, OP_SHA256);
-        roundtrip!(unique, OP_HASH160);
-        roundtrip!(unique, OP_HASH256);
-        roundtrip!(unique, OP_CODESEPARATOR);
-        roundtrip!(unique, OP_CHECKSIG);
-        roundtrip!(unique, OP_CHECKSIGVERIFY);
-        roundtrip!(unique, OP_CHECKMULTISIG);
-        roundtrip!(unique, OP_CHECKMULTISIGVERIFY);
-        roundtrip!(unique, OP_NOP1);
-        roundtrip!(unique, OP_CLTV);
-        roundtrip!(unique, OP_CSV);
-        roundtrip!(unique, OP_NOP4);
-        roundtrip!(unique, OP_NOP5);
-        roundtrip!(unique, OP_NOP6);
-        roundtrip!(unique, OP_NOP7);
-        roundtrip!(unique, OP_NOP8);
-        roundtrip!(unique, OP_NOP9);
-        roundtrip!(unique, OP_NOP10);
-        roundtrip!(unique, OP_RETURN_186);
-        roundtrip!(unique, OP_RETURN_187);
-        roundtrip!(unique, OP_RETURN_188);
-        roundtrip!(unique, OP_RETURN_189);
-        roundtrip!(unique, OP_RETURN_190);
-        roundtrip!(unique, OP_RETURN_191);
-        roundtrip!(unique, OP_RETURN_192);
-        roundtrip!(unique, OP_RETURN_193);
-        roundtrip!(unique, OP_RETURN_194);
-        roundtrip!(unique, OP_RETURN_195);
-        roundtrip!(unique, OP_RETURN_196);
-        roundtrip!(unique, OP_RETURN_197);
-        roundtrip!(unique, OP_RETURN_198);
-        roundtrip!(unique, OP_RETURN_199);
-        roundtrip!(unique, OP_RETURN_200);
-        roundtrip!(unique, OP_RETURN_201);
-        roundtrip!(unique, OP_RETURN_202);
-        roundtrip!(unique, OP_RETURN_203);
-        roundtrip!(unique, OP_RETURN_204);
-        roundtrip!(unique, OP_RETURN_205);
-        roundtrip!(unique, OP_RETURN_206);
-        roundtrip!(unique, OP_RETURN_207);
-        roundtrip!(unique, OP_RETURN_208);
-        roundtrip!(unique, OP_RETURN_209);
-        roundtrip!(unique, OP_RETURN_210);
-        roundtrip!(unique, OP_RETURN_211);
-        roundtrip!(unique, OP_RETURN_212);
-        roundtrip!(unique, OP_RETURN_213);
-        roundtrip!(unique, OP_RETURN_214);
-        roundtrip!(unique, OP_RETURN_215);
-        roundtrip!(unique, OP_RETURN_216);
-        roundtrip!(unique, OP_RETURN_217);
-        roundtrip!(unique, OP_RETURN_218);
-        roundtrip!(unique, OP_RETURN_219);
-        roundtrip!(unique, OP_RETURN_220);
-        roundtrip!(unique, OP_RETURN_221);
-        roundtrip!(unique, OP_RETURN_222);
-        roundtrip!(unique, OP_RETURN_223);
-        roundtrip!(unique, OP_RETURN_224);
-        roundtrip!(unique, OP_RETURN_225);
-        roundtrip!(unique, OP_RETURN_226);
-        roundtrip!(unique, OP_RETURN_227);
-        roundtrip!(unique, OP_RETURN_228);
-        roundtrip!(unique, OP_RETURN_229);
-        roundtrip!(unique, OP_RETURN_230);
-        roundtrip!(unique, OP_RETURN_231);
-        roundtrip!(unique, OP_RETURN_232);
-        roundtrip!(unique, OP_RETURN_233);
-        roundtrip!(unique, OP_RETURN_234);
-        roundtrip!(unique, OP_RETURN_235);
-        roundtrip!(unique, OP_RETURN_236);
-        roundtrip!(unique, OP_RETURN_237);
-        roundtrip!(unique, OP_RETURN_238);
-        roundtrip!(unique, OP_RETURN_239);
-        roundtrip!(unique, OP_RETURN_240);
-        roundtrip!(unique, OP_RETURN_241);
-        roundtrip!(unique, OP_RETURN_242);
-        roundtrip!(unique, OP_RETURN_243);
-        roundtrip!(unique, OP_RETURN_244);
-        roundtrip!(unique, OP_RETURN_245);
-        roundtrip!(unique, OP_RETURN_246);
-        roundtrip!(unique, OP_RETURN_247);
-        roundtrip!(unique, OP_RETURN_248);
-        roundtrip!(unique, OP_RETURN_249);
-        roundtrip!(unique, OP_RETURN_250);
-        roundtrip!(unique, OP_RETURN_251);
-        roundtrip!(unique, OP_RETURN_252);
-        roundtrip!(unique, OP_RETURN_253);
-        roundtrip!(unique, OP_RETURN_254);
-        roundtrip!(unique, OP_RETURN_255);
-        assert_eq!(unique.len(), 256);
-    }
-}
-
diff --git a/src/blockdata/script.rs b/src/blockdata/script.rs
deleted file mode 100644
index 508a91da..00000000
--- a/src/blockdata/script.rs
+++ /dev/null
@@ -1,1090 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Script
-//!
-//! Scripts define Bitcoin's digital signature scheme: a signature is formed
-//! from a script (the second half of which is defined by a coin to be spent,
-//! and the first half provided by the spending transaction), and is valid
-//! iff the script leaves `TRUE` on the stack after being evaluated.
-//! Bitcoin's script is a stack-based assembly language similar in spirit to
-//! Forth.
-//!
-//! This module provides the structures and functions needed to support scripts.
-//!
-
-use std::default::Default;
-use std::{error, fmt, io};
-
-#[cfg(feature = "serde")] use serde;
-
-use hash_types::{ScriptHash, WScriptHash};
-use blockdata::opcodes;
-use consensus::{encode, Decodable, Encodable};
-use hashes::Hash;
-#[cfg(feature="bitcoinconsensus")] use bitcoinconsensus;
-#[cfg(feature="bitcoinconsensus")] use std::convert;
-#[cfg(feature="bitcoinconsensus")] use OutPoint;
-
-use util::key::PublicKey;
-
-#[derive(Clone, Default, PartialOrd, Ord, PartialEq, Eq, Hash)]
-/// A Bitcoin script
-pub struct Script(Box<[u8]>);
-
-impl fmt::Debug for Script {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("Script(")?;
-        self.fmt_asm(f)?;
-        f.write_str(")")
-    }
-}
-
-impl fmt::Display for Script {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(self, f)
-    }
-}
-
-impl fmt::LowerHex for Script {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for &ch in self.0.iter() {
-            write!(f, "{:02x}", ch)?;
-        }
-        Ok(())
-    }
-}
-
-impl fmt::UpperHex for Script {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for &ch in self.0.iter() {
-            write!(f, "{:02X}", ch)?;
-        }
-        Ok(())
-    }
-}
-
-#[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>);
-display_from_debug!(Builder);
-
-/// Ways that a script might fail. Not everything is split up as
-/// much as it could be; patches welcome if more detailed errors
-/// would help you.
-#[derive(PartialEq, Eq, Debug, Clone)]
-pub enum Error {
-    /// Something did a non-minimal push; for more information see
-    /// `https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#Push_operators`
-    NonMinimalPush,
-    /// Some opcode expected a parameter, but it was missing or truncated
-    EarlyEndOfScript,
-    /// Tried to read an array off the stack as a number when it was more than 4 bytes
-    NumericOverflow,
-    #[cfg(feature="bitcoinconsensus")]
-    /// Error validating the script with bitcoinconsensus library
-    BitcoinConsensus(bitcoinconsensus::Error),
-    #[cfg(feature="bitcoinconsensus")]
-    /// Can not find the spent output
-    UnknownSpentOutput(OutPoint),
-    #[cfg(feature="bitcoinconsensus")]
-    /// Can not serialize the spending transaction
-    SerializationError
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(error::Error::description(self))
-    }
-}
-
-impl error::Error for Error {
-    fn cause(&self) -> Option<&error::Error> { None }
-
-    fn description(&self) -> &'static str {
-        match *self {
-            Error::NonMinimalPush => "non-minimal datapush",
-            Error::EarlyEndOfScript => "unexpected end of script",
-            Error::NumericOverflow => "numeric overflow (number on stack larger than 4 bytes)",
-            #[cfg(feature="bitcoinconsensus")]
-            Error::BitcoinConsensus(ref _n) => "bitcoinconsensus verification failed",
-            #[cfg(feature="bitcoinconsensus")]
-            Error::UnknownSpentOutput(ref _point) => "unknown spent output Transaction::verify()",
-            #[cfg(feature="bitcoinconsensus")]
-            Error::SerializationError => "can not serialize the spending transaction in Transaction::verify()",
-        }
-    }
-}
-
-#[cfg(feature="bitcoinconsensus")]
-#[doc(hidden)]
-impl convert::From<bitcoinconsensus::Error> for Error {
-    fn from(err: bitcoinconsensus::Error) -> Error {
-        match err {
-            _ => Error::BitcoinConsensus(err)
-        }
-    }
-}
-/// Helper to encode an integer in script format
-fn build_scriptint(n: i64) -> Vec<u8> {
-    if n == 0 { return vec![] }
-
-    let neg = n < 0;
-
-    let mut abs = if neg { -n } else { n } as usize;
-    let mut v = vec![];
-    while abs > 0xFF {
-        v.push((abs & 0xFF) as u8);
-        abs >>= 8;
-    }
-    // If the number's value causes the sign bit to be set, we need an extra
-    // byte to get the correct value and correct sign bit
-    if abs & 0x80 != 0 {
-        v.push(abs as u8);
-        v.push(if neg { 0x80u8 } else { 0u8 });
-    }
-    // Otherwise we just set the sign bit ourselves
-    else {
-        abs |= if neg { 0x80 } else { 0 };
-        v.push(abs as u8);
-    }
-    v
-}
-
-/// 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
-/// overflow since that's surprising --- and we don't want numbers that
-/// don't fit in 64 bits (for efficiency on modern processors) so we
-/// simply say, anything in excess of 32 bits is no longer a number.
-/// This is basically a ranged type implementation.
-pub fn read_scriptint(v: &[u8]) -> Result<i64, Error> {
-    let len = v.len();
-    if len == 0 { return Ok(0); }
-    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));
-    if v[len - 1] & 0x80 != 0 {
-        ret &= (1 << (sh - 1)) - 1;
-        ret = -ret;
-    }
-    Ok(ret)
-}
-
-/// This is like "`read_scriptint` then map 0 to false and everything
-/// else as true", except that the overflow rules don't apply.
-#[inline]
-pub fn read_scriptbool(v: &[u8]) -> bool {
-    !(v.is_empty() ||
-        ((v[v.len() - 1] == 0 || v[v.len() - 1] == 0x80) &&
-         v.iter().rev().skip(1).all(|&w| w == 0)))
-}
-
-/// Read a script-encoded unsigned integer
-pub fn read_uint(data: &[u8], size: usize) -> Result<usize, Error> {
-    if data.len() < size {
-        Err(Error::EarlyEndOfScript)
-    } else {
-        let mut ret = 0;
-        for (i, item) in data.iter().take(size).enumerate() {
-            ret += (*item as usize) << (i * 8);
-        }
-        Ok(ret)
-    }
-}
-
-impl Script {
-    /// Creates a new empty script
-    pub fn new() -> Script { Script(vec![].into_boxed_slice()) }
-
-    /// The length in bytes of the script
-    pub fn len(&self) -> usize { self.0.len() }
-
-    /// Whether the script is the empty script
-    pub fn is_empty(&self) -> bool { self.0.is_empty() }
-
-    /// Returns the script data
-    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() }
-
-    /// Convert the script into a byte vector
-    pub fn into_bytes(self) -> Vec<u8> { self.0.into_vec() }
-
-    /// Compute the P2SH output corresponding to this redeem script
-    pub fn to_p2sh(&self) -> Script {
-        Builder::new().push_opcode(opcodes::all::OP_HASH160)
-                      .push_slice(&ScriptHash::hash(&self.0)[..])
-                      .push_opcode(opcodes::all::OP_EQUAL)
-                      .into_script()
-    }
-
-    /// Compute the P2WSH output corresponding to this witnessScript (aka the "witness redeem
-    /// script")
-    pub fn to_v0_p2wsh(&self) -> Script {
-        Builder::new().push_int(0)
-                      .push_slice(&WScriptHash::hash(&self.0)[..])
-                      .into_script()
-    }
-
-    /// Checks whether a script pubkey is a p2sh output
-    #[inline]
-    pub fn is_p2sh(&self) -> bool {
-        self.0.len() == 23 &&
-        self.0[0] == opcodes::all::OP_HASH160.into_u8() &&
-        self.0[1] == opcodes::all::OP_PUSHBYTES_20.into_u8() &&
-        self.0[22] == opcodes::all::OP_EQUAL.into_u8()
-    }
-
-    /// Checks whether a script pubkey is a p2pkh output
-    #[inline]
-    pub fn is_p2pkh(&self) -> bool {
-        self.0.len() == 25 &&
-        self.0[0] == opcodes::all::OP_DUP.into_u8() &&
-        self.0[1] == opcodes::all::OP_HASH160.into_u8() &&
-        self.0[2] == opcodes::all::OP_PUSHBYTES_20.into_u8() &&
-        self.0[23] == opcodes::all::OP_EQUALVERIFY.into_u8() &&
-        self.0[24] == opcodes::all::OP_CHECKSIG.into_u8()
-    }
-
-    /// Checks whether a script pubkey is a p2pk output
-    #[inline]
-    pub fn is_p2pk(&self) -> bool {
-        (self.0.len() == 67 &&
-            self.0[0] == opcodes::all::OP_PUSHBYTES_65.into_u8() &&
-            self.0[66] == opcodes::all::OP_CHECKSIG.into_u8())
-     || (self.0.len() == 35 &&
-            self.0[0] == opcodes::all::OP_PUSHBYTES_33.into_u8() &&
-            self.0[34] == opcodes::all::OP_CHECKSIG.into_u8())
-    }
-
-    /// Checks whether a script pubkey is a Segregated Witness (segwit) program.
-    #[inline]
-    pub fn is_witness_program(&self) -> bool {
-        // A scriptPubKey (or redeemScript as defined in BIP16/P2SH) that consists of a 1-byte
-        // push opcode (for 0 to 16) followed by a data push between 2 and 40 bytes gets a new
-        // special meaning. The value of the first push is called the "version byte". The following
-        // byte vector pushed is called the "witness program".
-        let min_vernum: u8 = opcodes::all::OP_PUSHNUM_1.into_u8();
-        let max_vernum: u8 = opcodes::all::OP_PUSHNUM_16.into_u8();
-        self.0.len() >= 4
-            && self.0.len() <= 42
-            // Version 0 or PUSHNUM_1-PUSHNUM_16
-            && (self.0[0] == 0 || self.0[0] >= min_vernum && self.0[0] <= max_vernum)
-            // Second byte push opcode 2-40 bytes
-            && self.0[1] >= opcodes::all::OP_PUSHBYTES_2.into_u8()
-            && self.0[1] <= opcodes::all::OP_PUSHBYTES_40.into_u8()
-            // Check that the rest of the script has the correct size
-            && self.0.len() - 2 == self.0[1] as usize
-    }
-
-    /// Checks whether a script pubkey is a p2wsh output
-    #[inline]
-    pub fn is_v0_p2wsh(&self) -> bool {
-        self.0.len() == 34 &&
-        self.0[0] == opcodes::all::OP_PUSHBYTES_0.into_u8() &&
-        self.0[1] == opcodes::all::OP_PUSHBYTES_32.into_u8()
-    }
-
-    /// Checks whether a script pubkey is a p2wpkh output
-    #[inline]
-    pub fn is_v0_p2wpkh(&self) -> bool {
-        self.0.len() == 22 &&
-            self.0[0] == opcodes::all::OP_PUSHBYTES_0.into_u8() &&
-            self.0[1] == opcodes::all::OP_PUSHBYTES_20.into_u8()
-    }
-
-    /// 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
-    pub fn is_provably_unspendable(&self) -> bool {
-        !self.0.is_empty() && (opcodes::All::from(self.0[0]).classify() == opcodes::Class::ReturnOp ||
-                               opcodes::All::from(self.0[0]).classify() == opcodes::Class::IllegalOp)
-    }
-
-    /// Iterate over the script in the form of `Instruction`s, which are an enum covering
-    /// opcodes, datapushes and errors. At most one error will be returned and then the
-    /// iterator will end. To instead iterate over the script as sequence of bytes, treat
-    /// it as a slice using `script[..]` or convert it to a vector using `into_bytes()`.
-    pub fn iter(&self, enforce_minimal: bool) -> Instructions {
-        Instructions {
-            data: &self.0[..],
-            enforce_minimal: enforce_minimal,
-        }
-    }
-
-    #[cfg(feature="bitcoinconsensus")]
-    /// verify spend of an input script
-    /// # Parameters
-    ///  * index - the input index in spending which is spending this transaction
-    ///  * amount - the amount this script guards
-    ///  * spending - the transaction that attempts to spend the output holding this script
-    pub fn verify (&self, index: usize, amount: u64, spending: &[u8]) -> Result<(), Error> {
-        Ok(bitcoinconsensus::verify (&self.0[..], amount, spending, index)?)
-    }
-
-    /// Write the assembly decoding of the script to the formatter.
-    pub fn fmt_asm(&self, f: &mut fmt::Write) -> fmt::Result {
-        let mut index = 0;
-        while index < self.0.len() {
-            let opcode = opcodes::All::from(self.0[index]);
-            index += 1;
-
-            let data_len = if let opcodes::Class::PushBytes(n) = opcode.classify() {
-                n as usize
-            } else {
-                match opcode {
-                    opcodes::all::OP_PUSHDATA1 => {
-                        if self.0.len() < index + 1 {
-                            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; }
-                        }
-                    }
-                    opcodes::all::OP_PUSHDATA2 => {
-                        if self.0.len() < index + 2 {
-                            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; }
-                        }
-                    }
-                    opcodes::all::OP_PUSHDATA4 => {
-                        if self.0.len() < index + 4 {
-                            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; }
-                        }
-                    }
-                    _ => 0
-                }
-            };
-
-            if index > 1 { f.write_str(" ")?; }
-            // Write the opcode
-            if opcode == opcodes::all::OP_PUSHBYTES_0 {
-                f.write_str("OP_0")?;
-            } else {
-                write!(f, "{:?}", opcode)?;
-            }
-            // Write any pushdata
-            if data_len > 0 {
-                f.write_str(" ")?;
-                if index + data_len <= self.0.len() {
-                    for ch in &self.0[index..index + data_len] {
-                            write!(f, "{:02x}", ch)?;
-                    }
-                    index += data_len;
-                } else {
-                    f.write_str("<push past end>")?;
-                    break;
-                }
-            }
-        }
-        Ok(())
-    }
-
-    /// Get the assembly decoding of the script.
-    pub fn asm(&self) -> String {
-        let mut buf = String::new();
-        self.fmt_asm(&mut buf).unwrap();
-        buf
-    }
-}
-
-/// Creates a new script from an existing vector
-impl From<Vec<u8>> for Script {
-    fn from(v: Vec<u8>) -> Script { Script(v.into_boxed_slice()) }
-}
-
-impl_index_newtype!(Script, u8);
-
-/// A "parsed opcode" which allows iterating over a Script in a more sensible way
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum Instruction<'a> {
-    /// Push a bunch of data
-    PushBytes(&'a [u8]),
-    /// Some non-push opcode
-    Op(opcodes::All),
-    /// An opcode we were unable to parse
-    Error(Error)
-}
-
-/// Iterator over a script returning parsed opcodes
-pub struct Instructions<'a> {
-    data: &'a [u8],
-    enforce_minimal: bool,
-}
-
-impl<'a> Iterator for Instructions<'a> {
-    type Item = Instruction<'a>;
-
-    fn next(&mut self) -> Option<Instruction<'a>> {
-        if self.data.is_empty() {
-            return None;
-        }
-
-        match opcodes::All::from(self.data[0]).classify() {
-            opcodes::Class::PushBytes(n) => {
-                let n = n as usize;
-                if self.data.len() < n + 1 {
-                    self.data = &[];  // Kill iterator so that it does not return an infinite stream of errors
-                    return Some(Instruction::Error(Error::EarlyEndOfScript));
-                }
-                if self.enforce_minimal {
-                    if n == 1 && (self.data[1] == 0x81 || (self.data[1] > 0 && self.data[1] <= 16)) {
-                        self.data = &[];
-                        return Some(Instruction::Error(Error::NonMinimalPush));
-                    }
-                }
-                let ret = Some(Instruction::PushBytes(&self.data[1..n+1]));
-                self.data = &self.data[n + 1..];
-                ret
-            }
-            opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA1) => {
-                if self.data.len() < 2 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::EarlyEndOfScript));
-                }
-                let n = match read_uint(&self.data[1..], 1) {
-                    Ok(n) => n,
-                    Err(e) => {
-                        self.data = &[];
-                        return Some(Instruction::Error(e));
-                    }
-                };
-                if self.data.len() < n + 2 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::EarlyEndOfScript));
-                }
-                if self.enforce_minimal && n < 76 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::NonMinimalPush));
-                }
-                let ret = Some(Instruction::PushBytes(&self.data[2..n+2]));
-                self.data = &self.data[n + 2..];
-                ret
-            }
-            opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA2) => {
-                if self.data.len() < 3 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::EarlyEndOfScript));
-                }
-                let n = match read_uint(&self.data[1..], 2) {
-                    Ok(n) => n,
-                    Err(e) => {
-                        self.data = &[];
-                        return Some(Instruction::Error(e));
-                    }
-                };
-                if self.enforce_minimal && n < 0x100 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::NonMinimalPush));
-                }
-                if self.data.len() < n + 3 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::EarlyEndOfScript));
-                }
-                let ret = Some(Instruction::PushBytes(&self.data[3..n + 3]));
-                self.data = &self.data[n + 3..];
-                ret
-            }
-            opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA4) => {
-                if self.data.len() < 5 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::EarlyEndOfScript));
-                }
-                let n = match read_uint(&self.data[1..], 4) {
-                    Ok(n) => n,
-                    Err(e) => {
-                        self.data = &[];
-                        return Some(Instruction::Error(e));
-                    }
-                };
-                if self.enforce_minimal && n < 0x10000 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::NonMinimalPush));
-                }
-                if self.data.len() < n + 5 {
-                    self.data = &[];
-                    return Some(Instruction::Error(Error::EarlyEndOfScript));
-                }
-                let ret = Some(Instruction::PushBytes(&self.data[5..n + 5]));
-                self.data = &self.data[n + 5..];
-                ret
-            }
-            // Everything else we can push right through
-            _ => {
-                let ret = Some(Instruction::Op(opcodes::All::from(self.data[0])));
-                self.data = &self.data[1..];
-                ret
-            }
-        }
-    }
-}
-
-impl Builder {
-    /// Creates a new empty script
-    pub fn new() -> Builder {
-        Builder(vec![], None)
-    }
-
-    /// The length in bytes of the script
-    pub fn len(&self) -> usize { self.0.len() }
-
-    /// Whether the script is the empty script
-    pub fn is_empty(&self) -> bool { self.0.is_empty() }
-
-    /// 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.
-    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
-            );
-            self.push_opcode(opcode)
-        }
-        // We can also special-case zero
-        else if data == 0 {
-            self.push_opcode(opcodes::OP_FALSE)
-        }
-        // Otherwise encode it as data
-        else { self.push_scriptint(data) }
-    }
-
-    /// Adds instructions to push an integer onto the stack, using the explicit
-    /// encoding regardless of the availability of dedicated opcodes.
-    pub fn push_scriptint(self, data: i64) -> Builder {
-        self.push_slice(&build_scriptint(data))
-    }
-
-    /// Adds instructions to push some arbitrary data onto the stack
-    pub fn push_slice(mut self, data: &[u8]) -> Builder {
-        // Start with a PUSH opcode
-        match data.len() as u64 {
-            n if n < opcodes::Ordinary::OP_PUSHDATA1 as u64 => { self.0.push(n as u8); },
-            n if n < 0x100 => {
-                self.0.push(opcodes::Ordinary::OP_PUSHDATA1.into_u8());
-                self.0.push(n as u8);
-            },
-            n if n < 0x10000 => {
-                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 => {
-                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);
-            }
-            _ => panic!("tried to put a 4bn+ sized object into a script!")
-        }
-        // Then push the raw bytes
-        self.0.extend(data.iter().cloned());
-        self.1 = None;
-        self
-    }
-
-    /// Pushes a public key
-    pub fn push_key(self, key: &PublicKey) -> Builder {
-        if key.compressed {
-            self.push_slice(&key.key.serialize()[..])
-        } else {
-            self.push_slice(&key.key.serialize_uncompressed()[..])
-        }
-    }
-
-    /// Adds a single opcode to the script
-    pub fn push_opcode(mut self, data: opcodes::All) -> Builder {
-        self.0.push(data.into_u8());
-        self.1 = Some(data);
-        self
-    }
-
-    /// 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`.
-    pub fn push_verify(mut self) -> Builder {
-        match self.1 {
-            Some(opcodes::all::OP_EQUAL) => {
-                self.0.pop();
-                self.push_opcode(opcodes::all::OP_EQUALVERIFY)
-            },
-            Some(opcodes::all::OP_NUMEQUAL) => {
-                self.0.pop();
-                self.push_opcode(opcodes::all::OP_NUMEQUALVERIFY)
-            },
-            Some(opcodes::all::OP_CHECKSIG) => {
-                self.0.pop();
-                self.push_opcode(opcodes::all::OP_CHECKSIGVERIFY)
-            },
-            Some(opcodes::all::OP_CHECKMULTISIG) => {
-                self.0.pop();
-                self.push_opcode(opcodes::all::OP_CHECKMULTISIGVERIFY)
-            },
-            _ => self.push_opcode(opcodes::all::OP_VERIFY),
-        }
-    }
-
-    /// Converts the `Builder` into an unmodifiable `Script`
-    pub fn into_script(self) -> Script {
-        Script(self.0.into_boxed_slice())
-    }
-}
-
-/// Adds an individual opcode to the script
-impl Default for Builder {
-    fn default() -> Builder { Builder::new() }
-}
-
-/// Creates a new script from an existing vector
-impl From<Vec<u8>> for Builder {
-    fn from(v: Vec<u8>) -> Builder {
-        let script = Script(v.into_boxed_slice());
-        let last_op = match script.iter(false).last() {
-            Some(Instruction::Op(op)) => Some(op),
-            _ => None,
-        };
-        Builder(script.into_bytes(), last_op)
-    }
-}
-
-impl_index_newtype!(Builder, u8);
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for Script {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        use std::fmt::Formatter;
-
-        struct Visitor;
-        impl<'de> serde::de::Visitor<'de> for Visitor {
-            type Value = Script;
-
-            fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                formatter.write_str("a script")
-            }
-
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                let v: Vec<u8> = ::hex::decode(v).map_err(E::custom)?;
-                Ok(Script::from(v))
-            }
-
-            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                self.visit_str(v)
-            }
-
-            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-            where
-                E: serde::de::Error,
-            {
-                self.visit_str(&v)
-            }
-        }
-
-        deserializer.deserialize_str(Visitor)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for Script {
-    /// User-facing serialization for `Script`.
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&format!("{:x}", self))
-    }
-}
-
-// Network serialization
-impl Encodable for Script {
-    #[inline]
-    fn consensus_encode<S: io::Write>(
-        &self,
-        s: S,
-    ) -> Result<usize, encode::Error> {
-        self.0.consensus_encode(s)
-    }
-}
-
-impl Decodable for Script {
-    #[inline]
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
-        Ok(Script(Decodable::consensus_decode(d)?))
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::str::FromStr;
-    use hex::decode as hex_decode;
-
-    use super::*;
-    use super::build_scriptint;
-
-    use consensus::encode::{deserialize, serialize};
-    use blockdata::opcodes;
-    use util::key::PublicKey;
-
-    #[test]
-    fn script() {
-        let mut comp = vec![];
-        let mut script = Builder::new();
-        assert_eq!(&script[..], &comp[..]);
-
-        // small ints
-        script = script.push_int(1);  comp.push(81u8); assert_eq!(&script[..], &comp[..]);
-        script = script.push_int(0);  comp.push(0u8);  assert_eq!(&script[..], &comp[..]);
-        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[..]);
-        // 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[..]);
-        // 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[..]);
-
-        // data
-        script = script.push_slice("NRA4VR".as_bytes()); comp.extend([6u8, 78, 82, 65, 52, 86, 82].iter().cloned()); assert_eq!(&script[..], &comp[..]);
-
-        // keys
-        let keystr = "21032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af";
-        let key = PublicKey::from_str(&keystr[2..]).unwrap();
-        script = script.push_key(&key); comp.extend(hex_decode(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(hex_decode(keystr).unwrap().iter().cloned()); assert_eq!(&script[..], &comp[..]);
-
-        // opcodes
-        script = script.push_opcode(opcodes::all::OP_CHECKSIG); comp.push(0xACu8); assert_eq!(&script[..], &comp[..]);
-        script = script.push_opcode(opcodes::all::OP_CHECKSIG); comp.push(0xACu8); assert_eq!(&script[..], &comp[..]);
-    }
-
-    #[test]
-    fn script_builder() {
-        // 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(&hex_decode("16e1ae70ff0fa102905d4af297f6912bda6cce19").unwrap())
-                                   .push_opcode(opcodes::all::OP_EQUALVERIFY)
-                                   .push_opcode(opcodes::all::OP_CHECKSIG)
-                                   .into_script();
-        assert_eq!(&format!("{:x}", script), "76a91416e1ae70ff0fa102905d4af297f6912bda6cce1988ac");
-    }
-
-    #[test]
-    fn script_builder_verify() {
-        let simple = Builder::new()
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", simple), "69");
-        let simple2 = Builder::from(vec![])
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", simple2), "69");
-
-        let nonverify = Builder::new()
-            .push_verify()
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", nonverify), "6969");
-        let nonverify2 = Builder::from(vec![0x69])
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", nonverify2), "6969");
-
-        let equal = Builder::new()
-            .push_opcode(opcodes::all::OP_EQUAL)
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", equal), "88");
-        let equal2 = Builder::from(vec![0x87])
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", equal2), "88");
-
-        let numequal = Builder::new()
-            .push_opcode(opcodes::all::OP_NUMEQUAL)
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", numequal), "9d");
-        let numequal2 = Builder::from(vec![0x9c])
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", numequal2), "9d");
-
-        let checksig = Builder::new()
-            .push_opcode(opcodes::all::OP_CHECKSIG)
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", checksig), "ad");
-        let checksig2 = Builder::from(vec![0xac])
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", checksig2), "ad");
-
-        let checkmultisig = Builder::new()
-            .push_opcode(opcodes::all::OP_CHECKMULTISIG)
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", checkmultisig), "af");
-        let checkmultisig2 = Builder::from(vec![0xae])
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", checkmultisig2), "af");
-
-        let trick_slice = Builder::new()
-            .push_slice(&[0xae]) // OP_CHECKMULTISIG
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", trick_slice), "01ae69");
-        let trick_slice2 = Builder::from(vec![0x01, 0xae])
-            .push_verify()
-            .into_script();
-        assert_eq!(format!("{:x}", trick_slice2), "01ae69");
-   }
-
-    #[test]
-    fn script_serialize() {
-        let hex_script = hex_decode("6c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52").unwrap();
-        let script: Result<Script, _> = deserialize(&hex_script);
-        assert!(script.is_ok());
-        assert_eq!(serialize(&script.unwrap()), hex_script);
-    }
-
-    #[test]
-    fn scriptint_round_trip() {
-        assert_eq!(build_scriptint(-1), vec![0x81]);
-        assert_eq!(build_scriptint(255), vec![255, 0]);
-        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() {
-            assert_eq!(Ok(i), read_scriptint(&build_scriptint(i)));
-            assert_eq!(Ok(-i), read_scriptint(&build_scriptint(-i)));
-        }
-        assert!(read_scriptint(&build_scriptint(1 << 31)).is_err());
-        assert!(read_scriptint(&build_scriptint(-(1 << 31))).is_err());
-    }
-
-    #[test]
-    fn provably_unspendable_test() {
-        // p2pk
-        assert_eq!(hex_script!("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").is_provably_unspendable(), false);
-        assert_eq!(hex_script!("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").is_provably_unspendable(), false);
-        // p2pkhash
-        assert_eq!(hex_script!("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac").is_provably_unspendable(), false);
-        assert_eq!(hex_script!("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").is_provably_unspendable(), true);
-    }
-
-    #[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);
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    fn script_json_serialize() {
-        use serde_json;
-
-        let original = hex_script!("827651a0698faaa9a8a7a687");
-        let json = serde_json::to_value(&original).unwrap();
-        assert_eq!(json, serde_json::Value::String("827651a0698faaa9a8a7a687".to_owned()));
-        let des = serde_json::from_value(json).unwrap();
-        assert_eq!(original, des);
-    }
-
-    #[test]
-    fn script_asm() {
-        assert_eq!(hex_script!("6363636363686868686800").asm(),
-                   "OP_IF OP_IF OP_IF OP_IF OP_IF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_0");
-        assert_eq!(hex_script!("6363636363686868686800").asm(),
-                   "OP_IF OP_IF OP_IF OP_IF OP_IF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_0");
-        assert_eq!(hex_script!("2102715e91d37d239dea832f1460e91e368115d8ca6cc23a7da966795abad9e3b699ac").asm(),
-                   "OP_PUSHBYTES_33 02715e91d37d239dea832f1460e91e368115d8ca6cc23a7da966795abad9e3b699 OP_CHECKSIG");
-        // Elements Alpha peg-out transaction with some signatures removed for brevity. Mainly to test PUSHDATA1
-        assert_eq!(hex_script!("0047304402202457e78cc1b7f50d0543863c27de75d07982bde8359b9e3316adec0aec165f2f02200203fd331c4e4a4a02f48cf1c291e2c0d6b2f7078a784b5b3649fca41f8794d401004cf1552103244e602b46755f24327142a0517288cebd159eccb6ccf41ea6edf1f601e9af952103bbbacc302d19d29dbfa62d23f37944ae19853cf260c745c2bea739c95328fcb721039227e83246bd51140fe93538b2301c9048be82ef2fb3c7fc5d78426ed6f609ad210229bf310c379b90033e2ecb07f77ecf9b8d59acb623ab7be25a0caed539e2e6472103703e2ed676936f10b3ce9149fa2d4a32060fb86fa9a70a4efe3f21d7ab90611921031e9b7c6022400a6bb0424bbcde14cff6c016b91ee3803926f3440abf5c146d05210334667f975f55a8455d515a2ef1c94fdfa3315f12319a14515d2a13d82831f62f57ae").asm(),
-                   "OP_0 OP_PUSHBYTES_71 304402202457e78cc1b7f50d0543863c27de75d07982bde8359b9e3316adec0aec165f2f02200203fd331c4e4a4a02f48cf1c291e2c0d6b2f7078a784b5b3649fca41f8794d401 OP_0 OP_PUSHDATA1 552103244e602b46755f24327142a0517288cebd159eccb6ccf41ea6edf1f601e9af952103bbbacc302d19d29dbfa62d23f37944ae19853cf260c745c2bea739c95328fcb721039227e83246bd51140fe93538b2301c9048be82ef2fb3c7fc5d78426ed6f609ad210229bf310c379b90033e2ecb07f77ecf9b8d59acb623ab7be25a0caed539e2e6472103703e2ed676936f10b3ce9149fa2d4a32060fb86fa9a70a4efe3f21d7ab90611921031e9b7c6022400a6bb0424bbcde14cff6c016b91ee3803926f3440abf5c146d05210334667f975f55a8455d515a2ef1c94fdfa3315f12319a14515d2a13d82831f62f57ae");
-    }
-
-    #[test]
-    fn script_p2sh_p2p2k_template() {
-        // random outputs I picked out of the mempool
-        assert!(hex_script!("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").is_p2pkh());
-        assert!(!hex_script!("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").is_p2sh());
-        assert!(!hex_script!("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ad").is_p2pkh());
-        assert!(!hex_script!("").is_p2pkh());
-        assert!(hex_script!("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87").is_p2sh());
-        assert!(!hex_script!("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87").is_p2pkh());
-        assert!(!hex_script!("a314acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87").is_p2sh());
-    }
-
-    #[test]
-    fn script_p2pk() {
-        assert!(hex_script!("21021aeaf2f8638a129a3156fbe7e5ef635226b0bafd495ff03afe2c843d7e3a4b51ac").is_p2pk());
-        assert!(hex_script!("410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac").is_p2pk());
-    }
-
-    #[test]
-    fn p2sh_p2wsh_conversion() {
-        // Test vectors taken from Core tests/data/script_tests.json
-        // bare p2wsh
-        let redeem_script = hex_script!("410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac");
-        let expected_witout = hex_script!("0020b95237b48faaa69eb078e1170be3b5cbb3fddf16d0a991e14ad274f7b33a4f64");
-        assert!(redeem_script.to_v0_p2wsh().is_v0_p2wsh());
-        assert_eq!(redeem_script.to_v0_p2wsh(), expected_witout);
-
-        // p2sh
-        let redeem_script = hex_script!("0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8");
-        let expected_p2shout = hex_script!("a91491b24bf9f5288532960ac687abb035127b1d28a587");
-        assert!(redeem_script.to_p2sh().is_p2sh());
-        assert_eq!(redeem_script.to_p2sh(), expected_p2shout);
-
-        // p2sh-p2wsh
-        let redeem_script = hex_script!("410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac");
-        let expected_witout = hex_script!("0020b95237b48faaa69eb078e1170be3b5cbb3fddf16d0a991e14ad274f7b33a4f64");
-        let expected_out = hex_script!("a914f386c2ba255cc56d20cfa6ea8b062f8b5994551887");
-        assert!(redeem_script.to_p2sh().is_p2sh());
-        assert!(redeem_script.to_p2sh().to_v0_p2wsh().is_v0_p2wsh());
-        assert_eq!(redeem_script.to_v0_p2wsh(), expected_witout);
-        assert_eq!(redeem_script.to_v0_p2wsh().to_p2sh(), expected_out);
-    }
-
-    #[test]
-    fn test_iterator() {
-        let zero = hex_script!("00");
-        let zeropush = hex_script!("0100");
-
-        let nonminimal = hex_script!("4c0169b2");      // PUSHDATA1 for no reason
-        let minimal = hex_script!("0169b2");           // minimal
-        let nonminimal_alt = hex_script!("026900b2");  // non-minimal number but minimal push (should be OK)
-
-        let v_zero: Vec<Instruction> = zero.iter(true).collect();
-        let v_zeropush: Vec<Instruction> = zeropush.iter(true).collect();
-
-        let v_min: Vec<Instruction> = minimal.iter(true).collect();
-        let v_nonmin: Vec<Instruction> = nonminimal.iter(true).collect();
-        let v_nonmin_alt: Vec<Instruction> = nonminimal_alt.iter(true).collect();
-        let slop_v_min: Vec<Instruction> = minimal.iter(false).collect();
-        let slop_v_nonmin: Vec<Instruction> = nonminimal.iter(false).collect();
-        let slop_v_nonmin_alt: Vec<Instruction> = nonminimal_alt.iter(false).collect();
-
-        assert_eq!(
-            v_zero,
-            vec![
-                Instruction::PushBytes(&[]),
-            ]
-        );
-        assert_eq!(
-            v_zeropush,
-            vec![
-                Instruction::PushBytes(&[0]),
-            ]
-        );
-
-        assert_eq!(
-            v_min,
-            vec![
-                Instruction::PushBytes(&[105]),
-                Instruction::Op(opcodes::OP_NOP3),
-            ]
-        );
-
-        assert_eq!(
-            v_nonmin,
-            vec![
-                Instruction::Error(Error::NonMinimalPush),
-            ]
-        );
-
-        assert_eq!(
-            v_nonmin_alt,
-            vec![
-                Instruction::PushBytes(&[105, 0]),
-                Instruction::Op(opcodes::OP_NOP3),
-            ]
-        );
-
-        assert_eq!(v_min, slop_v_min);
-        assert_eq!(v_min, slop_v_nonmin);
-        assert_eq!(v_nonmin_alt, slop_v_nonmin_alt);
-    }
-
-	#[test]
-    fn script_ord() {
-        let script_1 = Builder::new().push_slice(&[1,2,3,4]).into_script();
-        let script_2 = Builder::new().push_int(10).into_script();
-        let script_3 = Builder::new().push_int(15).into_script();
-        let script_4 = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script();
-
-        assert!(script_1 < script_2);
-        assert!(script_2 < script_3);
-        assert!(script_3 < script_4);
-
-        assert!(script_1 <= script_1);
-        assert!(script_1 >= script_1);
-
-        assert!(script_4 > script_3);
-        assert!(script_3 > script_2);
-        assert!(script_2 > script_1);
-    }
-
-	#[test]
-	#[cfg(feature="bitcoinconsensus")]
-	fn test_bitcoinconsensus () {
-		// a random segwit transaction from the blockchain using native segwit
-		let spent = Builder::from(hex_decode("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d").unwrap()).into_script();
-		let spending = hex_decode("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000").unwrap();
-		spent.verify(0, 18393430, spending.as_slice()).unwrap();
-	}
-}
-
diff --git a/src/blockdata/transaction.rs b/src/blockdata/transaction.rs
deleted file mode 100644
index 7beac7f5..00000000
--- a/src/blockdata/transaction.rs
+++ /dev/null
@@ -1,1220 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Bitcoin Transaction
-//!
-//! A transaction describes a transfer of money. It consumes previously-unspent
-//! transaction outputs and produces new ones, satisfying the condition to spend
-//! the old outputs (typically a digital signature with a specific key must be
-//! provided) and defining the condition to spend the new ones. The use of digital
-//! signatures ensures that coins cannot be spent by unauthorized parties.
-//!
-//! This module provides the structures and functions needed to support transactions.
-//!
-
-use std::default::Default;
-use std::{fmt, io};
-
-use hashes::{self, Hash, sha256d};
-use hashes::hex::FromHex;
-
-use util::endian;
-#[cfg(feature="bitcoinconsensus")] use blockdata::script;
-use blockdata::script::Script;
-use consensus::{encode, serialize, Decodable, Encodable};
-use hash_types::*;
-use VarInt;
-
-/// A reference to a transaction output
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
-pub struct OutPoint {
-    /// The referenced transaction's txid
-    pub txid: Txid,
-    /// The index of the referenced output in its transaction's vout
-    pub vout: u32,
-}
-serde_struct_human_string_impl!(OutPoint, "an OutPoint", txid, vout);
-
-impl OutPoint {
-    /// Create a new [OutPoint].
-    #[inline]
-    pub fn new(txid: Txid, vout: u32) -> OutPoint {
-        OutPoint {
-            txid: txid,
-            vout: vout,
-        }
-    }
-
-    /// Creates a "null" `OutPoint`.
-    ///
-    /// This value is used for coinbase transactions because they don't have
-    /// any previous outputs.
-    #[inline]
-    pub fn null() -> OutPoint {
-        OutPoint {
-            txid: Default::default(),
-            vout: u32::max_value(),
-        }
-    }
-
-    /// Checks if an `OutPoint` is "null".
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin::blockdata::constants::genesis_block;
-    /// use bitcoin::network::constants::Network;
-    ///
-    /// let block = genesis_block(Network::Bitcoin);
-    /// let tx = &block.txdata[0];
-    ///
-    /// // Coinbase transactions don't have any previous output.
-    /// assert_eq!(tx.input[0].previous_output.is_null(), true);
-    /// ```
-    #[inline]
-    pub fn is_null(&self) -> bool {
-        *self == OutPoint::null()
-    }
-}
-
-impl Default for OutPoint {
-    fn default() -> Self {
-        OutPoint::null()
-    }
-}
-
-impl fmt::Display for OutPoint {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}:{}", self.txid, self.vout)
-    }
-}
-
-/// An error in parsing an OutPoint.
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum ParseOutPointError {
-    /// Error in TXID part.
-    Txid(hashes::hex::Error),
-    /// Error in vout part.
-    Vout(::std::num::ParseIntError),
-    /// Error in general format.
-    Format,
-    /// Size exceeds max.
-    TooLong,
-    /// Vout part is not strictly numeric without leading zeroes.
-    VoutNotCanonical,
-}
-
-impl fmt::Display for ParseOutPointError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ParseOutPointError::Txid(ref e) => write!(f, "error parsing TXID: {}", e),
-            ParseOutPointError::Vout(ref e) => write!(f, "error parsing vout: {}", e),
-            ParseOutPointError::Format => write!(f, "OutPoint not in <txid>:<vout> format"),
-            ParseOutPointError::TooLong => write!(f, "vout should be at most 10 digits"),
-            ParseOutPointError::VoutNotCanonical => write!(f, "no leading zeroes or + allowed in vout part"),
-        }
-    }
-}
-
-impl ::std::error::Error for ParseOutPointError {
-    fn description(&self) -> &str {
-        match *self {
-            ParseOutPointError::Txid(_) => "TXID parse error",
-            ParseOutPointError::Vout(_) => "vout parse error",
-            ParseOutPointError::Format => "outpoint format error",
-            ParseOutPointError::TooLong => "size error",
-            ParseOutPointError::VoutNotCanonical => "vout canonical error",
-        }
-    }
-
-    fn cause(&self) -> Option<&::std::error::Error> {
-        match *self {
-            ParseOutPointError::Txid(ref e) => Some(e),
-            ParseOutPointError::Vout(ref e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
-/// Parses a string-encoded transaction index (vout).
-/// It does not permit leading zeroes or non-digit characters.
-fn parse_vout(s: &str) -> Result<u32, ParseOutPointError> {
-    if s.len() > 1 {
-        let first = s.chars().nth(0).unwrap();
-        if first == '0' || first == '+' {
-            return Err(ParseOutPointError::VoutNotCanonical);
-        }
-    }
-    Ok(s.parse().map_err(ParseOutPointError::Vout)?)
-}
-
-impl ::std::str::FromStr for OutPoint {
-    type Err = ParseOutPointError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s.len() > 75 { // 64 + 1 + 10
-            return Err(ParseOutPointError::TooLong);
-        }
-        let find = s.find(':');
-        if find == None || find != s.rfind(':') {
-            return Err(ParseOutPointError::Format);
-        }
-        let colon = find.unwrap();
-        if colon == 0 || colon == s.len() - 1 {
-            return Err(ParseOutPointError::Format);
-        }
-        Ok(OutPoint {
-            txid: Txid::from_hex(&s[..colon]).map_err(ParseOutPointError::Txid)?,
-            vout: parse_vout(&s[colon+1..])?,
-        })
-    }
-}
-
-/// A transaction input, which defines old coins to be consumed
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct TxIn {
-    /// The reference to the previous output that is being used an an input
-    pub previous_output: OutPoint,
-    /// The script which pushes values on the stack which will cause
-    /// the referenced output's script to accept
-    pub script_sig: Script,
-    /// The sequence number, which suggests to miners which of two
-    /// conflicting transactions should be preferred, or 0xFFFFFFFF
-    /// to ignore this feature. This is generally never used since
-    /// the miner behaviour cannot be enforced.
-    pub sequence: u32,
-    /// Witness data: an array of byte-arrays.
-    /// Note that this field is *not* (de)serialized with the rest of the TxIn in
-    /// Encodable/Decodable, as it is (de)serialized at the end of the full
-    /// Transaction. It *is* (de)serialized with the rest of the TxIn in other
-    /// (de)serialization routines.
-    pub witness: Vec<Vec<u8>>
-}
-serde_struct_impl!(TxIn, previous_output, script_sig, sequence, witness);
-
-impl Default for TxIn {
-    fn default() -> TxIn {
-        TxIn {
-            previous_output: OutPoint::default(),
-            script_sig: Script::new(),
-            sequence: u32::max_value(),
-            witness: Vec::new(),
-        }
-    }
-}
-
-/// A transaction output, which defines new coins to be created from old ones.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct TxOut {
-    /// The value of the output, in satoshis
-    pub value: u64,
-    /// The script which must satisfy for the output to be spent
-    pub script_pubkey: Script
-}
-serde_struct_impl!(TxOut, value, script_pubkey);
-
-// This is used as a "null txout" in consensus signing code
-impl Default for TxOut {
-    fn default() -> TxOut {
-        TxOut { value: 0xffffffffffffffff, script_pubkey: Script::new() }
-    }
-}
-
-/// A Bitcoin transaction, which describes an authenticated movement of coins.
-///
-/// If any inputs have nonempty witnesses, the entire transaction is serialized
-/// in the post-BIP141 Segwit format which includes a list of witnesses. If all
-/// inputs have empty witnesses, the transaction is serialized in the pre-BIP141
-/// format.
-///
-/// There is one major exception to this: to avoid deserialization ambiguity,
-/// if the transaction has no inputs, it is serialized in the BIP141 style. Be
-/// aware that this differs from the transaction format in PSBT, which _never_
-/// uses BIP141. (Ordinarily there is no conflict, since in PSBT transactions
-/// are always unsigned and therefore their inputs have empty witnesses.)
-///
-/// The specific ambiguity is that Segwit uses the flag bytes `0001` where an old
-/// serializer would read the number of transaction inputs. The old serializer
-/// would interpret this as "no inputs, one output", which means the transaction
-/// is invalid, and simply reject it. Segwit further specifies that this encoding
-/// should *only* be used when some input has a nonempty witness; that is,
-/// witness-less transactions should be encoded in the traditional format.
-///
-/// However, in protocols where transactions may legitimately have 0 inputs, e.g.
-/// when parties are cooperatively funding a transaction, the "00 means Segwit"
-/// heuristic does not work. Since Segwit requires such a transaction be encoded
-/// in the original transaction format (since it has no inputs and therefore
-/// no input witnesses), a traditionally encoded transaction may have the `0001`
-/// Segwit flag in it, which confuses most Segwit parsers including the one in
-/// Bitcoin Core.
-///
-/// We therefore deviate from the spec by always using the Segwit witness encoding
-/// for 0-input transactions, which results in unambiguously parseable transactions.
-#[derive(Clone, PartialEq, Eq, Debug, Hash)]
-pub struct Transaction {
-    /// The protocol version, is currently expected to be 1 or 2 (BIP 68).
-    pub version: u32,
-    /// Block number before which this transaction is valid, or 0 for
-    /// valid immediately.
-    pub lock_time: u32,
-    /// List of inputs
-    pub input: Vec<TxIn>,
-    /// List of outputs
-    pub output: Vec<TxOut>,
-}
-serde_struct_impl!(Transaction, version, lock_time, input, output);
-
-impl Transaction {
-    /// Computes a "normalized TXID" which does not include any signatures.
-    /// This gives a way to identify a transaction that is ``the same'' as
-    /// another in the sense of having same inputs and outputs.
-    pub fn ntxid(&self) -> sha256d::Hash {
-        let cloned_tx = Transaction {
-            version: self.version,
-            lock_time: self.lock_time,
-            input: self.input.iter().map(|txin| TxIn { script_sig: Script::new(), witness: vec![], .. *txin }).collect(),
-            output: self.output.clone(),
-        };
-        cloned_tx.txid().into()
-    }
-
-    /// Computes the txid. For non-segwit transactions this will be identical
-    /// to the output of `wtxid()`, but for segwit transactions,
-    /// this will give the correct txid (not including witnesses) while `wtxid`
-    /// will also hash witnesses.
-    pub fn txid(&self) -> Txid {
-        let mut enc = Txid::engine();
-        self.version.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)
-    }
-
-    /// Computes SegWit-version of the transaction id (wtxid). For transaction with the witness
-    /// data this hash includes witness, for pre-witness transaction it is equal to the normal
-    /// value returned by txid() function.
-    pub fn wtxid(&self) -> Wtxid {
-        let mut enc = Wtxid::engine();
-        self.consensus_encode(&mut enc).unwrap();
-        Wtxid::from_engine(enc)
-    }
-
-    /// 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
-    /// 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 evaluating `script_pubkey` to determine which separators
-    /// get evaluated and which don't, which we don't have the information to
-    /// determine.
-    ///
-    /// # Panics
-    /// Panics if `input_index` is greater than or equal to `self.input.len()`
-    ///
-    pub fn signature_hash(&self, input_index: usize, script_pubkey: &Script, sighash_u32: u32) -> SigHash {
-        assert!(input_index < self.input.len());  // Panic on OOB
-
-        let (sighash, anyone_can_pay) = SigHashType::from_u32(sighash_u32).split_anyonecanpay_flag();
-
-        // Special-case sighash_single bug because this is easy enough.
-        if sighash == SigHashType::Single && input_index >= self.output.len() {
-            return SigHash::from_slice(&[1, 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]).unwrap();
-        }
-
-        // Build tx to sign
-        let mut tx = Transaction {
-            version: self.version,
-            lock_time: self.lock_time,
-            input: vec![],
-            output: vec![],
-        };
-        // Add all inputs necessary..
-        if anyone_can_pay {
-            tx.input = vec![TxIn {
-                previous_output: self.input[input_index].previous_output,
-                script_sig: script_pubkey.clone(),
-                sequence: self.input[input_index].sequence,
-                witness: vec![],
-            }];
-        } else {
-            tx.input = Vec::with_capacity(self.input.len());
-            for (n, input) in self.input.iter().enumerate() {
-                tx.input.push(TxIn {
-                    previous_output: input.previous_output,
-                    script_sig: if n == input_index { script_pubkey.clone() } else { Script::new() },
-                    sequence: if n != input_index && (sighash == SigHashType::Single || sighash == SigHashType::None) { 0 } else { input.sequence },
-                    witness: vec![],
-                });
-            }
-        }
-        // ..then all outputs
-        tx.output = match sighash {
-            SigHashType::All => self.output.clone(),
-            SigHashType::Single => {
-                let output_iter = self.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()
-            }
-            SigHashType::None => vec![],
-            _ => unreachable!()
-        };
-        // hash the result
-        let mut raw_vec = serialize(&tx);
-        raw_vec.extend_from_slice(&endian::u32_to_array_le(sighash_u32));
-        SigHash::hash(&raw_vec)
-    }
-
-    /// Gets the "weight" of this transaction, as defined by BIP141. For transactions with an empty
-    /// witness, this is simply the consensus-serialized size times 4. For transactions with a
-    /// witness, this is the non-witness consensus-serialized size multiplied by 3 plus the
-    /// with-witness consensus-serialized size.
-    #[inline]
-    pub fn get_weight(&self) -> usize {
-        let mut input_weight = 0;
-        let mut inputs_with_witnesses = 0;
-        for input in &self.input {
-            input_weight += 4*(32 + 4 + 4 + // outpoint (32+4) + nSequence
-                VarInt(input.script_sig.len() as u64).len() +
-                input.script_sig.len());
-            if !input.witness.is_empty() {
-                inputs_with_witnesses += 1;
-                input_weight += VarInt(input.witness.len() as u64).len();
-                for elem in &input.witness {
-                    input_weight += VarInt(elem.len() as u64).len() + elem.len();
-                }
-            }
-        }
-        let mut output_size = 0;
-        for output in &self.output {
-            output_size += 8 + // value
-                VarInt(output.script_pubkey.len() as u64).len() +
-                output.script_pubkey.len();
-        }
-        let non_input_size =
-        // version:
-        4 +
-        // count varints:
-        VarInt(self.input.len() as u64).len() +
-        VarInt(self.output.len() as u64).len() +
-        output_size +
-        // lock_time
-        4;
-        if inputs_with_witnesses == 0 {
-            non_input_size * 4 + input_weight
-        } else {
-            non_input_size * 4 + input_weight + self.input.len() - inputs_with_witnesses + 2
-        }
-    }
-
-    #[cfg(feature="bitcoinconsensus")]
-    /// Verify that this transaction is able to spend its inputs
-    /// The lambda spent should not return the same TxOut twice!
-    pub fn verify<S>(&self, mut spent: S) -> Result<(), script::Error>
-        where S: FnMut(&OutPoint) -> Option<TxOut> {
-        let tx = serialize(&*self);
-        for (idx, input) in self.input.iter().enumerate() {
-            if let Some(output) = spent(&input.previous_output) {
-                output.script_pubkey.verify(idx, output.value, tx.as_slice())?;
-            } else {
-                return Err(script::Error::UnknownSpentOutput(input.previous_output.clone()));
-            }
-        }
-        Ok(())
-    }
-
-    /// Is this a coin base transaction?
-    pub fn is_coin_base(&self) -> bool {
-        self.input.len() == 1 && self.input[0].previous_output.is_null()
-    }
-}
-
-impl_consensus_encoding!(TxOut, value, script_pubkey);
-
-impl Encodable for OutPoint {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let len = self.txid.consensus_encode(&mut s)?;
-        Ok(len + self.vout.consensus_encode(s)?)
-    }
-}
-impl Decodable for OutPoint {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        Ok(OutPoint {
-            txid: Decodable::consensus_decode(&mut d)?,
-            vout: Decodable::consensus_decode(d)?,
-        })
-    }
-}
-
-impl Encodable for TxIn {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let mut len = 0;
-        len += self.previous_output.consensus_encode(&mut s)?;
-        len += self.script_sig.consensus_encode(&mut s)?;
-        len += self.sequence.consensus_encode(s)?;
-        Ok(len)
-    }
-}
-impl Decodable for TxIn {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        Ok(TxIn {
-            previous_output: Decodable::consensus_decode(&mut d)?,
-            script_sig: Decodable::consensus_decode(&mut d)?,
-            sequence: Decodable::consensus_decode(d)?,
-            witness: vec![],
-        })
-    }
-}
-
-impl Encodable for Transaction {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let mut len = 0;
-        len += self.version.consensus_encode(&mut s)?;
-        let mut have_witness = self.input.is_empty();
-        for input in &self.input {
-            if !input.witness.is_empty() {
-                have_witness = true;
-                break;
-            }
-        }
-        if !have_witness {
-            len += self.input.consensus_encode(&mut s)?;
-            len += self.output.consensus_encode(&mut s)?;
-        } else {
-            len += 0u8.consensus_encode(&mut s)?;
-            len += 1u8.consensus_encode(&mut s)?;
-            len += self.input.consensus_encode(&mut s)?;
-            len += self.output.consensus_encode(&mut s)?;
-            for input in &self.input {
-                len += input.witness.consensus_encode(&mut s)?;
-            }
-        }
-        len += self.lock_time.consensus_encode(s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for Transaction {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let version = u32::consensus_decode(&mut d)?;
-        let input = Vec::<TxIn>::consensus_decode(&mut d)?;
-        // segwit
-        if input.is_empty() {
-            let segwit_flag = u8::consensus_decode(&mut d)?;
-            match segwit_flag {
-                // BIP144 input witnesses
-                1 => {
-                    let mut input = Vec::<TxIn>::consensus_decode(&mut d)?;
-                    let output = Vec::<TxOut>::consensus_decode(&mut d)?;
-                    for txin in input.iter_mut() {
-                        txin.witness = Decodable::consensus_decode(&mut d)?;
-                    }
-                    if !input.is_empty() && input.iter().all(|input| input.witness.is_empty()) {
-                        Err(encode::Error::ParseFailed("witness flag set but no witnesses present"))
-                    } else {
-                        Ok(Transaction {
-                            version: version,
-                            input: input,
-                            output: output,
-                            lock_time: Decodable::consensus_decode(d)?,
-                        })
-                    }
-                }
-                // We don't support anything else
-                x => {
-                    Err(encode::Error::UnsupportedSegwitFlag(x))
-                }
-            }
-        // non-segwit
-        } else {
-            Ok(Transaction {
-                version: version,
-                input: input,
-                output: Decodable::consensus_decode(&mut d)?,
-                lock_time: Decodable::consensus_decode(d)?,
-            })
-        }
-    }
-}
-
-/// 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 SigHashType {
-    /// 0x1: Sign all outputs
-    All		= 0x01,
-    /// 0x2: Sign no outputs --- anyone can choose the destination
-    None	= 0x02,
-    /// 0x3: Sign the output whose index matches this input's index. If none exists,
-    /// sign the hash `0000000000000000000000000000000000000000000000000000000000000001`.
-    /// (This rule is probably an unintentional C++ism, but it's consensus so we have
-    /// to follow it.)
-    Single	= 0x03,
-    /// 0x81: Sign all outputs but only this input
-    AllPlusAnyoneCanPay		= 0x81,
-    /// 0x82: Sign no outputs and only this input
-    NonePlusAnyoneCanPay	= 0x82,
-    /// 0x83: Sign one output and only this input (see `Single` for what "one output" means)
-    SinglePlusAnyoneCanPay	= 0x83
-}
-
-impl SigHashType {
-     /// Break the sighash flag into the "real" sighash flag and the ANYONECANPAY boolean
-     fn split_anyonecanpay_flag(&self) -> (SigHashType, bool) {
-         match *self {
-             SigHashType::All		=> (SigHashType::All, false),
-             SigHashType::None		=> (SigHashType::None, false),
-             SigHashType::Single	=> (SigHashType::Single, false),
-             SigHashType::AllPlusAnyoneCanPay		=> (SigHashType::All, true),
-             SigHashType::NonePlusAnyoneCanPay		=> (SigHashType::None, true),
-             SigHashType::SinglePlusAnyoneCanPay	=> (SigHashType::Single, true)
-         }
-     }
-
-     /// Reads a 4-byte uint32 as a sighash type
-     pub fn from_u32(n: u32) -> SigHashType {
-         match n & 0x9f {
-             // "real" sighashes
-             0x01 => SigHashType::All,
-             0x02 => SigHashType::None,
-             0x03 => SigHashType::Single,
-             0x81 => SigHashType::AllPlusAnyoneCanPay,
-             0x82 => SigHashType::NonePlusAnyoneCanPay,
-             0x83 => SigHashType::SinglePlusAnyoneCanPay,
-             // catchalls
-             x if x & 0x80 == 0x80 => SigHashType::AllPlusAnyoneCanPay,
-             _ => SigHashType::All
-         }
-     }
-
-     /// Converts to a u32
-     pub fn as_u32(&self) -> u32 { *self as u32 }
-}
-
-
-#[cfg(test)]
-mod tests {
-    use super::{OutPoint, ParseOutPointError, Transaction, TxIn};
-
-    use std::str::FromStr;
-    use blockdata::script::Script;
-    use consensus::encode::serialize;
-    use consensus::encode::deserialize;
-
-    use hashes::Hash;
-    use hashes::hex::FromHex;
-
-    use hash_types::*;
-
-    #[test]
-    fn test_outpoint() {
-        assert_eq!(OutPoint::from_str("i don't care"),
-                   Err(ParseOutPointError::Format));
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:1:1"),
-                   Err(ParseOutPointError::Format));
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:"),
-                   Err(ParseOutPointError::Format));
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:11111111111"),
-                   Err(ParseOutPointError::TooLong));
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:01"),
-                   Err(ParseOutPointError::VoutNotCanonical));
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:+42"),
-                   Err(ParseOutPointError::VoutNotCanonical));
-        assert_eq!(OutPoint::from_str("i don't care:1"),
-                   Err(ParseOutPointError::Txid(Txid::from_hex("i don't care").unwrap_err())));
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c945X:1"),
-                   Err(ParseOutPointError::Txid(Txid::from_hex("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c945X").unwrap_err())));
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:lol"),
-                   Err(ParseOutPointError::Vout(u32::from_str("lol").unwrap_err())));
- 
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:42"),
-                   Ok(OutPoint{
-                       txid: Txid::from_hex("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456").unwrap(),
-                       vout: 42,
-                   }));
-        assert_eq!(OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:0"),
-                   Ok(OutPoint{
-                       txid: Txid::from_hex("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456").unwrap(),
-                       vout: 0,
-                   }));
-    }
-
-    #[test]
-    fn test_txin() {
-        let txin: Result<TxIn, _> = deserialize(&Vec::<u8>::from_hex("a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff").unwrap());
-        assert!(txin.is_ok());
-    }
-
-    #[test]
-    fn test_txin_default() {
-        let txin = TxIn::default();
-        assert_eq!(txin.previous_output, OutPoint::default());
-        assert_eq!(txin.script_sig, Script::new());
-        assert_eq!(txin.sequence, 0xFFFFFFFF);
-        assert_eq!(txin.previous_output, OutPoint::default());
-        assert_eq!(txin.witness.len(), 0 as usize);
-    }
-
-    #[test]
-    fn test_is_coinbase () {
-        use network::constants::Network;
-        use blockdata::constants;
-
-        let genesis = constants::genesis_block(Network::Bitcoin);
-        assert! (genesis.txdata[0].is_coin_base());
-        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
-        let tx: Transaction = deserialize(&hex_tx).unwrap();
-        assert!(!tx.is_coin_base());
-    }
-
-    #[test]
-    fn test_nonsegwit_transaction() {
-        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
-        let tx: Result<Transaction, _> = deserialize(&hex_tx);
-        assert!(tx.is_ok());
-        let realtx = tx.unwrap();
-        // All these tests aren't really needed because if they fail, the hash check at the end
-        // will also fail. But these will show you where the failure is so I'll leave them in.
-        assert_eq!(realtx.version, 1);
-        assert_eq!(realtx.input.len(), 1);
-        // In particular this one is easy to get backward -- in bitcoin hashes are encoded
-        // as little-endian 256-bit numbers rather than as data strings.
-        assert_eq!(format!("{:x}", realtx.input[0].previous_output.txid),
-                   "ce9ea9f6f5e422c6a9dbcddb3b9a14d1c78fab9ab520cb281aa2a74a09575da1".to_string());
-        assert_eq!(realtx.input[0].previous_output.vout, 1);
-        assert_eq!(realtx.output.len(), 1);
-        assert_eq!(realtx.lock_time, 0);
-
-        assert_eq!(format!("{:x}", realtx.txid()),
-                   "a6eab3c14ab5272a58a5ba91505ba1a4b6d7a3a9fcbd187b6cd99a7b6d548cb7".to_string());
-        assert_eq!(format!("{:x}", realtx.wtxid()),
-                   "a6eab3c14ab5272a58a5ba91505ba1a4b6d7a3a9fcbd187b6cd99a7b6d548cb7".to_string());
-        assert_eq!(realtx.get_weight(), 193*4);
-    }
-
-    #[test]
-    fn test_segwit_transaction() {
-        let hex_tx = Vec::<u8>::from_hex(
-            "02000000000101595895ea20179de87052b4046dfe6fd515860505d6511a9004cf12a1f93cac7c01000000\
-            00ffffffff01deb807000000000017a9140f3444e271620c736808aa7b33e370bd87cb5a078702483045022\
-            100fb60dad8df4af2841adc0346638c16d0b8035f5e3f3753b88db122e70c79f9370220756e6633b17fd271\
-            0e626347d28d60b0a2d6cbb41de51740644b9fb3ba7751040121028fa937ca8cba2197a37c007176ed89410\
-            55d3bcb8627d085e94553e62f057dcc00000000"
-        ).unwrap();
-        let tx: Result<Transaction, _> = deserialize(&hex_tx);
-        assert!(tx.is_ok());
-        let realtx = tx.unwrap();
-        // All these tests aren't really needed because if they fail, the hash check at the end
-        // will also fail. But these will show you where the failure is so I'll leave them in.
-        assert_eq!(realtx.version, 2);
-        assert_eq!(realtx.input.len(), 1);
-        // In particular this one is easy to get backward -- in bitcoin hashes are encoded
-        // as little-endian 256-bit numbers rather than as data strings.
-        assert_eq!(format!("{:x}", realtx.input[0].previous_output.txid),
-                   "7cac3cf9a112cf04901a51d605058615d56ffe6d04b45270e89d1720ea955859".to_string());
-        assert_eq!(realtx.input[0].previous_output.vout, 1);
-        assert_eq!(realtx.output.len(), 1);
-        assert_eq!(realtx.lock_time, 0);
-
-        assert_eq!(format!("{:x}", realtx.txid()),
-                   "f5864806e3565c34d1b41e716f72609d00b55ea5eac5b924c9719a842ef42206".to_string());
-        assert_eq!(format!("{:x}", realtx.wtxid()),
-                   "80b7d8a82d5d5bf92905b06f2014dd699e03837ca172e3a59d51426ebbe3e7f5".to_string());
-        assert_eq!(realtx.get_weight(), 442);
-    }
-
-    #[test]
-    fn tx_no_input_deserialization() {
-        let hex_tx = Vec::<u8>::from_hex(
-            "010000000001000100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000"
-        ).unwrap();
-        let tx: Transaction = deserialize(&hex_tx).expect("deserialize tx");
-
-        assert_eq!(tx.input.len(), 0);
-        assert_eq!(tx.output.len(), 1);
-
-        let reser = serialize(&tx);
-        assert_eq!(hex_tx, reser);
-    }
-
-    #[test]
-    fn test_ntxid() {
-        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
-        let mut tx: Transaction = deserialize(&hex_tx).unwrap();
-
-        let old_ntxid = tx.ntxid();
-        assert_eq!(format!("{:x}", old_ntxid), "c3573dbea28ce24425c59a189391937e00d255150fa973d59d61caf3a06b601d");
-        // changing sigs does not affect it
-        tx.input[0].script_sig = Script::new();
-        assert_eq!(old_ntxid, tx.ntxid());
-        // changing pks does
-        tx.output[0].script_pubkey = Script::new();
-        assert!(old_ntxid != tx.ntxid());
-    }
-
-    #[test]
-    fn test_txid() {
-        // segwit tx from Liquid integration tests, txid/hash from Core decoderawtransaction
-        let hex_tx = Vec::<u8>::from_hex(
-            "01000000000102ff34f95a672bb6a4f6ff4a7e90fa8c7b3be7e70ffc39bc99be3bda67942e836c00000000\
-             23220020cde476664d3fa347b8d54ef3aee33dcb686a65ced2b5207cbf4ec5eda6b9b46e4f414d4c934ad8\
-             1d330314e888888e3bd22c7dde8aac2ca9227b30d7c40093248af7812201000000232200200af6f6a071a6\
-             9d5417e592ed99d256ddfd8b3b2238ac73f5da1b06fc0b2e79d54f414d4c0ba0c8f505000000001976a914\
-             dcb5898d9036afad9209e6ff0086772795b1441088ac033c0f000000000017a914889f8c10ff2bd4bb9dab\
-             b68c5c0d700a46925e6c87033c0f000000000017a914889f8c10ff2bd4bb9dabb68c5c0d700a46925e6c87\
-             033c0f000000000017a914889f8c10ff2bd4bb9dabb68c5c0d700a46925e6c87033c0f000000000017a914\
-             889f8c10ff2bd4bb9dabb68c5c0d700a46925e6c87033c0f000000000017a914889f8c10ff2bd4bb9dabb6\
-             8c5c0d700a46925e6c87033c0f000000000017a914889f8c10ff2bd4bb9dabb68c5c0d700a46925e6c8703\
-             3c0f000000000017a914889f8c10ff2bd4bb9dabb68c5c0d700a46925e6c87033c0f000000000017a91488\
-             9f8c10ff2bd4bb9dabb68c5c0d700a46925e6c87033c0f000000000017a914889f8c10ff2bd4bb9dabb68c\
-             5c0d700a46925e6c87033c0f000000000017a914889f8c10ff2bd4bb9dabb68c5c0d700a46925e6c870500\
-             47304402200380b8663e727d7e8d773530ef85d5f82c0b067c97ae927800a0876a1f01d8e2022021ee611e\
-             f6507dfd217add2cd60a8aea3cbcfec034da0bebf3312d19577b8c290147304402207bd9943ce1c2c5547b\
-             120683fd05d78d23d73be1a5b5a2074ff586b9c853ed4202202881dcf435088d663c9af7b23efb3c03b9db\
-             c0c899b247aa94a74d9b4b3c84f501483045022100ba12bba745af3f18f6e56be70f8382ca8e107d1ed5ce\
-             aa3e8c360d5ecf78886f022069b38ebaac8fe6a6b97b497cbbb115f3176f7213540bef08f9292e5a72de52\
-             de01695321023c9cd9c6950ffee24772be948a45dc5ef1986271e46b686cb52007bac214395a2102756e27\
-             cb004af05a6e9faed81fd68ff69959e3c64ac8c9f6cd0e08fd0ad0e75d2103fa40da236bd82202a985a910\
-             4e851080b5940812685769202a3b43e4a8b13e6a53ae050048304502210098b9687b81d725a7970d1eee91\
-             ff6b89bc9832c2e0e3fb0d10eec143930b006f02206f77ce19dc58ecbfef9221f81daad90bb4f468df3912\
-             12abc4f084fe2cc9bdef01483045022100e5479f81a3ad564103da5e2ec8e12f61f3ac8d312ab68763c1dd\
-             d7bae94c20610220789b81b7220b27b681b1b2e87198897376ba9d033bc387f084c8b8310c8539c2014830\
-             45022100aa1cc48a2d256c0e556616444cc08ae4959d464e5ffff2ae09e3550bdab6ce9f02207192d5e332\
-             9a56ba7b1ead724634d104f1c3f8749fe6081e6233aee3e855817a016953210260de9cc68658c61af984e3\
-             ab0281d17cfca1cc035966d335f474932d5e6c5422210355fbb768ce3ce39360277345dbb5f376e706459e\
-             5a2b5e0e09a535e61690647021023222ceec58b94bd25925dd9743dae6b928737491bd940fc5dd7c6f5d5f\
-             2adc1e53ae00000000"
-        ).unwrap();
-        let tx: Transaction = deserialize(&hex_tx).unwrap();
-
-        assert_eq!(format!("{:x}", tx.wtxid()), "d6ac4a5e61657c4c604dcde855a1db74ec6b3e54f32695d72c5e11c7761ea1b4");
-        assert_eq!(format!("{:x}", tx.txid()), "9652aa62b0e748caeec40c4cb7bc17c6792435cc3dfe447dd1ca24f912a1c6ec");
-        assert_eq!(tx.get_weight(), 2718);
-
-        // non-segwit tx from my mempool
-        let hex_tx = Vec::<u8>::from_hex(
-            "01000000010c7196428403d8b0c88fcb3ee8d64f56f55c8973c9ab7dd106bb4f3527f5888d000000006a47\
-             30440220503a696f55f2c00eee2ac5e65b17767cd88ed04866b5637d3c1d5d996a70656d02202c9aff698f\
-             343abb6d176704beda63fcdec503133ea4f6a5216b7f925fa9910c0121024d89b5a13d6521388969209df2\
-             7a8469bd565aff10e8d42cef931fad5121bfb8ffffffff02b825b404000000001976a914ef79e7ee9fff98\
-             bcfd08473d2b76b02a48f8c69088ac0000000000000000296a273236303039343836393731373233313237\
-             3633313032313332353630353838373931323132373000000000"
-        ).unwrap();
-        let tx: Transaction = deserialize(&hex_tx).unwrap();
-
-        assert_eq!(format!("{:x}", tx.wtxid()), "971ed48a62c143bbd9c87f4bafa2ef213cfa106c6e140f111931d0be307468dd");
-        assert_eq!(format!("{:x}", tx.txid()), "971ed48a62c143bbd9c87f4bafa2ef213cfa106c6e140f111931d0be307468dd");
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    fn test_txn_encode_decode() {
-        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
-        let tx: Transaction = deserialize(&hex_tx).unwrap();
-        serde_round_trip!(tx);
-    }
-
-    fn run_test_sighash(tx: &str, script: &str, input_index: usize, hash_type: i32, expected_result: &str) {
-        let tx: Transaction = deserialize(&Vec::<u8>::from_hex(tx).unwrap()[..]).unwrap();
-        let script = Script::from(Vec::<u8>::from_hex(script).unwrap());
-        let mut raw_expected = Vec::<u8>::from_hex(expected_result).unwrap();
-        raw_expected.reverse();
-        let expected_result = SigHash::from_slice(&raw_expected[..]).unwrap();
-
-        let actual_result = tx.signature_hash(input_index, &script, hash_type as u32);
-        assert_eq!(actual_result, expected_result);
-    }
-
-    // Test decoding transaction `4be105f158ea44aec57bf12c5817d073a712ab131df6f37786872cfc70734188`
-    // from testnet, which is the first BIP144-encoded transaction I encountered.
-    #[test]
-    #[cfg(feature = "serde")]
-    fn test_segwit_tx_decode() {
-        let hex_tx = Vec::<u8>::from_hex("010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff3603da1b0e00045503bd5704c7dd8a0d0ced13bb5785010800000000000a636b706f6f6c122f4e696e6a61506f6f6c2f5345475749542fffffffff02b4e5a212000000001976a914876fbb82ec05caa6af7a3b5e5a983aae6c6cc6d688ac0000000000000000266a24aa21a9edf91c46b49eb8a29089980f02ee6b57e7d63d33b18b4fddac2bcd7db2a39837040120000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
-        let tx: Transaction = deserialize(&hex_tx).unwrap();
-        assert_eq!(tx.get_weight(), 780);
-        serde_round_trip!(tx);
-
-        let consensus_encoded = serialize(&tx);
-        assert_eq!(consensus_encoded, hex_tx);
-    }
-
-
-    // These test vectors were stolen from libbtc, which is Copyright 2014 Jonas Schnelli MIT
-    // They were transformed by replacing {...} with run_test_sighash(...), then the ones containing
-    // OP_CODESEPARATOR in their pubkeys were removed
-    #[test]
-    fn test_sighash() {
-        run_test_sighash("907c2bc503ade11cc3b04eb2918b6f547b0630ab569273824748c87ea14b0696526c66ba740200000004ab65ababfd1f9bdd4ef073c7afc4ae00da8a66f429c917a0081ad1e1dabce28d373eab81d8628de802000000096aab5253ab52000052ad042b5f25efb33beec9f3364e8a9139e8439d9d7e26529c3c30b6c3fd89f8684cfd68ea0200000009ab53526500636a52ab599ac2fe02a526ed040000000008535300516352515164370e010000000003006300ab2ec229", "", 2, 1864164639, "31af167a6cf3f9d5f6875caa4d31704ceb0eba078d132b78dab52c3b8997317e");
-        run_test_sighash("a0aa3126041621a6dea5b800141aa696daf28408959dfb2df96095db9fa425ad3f427f2f6103000000015360290e9c6063fa26912c2e7fb6a0ad80f1c5fea1771d42f12976092e7a85a4229fdb6e890000000001abc109f6e47688ac0e4682988785744602b8c87228fcef0695085edf19088af1a9db126e93000000000665516aac536affffffff8fe53e0806e12dfd05d67ac68f4768fdbe23fc48ace22a5aa8ba04c96d58e2750300000009ac51abac63ab5153650524aa680455ce7b000000000000499e50030000000008636a00ac526563ac5051ee030000000003abacabd2b6fe000000000003516563910fb6b5", "65", 0, -1391424484, "48d6a1bd2cd9eec54eb866fc71209418a950402b5d7e52363bfb75c98e141175");
-        run_test_sighash("73107cbd025c22ebc8c3e0a47b2a760739216a528de8d4dab5d45cbeb3051cebae73b01ca10200000007ab6353656a636affffffffe26816dffc670841e6a6c8c61c586da401df1261a330a6c6b3dd9f9a0789bc9e000000000800ac6552ac6aac51ffffffff0174a8f0010000000004ac52515100000000", "5163ac63635151ac", 1, 1190874345, "06e328de263a87b09beabe222a21627a6ea5c7f560030da31610c4611f4a46bc");
-        run_test_sighash("50818f4c01b464538b1e7e7f5ae4ed96ad23c68c830e78da9a845bc19b5c3b0b20bb82e5e9030000000763526a63655352ffffffff023b3f9c040000000008630051516a6a5163a83caf01000000000553ab65510000000000", "6aac", 0, 946795545, "746306f322de2b4b58ffe7faae83f6a72433c22f88062cdde881d4dd8a5a4e2d");
-        run_test_sighash("a93e93440250f97012d466a6cc24839f572def241c814fe6ae94442cf58ea33eb0fdd9bcc1030000000600636a0065acffffffff5dee3a6e7e5ad6310dea3e5b3ddda1a56bf8de7d3b75889fc024b5e233ec10f80300000007ac53635253ab53ffffffff0160468b04000000000800526a5300ac526a00000000", "ac00636a53", 1, 1773442520, "5c9d3a2ce9365bb72cfabbaa4579c843bb8abf200944612cf8ae4b56a908bcbd");
-        run_test_sighash("d3b7421e011f4de0f1cea9ba7458bf3486bee722519efab711a963fa8c100970cf7488b7bb0200000003525352dcd61b300148be5d05000000000000000000", "535251536aac536a", 0, -1960128125, "29aa6d2d752d3310eba20442770ad345b7f6a35f96161ede5f07b33e92053e2a");
-        run_test_sighash("04bac8c5033460235919a9c63c42b2db884c7c8f2ed8fcd69ff683a0a2cccd9796346a04050200000003655351fcad3a2c5a7cbadeb4ec7acc9836c3f5c3e776e5c566220f7f965cf194f8ef98efb5e3530200000007526a006552526526a2f55ba5f69699ece76692552b399ba908301907c5763d28a15b08581b23179cb01eac03000000075363ab6a516351073942c2025aa98a05000000000765006aabac65abd7ffa6030000000004516a655200000000", "53ac6365ac526a", 1, 764174870, "bf5fdc314ded2372a0ad078568d76c5064bf2affbde0764c335009e56634481b");
-        run_test_sighash("c363a70c01ab174230bbe4afe0c3efa2d7f2feaf179431359adedccf30d1f69efe0c86ed390200000002ab51558648fe0231318b04000000000151662170000000000008ac5300006a63acac00000000", "", 0, 2146479410, "191ab180b0d753763671717d051f138d4866b7cb0d1d4811472e64de595d2c70");
-        run_test_sighash("8d437a7304d8772210a923fd81187c425fc28c17a5052571501db05c7e89b11448b36618cd02000000026a6340fec14ad2c9298fde1477f1e8325e5747b61b7e2ff2a549f3d132689560ab6c45dd43c3010000000963ac00ac000051516a447ed907a7efffebeb103988bf5f947fc688aab2c6a7914f48238cf92c337fad4a79348102000000085352ac526a5152517436edf2d80e3ef06725227c970a816b25d0b58d2cd3c187a7af2cea66d6b27ba69bf33a0300000007000063ab526553f3f0d6140386815d030000000003ab6300de138f00000000000900525153515265abac1f87040300000000036aac6500000000", "51", 3, -315779667, "b6632ac53578a741ae8c36d8b69e79f39b89913a2c781cdf1bf47a8c29d997a5");
-        run_test_sighash("fd878840031e82fdbe1ad1d745d1185622b0060ac56638290ec4f66b1beef4450817114a2c0000000009516a63ab53650051abffffffff37b7a10322b5418bfd64fb09cd8a27ddf57731aeb1f1f920ffde7cb2dfb6cdb70300000008536a5365ac53515369ecc034f1594690dbe189094dc816d6d57ea75917de764cbf8eccce4632cbabe7e116cd0100000003515352ffffffff035777fc000000000003515200abe9140300000000050063005165bed6d10200000000076300536363ab65195e9110", "635265", 0, 1729787658, "6e3735d37a4b28c45919543aabcb732e7a3e1874db5315abb7cc6b143d62ff10");
-        run_test_sighash("a63bc673049c75211aa2c09ecc38e360eaa571435fedd2af1116b5c1fa3d0629c269ecccbf0000000008ac65ab516352ac52ffffffffbf1a76fdda7f451a5f0baff0f9ccd0fe9136444c094bb8c544b1af0fa2774b06010000000463535253ffffffff13d6b7c3ddceef255d680d87181e100864eeb11a5bb6a3528cb0d70d7ee2bbbc02000000056a0052abab951241809623313b198bb520645c15ec96bfcc74a2b0f3db7ad61d455cc32db04afc5cc702000000016309c9ae25014d9473020000000004abab6aac3bb1e803", "", 3, -232881718, "6e48f3da3a4ac07eb4043a232df9f84e110485d7c7669dd114f679c27d15b97e");
-        run_test_sighash("4c565efe04e7d32bac03ae358d63140c1cfe95de15e30c5b84f31bb0b65bb542d637f49e0f010000000551abab536348ae32b31c7d3132030a510a1b1aacf7b7c3f19ce8dc49944ef93e5fa5fe2d356b4a73a00100000009abac635163ac00ab514c8bc57b6b844e04555c0a4f4fb426df139475cd2396ae418bc7015820e852f711519bc202000000086a00510000abac52488ff4aec72cbcfcc98759c58e20a8d2d9725aa4a80f83964e69bc4e793a4ff25cd75dc701000000086a52ac6aac5351532ec6b10802463e0200000000000553005265523e08680100000000002f39a6b0", "", 3, 70712784, "c6076b6a45e6fcfba14d3df47a34f6aadbacfba107e95621d8d7c9c0e40518ed");
-        run_test_sighash("fd22692802db8ae6ab095aeae3867305a954278f7c076c542f0344b2591789e7e33e4d29f4020000000151ffffffffb9409129cfed9d3226f3b6bab7a2c83f99f48d039100eeb5796f00903b0e5e5e0100000006656552ac63abd226abac0403e649000000000007abab51ac5100ac8035f10000000000095165006a63526a52510d42db030000000007635365ac6a63ab24ef5901000000000453ab6a0000000000", "536a52516aac6a", 1, 309309168, "7ca0f75e6530ec9f80d031fc3513ca4ecd67f20cb38b4dacc6a1d825c3cdbfdb");
-        run_test_sighash("a43f85f701ffa54a3cc57177510f3ea28ecb6db0d4431fc79171cad708a6054f6e5b4f89170000000008ac6a006a536551652bebeaa2013e779c05000000000665ac5363635100000000", "ac", 0, 2028978692, "58294f0d7f2e68fe1fd30c01764fe1619bcc7961d68968944a0e263af6550437");
-        run_test_sighash("c2b0b99001acfecf7da736de0ffaef8134a9676811602a6299ba5a2563a23bb09e8cbedf9300000000026300ffffffff042997c50300000000045252536a272437030000000007655353ab6363ac663752030000000002ab6a6d5c900000000000066a6a5265abab00000000", "52ac525163515251", 0, -894181723, "8b300032a1915a4ac05cea2f7d44c26f2a08d109a71602636f15866563eaafdc");
-        run_test_sighash("82f9f10304c17a9d954cf3380db817814a8c738d2c811f0412284b2c791ec75515f38c4f8c020000000265ab5729ca7db1b79abee66c8a757221f29280d0681355cb522149525f36da760548dbd7080a0100000001510b477bd9ce9ad5bb81c0306273a3a7d051e053f04ecf3a1dbeda543e20601a5755c0cfae030000000451ac656affffffff71141a04134f6c292c2e0d415e6705dfd8dcee892b0d0807828d5aeb7d11f5ef0300000001520b6c6dc802a6f3dd0000000000056aab515163bfb6800300000000015300000000", "", 3, -635779440, "d55ed1e6c53510f2608716c12132a11fb5e662ec67421a513c074537eeccc34b");
-        run_test_sighash("2074bad5011847f14df5ea7b4afd80cd56b02b99634893c6e3d5aaad41ca7c8ee8e5098df003000000026a6affffffff018ad59700000000000900ac656a526551635300000000", "65635265", 0, -1804671183, "663c999a52288c9999bff36c9da2f8b78d5c61b8347538f76c164ccba9868d0a");
-        run_test_sighash("7100b11302e554d4ef249ee416e7510a485e43b2ba4b8812d8fe5529fe33ea75f36d392c4403000000020000ffffffff3d01a37e075e9a7715a657ae1bdf1e44b46e236ad16fd2f4c74eb9bf370368810000000007636553ac536365ffffffff01db696a0400000000065200ac656aac00000000", "63005151", 0, -1210499507, "b9c3aee8515a4a3b439de1ffc9c156824bda12cb75bfe5bc863164e8fd31bd7a");
-        run_test_sighash("02c1017802091d1cb08fec512db7b012fe4220d57a5f15f9e7676358b012786e1209bcff950100000004acab6352ffffffff799bc282724a970a6fea1828984d0aeb0f16b67776fa213cbdc4838a2f1961a3010000000951516a536552ab6aabffffffff016c7b4b03000000000865abac5253ac5352b70195ad", "65655200516a", 0, -241626954, "be567cb47170b34ff81c66c1142cb9d27f9b6898a384d6dfc4fce16b75b6cb14");
-        run_test_sighash("4504cb1904c7a4acf375ddae431a74de72d5436efc73312cf8e9921f431267ea6852f9714a01000000066a656a656553a2fbd587c098b3a1c5bd1d6480f730a0d6d9b537966e20efc0e352d971576d0f87df0d6d01000000016321aeec3c4dcc819f1290edb463a737118f39ab5765800547522708c425306ebfca3f396603000000055300ac656a1d09281d05bfac57b5eb17eb3fa81ffcedfbcd3a917f1be0985c944d473d2c34d245eb350300000007656a51525152ac263078d9032f470f0500000000066aac00000052e12da60200000000003488410200000000076365006300ab539981e432", "52536a52526a", 1, -31909119, "f0a2deee7fd8a3a9fad6927e763ded11c940ee47e9e6d410f94fda5001f82e0c");
-        run_test_sighash("14bc7c3e03322ec0f1311f4327e93059c996275302554473104f3f7b46ca179bfac9ef753503000000016affffffff9d405eaeffa1ca54d9a05441a296e5cc3a3e32bb8307afaf167f7b57190b07e00300000008abab51ab5263abab45533aa242c61bca90dd15d46079a0ab0841d85df67b29ba87f2393cd764a6997c372b55030000000452005263ffffffff0250f40e02000000000651516a0063630e95ab0000000000046a5151ac00000000", "6a65005151", 0, -1460947095, "aa418d096929394c9147be8818d8c9dafe6d105945ab9cd7ec682df537b5dd79");
-        run_test_sighash("a08ff466049fb7619e25502ec22fedfb229eaa1fe275aa0b5a23154b318441bf547989d0510000000005ab5363636affffffff2b0e335cb5383886751cdbd993dc0720817745a6b1c9b8ab3d15547fc9aafd03000000000965656a536a52656a532b53d10584c290d3ac1ab74ab0a19201a4a039cb59dc58719821c024f6bf2eb26322b33f010000000965ac6aac0053ab6353ffffffff048decba6ebbd2db81e416e39dde1f821ba69329725e702bcdea20c5cc0ecc6402000000086363ab5351ac6551466e377b0468c0fa00000000000651ab53ac6a513461c6010000000008636a636365535100eeb3dc010000000006526a52ac516a43f362010000000005000063536500000000", "0063516a", 1, -1158911348, "f6a1ecb50bd7c2594ebecea5a1aa23c905087553e40486dade793c2f127fdfae");
-        run_test_sighash("f10a0356031cd569d652dbca8e7a4d36c8da33cdff428d003338602b7764fe2c96c505175b010000000465ac516affffffffbb54563c71136fa944ee20452d78dc87073ac2365ba07e638dce29a5d179da600000000003635152ffffffff9a411d8e2d421b1e6085540ee2809901e590940bbb41532fa38bd7a16b68cc350100000007535251635365636195df1603b61c45010000000002ab65bf6a310400000000026352fcbba10200000000016aa30b7ff0", "5351", 0, 1552495929, "9eb8adf2caecb4bf9ac59d7f46bd20e83258472db2f569ee91aba4cf5ee78e29");
-        run_test_sighash("c3325c9b012f659466626ca8f3c61dfd36f34670abc054476b7516a1839ec43cd0870aa0c0000000000753525265005351e7e3f04b0112650500000000000363ac6300000000", "acac", 0, -68961433, "5ca70e727d91b1a42b78488af2ed551642c32d3de4712a51679f60f1456a8647");
-        run_test_sighash("b500ca48011ec57c2e5252e5da6432089130603245ffbafb0e4c5ffe6090feb629207eeb0e010000000652ab6a636aab8302c9d2042b44f40500000000015278c05a050000000004ac5251524be080020000000007636aac63ac5252c93a9a04000000000965ab6553636aab5352d91f9ddb", "52005100", 0, -2024394677, "49c8a6940a461cc7225637f1e512cdd174c99f96ec05935a59637ededc77124c");
-        run_test_sighash("f52ff64b02ee91adb01f3936cc42e41e1672778962b68cf013293d649536b519bc3271dd2c00000000020065afee11313784849a7c15f44a61cd5fd51ccfcdae707e5896d131b082dc9322a19e12858501000000036aac654e8ca882022deb7c020000000006006a515352abd3defc0000000000016300000000", "63520063", 0, 1130989496, "7f208df9a5507e98c62cebc5c1e2445eb632e95527594929b9577b53363e96f6");
-        run_test_sighash("ab7d6f36027a7adc36a5cf7528fe4fb5d94b2c96803a4b38a83a675d7806dda62b380df86a0000000003000000ffffffff5bc00131e29e22057c04be854794b4877dda42e416a7a24706b802ff9da521b20000000007ac6a0065ac52ac957cf45501b9f06501000000000500ac6363ab25f1110b", "00526500536a635253", 0, 911316637, "5fa09d43c8aef6f6fa01c383a69a5a61a609cd06e37dce35a39dc9eae3ddfe6c");
-        run_test_sighash("f940888f023dce6360263c850372eb145b864228fdbbb4c1186174fa83aab890ff38f8c9a90300000000ffffffff01e80ccdb081e7bbae1c776531adcbfb77f2e5a7d0e5d0d0e2e6c8758470e85f00000000020053ffffffff03b49088050000000004656a52ab428bd604000000000951630065ab63ac636a0cbacf0400000000070063ac5265ac53d6e16604", "ac63", 0, 39900215, "713ddeeefcfe04929e7b6593c792a4efbae88d2b5280d1f0835d2214eddcbad6");
-        run_test_sighash("530ecd0b01ec302d97ef6f1b5a6420b9a239714013e20d39aa3789d191ef623fc215aa8b940200000005ac5351ab6a3823ab8202572eaa04000000000752ab6a51526563fd8a270100000000036a006581a798f0", "525153656a0063", 0, 1784562684, "fe42f73a8742676e640698222b1bd6b9c338ff1ccd766d3d88d7d3c6c6ac987e");
-        run_test_sighash("5d781d9303acfcce964f50865ddfddab527ea971aee91234c88e184979985c00b4de15204b0100000003ab6352a009c8ab01f93c8ef2447386c434b4498538f061845862c3f9d5751ad0fce52af442b3a902000000045165ababb909c66b5a3e7c81b3c45396b944be13b8aacfc0204f3f3c105a66fa8fa6402f1b5efddb01000000096a65ac636aacab656ac3c677c402b79fa4050000000004006aab5133e35802000000000751ab635163ab0078c2e025", "6aac51636a6a005265", 0, -882306874, "551ce975d58647f10adefb3e529d9bf9cda34751627ec45e690f135ef0034b95");
-        run_test_sighash("a9c57b1a018551bcbc781b256642532bbc09967f1cbe30a227d352a19365d219d3f11649a3030000000451655352b140942203182894030000000006ab00ac6aab654add350400000000003d379505000000000553abacac00e1739d36", "5363", 0, -1069721025, "6da32416deb45a0d720a1dbe6d357886eabc44029dd5db74d50feaffbe763245");
-        run_test_sighash("05c4fb94040f5119dc0b10aa9df054871ed23c98c890f1e931a98ffb0683dac45e98619fdc0200000007acab6a525263513e7495651c9794c4d60da835d303eb4ee6e871f8292f6ad0b32e85ef08c9dc7aa4e03c9c010000000500ab52acacfffffffffee953259cf14ced323fe8d567e4c57ba331021a1ef5ac2fa90f7789340d7c550100000007ac6aacac6a6a53ffffffff08d9dc820d00f18998af247319f9de5c0bbd52a475ea587f16101af3afab7c210100000003535363569bca7c0468e34f00000000000863536353ac51ac6584e319010000000006650052ab6a533debea030000000003ac0053ee7070020000000006ac52005253ac00000000", "6351005253", 2, 1386916157, "76c4013c40bfa1481badd9d342b6d4b8118de5ab497995fafbf73144469e5ff0");
-        run_test_sighash("ca66ae10049533c2b39f1449791bd6d3f039efe0a121ab7339d39ef05d6dcb200ec3fb2b3b020000000465006a53ffffffff534b8f97f15cc7fb4f4cea9bf798472dc93135cd5b809e4ca7fe4617a61895980100000000ddd83c1dc96f640929dd5e6f1151dab1aa669128591f153310d3993e562cc7725b6ae3d903000000046a52536582f8ccddb8086d8550f09128029e1782c3f2624419abdeaf74ecb24889cc45ac1a64492a0100000002516a4867b41502ee6ccf03000000000752acacab52ab6a4b7ba80000000000075151ab0052536300000000", "6553", 2, -62969257, "8085e904164ab9a8c20f58f0d387f6adb3df85532e11662c03b53c3df8c943cb");
-        run_test_sighash("ba646d0b0453999f0c70cb0430d4cab0e2120457bb9128ed002b6e9500e9c7f8d7baa20abe0200000001652a4e42935b21db02b56bf6f08ef4be5adb13c38bc6a0c3187ed7f6197607ba6a2c47bc8a03000000040052516affffffffa55c3cbfc19b1667594ac8681ba5d159514b623d08ed4697f56ce8fcd9ca5b0b00000000096a6a5263ac655263ab66728c2720fdeabdfdf8d9fb2bfe88b295d3b87590e26a1e456bad5991964165f888c03a0200000006630051ac00acffffffff0176fafe0100000000070063acac65515200000000", "63", 1, 2002322280, "9db4e320208185ee70edb4764ee195deca00ba46412d5527d9700c1cf1c3d057");
-        run_test_sighash("2ddb8f84039f983b45f64a7a79b74ff939e3b598b38f436def7edd57282d0803c7ef34968d02000000026a537eb00c4187de96e6e397c05f11915270bcc383959877868ba93bac417d9f6ed9f627a7930300000004516551abffffffffacc12f1bb67be3ae9f1d43e55fda8b885340a0df1175392a8bbd9f959ad3605003000000025163ffffffff02ff0f4700000000000070bd99040000000003ac53abf8440b42", "", 2, -393923011, "0133f1a161363b71dfb3a90065c7128c56bd0028b558b610142df79e055ab5c7");
-        run_test_sighash("b21fc15403b4bdaa994204444b59323a7b8714dd471bd7f975a4e4b7b48787e720cbd1f5f00000000000ffffffff311533001cb85c98c1d58de0a5fbf27684a69af850d52e22197b0dc941bc6ca9030000000765ab6363ab5351a8ae2c2c7141ece9a4ff75c43b7ea9d94ec79b7e28f63e015ac584d984a526a73fe1e04e0100000007526352536a5365ffffffff02a0a9ea030000000002ab52cfc4f300000000000465525253e8e0f342", "000000", 1, 1305253970, "d1df1f4bba2484cff8a816012bb6ec91c693e8ca69fe85255e0031711081c46a");
-        run_test_sighash("f821a042036ad43634d29913b77c0fc87b4af593ac86e9a816a9d83fd18dfcfc84e1e1d57102000000076a63ac52006351ffffffffbcdaf490fc75086109e2f832c8985716b3a624a422cf9412fe6227c10585d21203000000095252abab5352ac526affffffff2efed01a4b73ad46c7f7bc7fa3bc480f8e32d741252f389eaca889a2e9d2007e000000000353ac53ffffffff032ac8b3020000000009636300000063516300d3d9f2040000000006510065ac656aafa5de0000000000066352ab5300ac9042b57d", "525365", 1, 667065611, "0d17a92c8d5041ba09b506ddf9fd48993be389d000aad54f9cc2a44fcc70426b");
-        run_test_sighash("d62f183e037e0d52dcf73f9b31f70554bce4f693d36d17552d0e217041e01f15ad3840c838000000000963acac6a6a6a63ab63ffffffffabdfb395b6b4e63e02a763830f536fc09a35ff8a0cf604021c3c751fe4c88f4d0300000006ab63ab65ac53aa4d30de95a2327bccf9039fb1ad976f84e0b4a0936d82e67eafebc108993f1e57d8ae39000000000165ffffffff04364ad30500000000036a005179fd84010000000007ab636aac6363519b9023030000000008510065006563ac6acd2a4a02000000000000000000", "52", 1, 595020383, "da8405db28726dc4e0f82b61b2bfd82b1baa436b4e59300305cc3b090b157504");
-        run_test_sighash("44c200a5021238de8de7d80e7cce905606001524e21c8d8627e279335554ca886454d692e6000000000500acac52abbb8d1dc876abb1f514e96b21c6e83f429c66accd961860dc3aed5071e153e556e6cf076d02000000056553526a51870a928d0360a580040000000004516a535290e1e302000000000851ab6a00510065acdd7fc5040000000007515363ab65636abb1ec182", "6363", 0, -785766894, "ed53cc766cf7cb8071cec9752460763b504b2183442328c5a9761eb005c69501");
-        run_test_sighash("d682d52d034e9b062544e5f8c60f860c18f029df8b47716cabb6c1b4a4b310a0705e754556020000000400656a0016eeb88eef6924fed207fba7ddd321ff3d84f09902ff958c815a2bf2bb692eb52032c4d803000000076365ac516a520099788831f8c8eb2552389839cfb81a9dc55ecd25367acad4e03cfbb06530f8cccf82802701000000085253655300656a53ffffffff02d543200500000000056a510052ac03978b05000000000700ac51525363acfdc4f784", "", 2, -696035135, "e1a256854099907050cfee7778f2018082e735a1f1a3d91437584850a74c87bb");
-        run_test_sighash("e8c0dec5026575ddf31343c20aeeca8770afb33d4e562aa8ee52eeda6b88806fdfd4fe0a97030000000953acabab65ab516552ffffffffdde122c2c3e9708874286465f8105f43019e837746686f442666629088a970e0010000000153ffffffff01f98eee0100000000025251fe87379a", "63", 1, 633826334, "abe441209165d25bc6d8368f2e7e7dc21019056719fef1ace45542aa2ef282e2");
-        run_test_sighash("b288c331011c17569293c1e6448e33a64205fc9dc6e35bc756a1ac8b97d18e912ea88dc0770200000007635300ac6aacabfc3c890903a3ccf8040000000004656500ac9c65c9040000000009ab6a6aabab65abac63ac5f7702000000000365005200000000", "526a63", 0, 1574937329, "0dd1bd5c25533bf5f268aa316ce40f97452cca2061f0b126a59094ca5b65f7a0");
-        run_test_sighash("6b68ba00023bb4f446365ea04d68d48539aae66f5b04e31e6b38b594d2723ab82d44512460000000000200acffffffff5dfc6febb484fff69c9eeb7c7eb972e91b6d949295571b8235b1da8955f3137b020000000851ac6352516a535325828c8a03365da801000000000800636aabac6551ab0f594d03000000000963ac536365ac63636a45329e010000000005abac53526a00000000", "005151", 0, 1317038910, "42f5ba6f5fe1e00e652a08c46715871dc4b40d89d9799fd7c0ea758f86eab6a7");
-        run_test_sighash("046ac25e030a344116489cc48025659a363da60bc36b3a8784df137a93b9afeab91a04c1ed020000000951ab0000526a65ac51ffffffff6c094a03869fde55b9a8c4942a9906683f0a96e2d3e5a03c73614ea3223b2c29020000000500ab636a6affffffff3da7aa5ecef9071600866267674b54af1740c5aeb88a290c459caa257a2683cb0000000004ab6565ab7e2a1b900301b916030000000005abac63656308f4ed03000000000852ab53ac63ac51ac73d620020000000003ab00008deb1285", "6a", 2, 1299505108, "f79e6b776e2592bad45ca328c54abf14050c241d8f822d982c36ea890fd45757");
-        run_test_sighash("ff5400dd02fec5beb9a396e1cbedc82bedae09ed44bae60ba9bef2ff375a6858212478844b03000000025253ffffffff01e46c203577a79d1172db715e9cc6316b9cfc59b5e5e4d9199fef201c6f9f0f000000000900ab6552656a5165acffffffff02e8ce62040000000002515312ce3e00000000000251513f119316", "", 0, 1541581667, "1e0da47eedbbb381b0e0debbb76e128d042e02e65b11125e17fd127305fc65cd");
-        run_test_sighash("b54bf5ac043b62e97817abb892892269231b9b220ba08bc8dbc570937cd1ea7cdc13d9676c010000000451ab5365a10adb7b35189e1e8c00b86250f769319668189b7993d6bdac012800f1749150415b2deb0200000003655300ffffffff60b9f4fb9a7e17069fd00416d421f804e2ef2f2c67de4ca04e0241b9f9c1cc5d0200000003ab6aacfffffffff048168461cce1d40601b42fbc5c4f904ace0d35654b7cc1937ccf53fe78505a0100000008526563525265abacffffffff01dbf4e6040000000007acac656553636500000000", "63", 2, 882302077, "f5b38b0f06e246e47ce622e5ee27d5512c509f8ac0e39651b3389815eff2ab93");
-        run_test_sighash("ebf628b30360bab3fa4f47ce9e0dcbe9ceaf6675350e638baff0c2c197b2419f8e4fb17e16000000000452516365ac4d909a79be207c6e5fb44fbe348acc42fc7fe7ef1d0baa0e4771a3c4a6efdd7e2c118b0100000003acacacffffffffa6166e9101f03975721a3067f1636cc390d72617be72e5c3c4f73057004ee0ee010000000863636a6a516a5252c1b1e82102d8d54500000000000153324c900400000000015308384913", "0063516a51", 1, -1658428367, "eb2d8dea38e9175d4d33df41f4087c6fea038a71572e3bad1ea166353bf22184");
-        run_test_sighash("d6a8500303f1507b1221a91adb6462fb62d741b3052e5e7684ea7cd061a5fc0b0e93549fa50100000004acab65acfffffffffdec79bf7e139c428c7cfd4b35435ae94336367c7b5e1f8e9826fcb0ebaaaea30300000000ffffffffd115fdc00713d52c35ea92805414bd57d1e59d0e6d3b79a77ee18a3228278ada020000000453005151ffffffff040231510300000000085100ac6a6a000063c6041c0400000000080000536a6563acac138a0b04000000000263abd25fbe03000000000900656a00656aac510000000000", "ac526aac6a00", 1, -2007972591, "13d12a51598b34851e7066cd93ab8c5212d60c6ed2dae09d91672c10ccd7f87c");
-        run_test_sighash("e92492cc01aec4e62df67ea3bc645e2e3f603645b3c5b353e4ae967b562d23d6e043badecd0100000003acab65ffffffff02c7e5ea040000000002ab52e1e584010000000005536365515195d16047", "6551", 0, -424930556, "93c34627f526d73f4bea044392d1a99776b4409f7d3d835f23b03c358f5a61c2");
-        run_test_sighash("b28d5f5e015a7f24d5f9e7b04a83cd07277d452e898f78b50aae45393dfb87f94a26ef57720200000008ababac630053ac52ffffffff046475ed040000000008ab5100526363ac65c9834a04000000000251abae26b30100000000040000ac65ceefb900000000000000000000", "ac6551ac6a536553", 0, -1756558188, "5848d93491044d7f21884eef7a244fe7d38886f8ae60df49ce0dfb2a342cd51a");
-        run_test_sighash("efb8b09801f647553b91922a5874f8e4bb2ed8ddb3536ed2d2ed0698fac5e0e3a298012391030000000952ac005263ac52006affffffff04cdfa0f050000000007ac53ab51abac65b68d1b02000000000553ab65ac00d057d50000000000016a9e1fda010000000007ac63ac536552ac00000000", "6aac", 0, 1947322973, "603a9b61cd30fcea43ef0a5c18b88ca372690b971b379ee9e01909c336280511");
-        run_test_sighash("67761f2a014a16f3940dcb14a22ba5dc057fcffdcd2cf6150b01d516be00ef55ef7eb07a830100000004636a6a51ffffffff01af67bd050000000008526553526300510000000000", "6a00", 0, 1570943676, "079fa62e9d9d7654da8b74b065da3154f3e63c315f25751b4d896733a1d67807");
-        run_test_sighash("ec02fbee03120d02fde12574649660c441b40d330439183430c6feb404064d4f507e704f3c0100000000ffffffffe108d99c7a4e5f75cc35c05debb615d52fac6e3240a6964a29c1704d98017fb60200000002ab63fffffffff726ec890038977adfc9dadbeaf5e486d5fcb65dc23acff0dd90b61b8e2773410000000002ac65e9dace55010f881b010000000005ac00ab650000000000", "51ac525152ac6552", 2, -1564046020, "3f988922d8cd11c7adff1a83ce9499019e5ab5f424752d8d361cf1762e04269b");
-        run_test_sighash("33b03bf00222c7ca35c2f8870bbdef2a543b70677e413ce50494ac9b22ea673287b6aa55c50000000005ab00006a52ee4d97b527eb0b427e4514ea4a76c81e68c34900a23838d3e57d0edb5410e62eeb8c92b6000000000553ac6aacac42e59e170326245c000000000009656553536aab516aabb1a10603000000000852ab52ab6a516500cc89c802000000000763ac6a63ac516300000000", "", 0, 557416556, "41bead1b073e1e9fee065dd612a617ca0689e8f9d3fed9d0acfa97398ebb404c");
-        run_test_sighash("813eda1103ac8159850b4524ef65e4644e0fc30efe57a5db0c0365a30446d518d9b9aa8fdd0000000003656565c2f1e89448b374b8f12055557927d5b33339c52228f7108228149920e0b77ef0bcd69da60000000006abac00ab63ab82cdb7978d28630c5e1dc630f332c4245581f787936f0b1e84d38d33892141974c75b4750300000004ac53ab65ffffffff0137edfb02000000000000000000", "0063", 1, -1948560575, "71dfcd2eb7f2e6473aed47b16a6d5fcbd0af22813d892e9765023151e07771ec");
-        run_test_sighash("9e45d9aa0248c16dbd7f435e8c54ae1ad086de50c7b25795a704f3d8e45e1886386c653fbf01000000025352fb4a1acefdd27747b60d1fb79b96d14fb88770c75e0da941b7803a513e6d4c908c6445c7010000000163ffffffff014069a8010000000001520a794fb3", "51ac005363", 1, -719113284, "0d31a221c69bd322ef7193dd7359ddfefec9e0a1521d4a8740326d46e44a5d6a");
-        run_test_sighash("c3efabba03cb656f154d1e159aa4a1a4bf9423a50454ebcef07bc3c42a35fb8ad84014864d0000000000d1cc73d260980775650caa272e9103dc6408bdacaddada6b9c67c88ceba6abaa9caa2f7d020000000553536a5265ffffffff9f946e8176d9b11ff854b76efcca0a4c236d29b69fb645ba29d406480427438e01000000066a0065005300ffffffff040419c0010000000003ab6a63cdb5b6010000000009006300ab5352656a63f9fe5e050000000004acac5352611b980100000000086a00acac00006a512d7f0c40", "0053", 0, -59089911, "c503001c16fbff82a99a18d88fe18720af63656fccd8511bca1c3d0d69bd7fc0");
-        run_test_sighash("efb55c2e04b21a0c25e0e29f6586be9ef09f2008389e5257ebf2f5251051cdc6a79fce2dac020000000351006affffffffaba73e5b6e6c62048ba5676d18c33ccbcb59866470bb7911ccafb2238cfd493802000000026563ffffffffe62d7cb8658a6eca8a8babeb0f1f4fa535b62f5fc0ec70eb0111174e72bbec5e0300000009abababac516365526affffffffbf568789e681032d3e3be761642f25e46c20322fa80346c1146cb47ac999cf1b0300000000b3dbd55902528828010000000001ab0aac7b0100000000015300000000", "acac52", 3, 1638140535, "e84444d91580da41c8a7dcf6d32229bb106f1be0c811b2292967ead5a96ce9d4");
-        run_test_sighash("91d3b21903629209b877b3e1aef09cd59aca6a5a0db9b83e6b3472aceec3bc2109e64ab85a0200000003530065ffffffffca5f92de2f1b7d8478b8261eaf32e5656b9eabbc58dcb2345912e9079a33c4cd010000000700ab65ab00536ad530611da41bbd51a389788c46678a265fe85737b8d317a83a8ff7a839debd18892ae5c80300000007ab6aac65ab51008b86c501038b8a9a05000000000263525b3f7a040000000007ab535353ab00abd4e3ff04000000000665ac51ab65630b7b656f", "6551525151516a00", 2, 499657927, "ef4bd7622eb7b2bbbbdc48663c1bc90e01d5bde90ff4cb946596f781eb420a0c");
-        run_test_sighash("ceecfa6c02b7e3345445b82226b15b7a097563fa7d15f3b0c979232b138124b62c0be007890200000009abac51536a63525253ffffffffbae481ccb4f15d94db5ec0d8854c24c1cc8642bd0c6300ede98a91ca13a4539a0200000001ac50b0813d023110f5020000000006acabac526563e2b0d0040000000009656aac0063516a536300000000", "0063526500", 0, -1862053821, "e1600e6df8a6160a79ac32aa40bb4644daa88b5f76c0d7d13bf003327223f70c");
-        run_test_sighash("f06f64af04fdcb830464b5efdb3d5ee25869b0744005375481d7b9d7136a0eb8828ad1f0240200000003516563fffffffffd3ba192dabe9c4eb634a1e3079fca4f072ee5ceb4b57deb6ade5527053a92c5000000000165ffffffff39f43401a36ba13a5c6dd7f1190e793933ae32ee3bf3e7bfb967be51e681af760300000009650000536552636a528e34f50b21183952cad945a83d4d56294b55258183e1627d6e8fb3beb8457ec36cadb0630000000005abab530052334a7128014bbfd10100000000085352ab006a63656afc424a7c", "53650051635253ac00", 2, 313255000, "d309da5afd91b7afa257cfd62df3ca9df036b6a9f4b38f5697d1daa1f587312b");
-        run_test_sighash("6dfd2f98046b08e7e2ef5fff153e00545faf7076699012993c7a30cb1a50ec528281a9022f030000000152ffffffff1f535e4851920b968e6c437d84d6ecf586984ebddb7d5db6ae035bd02ba222a8010000000651006a53ab51605072acb3e17939fa0737bc3ee43bc393b4acd58451fc4ffeeedc06df9fc649828822d5010000000253525a4955221715f27788d302382112cf60719be9ae159c51f394519bd5f7e70a4f9816c7020200000009526a6a51636aab656a36d3a5ff0445548e0100000000086a6a00516a52655167030b050000000004ac6a63525cfda8030000000000e158200000000000010000000000", "535263ac6a65515153", 3, 585774166, "72b7da10704c3ca7d1deb60c31b718ee12c70dc9dfb9ae3461edce50789fe2ba");
-        run_test_sighash("2a45cd1001bf642a2315d4a427eddcc1e2b0209b1c6abd2db81a800c5f1af32812de42032702000000050051525200ffffffff032177db050000000005530051abac49186f000000000004ab6aab00645c0000000000000765655263acabac00000000", "6a65", 0, -1774715722, "6a9ac3f7da4c7735fbc91f728b52ecbd602233208f96ac5592656074a5db118a");
-        run_test_sighash("ca816e7802cd43d66b9374cd9bf99a8da09402d69c688d8dcc5283ace8f147e1672b757e020200000005516aabab5240fb06c95c922342279fcd88ba6cd915933e320d7becac03192e0941e0345b79223e89570300000004005151ac353ecb5d0264dfbd010000000005ac6aacababd5d70001000000000752ac53ac6a5151ec257f71", "63ac", 1, 774695685, "cc180c4f797c16a639962e7aec58ec4b209853d842010e4d090895b22e7a7863");
-        run_test_sighash("b42b955303942fedd7dc77bbd9040aa0de858afa100f399d63c7f167b7986d6c2377f66a7403000000066aac00525100ffffffff0577d04b64880425a3174055f94191031ad6b4ca6f34f6da9be7c3411d8b51fc000000000300526a6391e1cf0f22e45ef1c44298523b516b3e1249df153590f592fcb5c5fc432dc66f3b57cb03000000046a6aac65ffffffff0393a6c9000000000004516a65aca674ac0400000000046a525352c82c370000000000030053538e577f89", "", 1, -1237094944, "566953eb806d40a9fb684d46c1bf8c69dea86273424d562bd407b9461c8509af");
-        run_test_sighash("92c9fe210201e781b72554a0ed5e22507fb02434ddbaa69aff6e74ea8bad656071f1923f3f02000000056a63ac6a514470cef985ba83dcb8eee2044807bedbf0d983ae21286421506ae276142359c8c6a34d68020000000863ac63525265006aa796dd0102ca3f9d05000000000800abab52ab535353cd5c83010000000007ac00525252005322ac75ee", "5165", 0, 97879971, "6e6307cef4f3a9b386f751a6f40acebab12a0e7e17171d2989293cbec7fd45c2");
-        run_test_sighash("ccca1d5b01e40fe2c6b3ee24c660252134601dab785b8f55bd6201ffaf2fddc7b3e2192325030000000365535100496d4703b4b66603000000000665535253ac633013240000000000015212d2a502000000000951abac636353636a5337b82426", "0052", 0, -1691630172, "577bf2b3520b40aef44899a20d37833f1cded6b167e4d648fc5abe203e43b649");
-        run_test_sighash("bc1a7a3c01691e2d0c4266136f12e391422f93655c71831d90935fbda7e840e50770c61da20000000008635253abac516353ffffffff031f32aa020000000003636563786dbc0200000000003e950f00000000000563516a655184b8a1de", "51536a", 0, -1627072905, "730bc25699b46703d7718fd5f5c34c4b5f00f594a9968ddc247fa7d5175124ed");
-        run_test_sighash("076d209e02d904a6c40713c7225d23e7c25d4133c3c3477828f98c7d6dbd68744023dbb66b030000000753ab00536565acffffffff10975f1b8db8861ca94c8cc7c7cff086ddcd83e10b5fffd4fc8f2bdb03f9463c0100000000ffffffff029dff76010000000006526365530051a3be6004000000000000000000", "515253ac65acacac", 1, -1207502445, "66c488603b2bc53f0d22994a1f0f66fb2958203102eba30fe1d37b27a55de7a5");
-        run_test_sighash("cac6382d0462375e83b67c7a86c922b569a7473bfced67f17afd96c3cd2d896cf113febf9e0300000003006a53ffffffffaa4913b7eae6821487dd3ca43a514e94dcbbf350f8cc4cafff9c1a88720711b800000000096a6a525300acac6353ffffffff184fc4109c34ea27014cc2c1536ef7ed1821951797a7141ddacdd6e429fae6ff01000000055251655200ffffffff9e7b79b4e6836e290d7b489ead931cba65d1030ccc06f20bd4ca46a40195b33c030000000008f6bc8304a09a2704000000000563655353511dbc73050000000000cf34c500000000000091f76e0000000000085200ab00005100abd07208cb", "0063656a", 2, -1488731031, "bf078519fa87b79f40abc38f1831731422722c59f88d86775535f209cb41b9b1");
-        run_test_sighash("1711146502c1a0b82eaa7893976fefe0fb758c3f0e560447cef6e1bde11e42de91a125f71c030000000015bd8c04703b4030496c7461482481f290c623be3e76ad23d57a955807c9e851aaaa20270300000000d04abaf20326dcb7030000000001632225350400000000075263ac00520063dddad9020000000000af23d148", "52520053510063", 0, 1852122830, "e33d5ee08c0f3c130a44d7ce29606450271b676f4a80c52ab9ffab00cecf67f8");
-        run_test_sighash("22d81c740469695a6a83a9a4824f77ecff8804d020df23713990afce2b72591ed7de98500502000000065352526a6a6affffffff90dc85e118379b1005d7bbc7d2b8b0bab104dad7eaa49ff5bead892f17d8c3ba010000000665656300ab51ffffffff965193879e1d5628b52005d8560a35a2ba57a7f19201a4045b7cbab85133311d0200000003ac005348af21a13f9b4e0ad90ed20bf84e4740c8a9d7129632590349afc03799414b76fd6e826200000000025353ffffffff04a0d40d04000000000060702700000000000652655151516ad31f1502000000000365ac0069a1ac0500000000095100655300ab53525100000000", "51636a52ac", 0, -1644680765, "add7f5da27262f13da6a1e2cc2feafdc809bd66a67fb8ae2a6f5e6be95373b6f");
-        run_test_sighash("a27dcbc801e3475174a183586082e0914c314bc9d79d1570f29b54591e5e0dff07fbb45a7f0000000004ac53ab51ffffffff027347f5020000000005535351ab63d0e5c9030000000009ac65ab6a63515200ab7cd632ed", "ac63636553", 0, -686435306, "883a6ea3b2cc53fe8a803c229106366ca14d25ffbab9fef8367340f65b201da6");
-        run_test_sighash("0728c606014c1fd6005ccf878196ba71a54e86cc8c53d6db500c3cc0ac369a26fac6fcbc210000000005ab53ac5365ba9668290182d7870100000000066a000053655100000000", "65", 0, 1789961588, "ab6baa6da3b2bc853868d166f8996ad31d63ef981179f9104f49968fd61c8427");
-        run_test_sighash("ed3bb93802ddbd08cb030ef60a2247f715a0226de390c9c1a81d52e83f8674879065b5f87d0300000003ab6552ffffffff04d2c5e60a21fb6da8de20bf206db43b720e2a24ce26779bca25584c3f765d1e0200000008ab656a6aacab00ab6e946ded025a811d04000000000951abac6352ac00ab5143cfa3030000000005635200636a00000000", "5352ac650065535300", 1, -668727133, "e9995065e1fddef72a796eef5274de62012249660dc9d233a4f24e02a2979c87");
-        run_test_sighash("59f4629d030fa5d115c33e8d55a79ea3cba8c209821f979ed0e285299a9c72a73c5bba00150200000002636affffffffd8aca2176df3f7a96d0dc4ee3d24e6cecde1582323eec2ebef9a11f8162f17ac0000000007ab6565acab6553ffffffffeebc10af4f99c7a21cbc1d1074bd9f0ee032482a71800f44f26ee67491208e0403000000065352ac656351ffffffff0434e955040000000004ab515152caf2b305000000000365ac007b1473030000000003ab530033da970500000000060051536a5253bb08ab51", "", 2, 396340944, "0e9c47973ef2c292b2252c623f465bbb92046fe0b893eebf4e1c9e02cb01c397");
-        run_test_sighash("33a98004029d262f951881b20a8d746c8c707ea802cd2c8b02a33b7e907c58699f97e42be80100000007ac53536552abacdee04cc01d205fd8a3687fdf265b064d42ab38046d76c736aad8865ca210824b7c622ecf02000000070065006a536a6affffffff01431c5d010000000000270d48ee", "", 1, 921554116, "ff9d7394002f3f196ea25472ea6c46f753bd879a7244795157bb7235c9322902");
-        run_test_sighash("aac18f2b02b144ed481557c53f2146ae523f24fcde40f3445ab0193b6b276c315dc2894d2300000000075165650000636a233526947dbffc76aec7db1e1baa6868ad4799c76e14794dcbaaec9e713a83967f6a65170200000005abac6551ab27d518be01b652a30000000000015300000000", "52ac5353", 1, 1559377136, "59fc2959bb7bb24576cc8a237961ed95bbb900679d94da6567734c4390cb6ef5");
-        run_test_sighash("5ab79881033555b65fe58c928883f70ce7057426fbdd5c67d7260da0fe8b1b9e6a2674cb850300000009ac516aac6aac006a6affffffffa5be9223b43c2b1a4d120b5c5b6ec0484f637952a3252181d0f8e813e76e11580200000000e4b5ceb8118cb77215bbeedc9a076a4d087bb9cd1473ea32368b71daeeeacc451ec209010000000005acac5153aced7dc34e02bc5d11030000000005ac5363006a54185803000000000552ab00636a00000000", "5100", 1, 1927062711, "e9f53d531c12cce1c50abed4ac521a372b4449b6a12f9327c80020df6bff66c0");
-        run_test_sighash("6c2c8fac0124b0b7d4b610c3c5b91dee32b7c927ac71abdf2d008990ca1ac40de0dfd530660300000006ababac5253656bd7eada01d847ec000000000004ac52006af4232ec8", "6a6a6a0051", 0, -340809707, "fb51eb9d7e47d32ff2086205214f90c7c139e08c257a64829ae4d2b301071c6a");
-        run_test_sighash("0e803682024f79337b25c98f276d412bc27e56a300aa422c42994004790cee213008ff1b8303000000080051ac65ac655165f421a331892b19a44c9f88413d057fea03c3c4a6c7de4911fe6fe79cf2e9b3b10184b1910200000005525163630096cb1c670398277204000000000253acf7d5d502000000000963536a6a636a5363ab381092020000000002ac6a911ccf32", "6565", 1, -1492094009, "f0672638a0e568a919e9d8a9cbd7c0189a3e132940beeb52f111a89dcc2daa2c");
-        run_test_sighash("7d71669d03022f9dd90edac323cde9e56354c6804c6b8e687e9ae699f46805aafb8bcaa636000000000253abffffffff698a5fdd3d7f2b8b000c68333e4dd58fa8045b3e2f689b889beeb3156cecdb490300000009525353abab0051acabc53f0aa821cdd69b473ec6e6cf45cf9b38996e1c8f52c27878a01ec8bb02e8cb31ad24e500000000055353ab0052ffffffff0447a23401000000000565ab53ab5133aaa0030000000006515163656563057d110300000000056a6aacac52cf13b5000000000003526a5100000000", "6a6a51", 1, -1349253507, "722efdd69a7d51d3d77bed0ac5544502da67e475ea5857cd5af6bdf640a69945");
-        run_test_sighash("9ff618e60136f8e6bb7eabaaac7d6e2535f5fba95854be6d2726f986eaa9537cb283c701ff02000000026a65ffffffff012d1c0905000000000865ab00ac6a516a652f9ad240", "51515253635351ac", 0, 1571304387, "659cd3203095d4a8672646add7d77831a1926fc5b66128801979939383695a79");
-        run_test_sighash("09adb2e90175ca0e816326ae2dce7750c1b27941b16f6278023dbc294632ab97977852a09d030000000465ab006affffffff027739cf0100000000075151ab63ac65ab8a5bb601000000000653ac5151520011313cdc", "ac", 0, -76831756, "478ee06501b4965b40bdba6cbaad9b779b38555a970912bb791b86b7191c54bc");
-        run_test_sighash("fd22ebaa03bd588ad16795bea7d4aa7f7d48df163d75ea3afebe7017ce2f350f6a0c1cb0bb00000000086aabac5153526363ffffffff488e0bb22e26a565d77ba07178d17d8f85702630ee665ec35d152fa05af3bda10200000004515163abffffffffeb21035849e85ad84b2805e1069a91bb36c425dc9c212d9bae50a95b6bfde1200300000001ab5df262fd02b69848040000000008ab6363636a6363ace23bf2010000000007655263635253534348c1da", "006353526563516a00", 0, -1491036196, "92364ba3c7a85d4e88885b8cb9b520dd81fc29e9d2b750d0790690e9c1246673");
-        run_test_sighash("b04154610363fdade55ceb6942d5e5a723323863b48a0cb04fdcf56210717955763f56b08d0300000009ac526a525151635151ffffffff93a176e76151a9eabdd7af00ef2af72f9e7af5ecb0aa4d45d00618f394cdd03c030000000074d818b332ebe05dc24c44d776cf9d275c61f471cc01efce12fd5a16464157f1842c65cb00000000066a0000ac6352d3c4134f01d8a1c0030000000005520000005200000000", "5200656a656351", 2, -9757957, "6e3e5ba77f760b6b5b5557b13043f1262418f3dd2ce7f0298b012811fc8ad5bc");
-        run_test_sighash("94533db7015e70e8df715066efa69dbb9c3a42ff733367c18c22ff070392f988f3b93920820000000006535363636300ce4dac3e03169af80300000000080065ac6a53ac65ac39c050020000000006abacab6aacac708a02050000000005ac5251520000000000", "6553", 0, -360458507, "5418cf059b5f15774836edd93571e0eed3855ba67b2b08c99dccab69dc87d3e9");
-        run_test_sighash("c8597ada04f59836f06c224a2640b79f3a8a7b41ef3efa2602592ddda38e7597da6c639fee0300000009005251635351acabacffffffff4c518f347ee694884b9d4072c9e916b1a1f0a7fc74a1c90c63fdf8e5a185b6ae02000000007113af55afb41af7518ea6146786c7c726641c68c8829a52925e8d4afd07d8945f68e7230300000008ab00ab65ab650063ffffffffc28e46d7598312c420e11dfaae12add68b4d85adb182ae5b28f8340185394b63000000000165ffffffff04dbabb7010000000000ee2f6000000000000852ab6500ab6a51acb62a27000000000009ac53515300ac006a6345fb7505000000000752516a0051636a00000000", "", 3, 15199787, "0d66003aff5bf78cf492ecbc8fd40c92891acd58d0a271be9062e035897f317e");
-        run_test_sighash("c33028b301d5093e1e8397270d75a0b009b2a6509a01861061ab022ca122a6ba935b8513320200000000ffffffff013bcf5a0500000000015200000000", "", 0, -513413204, "6b1459536f51482f5dbf42d7e561896557461e1e3b6bf67871e2b51faae2832c");
-        run_test_sighash("43b2727901a7dd06dd2abf690a1ccedc0b0739cb551200796669d9a25f24f71d8d101379f50300000000ffffffff0418e031040000000000863d770000000000085352ac526563ac5174929e040000000004ac65ac00ec31ac0100000000066a51ababab5300000000", "65", 0, -492874289, "154ff7a9f0875edcfb9f8657a0b98dd9600fabee3c43eb88af37cf99286d516c");
-        run_test_sighash("fe6ddf3a02657e42a7496ef170b4a8caf245b925b91c7840fd28e4a22c03cb459cb498b8d603000000065263656a650071ce6bf8d905106f9f1faf6488164f3decac65bf3c5afe1dcee20e6bc3cb6d052561985a030000000163295b117601343dbb0000000000026563dba521df", "", 1, -1696179931, "d9684685c99ce48f398fb467a91a1a59629a850c429046fb3071f1fa9a5fe816");
-        run_test_sighash("c61523ef0129bb3952533cbf22ed797fa2088f307837dd0be1849f20decf709cf98c6f032f03000000026563c0f1d378044338310400000000066363516a5165a14fcb0400000000095163536a6a00ab53657271d60200000000001d953f0500000000010000000000", "53516353005153", 0, 1141615707, "7e975a72db5adaa3c48d525d9c28ac11cf116d0f8b16ce08f735ad75a80aec66");
-        run_test_sighash("ba3dac6c0182562b0a26d475fe1e36315f0913b6869bdad0ecf21f1339a5fcbccd32056c840200000000ffffffff04300351050000000000220ed405000000000851abac636565ac53dbbd19020000000007636363ac6a52acbb005a0500000000016abd0c78a8", "63006a635151005352", 0, 1359658828, "47bc8ab070273e1f4a0789c37b45569a6e16f3f3092d1ce94dddc3c34a28f9f4");
-        run_test_sighash("ac27e7f5025fc877d1d99f7fc18dd4cadbafa50e34e1676748cc89c202f93abf36ed46362101000000036300abffffffff958cd5381962b765e14d87fc9524d751e4752dd66471f973ed38b9d562e525620100000003006500ffffffff02b67120050000000004ac51516adc330c0300000000015200000000", "656352", 1, 15049991, "f3374253d64ac264055bdbcc32e27426416bd595b7c7915936c70f839e504010");
-        run_test_sighash("7e50207303146d1f7ad62843ae8017737a698498d4b9118c7a89bb02e8370307fa4fada41d000000000753006300005152b7afefc85674b1104ba33ef2bf37c6ed26316badbc0b4aa6cb8b00722da4f82ff3555a6c020000000900ac656363ac51ac52ffffffff93fab89973bd322c5d7ad7e2b929315453e5f7ada3072a36d8e33ca8bebee6e0020000000300acab930da52b04384b04000000000004650052ac435e380200000000076a6a515263ab6aa9494705000000000600ab6a525252af8ba90100000000096565acab526353536a279b17ad", "acac005263536aac63", 1, -34754133, "4e6357da0057fb7ff79da2cc0f20c5df27ff8b2f8af4c1709e6530459f7972b0");
-        run_test_sighash("5a59e0b9040654a3596d6dab8146462363cd6549898c26e2476b1f6ae42915f73fd9aedfda00000000036363abffffffff9ac9e9ca90be0187be2214251ff08ba118e6bf5e2fd1ba55229d24e50a510d53010000000165ffffffff41d42d799ac4104644969937522873c0834cc2fcdab7cdbecd84d213c0e96fd60000000000ffffffffd838db2c1a4f30e2eaa7876ef778470f8729fcf258ad228b388df2488709f8410300000000fdf2ace002ceb6d903000000000265654c1310040000000003ac00657e91c0ec", "536a63ac", 0, 82144555, "98ccde2dc14d14f5d8b1eeea5364bd18fc84560fec2fcea8de4d88b49c00695e");
-        run_test_sighash("156ebc8202065d0b114984ee98c097600c75c859bfee13af75dc93f57c313a877efb09f230010000000463536a51ffffffff81114e8a697be3ead948b43b5005770dd87ffb1d5ccd4089fa6c8b33d3029e9c03000000066a5251656351ffffffff01a87f140000000000050000ac51ac00000000", "00", 0, -362221092, "a903c84d8c5e71134d1ab6dc1e21ac307c4c1a32c90c90f556f257b8a0ec1bf5");
-        run_test_sighash("6d97a9a5029220e04f4ccc342d8394c751282c328bf1c132167fc05551d4ca4da4795f6d4e02000000076a0052ab525165ffffffff9516a205e555fa2a16b73e6db6c223a9e759a7e09c9a149a8f376c0a7233fa1b0100000007acab51ab63ac6affffffff04868aed04000000000652ac65ac536a396edf01000000000044386c0000000000076aab5363655200894d48010000000001ab8ebefc23", "6351526aac51", 1, 1943666485, "f0bd4ca8e97203b9b4e86bc24bdc8a1a726db5e99b91000a14519dc83fc55c29");
-        run_test_sighash("05921d7c048cf26f76c1219d0237c226454c2a713c18bf152acc83c8b0647a94b13477c07f0300000003ac526afffffffff2f494453afa0cabffd1ba0a626c56f90681087a5c1bd81d6adeb89184b27b7402000000036a6352ffffffff0ad10e2d3ce355481d1b215030820da411d3f571c3f15e8daf22fe15342fed04000000000095f29f7b93ff814a9836f54dc6852ec414e9c4e16a506636715f569151559100ccfec1d100000000055263656a53ffffffff04f4ffef010000000008ac6a6aabacabab6a0e6689040000000006ab536a5352abe364d005000000000965536363655251ab53807e00010000000004526aab63f18003e3", "6363ac51", 3, -375891099, "001b0b176f0451dfe2d9787b42097ceb62c70d324e925ead4c58b09eebdf7f67");
-        run_test_sighash("b9b44d9f04b9f15e787d7704e6797d51bc46382190c36d8845ec68dfd63ee64cf7a467b21e00000000096aac00530052ab636aba1bcb110a80c5cbe073f12c739e3b20836aa217a4507648d133a8eedd3f02cb55c132b203000000076a000063526352b1c288e3a9ff1f2da603f230b32ef7c0d402bdcf652545e2322ac01d725d75f5024048ad0100000000ffffffffffd882d963be559569c94febc0ef241801d09dc69527c9490210f098ed8203c700000000056a006300ab9109298d01719d9a0300000000066a52ab006365d7894c5b", "ac6351650063636a", 3, -622355349, "ac87b1b93a6baab6b2c6624f10e8ebf6849b0378ef9660a3329073e8f5553c8d");
-        run_test_sighash("ff60473b02574f46d3e49814c484081d1adb9b15367ba8487291fc6714fd6e3383d5b335f001000000026a6ae0b82da3dc77e5030db23d77b58c3c20fa0b70aa7d341a0f95f3f72912165d751afd57230300000008ac536563516a6363ffffffff04f86c0200000000000553acab636ab13111000000000003510065f0d3f305000000000951ab516a65516aabab730a3a010000000002515200000000", "ac6a", 1, 1895032314, "0767e09bba8cd66d55915677a1c781acd5054f530d5cf6de2d34320d6c467d80");
-        run_test_sighash("f218026204f4f4fc3d3bd0eada07c57b88570d544a0436ae9f8b753792c0c239810bb30fbc0200000002536affffffff8a468928d6ec4cc10aa0f73047697970e99fa64ae8a3b4dca7551deb0b639149010000000851ab520052650051ffffffffa98dc5df357289c9f6873d0f5afcb5b030d629e8f23aa082cf06ec9a95f3b0cf0000000000ffffffffea2c2850c5107705fd380d6f29b03f533482fd036db88739122aac9eff04e0aa010000000365536a03bd37db034ac4c4020000000007515152655200ac33b27705000000000151efb71e0000000000007b65425b", "515151", 3, -1772252043, "de35c84a58f2458c33f564b9e58bc57c3e028d629f961ad1b3c10ee020166e5a");
-        run_test_sighash("48e7d42103b260b27577b70530d1ac2fed2551e9dd607cbcf66dca34bb8c03862cf8f5fd5401000000075151526aacab00ffffffff1e3d3b841552f7c6a83ee379d9d66636836673ce0b0eda95af8f2d2523c91813030000000665acac006365ffffffff388b3c386cd8c9ef67c83f3eaddc79f1ff910342602c9152ffe8003bce51b28b0100000008636363006a636a52ffffffff04b8f67703000000000852005353ac6552520cef720200000000085151ab6352ab00ab5096d6030000000005516a005100662582020000000001ac6c137280", "6a65", 1, 1513618429, "e2fa3e1976aed82c0987ab30d4542da2cb1cffc2f73be13480132da8c8558d5c");
-        run_test_sighash("91ebc4cf01bc1e068d958d72ee6e954b196f1d85b3faf75a521b88a78021c543a06e056279000000000265ab7c12df0503832121030000000000cc41a6010000000005ab5263516540a951050000000006ab63ab65acac00000000", "526a0065636a6a6aac", 0, -614046478, "7de4ba875b2e584a7b658818c112e51ee5e86226f5a80e5f6b15528c86400573");
-        run_test_sighash("3cd4474201be7a6c25403bf00ca62e2aa8f8f4f700154e1bb4d18c66f7bb7f9b975649f0dc0100000006535151535153ffffffff01febbeb000000000006005151006aac00000000", "", 0, -1674687131, "6b77ca70cc452cc89acb83b69857cda98efbfc221688fe816ef4cb4faf152f86");
-        run_test_sighash("92fc95f00307a6b3e2572e228011b9c9ed41e58ddbaefe3b139343dbfb3b34182e9fcdc3f50200000002acab847bf1935fde8bcfe41c7dd99683289292770e7f163ad09deff0e0665ed473cd2b56b0f40300000006516551ab6351294dab312dd87b9327ce2e95eb44b712cfae0e50fda15b07816c8282e8365b643390eaab01000000026aacffffffff016e0b6b040000000001ac00000000", "650065acac005300", 2, -1885164012, "bd7d26bb3a98fc8c90c972500618bf894cb1b4fe37bf5481ff60eef439d3b970");
-        run_test_sighash("4db591ab018adcef5f4f3f2060e41f7829ce3a07ea41d681e8cb70a0e37685561e4767ac3b0000000005000052acabd280e63601ae6ef20000000000036a636326c908f7", "ac6a51526300630052", 0, 862877446, "355ccaf30697c9c5b966e619a554d3323d7494c3ea280a9b0dfb73f953f5c1cb");
-        run_test_sighash("c80abebd042cfec3f5c1958ee6970d2b4586e0abec8305e1d99eb9ee69ecc6c2cbd76374380000000007ac53006300ac510acee933b44817db79320df8094af039fd82111c7726da3b33269d3820123694d849ee5001000000056a65ab526562699bea8530dc916f5d61f0babea709dac578774e8a4dcd9c640ec3aceb6cb2443f24f302000000020063ea780e9e57d1e4245c1e5df19b4582f1bf704049c5654f426d783069bcc039f2d8fa659f030000000851ab53635200006a8d00de0b03654e8500000000000463ab635178ebbb0400000000055100636aab239f1d030000000006ab006300536500000000", "6565ac515100", 3, 1460851377, "b35bb1b72d02fab866ed6bbbea9726ab32d968d33a776686df3ac16aa445871e");
-        run_test_sighash("0337b2d5043eb6949a76d6632b8bb393efc7fe26130d7409ef248576708e2d7f9d0ced9d3102000000075352636a5163007034384dfa200f52160690fea6ce6c82a475c0ef1caf5c9e5a39f8f9ddc1c8297a5aa0eb02000000026a51ffffffff38e536298799631550f793357795d432fb2d4231f4effa183c4e2f61a816bcf0030000000463ac5300706f1cd3454344e521fde05b59b96e875c8295294da5d81d6cc7efcfe8128f150aa54d6503000000008f4a98c704c1561600000000000072cfa6000000000000e43def01000000000100cf31cc0500000000066365526a6500cbaa8e2e", "", 3, 2029506437, "7615b4a7b3be865633a31e346bc3db0bcc410502c8358a65b8127089d81b01f8");
-        run_test_sighash("cbc79b10020b15d605680a24ee11d8098ad94ae5203cb6b0589e432832e20c27b72a926af20300000006ab65516a53acbb854f3146e55c508ece25fa3d99dbfde641a58ed88c051a8a51f3dacdffb1afb827814b02000000026352c43e6ef30302410a020000000000ff4bd90100000000065100ab63000008aa8e0400000000095265526565ac5365abc52c8a77", "53526aac0051", 0, 202662340, "984efe0d8d12e43827b9e4b27e97b3777ece930fd1f589d616c6f9b71dab710e");
-        run_test_sighash("4e8594d803b1d0a26911a2bcdd46d7cbc987b7095a763885b1a97ca9cbb747d32c5ab9aa91030000000353ac53a0cc4b215e07f1d648b6eeb5cdbe9fa32b07400aa773b9696f582cebfd9930ade067b2b200000000060065abab6500fc99833216b8e27a02defd9be47fafae4e4a97f52a9d2a210d08148d2a4e5d02730bcd460100000004516351ac37ce3ae1033baa55040000000006006a636a63acc63c990400000000025265eb1919030000000005656a6a516a00000000", "", 1, -75217178, "04c5ee48514cd033b82a28e336c4d051074f477ef2675ce0ce4bafe565ee9049");
-        run_test_sighash("44e1a2b4010762af23d2027864c784e34ef322b6e24c70308a28c8f2157d90d17b99cd94a401000000085163656565006300ffffffff0198233d020000000002000000000000", "52525153656365", 0, 1119696980, "d9096de94d70c6337da6202e6e588166f31bff5d51bb5adc9468594559d65695");
-        run_test_sighash("44ca65b901259245abd50a745037b17eb51d9ce1f41aa7056b4888285f48c6f26cb97b7a25020000000552636363abffffffff047820350400000000040053acab14f3e603000000000652635100ab630ce66c03000000000001bdc704000000000765650065ac51ac3e886381", "51", 0, -263340864, "ed5622ac642d11f90e68c0feea6a2fe36d880ecae6b8c0d89c4ea4b3d162bd90");
-        run_test_sighash("cfa147d2017fe84122122b4dda2f0d6318e59e60a7207a2d00737b5d89694d480a2c26324b0000000006006351526552ffffffff0456b5b804000000000800516aab525363ab166633000000000004655363ab254c0e02000000000952ab6a6a00ab525151097c1b020000000009656a52ac6300530065ad0d6e50", "6a535165ac6a536500", 0, -574683184, "f926d4036eac7f019a2b0b65356c4ee2fe50e089dd7a70f1843a9f7bc6997b35");
-        run_test_sighash("91c5d5f6022fea6f230cc4ae446ce040d8313071c5ac1749c82982cc1988c94cb1738aa48503000000016a19e204f30cb45dd29e68ff4ae160da037e5fc93538e21a11b92d9dd51cf0b5efacba4dd70000000005656a6aac51ffffffff03db126905000000000953006a53ab6563636a36a273030000000006656a52656552b03ede00000000000352516500000000", "530052526a00", 1, 1437328441, "255c125b60ee85f4718b2972174c83588ee214958c3627f51f13b5fb56c8c317");
-        run_test_sighash("03f20dc202c886907b607e278731ebc5d7373c348c8c66cac167560f19b341b782dfb634cb03000000076a51ac6aab63abea3e8de7adb9f599c9caba95aa3fa852e947fc88ed97ee50e0a0ec0d14d164f44c0115c10100000004ab5153516fdd679e0414edbd000000000005ac636a53512021f2040000000007006a0051536a52c73db2050000000005525265ac5369046e000000000003ab006a1ef7bd1e", "52656a", 0, 1360223035, "5a0a05e32ce4cd0558aabd5d79cd5fcbffa95c07137506e875a9afcba4bef5a2");
-        run_test_sighash("d9611140036881b61e01627078512bc3378386e1d4761f959d480fdb9d9710bebddba2079d020000000763536aab5153ab819271b41e228f5b04daa1d4e72c8e1955230accd790640b81783cfc165116a9f535a74c000000000163ffffffffa2e7bb9a28e810624c251ff5ba6b0f07a356ac082048cf9f39ec036bba3d431a02000000076a000000ac65acffffffff01678a820000000000085363515153ac635100000000", "535353", 2, -82213851, "52b9e0778206af68998cbc4ebdaad5a9469e04d0a0a6cef251abfdbb74e2f031");
-        run_test_sighash("98b3a0bf034233afdcf0df9d46ac65be84ef839e58ee9fa59f32daaa7d684b6bdac30081c60200000007636351acabababffffffffc71cf82ded4d1593e5825618dc1d5752ae30560ecfaa07f192731d68ea768d0f0100000006650052636563f3a2888deb5ddd161430177ce298242c1a86844619bc60ca2590d98243b5385bc52a5b8f00000000095365acacab520052ac50d4722801c3b8a60300000000035165517e563b65", "51", 1, -168940690, "b6b684e2d2ecec8a8dce4ed3fc1147f8b2e45732444222aa8f52d860c2a27a9d");
-        run_test_sighash("97be4f7702dc20b087a1fdd533c7de762a3f2867a8f439bddf0dcec9a374dfd0276f9c55cc0300000000cdfb1dbe6582499569127bda6ca4aaff02c132dc73e15dcd91d73da77e92a32a13d1a0ba0200000002ab51ffffffff048cfbe202000000000900516351515363ac535128ce0100000000076aac5365ab6aabc84e8302000000000863536a53ab6a6552f051230500000000066aac535153510848d813", "ac51", 0, 229541474, "e5da9a416ea883be1f8b8b2d178463633f19de3fa82ae25d44ffb531e35bdbc8");
-        run_test_sighash("085b6e04040b5bff81e29b646f0ed4a45e05890a8d32780c49d09643e69cdccb5bd81357670100000001abffffffffa5c981fe758307648e783217e3b4349e31a557602225e237f62b636ec26df1a80300000004650052ab4792e1da2930cc90822a8d2a0a91ea343317bce5356b6aa8aae6c3956076aa33a5351a9c0300000004abac5265e27ddbcd472a2f13325cc6be40049d53f3e266ac082172f17f6df817db1936d9ff48c02b000000000152ffffffff021aa7670500000000085353635163ab51ac14d584000000000001aca4d136cc", "6a525300536352536a", 0, -1398925877, "41ecca1e8152ec55074f4c39f8f2a7204dda48e9ec1e7f99d5e7e4044d159d43");
-        run_test_sighash("eec32fff03c6a18b12cd7b60b7bdc2dd74a08977e53fdd756000af221228fe736bd9c42d870100000007005353ac515265ffffffff037929791a188e9980e8b9cc154ad1b0d05fb322932501698195ab5b219488fc02000000070063510065ab6a0bfc176aa7e84f771ea3d45a6b9c24887ceea715a0ff10ede63db8f089e97d927075b4f1000000000551abab63abffffffff02eb933c000000000000262c420000000000036563632549c2b6", "6352", 2, 1480445874, "ff8a4016dfdd918f53a45d3a1f62b12c407cd147d68ca5c92b7520e12c353ff5");
-        run_test_sighash("3ab70f4604e8fc7f9de395ec3e4c3de0d560212e84a63f8d75333b604237aa52a10da17196000000000763526a6553ac63a25de6fd66563d71471716fe59087be0dde98e969e2b359282cf11f82f14b00f1c0ac70f02000000050052516aacdffed6bb6889a13e46956f4b8af20752f10185838fd4654e3191bf49579c961f5597c36c0100000005ac636363abc3a1785bae5b8a1b4be5d0cbfadc240b4f7acaa7dfed6a66e852835df5eb9ac3c553766801000000036a65630733b7530218569602000000000952006a6a6a51acab52777f06030000000007ac0063530052abc08267c9", "000000536aac0000", 1, 1919096509, "df1c87cf3ba70e754d19618a39fdbd2970def0c1bfc4576260cba5f025b87532");
-        run_test_sighash("bdb6b4d704af0b7234ced671c04ba57421aba7ead0a117d925d7ebd6ca078ec6e7b93eea6600000000026565ffffffff3270f5ad8f46495d69b9d71d4ab0238cbf86cc4908927fbb70a71fa3043108e6010000000700516a65655152ffffffff6085a0fdc03ae8567d0562c584e8bfe13a1bd1094c518690ebcb2b7c6ce5f04502000000095251530052536a53aba576a37f2c516aad9911f687fe83d0ae7983686b6269b4dd54701cb5ce9ec91f0e6828390300000000ffffffff04cc76cc020000000002656a01ffb702000000000253ab534610040000000009acab006565516a00521f55f5040000000000389dfee9", "6a525165", 0, 1336204763, "71c294523c48fd7747eebefbf3ca06e25db7b36bff6d95b41c522fecb264a919");
-        run_test_sighash("54258edd017d22b274fbf0317555aaf11318affef5a5f0ae45a43d9ca4aa652c6e85f8a040010000000953ac65ab5251656500ffffffff03321d450000000000085265526a51526a529ede8b030000000003635151ce6065020000000001534c56ec1b", "acac", 0, 2094130012, "110d90fea9470dfe6c5048f45c3af5e8cc0cb77dd58fd13d338268e1c24b1ccc");
-        run_test_sighash("ce0d322e04f0ffc7774218b251530a7b64ebefca55c90db3d0624c0ff4b3f03f918e8cf6f60300000003656500ffffffff9cce943872da8d8af29022d0b6321af5fefc004a281d07b598b95f6dcc07b1830200000007abab515351acab8d926410e69d76b7e584aad1470a97b14b9c879c8b43f9a9238e52a2c2fefc2001c56af8010000000400ab5253cd2cd1fe192ce3a93b5478af82fa250c27064df82ba416dfb0debf4f0eb307a746b6928901000000096500abacac6a0063514214524502947efc0200000000035251652c40340100000000096a6aab52000052656a5231c54c", "51", 2, -2090320538, "0322ca570446869ec7ec6ad66d9838cff95405002d474c0d3c17708c7ee039c6");
-        run_test_sighash("233cd90b043916fc41eb870c64543f0111fb31f3c486dc72457689dea58f75c16ae59e9eb2000000000500536a6a6affffffff9ae30de76be7cd57fb81220fce78d74a13b2dbcad4d023f3cadb3c9a0e45a3ce000000000965ac6353ac5165515130834512dfb293f87cb1879d8d1b20ebad9d7d3d5c3e399a291ce86a3b4d30e4e32368a9020000000453005165ffffffff26d84ae93eb58c81158c9b3c3cbc24a84614d731094f38d0eea8686dec02824d0300000005636a65abacf02c784001a0bd5d03000000000900655351ab65ac516a416ef503", "", 1, -295106477, "b79f31c289e95d9dadec48ebf88e27c1d920661e50d090e422957f90ff94cb6e");
-        run_test_sighash("9200e26b03ff36bc4bf908143de5f97d4d02358db642bd5a8541e6ff709c420d1482d471b70000000008abab65536a636553ffffffff61ba6d15f5453b5079fb494af4c48de713a0c3e7f6454d7450074a2a80cb6d880300000007ac6a00ab5165515dfb7574fbce822892c2acb5d978188b1d65f969e4fe874b08db4c791d176113272a5cc10100000000ffffffff0420958d000000000009ac63516a0063516353dd885505000000000465ac00007b79e901000000000066d8bf010000000005525252006a00000000", "ac5152", 0, 2089531339, "89ec7fab7cfe7d8d7d96956613c49dc48bf295269cfb4ea44f7333d88c170e62");
-        run_test_sighash("45f335ba01ce2073a8b0273884eb5b48f56df474fc3dff310d9706a8ac7202cf5ac188272103000000025363ffffffff049d859502000000000365ab6a8e98b1030000000002ac51f3a80603000000000752535151ac00000306e30300000000020051b58b2b3a", "", 0, 1899564574, "78e01310a228f645c23a2ad0acbb8d91cedff4ecdf7ca997662c6031eb702b11");
-        run_test_sighash("94083c840288d40a6983faca876d452f7c52a07de9268ad892e70a81e150d602a773c175ad03000000007ec3637d7e1103e2e7e0c61896cbbf8d7e205b2ecc93dd0d6d7527d39cdbf6d335789f660300000000ffffffff019e1f7b03000000000800ac0051acac0053539cb363", "", 1, -183614058, "a17b66d6bb427f42653d08207a22b02353dd19ccf2c7de6a9a3a2bdb7c49c9e7");
-        run_test_sighash("30e0d4d20493d0cd0e640b757c9c47a823120e012b3b64c9c1890f9a087ae4f2001ca22a61010000000152f8f05468303b8fcfaad1fb60534a08fe90daa79bff51675472528ebe1438b6f60e7f60c10100000009526aab6551ac510053ffffffffaaab73957ea2133e32329795221ed44548a0d3a54d1cf9c96827e7cffd1706df0200000009ab00526a005265526affffffffd19a6fe54352015bf170119742821696f64083b5f14fb5c7d1b5a721a3d7786801000000085265abababac53abffffffff020f39bd030000000004ab6aac52049f6c050000000004ab52516aba5b4c60", "6a6365516a6a655253", 0, -624256405, "8e221a6c4bf81ca0d8a0464562674dcd14a76a32a4b7baf99450dd9195d411e6");
-        run_test_sighash("5c0ac112032d6885b7a9071d3c5f493aa16c610a4a57228b2491258c38de8302014276e8be030000000300ab6a17468315215262ad5c7393bb5e0c5a6429fd1911f78f6f72dafbbbb78f3149a5073e24740300000003ac5100ffffffff33c7a14a062bdea1be3c9c8e973f54ade53fe4a69dcb5ab019df5f3345050be00100000008ac63655163526aab428defc0033ec36203000000000765516365536a00ae55b2000000000002ab53f4c0080400000000095265516a536563536a00000000", "6a005151006a", 2, 272749594, "91082410630337a5d89ff19145097090f25d4a20bdd657b4b953927b2f62c73b");
-        run_test_sighash("e3683329026720010b08d4bec0faa244f159ae10aa582252dd0f3f80046a4e145207d54d31000000000852acac52656aacac3aaf2a5017438ad6adfa3f9d05f53ebed9ceb1b10d809d507bcf75e0604254a8259fc29c020000000653526552ab51f926e52c04b44918030000000000f7679c0100000000090000525152005365539e3f48050000000009516500ab635363ab008396c905000000000253650591024f", "6a6365", 0, 908746924, "458aec3b5089a585b6bad9f99fd37a2b443dc5a2eefac2b7e8c5b06705efc9db");
-        run_test_sighash("00b20fd104dd59705b84d67441019fa26c4c3dec5fd3b50eca1aa549e750ef9ddb774dcabe000000000651ac656aac65ffffffff52d4246f2db568fc9eea143e4d260c698a319f0d0670f84c9c83341204fde48b0200000000ffffffffb8aeabb85d3bcbc67b132f1fd815b451ea12dcf7fc169c1bc2e2cf433eb6777a03000000086a51ac6aab6563acd510d209f413da2cf036a31b0def1e4dcd8115abf2e511afbcccb5ddf41d9702f28c52900100000006ac52ab6a0065ffffffff039c8276000000000008ab53655200656a52401561010000000003acab0082b7160100000000035100ab00000000", "535265", 1, -947367579, "3212c6d6dd8d9d3b2ac959dec11f4638ccde9be6ed5d36955769294e23343da0");
-        run_test_sighash("624d28cb02c8747915e9af2b13c79b417eb34d2fa2a73547897770ace08c6dd9de528848d3030000000651ab63abab533c69d3f9b75b6ef8ed2df50c2210fd0bf4e889c42477d58682f711cbaece1a626194bb85030000000765acab53ac5353ffffffff018cc280040000000009abacabac52636352ac6859409e", "ac51ac", 1, 1005144875, "919144aada50db8675b7f9a6849c9d263b86450570293a03c245bd1e3095e292");
-        run_test_sighash("8f28471d02f7d41b2e70e9b4c804f2d90d23fb24d53426fa746bcdcfffea864925bdeabe3e0200000001acffffffff76d1d35d04db0e64d65810c808fe40168f8d1f2143902a1cc551034fd193be0e0000000001acffffffff048a5565000000000005005151516afafb610400000000045263ac53648bb30500000000086363516a6a5165513245de01000000000000000000", "6a0053510053", 1, -1525137460, "305fc8ff5dc04ebd9b6448b03c9a3d945a11567206c8d5214666b30ec6d0d6cc");
-        run_test_sighash("10ec50d7046b8b40e4222a3c6449490ebe41513aad2eca7848284a08f3069f3352c2a9954f0000000009526aac656352acac53ffffffff0d979f236155aa972472d43ee6f8ce22a2d052c740f10b59211454ff22cb7fd00200000007acacacab63ab53ffffffffbbf97ebde8969b35725b2e240092a986a2cbfd58de48c4475fe077bdd493a20c010000000663ab5365ababffffffff4600722d33b8dba300d3ad037bcfc6038b1db8abfe8008a15a1de2da2264007302000000035351ac6dbdafaf020d0ccf04000000000663ab6a51ab6ae06e5e0200000000036aabab00000000", "", 0, -1658960232, "2420dd722e229eccafae8508e7b8d75c6920bfdb3b5bac7cb8e23419480637c2");
-        run_test_sighash("43559290038f32fda86580dd8a4bc4422db88dd22a626b8bd4f10f1c9dd325c8dc49bf479f01000000026351ffffffff401339530e1ed3ffe996578a17c3ec9d6fccb0723dd63e7b3f39e2c44b976b7b0300000006ab6a65656a51ffffffff6fb9ba041c96b886482009f56c09c22e7b0d33091f2ac5418d05708951816ce7000000000551ac525100ffffffff020921e40500000000035365533986f40500000000016a00000000", "52ac51", 0, 1769771809, "02040283ef2291d8e1f79bb71bdabe7c1546c40d7ed615c375643000a8b9600d");
-        run_test_sighash("35b6fc06047ebad04783a5167ab5fc9878a00c4eb5e7d70ef297c33d5abd5137a2dea9912402000000036aacacffffffff21dc291763419a584bdb3ed4f6f8c60b218aaa5b99784e4ba8acfec04993e50c03000000046a00ac6affffffff69e04d77e4b662a82db71a68dd72ef0af48ca5bebdcb40f5edf0caf591bb41020200000000b5db78a16d93f5f24d7d932f93a29bb4b784febd0cbb1943f90216dc80bba15a0567684b000000000853ab52ab5100006a1be2208a02f6bdc103000000000265ab8550ea04000000000365636a00000000", "", 0, -1114114836, "1c8655969b241e717b841526f87e6bd68b2329905ba3fc9e9f72526c0b3ea20c");
-        run_test_sighash("f35befbc03faf8c25cc4bc0b92f6239f477e663b44b83065c9cb7cf231243032cf367ce3130000000005ab65526a517c4c334149a9c9edc39e29276a4b3ffbbab337de7908ea6f88af331228bd90086a6900ba020000000151279d19950d2fe81979b72ce3a33c6d82ebb92f9a2e164b6471ac857f3bbd3c0ea213b542010000000953ab51635363520065052657c20300a9ba04000000000452636a6a0516ea020000000008535253656365ababcfdd3f01000000000865ac516aac00530000000000", "", 2, -99793521, "c834a5485e68dc13edb6c79948784712122440d7fa5bbaa5cd2fc3d4dac8185d");
-        run_test_sighash("d3da18520216601acf885414538ce2fb4d910997eeb91582cac42eb6982c9381589587794f0300000000fffffffff1b1c9880356852e10cf41c02e928748dd8fae2e988be4e1c4cb32d0bfaea6f7000000000465ab6aabffffffff02fb0d69050000000002ababeda8580500000000085163526565ac52522b913c95", "ac", 1, -1247973017, "99b32b5679d91e0f9cdd6737afeb07459806e5acd7630c6a3b9ab5d550d0c003");
-        run_test_sighash("8218eb740229c695c252e3630fc6257c42624f974bc856b7af8208df643a6c520ef681bfd00000000002510066f30f270a09b2b420e274c14d07430008e7886ec621ba45665057120afce58befca96010300000004525153ab84c380a9015d96100000000000076a5300acac526500000000", "ac005263", 0, -1855679695, "5071f8acf96aea41c7518bd1b5b6bbe16258b529df0c03f9e374b83c66b742c6");
-        run_test_sighash("1123e7010240310013c74e5def60d8e14dd67aedff5a57d07a24abc84d933483431b8cf8ea0300000003530051fc6775ff1a23c627a2e605dd2560e84e27f4208300071e90f4589e762ad9c9fe8d0da95e020000000465655200ffffffff04251598030000000004ab65ab639d28d90400000000096563636aacac525153474df801000000000851525165ac51006a75e23b040000000000e5bd3a4a", "6363636565", 0, -467124448, "9cb0dd04e9fe287b112e94a1647590d27e8b164ca13c4fe70c610fd13f82c2fd");
-        run_test_sighash("3b937e05032b8895d2f4945cb7e3679be2fbd15311e2414f4184706dbfc0558cf7de7b4d000000000001638b91a12668a3c3ce349788c961c26aa893c862f1e630f18d80e7843686b6e1e6fc396310000000000852635353ab65ac51eeb09dd1c9605391258ee6f74b9ae17b5e8c2ef010dc721c5433dcdc6e93a1593e3b6d1700000000085365ac6553526351ffffffff0308b18e04000000000253acb6dd00040000000008536aac5153ac516ab0a88201000000000500ac006500804e3ff2", "", 0, 416167343, "595a3c02254564634e8085283ec4ea7c23808da97ce9c5da7aecd7b553e7fd7f");
-        run_test_sighash("a48f27ca047997470da74c8ee086ddad82f36d9c22e790bd6f8603ee6e27ad4d3174ea875403000000095153ac636aab6aacabffffffffefc936294e468d2c9a99e09909ba599978a8c0891ad47dc00ba424761627cef202000000056a51630053ffffffff304cae7ed2d3dbb4f2fbd679da442aed06221ffda9aee460a28ceec5a9399f4e0200000000f5bddf82c9c25fc29c5729274c1ff0b43934303e5f595ce86316fc66ad263b96ca46ab8d0100000003536500d7cf226b0146b00c04000000000200ac5c2014ce", "515100636563", 0, 1991799059, "9c051a7092fe17fa62b1720bc2c4cb2ffc1527d9fb0b006d2e142bb8fe07bf3c");
-        run_test_sighash("180cd53101c5074cf0b7f089d139e837fe49932791f73fa2342bd823c6df6a2f72fe6dba1303000000076a6a63ac53acabffffffff03853bc1020000000007ac526a6a6a6a003c4a8903000000000453515163a0fbbd030000000005ab656a5253253d64cf", "ac65", 0, -1548453970, "4d8efb3b99b9064d2f6be33b194a903ffabb9d0e7baa97a48fcec038072aac06");
-        run_test_sighash("c21ec8b60376c47e057f2c71caa90269888d0ffd5c46a471649144a920d0b409e56f190b700000000008acac6a526a536365ffffffff5d315d9da8bf643a9ba11299450b1f87272e6030fdb0c8adc04e6c1bfc87de9a0000000000ea43a9a142e5830c96b0ce827663af36b23b0277244658f8f606e95384574b91750b8e940000000007516a63ac0063acffffffff023c61be0400000000055165ab5263313cc8020000000006006a53526551ed8c3d56", "6a", 1, 1160627414, "a638cc17fd91f4b1e77877e8d82448c84b2a4e100df1373f779de7ad32695112");
-        run_test_sighash("b8fd394001ed255f49ad491fecc990b7f38688e9c837ccbc7714ddbbf5404f42524e68c18f0000000007ab6353535363ab081e15ee02706f7d050000000008515200535351526364c7ec040000000005636a53acac9206cbe1", "655352ac", 0, -1251578838, "8e0697d8cd8a9ccea837fd798cc6c5ed29f6fbd1892ee9bcb6c944772778af19");
-        run_test_sighash("e42a76740264677829e30ed610864160c7f97232c16528fe5610fc08814b21c34eefcea69d010000000653006a6a0052ffffffff647046cf44f217d040e6a8ff3f295312ab4dd5a0df231c66968ad1c6d8f4428000000000025352ffffffff0199a7f900000000000000000000", "655263006a005163", 1, 1122505713, "7cda43f1ff9191c646c56a4e29b1a8c6cb3f7b331da6883ef2f0480a515d0861");
-        run_test_sighash("a2dfa4690214c1ab25331815a5128f143219de51a47abdc7ce2d367e683eeb93960a31af9f010000000363636affffffff8be0628abb1861b078fcc19c236bc4cc726fa49068b88ad170adb2a97862e7460200000004ac655363ffffffff0441f11103000000000153dbab0c000000000009ab53ac5365526aab63abbb95050000000004ab52516a29a029040000000003ac526a00000000", "6a52ac63", 1, -1302210567, "913060c7454e6c80f5ba3835454b54db2188e37dc4ce72a16b37d11a430b3d23");
-        run_test_sighash("9dbc591f04521670af83fb3bb591c5d4da99206f5d38e020289f7db95414390dddbbeb56680100000004ac5100acffffffffb6a40b5e29d5e459f8e72d39f800089529f0889006cad3d734011991da8ef09d0100000009526a5100acab536a515fc427436df97cc51dc8497642ffc868857ee245314d28b356bd70adba671bd6071301fc0000000000ffffffff487efde2f620566a9b017b2e6e6d42525e4070f73a602f85c6dfd58304518db30000000005516353006a8d8090180244904a0200000000046a65656ab1e9c203000000000451ab63aba06a5449", "", 0, -1414953913, "bae189eb3d64aedbc28a6c28f6c0ccbd58472caaf0cf45a5aabae3e031dd1fea");
-        run_test_sighash("1345fb2c04bb21a35ae33a3f9f295bece34650308a9d8984a989dfe4c977790b0c21ff9a7f0000000006ac52ac6a0053ffffffff7baee9e8717d81d375a43b691e91579be53875350dfe23ba0058ea950029fcb7020000000753ab53ab63ab52ffffffff684b6b3828dfb4c8a92043b49b8cb15dd3a7c98b978da1d314dce5b9570dadd202000000086353ab6a5200ac63d1a8647bf667ceb2eae7ec75569ca249fbfd5d1b582acfbd7e1fcf5886121fca699c011d0100000003ac006affffffff049b1eb00300000000001e46dc0100000000080065ab6a6a630065ca95b40300000000030051520c8499010000000006ab6aac526a6500000000", "53526aac636300", 2, 1809978100, "cfeaa36790bc398783d4ca45e6354e1ea52ee74e005df7f9ebd10a680e9607bf");
-        run_test_sighash("7d75dc8f011e5f9f7313ba6aedef8dbe10d0a471aca88bbfc0c4a448ce424a2c5580cda1560300000003ab5152ffffffff01997f8e0200000000096552ac6a65656563530d93bbcc", "00656a6563", 0, 1414485913, "ec91eda1149f75bffb97612569a78855498c5d5386d473752a2c81454f297fa7");
-        run_test_sighash("1459179504b69f01c066e8ade5e124c748ae5652566b34ed673eea38568c483a5a4c4836ca0100000008ac5352006563656affffffff5d4e037880ab1975ce95ea378d2874dcd49d5e01e1cdbfae3343a01f383fa35800000000095251ac52ac6aac6500ffffffff7de3ae7d97373b7f2aeb4c55137b5e947b2d5fb325e892530cb589bc4f92abd503000000086563ac53ab520052ffffffffb4db36a32d6e543ef49f4bafde46053cb85b2a6c4f0e19fa0860d9083901a1190300000003ab51531bbcfe5504a6dbda040000000008536a5365abac6500d660c80300000000096565abab6a53536a6a54e84e010000000003acac52df2ccf0500000000025351220c857e", "", 2, 1879181631, "3aad18a209fab8db44954eb55fd3cc7689b5ec9c77373a4d5f4dae8f7ae58d14");
-        run_test_sighash("cabb1b06045a895e6dcfc0c1e971e94130c46feace286759f69a16d298c8b0f6fd0afef8f20300000004ac006352ffffffffa299f5edac903072bfb7d29b663c1dd1345c2a33546a508ba5cf17aab911234602000000056a65515365ffffffff89a20dc2ee0524b361231092a070ace03343b162e7162479c96b757739c8394a0300000002abab92ec524daf73fabee63f95c1b79fa8b84e92d0e8bac57295e1d0adc55dc7af5534ebea410200000001534d70e79b04674f6f00000000000600abacab53517d60cc0200000000035265ab96c51d040000000004ac6300ac62a787050000000008006a516563ab63639e2e7ff7", "6551ac6351ac", 3, 1942663262, "d0c4a780e4e0bc22e2f231e23f01c9d536b09f6e5be51c123d218e906ec518be");
-        run_test_sighash("8b96d7a30132f6005b5bd33ea82aa325e2bcb441f46f63b5fca159ac7094499f380f6b7e2e00000000076aacabac6300acffffffff0158056700000000000465005100c319e6d0", "52006a", 0, -1100733473, "fb4bd26a91b5cf225dd3f170eb09bad0eac314bc1e74503cc2a3f376833f183e");
-        run_test_sighash("112191b7013cfbe18a175eaf09af7a43cbac2c396f3695bbe050e1e5f4250603056d60910e02000000001c8a5bba03738a22010000000005525352656a77a149010000000002510003b52302000000000351ac52722be8e6", "65ac6565", 0, -1847972737, "8e795aeef18f510d117dfa2b9f4a2bd2e2847a343205276cedd2ba14548fd63f");
-        run_test_sighash("ce6e1a9e04b4c746318424705ea69517e5e0343357d131ad55d071562d0b6ebfedafd6cb840100000003656553ffffffff67bd2fa78e2f52d9f8900c58b84c27ef9d7679f67a0a6f78645ce61b883fb8de000000000100d699a56b9861d99be2838e8504884af4d30b909b1911639dd0c5ad47c557a0773155d4d303000000046a5151abffffffff9fdb84b77c326921a8266854f7bbd5a71305b54385e747fe41af8a397e78b7fa010000000863acac6a51ab00ac0d2e9b9d049b8173010000000007ac53526a650063ba9b7e010000000008526a00525263acac0ab3fd030000000000ea8a0303000000000200aca61a97b9", "", 1, -1276952681, "b6ed4a3721be3c3c7305a5128c9d418efa58e419580cec0d83f133a93e3a22c5");
-        run_test_sighash("2f7353dd02e395b0a4d16da0f7472db618857cd3de5b9e2789232952a9b154d249102245fd030000000151617fd88f103280b85b0a198198e438e7cab1a4c92ba58409709997cc7a65a619eb9eec3c0200000003636aabffffffff0397481c0200000000045300636a0dc97803000000000009d389030000000003ac6a53134007bb", "0000536552526a", 0, -1912746174, "30c4cd4bd6b291f7e9489cc4b4440a083f93a7664ea1f93e77a9597dab8ded9c");
-        run_test_sighash("89e7928c04363cb520eff4465251fd8e41550cbd0d2cdf18c456a0be3d634382abcfd4a2130200000006ac516a6a656355042a796061ed72db52ae47d1607b1ceef6ca6aea3b7eea48e7e02429f382b378c4e51901000000085351ab6352ab5252ffffffff53631cbda79b40183000d6ede011c778f70147dc6fa1aed3395d4ce9f7a8e69701000000096a6553ab52516a52abad0de418d80afe059aab5da73237e0beb60af4ac490c3394c12d66665d1bac13bdf29aa8000000000153f2b59ab6027a33eb040000000007005351ac5100ac88b941030000000003ab0052e1e8a143", "63656a", 0, 1258533326, "b575a04b0bb56e38bbf26e1a396a76b99fb09db01527651673a073a75f0a7a34");
-        run_test_sighash("ca356e2004bea08ec2dd2df203dc275765dc3f6073f55c46513a588a7abcc4cbde2ff011c7020000000553525100003aefec4860ef5d6c1c6be93e13bd2d2a40c6fb7361694136a7620b020ecbaca9413bcd2a030000000965ac00536352535100ace4289e00e97caaea741f2b89c1143060011a1f93090dc230bee3f05e34fbd8d8b6c399010000000365526affffffff48fc444238bda7a757cb6a98cb89fb44338829d3e24e46a60a36d4e24ba05d9002000000026a53ffffffff03d70b440200000000056a6a526aac853c97010000000002515335552202000000000351635300000000", "0052", 3, -528192467, "fc93cc056c70d5e033933d730965f36ad81ef64f1762e57f0bc5506c5b507e24");
-        run_test_sighash("82d4fa65017958d53e562fac073df233ab154bd0cf6e5a18f57f4badea8200b217975e31030200000004636aab51ac0891a204227cc9050000000006635200655365bfef8802000000000865650051635252acfc2d09050000000006ab65ac51516380195e030000000007ac52525352510063d50572", "53", 0, -713567171, "e095003ca82af89738c1863f0f5488ec56a96fb81ea7df334f9344fcb1d0cf40");
-        run_test_sighash("75f6949503e0e47dd70426ef32002d6cdb564a45abedc1575425a18a8828bf385fa8e808e600000000036aabab82f9fd14e9647d7a1b5284e6c55169c8bd228a7ea335987cef0195841e83da45ec28aa2e0300000002516350dc6fe239d150efdb1b51aa288fe85f9b9f741c72956c11d9dcd176889963d699abd63f0000000001ab429a63f502777d20010000000007abac52ac516a53d081d9020000000003acac630c3cc3a8", "535152516551510000", 1, 973814968, "c6ec1b7cb5c16a1bfd8a3790db227d2acc836300534564252b57bd66acf95092");
-        run_test_sighash("e86a24bc03e4fae784cdf81b24d120348cb5e52d937cd9055402fdba7e43281e482e77a1c100000000046363006affffffffa5447e9bdcdab22bd20d88b19795d4c8fb263fbbf7ce8f4f9a85f865953a6325020000000663ac53535253ffffffff9f8b693bc84e0101fc73748e0513a8cecdc264270d8a4ee1a1b6717607ee1eaa00000000026a513417bf980158d82c020000000009005253005351acac5200000000", "6353516365536a6a", 2, -563792735, "508129278ef07b43112ac32faf00170ad38a500eed97615a860fd58baaad174b");
-        run_test_sighash("536bc5e60232eb60954587667d6bcdd19a49048d67a027383cc0c2a29a48b960dc38c5a0370300000005ac636300abffffffff8f1cfc102f39b1c9348a2195d496e602c77d9f57e0769dabde7eaaedf9c69e250100000006acabab6a6351ffffffff0432f56f0400000000046a5365517fd54b0400000000035265539484e4050000000003536a5376dc25020000000008ac536aab6aab536ab978e686", "ac0051006a006a006a", 0, -273074082, "f151f1ec305f698d9fdce18ea292b145a58d931f1518cf2a4c83484d9a429638");
-        run_test_sighash("fab796ee03f737f07669160d1f1c8bf0800041157e3ac7961fea33a293f976d79ce49c02ab0200000003ac5252eb097ea1a6d1a7ae9dace338505ba559e579a1ee98a2e9ad96f30696d6337adcda5a85f403000000096500abab656a6a656396d5d41a9b11f571d91e4242ddc0cf2420eca796ad4882ef1251e84e42b930398ec69dd80100000005526551ac6a8e5d0de804f763bb0400000000015288271a010000000001acf2bf2905000000000300ab51c9641500000000000952655363636365ac5100000000", "00ac536552", 0, -1854521113, "f3bbab70b759fe6cfae1bf349ce10716dbc64f6e9b32916904be4386eb461f1f");
-        run_test_sighash("f2b539a401e4e8402869d5e1502dbc3156dbce93583f516a4947b333260d5af1a34810c6a00200000003525363ffffffff01d305e2000000000005acab535200a265fe77", "", 0, -1435650456, "41617b27321a830c712638dbb156dae23d4ef181c7a06728ccbf3153ec53d7dd");
-        run_test_sighash("9f10b1d8033aee81ac04d84ceee0c03416a784d1017a2af8f8a34d2f56b767aea28ff88c8f02000000025352ffffffff748cb29843bea8e9c44ed5ff258df1faf55fbb9146870b8d76454786c4549de100000000016a5ba089417305424d05112c0ca445bc7107339083e7da15e430050d578f034ec0c589223b0200000007abac53ac6565abffffffff025a4ecd010000000006636563ab65ab40d2700000000000056a6553526333fa296c", "", 0, -395044364, "20fd0eee5b5716d6cbc0ddf852614b686e7a1534693570809f6719b6fcb0a626");
-        run_test_sighash("ff2ecc09041b4cf5abb7b760e910b775268abee2792c7f21cc5301dd3fecc1b4233ee70a2c0200000009acac5300006a51526affffffffeb39c195a5426afff38379fc85369771e4933587218ef4968f3f05c51d6b7c92000000000165453a5f039b8dbef7c1ffdc70ac383b481f72f99f52b0b3a5903c825c45cfa5d2c0642cd50200000001654b5038e6c49daea8c0a9ac8611cfe904fc206dad03a41fb4e5b1d6d85b1ecad73ecd4c0102000000096a51000053ab656565bdb5548302cc719200000000000452655265214a3603000000000300ab6a00000000", "52516a006a63", 1, -2113289251, "37ed6fae36fcb3360c69cac8b359daa62230fc1419b2cf992a32d8f3e079dcff");
-        run_test_sighash("70a8577804e553e462a859375957db68cfdf724d68caeacf08995e80d7fa93db7ebc04519d02000000045352ab53619f4f2a428109c5fcf9fee634a2ab92f4a09dc01a5015e8ecb3fc0d9279c4a77fb27e900000000006ab6a51006a6affffffff3ed1a0a0d03f25c5e8d279bb5d931b7eb7e99c8203306a6c310db113419a69ad010000000565516300abffffffff6bf668d4ff5005ef73a1b0c51f32e8235e67ab31fe019bf131e1382050b39a630000000004536a6563ffffffff02faf0bb00000000000163cf2b4b05000000000752ac635363acac15ab369f", "ac", 0, -1175809030, "1c9d6816c20865849078f9777544b5ddf37c8620fe7bd1618e4b72fb72dddca1");
-        run_test_sighash("a3604e5304caa5a6ba3c257c20b45dcd468f2c732a8ca59016e77b6476ac741ce8b16ca8360200000004acac6553ffffffff695e7006495517e0b79bd4770f955040610e74d35f01e41c9932ab8ccfa3b55d0300000007ac5253515365acffffffff6153120efc5d73cd959d72566fc829a4eb00b3ef1a5bd3559677fb5aae116e38000000000400abab52c29e7abd06ff98372a3a06227386609adc7665a602e511cadcb06377cc6ac0b8f63d4fdb03000000055100acabacffffffff04209073050000000009ab5163ac525253ab6514462e05000000000952abacab636300656a20672c0400000000025153b276990000000000056565ab6a5300000000", "5351", 0, 1460890590, "249c4513a49076c6618aabf736dfd5ae2172be4311844a62cf313950b4ba94be");
-        run_test_sighash("c6a72ed403313b7d027f6864e705ec6b5fa52eb99169f8ea7cd884f5cdb830a150cebade870100000009ac63ab516565ab6a51ffffffff398d5838735ff43c390ca418593dbe43f3445ba69394a6d665b5dc3b4769b5d700000000075265acab515365ffffffff7ee5616a1ee105fd18189806a477300e2a9cf836bf8035464e8192a0d785eea3030000000700ac6a51516a52ffffffff018075fd0000000000015100000000", "005251acac5252", 2, -656067295, "2cc1c7514fdc512fd45ca7ba4f7be8a9fe6d3318328bc1a61ae6e7675047e654");
-        run_test_sighash("93c12cc30270fc4370c960665b8f774e07942a627c83e58e860e38bd6b0aa2cb7a2c1e060901000000036300abffffffff4d9b618035f9175f564837f733a2b108c0f462f28818093372eec070d9f0a5440300000001acffffffff039c2137020000000001525500990100000000055265ab636a07980e0300000000005ba0e9d1", "656a5100", 1, 18954182, "6beca0e0388f824ca33bf3589087a3c8ad0857f9fe7b7609ae3704bef0eb83e2");
-        run_test_sighash("97bddc63015f1767619d56598ad0eb5c7e9f880b24a928fea1e040e95429c930c1dc653bdb0100000008ac53acac00005152aaa94eb90235ed10040000000000287bdd0400000000016a8077673a", "acac6a536352655252", 0, -813649781, "5990b139451847343c9bb89cdba0e6daee6850b60e5b7ea505b04efba15f5d92");
-        run_test_sighash("cc3c9dd303637839fb727270261d8e9ddb8a21b7f6cbdcf07015ba1e5cf01dc3c3a327745d0300000000d2d7804fe20a9fca9659a0e49f258800304580499e8753046276062f69dbbde85d17cd2201000000096352536a520000acabffffffffbc75dfa9b5f81f3552e4143e08f485dfb97ae6187330e6cd6752de6c21bdfd21030000000600ab53650063ffffffff0313d0140400000000096565515253526aacac167f0a040000000008acab00535263536a9a52f8030000000006abab5151ab63f75b66f2", "6a635353636a65ac65", 1, 377286607, "dbc7935d718328d23d73f8a6dc4f53a267b8d4d9816d0091f33823bd1f0233e9");
-        run_test_sighash("236f91b702b8ffea3b890700b6f91af713480769dda5a085ae219c8737ebae90ff25915a3203000000056300ac6300811a6a10230f12c9faa28dae5be2ebe93f37c06a79e76214feba49bb017fb25305ff84eb020000000100ffffffff041e351703000000000351ac004ff53e050000000003ab53636c1460010000000000cb55f701000000000651520051ab0000000000", "acac636a6aac5300", 0, 406448919, "793a3d3c37f6494fab79ff10c16702de002f63e34be25dd8561f424b0ea938c4");
-        run_test_sighash("c47d5ad60485cb2f7a825587b95ea665a593769191382852f3514a486d7a7a11d220b62c54000000000663655253acab8c3cf32b0285b040e50dcf6987ddf7c385b3665048ad2f9317b9e0c5ba0405d8fde4129b00000000095251ab00ac65635300ffffffff549fe963ee410d6435bb2ed3042a7c294d0c7382a83edefba8582a2064af3265000000000152fffffffff7737a85e0e94c2d19cd1cde47328ece04b3e33cd60f24a8a345da7f2a96a6d0000000000865ab6a0051656aab28ff30d5049613ea020000000005ac51000063f06df1050000000008ac63516aabac5153afef5901000000000700656500655253688bc00000000000086aab5352526a53521ff1d5ff", "51ac52", 2, -1296011911, "0c1fd44476ff28bf603ad4f306e8b6c7f0135a441dc3194a6f227cb54598642a");
-        run_test_sighash("0b43f122032f182366541e7ee18562eb5f39bc7a8e5e0d3c398f7e306e551cdef773941918030000000863006351ac51acabffffffffae586660c8ff43355b685dfa8676a370799865fbc4b641c5a962f0849a13d8250100000005abab63acabffffffff0b2b6b800d8e77807cf130de6286b237717957658443674df047a2ab18e413860100000008ab6aac655200ab63ffffffff04f1dbca03000000000800635253ab656a52a6eefd0300000000036365655d8ca90200000000005a0d530400000000015300000000", "65ac65acac", 0, 351448685, "86f26e23822afd1bdfc9fff92840fc1e60089f12f54439e3ab9e5167d0361dcf");
-        run_test_sighash("af1c4ab301ec462f76ee69ba419b1b2557b7ded639f3442a3522d4f9170b2d6859765c3df402000000016affffffff01a5ca6c000000000008ab52536aab00005300000000", "6a6351", 0, 110304602, "e88ed2eea9143f2517b15c03db00767eb01a5ce12193b99b964a35700607e5f4");
-        run_test_sighash("0bfd34210451c92cdfa02125a62ba365448e11ff1db3fb8bc84f1c7e5615da40233a8cd368010000000252ac9a070cd88dec5cf9aed1eab10d19529720e12c52d3a21b92c6fdb589d056908e43ea910e0200000009ac516a52656a6a5165ffffffffc3edcca8d2f61f34a5296c405c5f6bc58276416c720c956ff277f1fb81541ddd00000000030063abffffffff811247905cdfc973d179c03014c01e37d44e78f087233444dfdce1d1389d97c302000000065163000063ab1724a26e02ca37c902000000000851ab53525352ac529012a90100000000085200525253535353fa32575b", "5352ac6351", 1, -1087700448, "b8f1e1f35e3e1368bd17008c756e59cced216b3c699bcd7bebdb5b6c8eec4697");
-        run_test_sighash("467a3e7602e6d1a7a531106791845ec3908a29b833598e41f610ef83d02a7da3a1900bf2960000000005ab6a636353ffffffff031db6dac6f0bafafe723b9199420217ad2c94221b6880654f2b35114f44b1df010000000965ab52636a63ac6352ffffffff02b3b95c0100000000026300703216030000000001ab3261c0aa", "6a", 0, 2110869267, "3078b1d1a7713c6d101c64afe35adfae0977a5ab4c7e07a0b170b041258adbf2");
-        run_test_sighash("8713bc4f01b411149d575ebae575f5dd7e456198d61d238695df459dd9b86c4e3b2734b62e0300000004abac6363ffffffff03b58049050000000002ac653c714c04000000000953656a005151526a527b5a9e03000000000652ac5100525300000000", "52", 0, -647281251, "0e0bed1bf2ff255aef6e5c587f879ae0be6222ab33bd75ee365ec6fbb8acbe38");
-        run_test_sighash("b5a7df6102107beded33ae7f1dec0531d4829dff7477260925aa2cba54119b7a07d92d5a1d02000000046a516a52803b625c334c1d2107a326538a3db92c6c6ae3f7c3516cd90a09b619ec6f58d10e77bd6703000000056563006a63ffffffff0117484b03000000000853acab52526a65abc1b548a1", "ac006a525100", 0, 2074359913, "680336db57347d8183b8898cd27a83f1ba5884155aeae5ce20b4840b75e12871");
-        run_test_sighash("49eb2178020a04fca08612c34959fd41447319c190fb7ffed9f71c235aa77bec28703aa1820200000003ac6353abaff326071f07ec6b77fb651af06e8e8bd171068ec96b52ed584de1d71437fed186aecf0300000001acffffffff03da3dbe02000000000652ac63ac6aab8f3b680400000000096a536a65636a53516a5175470100000000016500000000", "6a536365", 0, 1283691249, "c670219a93234929f662ecb9aa148a85a2d281e83f4e53d10509461cdea47979");
-        run_test_sighash("0f96cea9019b4b3233c0485d5b1bad770c246fe8d4a58fb24c3b7dfdb3b0fd90ea4e8e947f0300000006006a5163515303571e1e01906956030000000005ab635353abadc0fbbe", "acac", 0, -1491469027, "716a8180e417228f769dcb49e0491e3fda63badf3d5ea0ceeac7970d483dd7e2");
-        run_test_sighash("148e68480196eb52529af8e83e14127cbfdbd4a174e60a86ac2d86eac9665f46f4447cf7aa01000000045200ac538f8f871401cf240c0300000000065252ab52656a5266cf61", "", 0, -344314825, "eacc47c5a53734d6ae3aedbc6a7c0a75a1565310851b29ef0342dc4745ceb607");
-        run_test_sighash("6c7913f902aa3f5f939dd1615114ce961beda7c1e0dd195be36a2f0d9d047c28ac62738c3a020000000453abac00ffffffff477bf2c5b5c6733881447ac1ecaff3a6f80d7016eee3513f382ad7f554015b970100000007ab6563acab5152ffffffff04e58fe1040000000009ab00526aabab526553e59790010000000002ab525a834b03000000000035fdaf0200000000086551ac65515200ab00000000", "63ac53", 1, 1285478169, "1536da582a0b6de017862445e91ba14181bd6bf953f4de2f46b040d351a747c9");
-        run_test_sighash("3320f6730132f830c4681d0cae542188e4177cad5d526fae84565c60ceb5c0118e844f90bd030000000163ffffffff0257ec5a040000000005525251ac6538344d000000000002515200000000", "5352656a53ac516a65", 0, 788050308, "3afacaca0ef6be9d39e71d7b1b118994f99e4ea5973c9107ca687d28d8eba485");
-        run_test_sighash("c13aa4b702eedd7cde09d0416e649a890d40e675aa9b5b6d6912686e20e9b9e10dbd40abb1000000000863ab6353515351ac11d24dc4cc22ded7cdbc13edd3f87bd4b226eda3e4408853a57bcd1becf2df2a1671fd1600000000045165516affffffff01baea300100000000076aab52ab53005300000000", "0065", 0, -1195908377, "241a23e7b1982d5f78917ed97a8678087acbbffe7f624b81df78a5fe5e41e754");
-        run_test_sighash("a2692fff03b2387f5bacd5640c86ba7df574a0ee9ed7f66f22c73cccaef3907eae791cbd230200000004536363abffffffff4d9fe7e5b375de88ba48925d9b2005447a69ea2e00495a96eafb2f144ad475b40000000008000053000052636537259bee3cedd3dcc07c8f423739690c590dc195274a7d398fa196af37f3e9b4a1413f810000000006ac63acac52abffffffff04c65fe60200000000075151536365ab657236fc020000000009005263ab00656a6a5195b8b6030000000007ac5165636aac6a7d7b66010000000002acab00000000", "51", 2, -826546582, "925037c7dc7625f3f12dc83904755a37016560de8e1cdd153c88270a7201cf15");
-        run_test_sighash("2c5b003201b88654ac2d02ff6762446cb5a4af77586f05e65ee5d54680cea13291efcf930d0100000005ab536a006a37423d2504100367000000000004536a515335149800000000000152166aeb03000000000452510063226c8e03000000000000000000", "635251", 0, 1060344799, "7e058ca5dd07640e4aae7dea731cfb7d7fef1bfd0d6d7b6ce109d041f4ca2a31");
-        run_test_sighash("f981b9e104acb93b9a7e2375080f3ea0e7a94ce54cd8fb25c57992fa8042bdf4378572859f0100000002630008604febba7e4837da77084d5d1b81965e0ea0deb6d61278b6be8627b0d9a2ecd7aeb06a0300000005ac5353536a42af3ef15ce7a2cd60482fc0d191c4236e66b4b48c9018d7dbe4db820f5925aad0e8b52a0300000008ab0063510052516301863715efc8608bf69c0343f18fb81a8b0c720898a3563eca8fe630736c0440a179129d03000000086aac6a52ac6a63ac44fec4c00408320a03000000000062c21c030000000007ac6a655263006553835f0100000000015303cd60000000000005535263536558b596e0", "00", 0, -2140385880, "49870a961263354c9baf108c6979b28261f99b374e97605baa532d9fa3848797");
-        run_test_sighash("c4b702e502f1a54f235224f0e6de961d2e53b506ab45b9a40805d1dacd35148f0acf24ca5e00000000085200ac65ac53acabf34ba6099135658460de9d9b433b84a8562032723635baf21ca1db561dce1c13a06f4407000000000851ac006a63516aabffffffff02a853a603000000000163d17a67030000000005ab63006a5200000000", "ac5363515153", 1, 480734903, "5c46f7ac3d6460af0da28468fcc5b3c87f2b9093d0f837954b7c8174b4d7b6e7");
-        run_test_sighash("9b83f78704f492b9b353a3faad8d93f688e885030c274856e4037818848b99e490afef27770200000000ffffffff36b60675a5888c0ef4d9e11744ecd90d9fe9e6d8abb4cff5666c898fdce98d9e00000000056aab656352596370fca7a7c139752971e169a1af3e67d7656fc4fc7fd3b98408e607c2f2c836c9f27c030000000653ac51ab6300a0761de7e158947f401b3595b7dc0fe7b75fa9c833d13f1af57b9206e4012de0c41b8124030000000953656a53ab53510052242e5f5601bf83b301000000000465516a6300000000", "63515200ac656365", 3, -150879312, "9cf05990421ea853782e4a2c67118e03434629e7d52ab3f1d55c37cf7d72cdc4");
-        run_test_sighash("f492a9da04f80b679708c01224f68203d5ea2668b1f442ebba16b1aa4301d2fe5b4e2568f3010000000953005351525263ab65ffffffff93b34c3f37d4a66df255b514419105b56d7d60c24bf395415eda3d3d8aa5cd0101000000020065ffffffff9dba34dabdc4f1643b372b6b77fdf2b482b33ed425914bb4b1a61e4fad33cf390000000002ab52ffffffffbbf3dc82f397ef3ee902c5146c8a80d9a1344fa6e38b7abce0f157be7adaefae0000000009515351005365006a51ffffffff021359ba010000000000403fea0200000000095200ac6353abac635300000000", "00ac51acacac", 0, -2115078404, "fd44fc98639ca32c927929196fc3f3594578f4c4bd248156a25c04a65bf3a9f3");
-        run_test_sighash("2f73e0b304f154d3a00fde2fdd40e791295e28d6cb76af9c0fd8547acf3771a02e3a92ba37030000000852ac6351ab6565639aa95467b065cec61b6e7dc4d6192b5536a7c569315fb43f470078b31ed22a55dab8265f02000000080065636a6aab6a53ffffffff9e3addbff52b2aaf9fe49c67017395198a9b71f0aa668c5cb354d06c295a691a0100000000ffffffff45c2b4019abaf05c5e484df982a4a07459204d1343a6ee5badade358141f8f990300000007ac516a6aacac6308655cd601f3bc2f0000000000015200000000", "", 0, -2082053939, "9a95e692e1f78efd3e46bb98f178a1e3a0ef60bd0301d9f064c0e5703dc879c2");
-        run_test_sighash("5a60b9b503553f3c099f775db56af3456330f1e44e67355c4ab290d22764b9144a7b5f959003000000030052acbd63e0564decc8659aa53868be48c1bfcda0a8c9857b0db32a217bc8b46d9e7323fe9649020000000553ac6551abd0ecf806211db989bead96c09c7f3ec5f73c1411d3329d47d12f9e46678f09bac0dc383e0200000000ffffffff01494bb202000000000500516551ac00000000", "ac", 0, 1169947809, "62a36c6e8da037202fa8aeae03e533665376d5a4e0a854fc4624a75ec52e4eb1");
-        run_test_sighash("e3649aa40405e6ffe377dbb1bbbb672a40d8424c430fa6512c6165273a2b9b6afa9949ec430200000007630052ab655153a365f62f2792fa90c784efe3f0981134d72aac0b1e1578097132c7f0406671457c332b84020000000353ab6ad780f40cf51be22bb4ff755434779c7f1def4999e4f289d2bd23d142f36b66fbe5cfbb4b01000000076a5252abac52ab1430ffdc67127c9c0fc97dcd4b578dab64f4fb9550d2b59d599773962077a563e8b6732c02000000016affffffff04cb2687000000000002ab636e320904000000000252acf70e9401000000000100dc3393050000000006ab0063536aacbc231765", "65520053", 3, -2016196547, "f64f805f0ff7f237359fa6b0e58085f3c766d1859003332223444fd29144112a");
-        run_test_sighash("4c4be7540344050e3044f0f1d628039a334a7c1f7b4573469cfea46101d6888bb6161fe9710200000000ffffffffac85a4fdad641d8e28523f78cf5b0f4dc74e6c5d903c10b358dd13a5a1fd8a06000000000163e0ae75d05616b72467b691dc207fe2e65ea35e2eadb7e06ea442b2adb9715f212c0924f10200000000ffffffff0194ddfe02000000000265ac00000000", "00006500", 1, -479922562, "d66924d49f03a6960d3ca479f3415d638c45889ce9ab05e25b65ac260b51d634");
-        run_test_sighash("202c18eb012bc0a987e69e205aea63f0f0c089f96dd8f0e9fcde199f2f37892b1d4e6da90302000000055352ac6565ffffffff0257e5450100000000025300ad257203000000000000000000", "520052ac6a005265", 0, 168054797, "502967a6f999f7ee25610a443caf8653dda288e6d644a77537bcc115a8a29894");
-        run_test_sighash("32fa0b0804e6ea101e137665a041cc2350b794e59bf42d9b09088b01cde806ec1bbea077df0200000008515153650000006506a11c55904258fa418e57b88b12724b81153260d3f4c9f080439789a391ab147aabb0fa0000000007000052ac51ab510986f2a15c0d5e05d20dc876dd2dafa435276d53da7b47c393f20900e55f163b97ce0b800000000008ab526a520065636a8087df7d4d9c985fb42308fb09dce704650719140aa6050e8955fa5d2ea46b464a333f870000000009636300636a6565006affffffff01994a0d040000000002536500000000", "516563530065", 2, -163068286, "f58637277d2bc42e18358dc55f7e87e7043f5e33f4ce1fc974e715ef0d3d1c2a");
-        run_test_sighash("ae23424d040cd884ebfb9a815d8f17176980ab8015285e03fdde899449f4ae71e04275e9a80100000007ab006553530053ffffffff018e06db6af519dadc5280c07791c0fd33251500955e43fe4ac747a4df5c54df020000000251ac330e977c0fec6149a1768e0d312fdb53ed9953a3737d7b5d06aad4d86e9970346a4feeb5030000000951ab51ac6563ab526a67cabc431ee3d8111224d5ecdbb7d717aa8fe82ce4a63842c9bd1aa848f111910e5ae1eb0100000004ac515300bfb7e0d7048acddc030000000009636a5253636a655363a3428e040000000001525b99c6050000000004655265ab717e6e020000000000d99011eb", "ac6a6a516565", 1, -716251549, "b098eb9aff1bbd375c70a0cbb9497882ab51f3abfebbf4e1f8d74c0739dc7717");
-        run_test_sighash("030f44fc01b4a9267335a95677bd190c1c12655e64df74addc53b753641259af1a54146baa020000000152e004b56c04ba11780300000000026a53f125f001000000000251acd2cc7c03000000000763536563655363c9b9e50500000000015200000000", "ac", 0, -1351818298, "19dd32190ed2a37be22f0224a9b55b91e37290577c6c346d36d32774db0219a3");
-        run_test_sighash("c05f448f02817740b30652c5681a3b128322f9dc97d166bd4402d39c37c0b14506d8adb5890300000003536353ffffffffa188b430357055ba291c648f951cd2f9b28a2e76353bef391b71a889ba68d5fc02000000056565526a6affffffff02745f73010000000001ab3ec34c0400000000036aac5200000000", "516551510053", 0, -267877178, "3a1c6742d4c374f061b1ebe330b1e169a113a19792a1fdde979b53e094cc4a3c");
-        run_test_sighash("163ba45703dd8c2c5a1c1f8b806afdc710a2a8fc40c0138e2d83e329e0e02a9b6c837ff6b8000000000700655151ab6a522b48b8f134eb1a7e6f5a6fa319ce9d11b36327ba427b7d65ead3b4a6a69f85cda8bbcd22030000000563656552acffffffffdbcf4955232bd11eef0cc6954f3f6279675b2956b9bcc24f08c360894027a60201000000066500006500abffffffff04d0ce9d0200000000008380650000000000015233f360040000000003006aabedcf0801000000000000000000", "000065006500ac", 0, 216965323, "9afe3f4978df6a86e9a8ebd62ef6a9d48a2203f02629349f1864ef2b8b92fd55");
-        run_test_sighash("fe647f950311bf8f3a4d90afd7517df306e04a344d2b2a2fea368935faf11fa6882505890d0000000005ab5100516affffffff43c140947d9778718919c49c0535667fc6cc727f5876851cb8f7b6460710c7f60100000000ffffffffce4aa5d90d7ab93cbec2e9626a435afcf2a68dd693c15b0e1ece81a9fcbe025e0300000000ffffffff02f34806020000000002515262e54403000000000965635151ac655363636de5ce24", "6a005100ac516351", 2, 989643518, "818a7ceaf963f52b5c48a7f01681ac6653c26b63a9f491856f090d9d60f2ffe3");
-        run_test_sighash("cef7316804c3e77fe67fc6207a1ea6ae6eb06b3bf1b3a4010a45ae5c7ad677bb8a4ebd16d90200000009ac536a5152ac5263005301ab8a0da2b3e0654d31a30264f9356ba1851c820a403be2948d35cafc7f9fe67a06960300000006526a63636a53ffffffffbada0d85465199fa4232c6e4222df790470c5b7afd54704595a48eedd7a4916b030000000865ab63ac006a006ab28dba4ad55e58b5375053f78b8cdf4879f723ea4068aed3dd4138766cb4d80aab0aff3d0300000003ac6a00ffffffff010f5dd6010000000006ab006aab51ab00000000", "", 1, 889284257, "d0f32a6db43378af84b063a6706d614e2d647031cf066997c48c04de3b493a94");
-        run_test_sighash("7b3ff28004ba3c7590ed6e36f45453ebb3f16636fe716acb2418bb2963df596a50ed954d2e03000000065251515265abffffffff706ee16e32e22179400c9841013971645dabf63a3a6d2d5feb42f83aa468983e030000000653ac51ac5152ffffffffa03a16e5e5de65dfa848b9a64ee8bf8656cc1f96b06a15d35bd5f3d32629876e020000000043c1a3965448b3b46f0f0689f1368f3b2981208a368ec5c30defb35595ef9cf95ffd10e902000000036aac65253a5bbe042e907204000000000800006565656352634203b4020000000002656336b3b7010000000001ab7a063f0100000000026500a233cb76", "006551636a53ac5251", 1, -1144216171, "68c7bd717b399b1ee33a6562a916825a2fed3019cdf4920418bb72ffd7403c8c");
-        run_test_sighash("1be8ee5604a9937ebecffc832155d9ba7860d0ca451eaced58ca3688945a31d93420c27c460100000006abac5300535288b65458af2f17cbbf7c5fbcdcfb334ffd84c1510d5500dc7d25a43c36679b702e850f7c0200000003005300ffffffff7c237281cb859653eb5bb0a66dbb7aeb2ac11d99ba9ed0f12c766a8ae2a2157203000000086aabac526365acabfffffffff09d3d6639849f442a6a52ad10a5d0e4cb1f4a6b22a98a8f442f60280c9e5be80200000007ab00ab6565ab52ffffffff0398fe83030000000005526aababacbdd6ec010000000005535252ab6a82c1e6040000000001652b71c40c", "6563526353656351", 2, -853634888, "0d936cceda2f56c7bb87d90a7b508f6208577014ff280910a710580357df25f3");
-        run_test_sighash("9e0f99c504fbca858c209c6d9371ddd78985be1ab52845db0720af9ae5e2664d352f5037d4010000000552ac53636affffffff0e0ce866bc3f5b0a49748f597c18fa47a2483b8a94cef1d7295d9a5d36d31ae7030000000663515263ac635bb5d1698325164cdd3f7f3f7831635a3588f26d47cc30bf0fefd56cd87dc4e84f162ab702000000036a6365ffffffff85c2b1a61de4bcbd1d5332d5f59f338dd5e8accbc466fd860f96eef1f54c28ec030000000165ffffffff04f5cabd010000000007000052ac526563c18f1502000000000465510051dc9157050000000008655363ac525253ac506bb600000000000865656a53ab63006a00000000", "006a6a0052", 0, 1186324483, "2f9b7348600336512686e7271c53015d1cb096ab1a5e0bce49acd35bceb42bc8");
-        run_test_sighash("11ce51f90164b4b54b9278f0337d95c50d16f6828fcb641df9c7a041a2b274aa70b1250f2b0000000008ab6a6a65006551524c9fe7f604af44be050000000005525365006521f79a0300000000015306bb4e04000000000265ac99611a05000000000765acab656500006dc866d0", "", 0, -1710478768, "cfa4b7573559b3b199478880c8013fa713ca81ca8754a3fd68a6d7ee6147dc5a");
-        run_test_sighash("86bc233e02ba3c647e356558e7252481a7769491fb46e883dd547a4ce9898fc9a1ca1b77790000000006ab5351abab51f0c1d09c37696d5c7c257788f5dff5583f4700687bcb7d4acfb48521dc953659e325fa390300000003acac5280f29523027225af03000000000963abac0065ab65acab7e59d90400000000016549dac846", "53006aac52acac", 0, 711159875, "880330ccde00991503ea598a6dfd81135c6cda9d317820352781417f89134d85");
-        run_test_sighash("beac155d03a853bf18cd5c490bb2a245b3b2a501a3ce5967945b0bf388fec2ba9f04c03d68030000000012fe96283aec4d3aafed8f888b0f1534bd903f9cd1af86a7e64006a2fa0d2d30711af770010000000163ffffffffd963a19d19a292104b9021c535d3e302925543fb3b5ed39fb2124ee23a9db00302000000056500ac63acffffffff01ad67f503000000000300ac5189f78db2", "53536a636500", 2, 748992863, "bde3dd0575164d7ece3b5783ce0783ffddb7df98f178fe6468683230314f285a");
-        run_test_sighash("489ebbf10478e260ba88c0168bd7509a651b36aaee983e400c7063da39c93bf28100011f280100000004abab63ab2fc856f05f59b257a4445253e0d91b6dffe32302d520ac8e7f6f2467f7f6b4b65f2f59e903000000096353abacab6351656affffffff0122d9480db6c45a2c6fd68b7bc57246edffbf6330c39ccd36aa3aa45ec108fc030000000265ab9a7e78a69aadd6b030b12602dff0739bbc346b466c7c0129b34f50ae1f61e634e11e9f3d0000000006516a53525100ffffffff011271070000000000086563ab6353536352c4dd0e2c", "", 0, -293358504, "4eba3055bc2b58765593ec6e11775cea4b6493d8f785e28d01e2d5470ea71575");
-        run_test_sighash("6911195d04f449e8eade3bc49fd09b6fb4b7b7ec86529918b8593a9f6c34c2f2d301ec378b000000000263ab49162266af054643505b572c24ff6f8e4c920e601b23b3c42095881857d00caf56b28acd030000000565525200ac3ac4d24cb59ee8cfec0950312dcdcc14d1b360ab343e834004a5628d629642422f3c5acc02000000035100accf99b663e3c74787aba1272129a34130668a877cc6516bfb7574af9fa6d07f9b4197303400000000085351ab5152635252ffffffff042b3c95000000000000ff92330200000000046a5252ab884a2402000000000853530065520063000d78be03000000000953abab52ab53ac65aba72cb34b", "6a", 2, -637739405, "6b80d74eb0e7ee59d14f06f30ba7d72a48d3a8ff2d68d3b99e770dec23e9284f");
-        run_test_sighash("746347cf03faa548f4c0b9d2bd96504d2e780292730f690bf0475b188493fb67ca58dcca4f0000000002005336e3521bfb94c254058e852a32fc4cf50d99f9cc7215f7c632b251922104f638aa0b9d080100000008656aac5351635251ffffffff4da22a678bb5bb3ad1a29f97f6f7e5b5de11bb80bcf2f7bb96b67b9f1ac44d09030000000365ababffffffff036f02b30000000000076353ab6aac63ac50b72a050000000002acaba8abf804000000000663006a6a6353797eb999", "acac5100", 1, -1484493812, "164c32a263f357e385bd744619b91c3f9e3ce6c256d6a827d6defcbdff38fa75");
-        run_test_sighash("e17149010239dd33f847bf1f57896db60e955117d8cf013e7553fae6baa9acd3d0f1412ad90200000006516500516500cb7b32a8a67d58dddfb6ceb5897e75ef1c1ff812d8cd73875856487826dec4a4e2d2422a0100000004ac525365196dbb69039229270400000000070000535351636a8b7596020000000006ab51ac52655131e99d040000000003516551ee437f5c", "ac656a53", 1, 1102662601, "8858bb47a042243f369f27d9ab4a9cd6216adeac1c1ac413ed0890e46f23d3f3");
-        run_test_sighash("144971940223597a2d1dec49c7d4ec557e4f4bd207428618bafa3c96c411752d494249e1fb0100000004526a5151ffffffff340a545b1080d4f7e2225ff1c9831f283a7d4ca4d3d0a29d12e07d86d6826f7f0200000003006553ffffffff03c36965000000000000dfa9af00000000000451636aac7f7d140300000000016300000000", "", 1, -108117779, "c84fcaf9d779df736a26cc3cabd04d0e61150d4d5472dd5358d6626e610be57f");
-        run_test_sighash("2aee6b9a02172a8288e02fac654520c9dd9ab93cf514d73163701f4788b4caeeb9297d2e250300000004ab6363008fb36695528d7482710ea2926412f877a3b20acae31e9d3091406bfa6b62ebf9d9d2a6470100000009535165536a63520065ffffffff03f7b560050000000003acab6a9a8338050000000000206ce90000000000056552516a5100000000", "5252", 1, -1102319963, "fa4676c374ae3a417124b4c970d1ed3319dc3ac91fb36efca1aa9ed981a8aa1b");
-        run_test_sighash("9554595203ad5d687f34474685425c1919e3d2cd05cf2dac89d5f33cd3963e5bb43f8706480100000000ffffffff9de2539c2fe3000d59afbd376cb46cefa8bd01dbc43938ff6089b63d68acdc2b02000000096553655251536a6500fffffffff9695e4016cd4dfeb5f7dadf00968e6a409ef048f81922cec231efed4ac78f5d010000000763abab6a5365006caaf0070162cc640200000000045163ab5100000000", "", 0, -1105256289, "e8e10ed162b1a43bfd23bd06b74a6c2f138b8dc1ab094ffb2fa11d5b22869bee");
-        run_test_sighash("04f51f2a0484cba53d63de1cb0efdcb222999cdf2dd9d19b3542a896ca96e23a643dfc45f00200000007acac53510063002b091fd0bfc0cfb386edf7b9e694f1927d7a3cf4e1d2ce937c1e01610313729ef6419ae7030000000165a3372a913c59b8b3da458335dc1714805c0db98992fd0d93f16a7f28c55dc747fe66a5b503000000095351ab65ab52536351ffffffff5650b318b3e236802a4e41ed9bc0a19c32b7aa3f9b2cda1178f84499963a0cde000000000165ffffffff0383954f04000000000553ac536363a8fc90030000000000a2e315000000000005acab00ab5100000000", "0053", 2, -1424653648, "a5bc0356f56b2b41a2314ec05bee7b91ef57f1074bcd2efc4da442222269d1a3");
-        run_test_sighash("53dc1a88046531c7b57a35f4d9adf101d068bf8d63fbbedaf4741dba8bc5e92c8725def571030000000453655251fcdf116a226b3ec240739c4c7493800e4edfe67275234e371a227721eac43d3d9ecaf1b50300000003ac0052ffffffff2c9279ffeea4718d167e9499bd067600715c14484e373ef93ae4a31d2f5671ab0000000009516553ac636a6a65001977752eeba95a8f16b88c571a459c2f2a204e23d48cc7090e4f4cc35846ca7fc0a455ce00000000055165ac0063188143f80205972902000000000765ac63ac516353c7b6a50000000000036a510000000000", "655351536a", 0, 103806788, "b276584d3514e5b4e058167c41dc02915b9d97f6795936a51f40e894ed8508bc");
-        run_test_sighash("5a06cb4602dcfc85f49b8d14513f33c48f67146f2ee44959bbca092788e6823b2719f3160b0200000001ab3c013f2518035b9ea635f9a1c74ec1a3fb7496a160f46aae2e09bfc5cd5111a0f20969e003000000015158c89ab7049f20d6010000000008ac6a52abac53515349765e00000000000300ab638292630100000000045351ab0086da09010000000006656a6365525300000000", "526a63", 1, 1502936586, "bdfaff8a4e775379c5dc26e024968efa805f923de53fa8272dd53ec582afa0c5");
-        run_test_sighash("ca9d84fa0129011e1bf27d7cb71819650b59fb292b053d625c6f02b0339249b498ff7fd4b601000000025352ffffffff032173a0040000000008525253abab5152639473bb030000000009005153526a53535151d085bd0000000000086a5365ab5165655300000000", "005152ac51", 0, 580353445, "c629d93b02037f40aa110e46d903edb34107f64806aa0c418d435926feef68b8");
-        run_test_sighash("e3cdbfb4014d90ae6a4401e85f7ac717adc2c035858bf6ff48979dd399d155bce1f150daea0300000002ac51a67a0d39017f6c71040000000005535200535200000000", "", 0, -1899950911, "c1c7df8206e661d593f6455db1d61a364a249407f88e99ecad05346e495b38d7");
-        run_test_sighash("b2b6b9ab0283d9d73eeae3d847f41439cd88279c166aa805e44f8243adeb3b09e584efb1df00000000026300ffffffff7dfe653bd67ca094f8dab51007c6adaced09de2af745e175b9714ca1f5c68d050000000003ac6500aa8e596903fd3f3204000000000553ac6a6a533a2e210500000000075253acabab526392d0ee020000000008520065635200ab5200000000", "65acacac65005365", 0, 28298553, "39c2aaa2496212b3ab120ab7d7f37c5e852bfe38d20f5226413a2268663eeae8");
-        run_test_sighash("4314339e01de40faabcb1b970245a7f19eedbc17c507dac86cf986c2973715035cf95736ae0200000007abababababab65bde67b900151510b04000000000853ac00655200535300000000", "52", 0, 399070095, "47585dc25469d04ff3a60939d0a03779e3e81a411bf0ca18b91bb925ebd30718");
-        run_test_sighash("f063171b03e1830fdc1d685a30a377537363ccafdc68b42bf2e3acb908dac61ee24b37595c020000000765ac5100ab6aacf447bc8e037b89d6cadd62d960cc442d5ced901d188867b5122b42a862929ce45e7b628d010000000253aba009a1ba42b00f1490b0b857052820976c675f335491cda838fb7934d5eea0257684a2a202000000001e83cf2401a7f777030000000008ab6553526a53526a00000000", "", 2, 1984790332, "c19caada8e71535e29a86fa29cfd9b74a0c7412003fc722a121005e461e01636");
-        run_test_sighash("cf7bdc250249e22cbe23baf6b648328d31773ea0e771b3b76a48b4748d7fbd390e88a004d30000000003ac536a4ab8cce0e097136c90b2037f231b7fde2063017facd40ed4e5896da7ad00e9c71dd70ae600000000096a0063516352525365ffffffff01b71e3e00000000000300536a00000000", "", 1, 546970113, "6a815ba155270af102322c882f26d22da11c5330a751f520807936b320b9af5d");
-        run_test_sighash("ac7a125a0269d35f5dbdab9948c48674616e7507413cd10e1acebeaf85b369cd8c88301b7c030000000963656aac6a530053abffffffffed94c39a582e1a46ce4c6bffda2ccdb16cda485f3a0d94b06206066da12aecfe010000000752abab63536363ef71dcfb02ee07fa0400000000016a6908c802000000000751656a6551abac688c2c2d", "6a6351526551", 0, 858400684, "552ff97d7924f51cda6d1b94be53483153ef725cc0a3a107adbef220c753f9a6");
-        run_test_sighash("3a1f454a03a4591e46cf1f7605a3a130b631bf4dfd81bd2443dc4fac1e0a224e74112884fe0000000005516aac6a53a87e78b55548601ffc941f91d75eab263aa79cd498c88c37fdf275a64feff89fc1710efe03000000016a39d7ef6f2a52c00378b4f8f8301853b61c54792c0f1c4e2cd18a08cb97a7668caa008d970200000002656affffffff017642b20100000000096a63535253abac6a6528271998", "51", 2, 1459585400, "e9a7f21fc2d38be7be47095fbc8f1bf8923660aa4d71df6d797ae0ba5ca4d5b0");
-        run_test_sighash("6269e0fa0173e76e89657ca495913f1b86af5b8f1c1586bcd6c960aede9bc759718dfd5044000000000352ac530e2c7bd90219849b000000000007ab00ab6a53006319f281000000000007ab00515165ac5200000000", "6a", 0, -2039568300, "62094f98234a05bf1b9c7078c5275ed085656856fb5bdfd1b48090e86b53dd85");
-        run_test_sighash("eb2bc00604815b9ced1c604960d54beea4a3a74b5c0035d4a8b6bfec5d0c9108f143c0e99a0000000000ffffffff22645b6e8da5f11d90e5130fd0a0df8cf79829b2647957471d881c2372c527d8010000000263acffffffff1179dbaf17404109f706ae27ad7ba61e860346f63f0c81cb235d2b05d14f2c1003000000025300264cb23aaffdc4d6fa8ec0bb94eff3a2e50a83418a8e9473a16aaa4ef8b855625ed77ef40100000003ac51acf8414ad404dd328901000000000652526500006ab6261c000000000002526a72a4c9020000000006ac526500656586d2e7000000000006656aac00ac5279cd8908", "51", 1, -399279379, "d37532e7b2b8e7db5c7c534197600397ebcc15a750e3af07a3e2d2e4f84b024f");
-        run_test_sighash("eba8b0de04ac276293c272d0d3636e81400b1aaa60db5f11561480592f99e6f6fa13ad387002000000070053acab536563bebb23d66fd17d98271b182019864a90e60a54f5a615e40b643a54f8408fa8512cfac927030000000963ac6a6aabac65ababffffffff890a72192bc01255058314f376bab1dc72b5fea104c154a15d6faee75dfa5dba020000000100592b3559b0085387ac7575c05b29b1f35d9a2c26a0c27903cc0f43e7e6e37d5a60d8305a030000000252abffffffff0126518f05000000000000000000", "005300635252635351", 1, 664344756, "26dc2cba4bd5334e5c0b3a520b44cc1640c6b923d10e576062f1197171724097");
-        run_test_sighash("185cda1a01ecf7a8a8c28466725b60431545fc7a3367ab68e34d486e8ea85ee3128e0d8384000000000465ac63abec88b7bb031c56eb04000000000965636a51005252006a7c78d5040000000007acac63abac51ac3024a40500000000086300526a51abac51464c0e8c", "0065535265515352", 0, 1594558917, "b5280b9610c0625a65b36a8c2402a95019a7bbb9dd3de77f7c3cb1d82c3263ba");
-        run_test_sighash("92c9fb780138abc472e589d5b59489303f234acc838ca66ffcdf0164517a8679bb622a4267020000000153468e373d04de03fa020000000009ac006a5265ab5163006af649050000000007515153006a00658ceb59030000000001ac36afa0020000000009ab53006351ab51000000000000", "6a", 0, 2059357502, "e2358dfb51831ee81d7b0bc602a65287d6cd2dbfacf55106e2bf597e22a4b573");
-        run_test_sighash("6f62138301436f33a00b84a26a0457ccbfc0f82403288b9cbae39986b34357cb2ff9b889b302000000045253655335a7ff6701bac9960400000000086552ab656352635200000000", "6aac51", 0, 1444414211, "502a2435fd02898d2ff3ab08a3c19078414b32ec9b73d64a944834efc9dae10c");
-        run_test_sighash("9981143a040a88c2484ac3abe053849e72d04862120f424f373753161997dd40505dcb4783030000000700536365536565a2e10da3f4b1c1ad049d97b33f0ae0ea48c5d7c30cc8810e144ad93be97789706a5ead180100000003636a00ffffffffbdcbac84c4bcc87f03d0ad83fbe13b369d7e42ddb3aecf40870a37e814ad8bb5010000000963536a5100636a53abffffffff883609905a80e34202101544f69b58a0b4576fb7391e12a769f890eef90ffb72020000000651656352526affffffff04243660000000000004ab5352534a9ce001000000000863656363ab6a53652df19d030000000003ac65acedc51700000000000000000000", "ac6300acac", 2, 293672388, "7ba99b289c04718a7283f150d831175ed6303081e191a0608ea81f78926c5bdf");
-        run_test_sighash("49f7d0b6037bba276e910ad3cd74966c7b3bc197ffbcfefd6108d6587006947e97789835ea0300000008526a52006a650053ffffffff8d7b6c07cd10f4c4010eac7946f61aff7fb5f3920bdf3467e939e58a1d4100ab03000000076aac63ac535351ffffffff8f48c3ba2d52ad67fbcdc90d8778f3c8a3894e3c35b9730562d7176b81af23c80100000003ab5265ffffffff0301e3ef0300000000046a525353e899ac0500000000075153ab6a65abac259bea0400000000007b739972", "53516aacac6aac", 1, 955403557, "5d366a7f4346ae18aeb7c9fc4dab5af71173184aa20ed22fcb4ea8511ad25449");
-        run_test_sighash("58a4fed801fbd8d92db9dfcb2e26b6ff10b120204243fee954d7dcb3b4b9b53380e7bb8fb60100000003006351ffffffff02a0795b050000000006536351ac6aac2718d00200000000075151acabac515354d21ba1", "005363515351", 0, -1322430665, "bbee941bbad950424bf40e3623457db47f60ed29deaa43c99dec702317cb3326");
-        run_test_sighash("17fad0d303da0d764fedf9f2887a91ea625331b28704940f41e39adf3903d8e75683ef6d46020000000151ffffffffff376eea4e880bcf0f03d33999104aafed2b3daf4907950bb06496af6b51720a020000000900636a63525253525196521684f3b08497bad2c660b00b43a6a517edc58217876eb5e478aa3b5fda0f29ee1bea00000000046aacab6affffffff03dde8e2050000000007ac5365ac51516a14772e000000000005630000abacbbb360010000000006ab5251ab656a50f180f0", "0053", 0, -1043701251, "a3bdf8771c8990971bff9b4e7d59b7829b067ed0b8d3ac1ec203429811384668");
-        run_test_sighash("5a2257df03554550b774e677f348939b37f8e765a212e566ce6b60b4ea8fed4c9504b7f7d1000000000653655265ab5258b67bb931df15b041177cf9599b0604160b79e30f3d7a594e7826bae2c29700f6d8f8f40300000005515300ac6a159cf8808a41f504eb5c2e0e8a9279f3801a5b5d7bc6a70515fbf1c5edc875bb4c9ffac500000000050063510052ffffffff0422a90105000000000965006a650000516a006417d2020000000006526363ab00524d969d0100000000035153acc4f077040000000005ac5200636500000000", "6a52", 1, -1482463464, "37b794b05d0687c9b93d5917ab068f6b2f0e38406ff04e7154d104fc1fb14cdc");
-        run_test_sighash("e0032ad601269154b3fa72d3888a3151da0aed32fb2e1a15b3ae7bee57c3ddcffff76a1321010000000100110d93ae03f5bd080100000000075263516a6551002871e60100000000046a005252eaa753040000000004ab6aab526e325c71", "630052", 0, -1857873018, "ea117348e94de86381bb8ad1c7f93b8c623f0272104341701bb54e6cb433596c");
-        run_test_sighash("014b2a5304d46764817aca180dca50f5ab25f2e0d5749f21bb74a2f8bf6b8b7b3fa8189cb7030000000965ac5165ab6a51ac6360ecd91e8abc7e700a4c36c1a708a494c94bb20cbe695c408543146566ab22be43beae9103000000045163ab00ffffffffffa48066012829629a9ec06ccd4905a05df0e2b745b966f6a269c9c8e13451fc00000000026565ffffffffc40ccadc21e65fe8a4b1e072f4994738ccaf4881ae6fede2a2844d7da4d199ab02000000065152ab536aabffffffff01b6e054030000000004515352ab3e063432", "", 0, 1056459916, "a7aff48f3b8aeb7a4bfe2e6017c80a84168487a69b69e46681e0d0d8e63a84b6");
-        run_test_sighash("1201ab5d04f89f07c0077abd009762e59db4bb0d86048383ba9e1dad2c9c2ad96ef660e6d00200000007ab6a65ac5200652466fa5143ab13d55886b6cdc3d0f226f47ec1c3020c1c6e32602cd3428aceab544ef43e00000000086a6a6a526a6a5263ffffffffd5be0b0be13ab75001243749c839d779716f46687e2e9978bd6c9e2fe457ee48020000000365abab1e1bac0f72005cf638f71a3df2e3bbc0fa35bf00f32d9c7dc9c39a5e8909f7d53170c8ae0200000008ab6a51516363516affffffff02f0a6210500000000036300ac867356010000000009acab65ac6353536a659356d367", "ac53535252", 0, 917543338, "418acc156c2bc76a5d7baa58db29f1b4cf6c266c9222ed167ef5b4d47f0e0f41");
-        run_test_sighash("344fa11e01c19c4dd232c77742f0dd0aeb3695f18f76da627628741d0ee362b0ea1fb3a2180200000007635151005100529bab25af01937c1f0500000000055153ab53656e7630af", "6351005163ac51", 0, -629732125, "228ca52a0a376fe0527a61cfa8da6d7baf87486bba92d49dfd3899cac8a1034f");
-        run_test_sighash("b2fda1950191358a2b855f5626a0ebc830ab625bea7480f09f9cd3b388102e35c0f303124c030000000565ac65ab53ffffffff03f9c5ec04000000000765ab51516551650e2b9f0500000000045365525284e8f6040000000001ac00000000", "ac51655253", 0, 1433027632, "d2fa7e13c34cecda5105156bd2424c9b84ee0a07162642b0706f83243ff811a8");
-        run_test_sighash("a4a6bbd201aa5d882957ac94f2c74d4747ae32d69fdc765add4acc2b68abd1bdb8ee333d6e0300000008516a6552515152abffffffff02c353cb040000000007ac6351ab51536588bd320500000000066552525253ac00000000", "", 0, 1702060459, "499da7d74032388f820645191ac3c8d20f9dba8e8ded7fa3a5401ea2942392a1");
-        run_test_sighash("83a583d204d926f2ee587a83dd526cf1e25a44bb668e45370798f91a2907d184f7cddcbbc7030000000700ab6565536a539f71d3776300dffdfa0cdd1c3784c9a1f773e34041ca400193612341a9c42df64e3f550e01000000050052515251ffffffff52dab2034ab0648553a1bb8fc4e924b2c89ed97c18dfc8a63e248b454035564b01000000015139ab54708c7d4d2c2886290f08a5221cf69592a810fd1979d7b63d35c271961e710424fd0300000005ac65ac5251ffffffff01168f7c030000000000a85e5fb0", "6a536353656a00", 0, 179595345, "5350a31ac954a0b49931239d0ecafbf34d035a537fd0c545816b8fdc355e9961");
-        run_test_sighash("ffd35d51042f290108fcb6ea49a560ba0a6560f9181da7453a55dfdbdfe672dc800b39e7320200000006630065516a65f2166db2e3827f44457e86dddfd27a8af3a19074e216348daa0204717d61825f198ec0030100000006ab51abab00abffffffffdf41807adb7dff7db9f14d95fd6dc4e65f8402c002d009a3f1ddedf6f4895fc8030000000500ab006a65a5a848345052f860620abd5fcd074195548ce3bd0839fa9ad8642ed80627bf43a0d47dbd010000000765ab006a656a53b38cdd6502a186da05000000000765ab00ab006a53527c0e0100000000085365ab51acacac52534bd1b1", "6a635253ac0000", 0, 1095082149, "3c05473a816621a3613f0e903faa1a1e44891dd40862b029e41fc520776350fa");
-        run_test_sighash("6c9a4b98013c8f1cae1b1df9f0f2de518d0c50206a0ab871603ac682155504c0e0ce946f460100000000ffffffff04e9266305000000000753535100ac6aacded39e04000000000365ac6ab93ccd010000000002515397bf3d050000000003ab636300000000", "63520052ac656353", 0, -352633155, "936eff8cdfd771be24124da87c7b24feb48da7cbc2c25fb5ba13d1a23255d902");
-        run_test_sighash("c4b80f850323022205b3e1582f1ed097911a81be593471a8dce93d5c3a7bded92ef6c7c1260100000002006affffffff70294d62f37c3da7c5eae5d67dce6e1b28fedd7316d03f4f48e1829f78a88ae801000000096a5200530000516351f6b7b544f7c39189d3a2106ca58ce4130605328ce7795204be592a90acd81bef517d6f170200000000ffffffff012ab8080000000000075100006365006335454c1e", "53ac6a536aacac", 0, -1124103895, "06277201504e6bf8b8c94136fad81b6e3dadacb9d4a2c21a8e10017bfa929e0e");
-        run_test_sighash("8ab69ed50351b47b6e04ac05e12320984a63801716739ed7a940b3429c9c9fed44d3398ad40300000006536a516a52638171ef3a46a2adb8025a4884b453889bc457d63499971307a7e834b0e76eec69c943038a0300000000ffffffff566bb96f94904ed8d43d9d44a4a6301073cef2c011bf5a12a89bedbaa03e4724030000000265acb606affd01edea38050000000008515252516aacac6300000000", "65000000006365ac53", 0, -1338942849, "7912573937824058103cb921a59a7f910a854bf2682f4116a393a2045045a8c3");
-        run_test_sighash("2484991e047f1cf3cfe38eab071f915fe86ebd45d111463b315217bf9481daf0e0d10902a402000000006e71a424eb1347ffa638363604c0d5eccbc90447ff371e000bf52fc743ec832851bb564a0100000001abffffffffef7d014fad3ae7927948edbbb3afe247c1bcbe7c4c8f5d6cf97c799696412612020000000851536a5353006a001dfee0d7a0dd46ada63b925709e141863f7338f34f7aebde85d39268ae21b77c3068c01d0000000008535151ab00636563ffffffff018478070200000000095200635365ac52ab5341b08cd3", "", 3, 265623923, "24cb420a53b4f8bb477f7cbb293caabfd2fc47cc400ce37dbbab07f92d3a9575");
-        run_test_sighash("54839ef9026f65db30fc9cfcb71f5f84d7bb3c48731ab9d63351a1b3c7bc1e7da22bbd508e0300000000442ad138f170e446d427d1f64040016032f36d8325c3b2f7a4078766bdd8fb106e52e8d20000000003656500ffffffff02219aa101000000000851ababac52ab00659646bd02000000000552acacabac24c394a5", "ac", 0, 906807497, "69264faadcd1a581f7000570a239a0a26b82f2ad40374c5b9c1f58730514de96");
-        run_test_sighash("5036d7080434eb4eef93efda86b9131b0b4c6a0c421e1e5feb099a28ff9dd8477728639f77030000000951516aab535152ab5391429be9cce85d9f3d358c5605cf8c3666f034af42740e94d495e28b9aaa1001ba0c87580300000008006552ab00ab006affffffffd838978e10c0c78f1cd0a0830d6815f38cdcc631408649c32a25170099669daa0000000002acab8984227e804ad268b5b367285edcdf102d382d027789250a2c0641892b480c21bf84e3fb0100000000b518041e023d8653010000000001004040fb0100000000080051ac5200636a6300000000", "52ac", 0, 366357656, "bd0e88829afa6bdc1e192bb8b2d9d14db69298a4d81d464cbd34df0302c634c6");
-        run_test_sighash("9ad5ccf503fa4facf6a27b538bc910cce83c118d6dfd82f3fb1b8ae364a1aff4dcefabd38f03000000096365655263ac655300807c48130c5937190a996105a69a8eba585e0bd32fadfc57d24029cbed6446d30ebc1f100100000004000053650f0ccfca1356768df7f9210cbf078a53c72e0712736d9a7a238e0115faac0ca383f219d0010000000600ab536552002799982b0221b8280000000000000c41320000000000086552ac6365636a6595f233a3", "6a5152", 2, 553208588, "f99c29a79f1d73d2a69c59abbb5798e987639e36d4c44125d8dc78a94ddcfb13");
-        run_test_sighash("669538a204047214ce058aed6a07ca5ad4866c821c41ac1642c7d63ed0054f84677077a84f030000000853abacab6a655353ffffffff70c2a071c115282924e3cb678b13800c1d29b6a028b3c989a598c491bc7c76c5030000000752ac52ac5163ac80420e8a6e43d39af0163271580df6b936237f15de998e9589ec39fe717553d415ac02a4030000000463635153184ad8a5a4e69a8969f71288c331aff3c2b7d1b677d2ebafad47234840454b624bf7ac1d03000000056a63abab63df38c24a02fbc63a040000000002ab535ec3dc050000000002536500000000", "635153", 3, -190399351, "9615541884dfb1feeb08073a6a6aa73ef694bc5076e52187fdf4138a369f94d9");
-        run_test_sighash("972128b904e7b673517e96e98d80c0c8ceceae76e2f5c126d63da77ffd7893fb53308bb2da0300000006ac6552ab52acffffffff4cac767c797d297c079a93d06dc8569f016b4bf7a7d79b605c526e1d36a40e2202000000095365ab636aac6a6a6a69928d2eddc836133a690cfb72ec2d3115bf50fb3b0d10708fa5d2ebb09b4810c426a1db01000000060052526300001e8e89585da7e77b2dd2e30625887f0660accdf29e53a614d23cf698e6fc8ab03310e87700000000076a520051acac6555231ddb0330ec2d03000000000200abfaf457040000000004ab6a6352bdc42400000000000153d6dd2f04", "", 0, 209234698, "4a92fec1eb03f5bd754ee9bfd70707dc4420cc13737374f4675f48529be518e4");
-        run_test_sighash("5374f0c603d727f63006078bd6c3dce48bd5d0a4b6ea00a47e5832292d86af258ea0825c260000000009655353636352526a6af2221067297d42a9f8933dfe07f61a574048ff9d3a44a3535cd8eb7de79fb7c45b6f47320200000003ac006affffffff153d917c447d367e75693c5591e0abf4c94bbdd88a98ab8ad7f75bfe69a08c470200000005ac65516365ffffffff037b5b7b000000000001515dc4d904000000000004bb26010000000004536a6aac00000000", "516552516352ac", 2, 328538756, "8bb7a0129eaf4b8fc23e911c531b9b7637a21ab11a246352c6c053ff6e93fcb6");
-        run_test_sighash("c441132102cc82101b6f31c1025066ab089f28108c95f18fa67db179610247086350c163bd010000000651525263ab00ffffffff9b8d56b1f16746f075249b215bdb3516cbbe190fef6292c75b1ad8a8988897c3000000000751ab6553abab00ffffffff02f9078b000000000009ab0053ac51ac00ab51c0422105000000000651006563525200000000", "ac51", 0, -197051790, "55acd8293ed0be6792150a3d7ced6c5ccd153ca7daf09cee035c1b0dac92bb96");
-        run_test_sighash("8bff9d170419fa6d556c65fa227a185fe066efc1decf8a1c490bc5cbb9f742d68da2ab7f320100000007ab000053525365a7a43a80ab9593b9e8b6130a7849603b14b5c9397a190008d89d362250c3a2257504eb810200000007acabacac00ab51ee141be418f003e75b127fd3883dbf4e8c3f6cd05ca4afcaac52edd25dd3027ae70a62a00000000008ac52526a5200536affffffffb8058f4e1d7f220a1d1fa17e96d81dfb9a304a2de4e004250c9a576963a586ae0300000005abacac5363b9bc856c039c01d804000000000951656aac53005365acb0724e00000000000565abab63acea7c7a0000000000036a00ac00000000", "6565", 1, -1349282084, "2b822737c2affeefae13451d7c9db22ff98e06490005aba57013f6b9bbc97250");
-        run_test_sighash("0e1633b4041c50f656e882a53fde964e7f0c853b0ada0964fc89ae124a2b7ffc5bc97ea6230100000006ac6aacacabacffffffff2e35f4dfcad2d53ea1c8ada8041d13ea6c65880860d96a14835b025f76b1fbd9000000000351515121270867ef6bf63a91adbaf790a43465c61a096acc5a776b8e5215d4e5cd1492e611f761000000000600ac6aab5265ffffffff63b5fc39bcac83ca80ac36124abafc5caee608f9f63a12479b68473bd4bae769000000000965ac52acac5263acabffffffff0163153e020000000008ab005165ab65515300000000", "6a6aac00", 0, -968477862, "20732d5073805419f275c53784e78db45e53332ee618a9fcf60a3417a6e2ca69");
-        run_test_sighash("2b052c24022369e956a8d318e38780ef73b487ba6a8f674a56bdb80a9a63634c6110fb5154010000000251acffffffff48fe138fb7fdaa014d67044bc05940f4127e70c113c6744fbd13f8d51d45143e01000000005710db3804e01aa9030000000008acac6a516a5152abfd55aa01000000000751ab510000ac636d6026010000000000b97da9000000000000fddf3b53", "006552", 0, 595461670, "685d67d84755906d67a007a7d4fa311519467b9bdc6a351913246a41e082a29f");
-        run_test_sighash("7888b71403f6d522e414d4ca2e12786247acf3e78f1918f6d727d081a79813d129ee8befce0100000009ab516a6353ab6365abffffffff4a882791bf6400fda7a8209fb2c83c6eef51831bdf0f5dacde648859090797ec030000000153ffffffffbb08957d59fa15303b681bad19ccf670d7d913697a2f4f51584bf85fcf91f1f30200000008526565ac52ac63acffffffff0227c0e8050000000001ac361dc801000000000800515165ab00ab0000000000", "656a", 2, 1869281295, "f43378a0b7822ad672773944884e866d7a46579ee34f9afc17b20afc1f6cf197");
-        run_test_sighash("cc4dda57047bd0ca6806243a6a4b108f7ced43d8042a1acaa28083c9160911cf47eab910c40200000007526a0000ab6a63e4154e581fcf52567836c9a455e8b41b162a78c85906ccc1c2b2b300b4c69caaaa2ba0230300000008ab5152ac5100ab65ffffffff69696b523ed4bd41ecd4d65b4af73c9cf77edf0e066138712a8e60a04614ea1c0300000004ab6a000016c9045c7df7836e05ac4b2e397e2dd72a5708f4a8bf6d2bc36adc5af3cacefcf074b8b403000000065352ac5252acffffffff01d7e380050000000000cf4e699a", "525163656351", 1, -776533694, "ff18c5bffd086e00917c2234f880034d24e7ea2d1e1933a28973d134ca9e35d2");
-        run_test_sighash("b7877f82019c832707a60cf14fba44cfa254d787501fdd676bd58c744f6e951dbba0b3b77f0200000009ac515263ac53525300a5a36e500148f89c0500000000085265ac6a6a65acab00000000", "6563", 0, -1785108415, "cb6e4322955af12eb29613c70e1a00ddbb559c887ba844df0bcdebed736dffbd");
-        run_test_sighash("aeb14046045a28cc59f244c2347134d3434faaf980961019a084f7547218785a2bd03916f3000000000165f852e6104304955bda5fa0b75826ee176211acc4a78209816bbb4419feff984377b2352200000000003a94a5032df1e0d60390715b4b188c330e4bb7b995f07cdef11ced9d17ee0f60bb7ffc8e0100000002516513e343a5c1dc1c80cd4561e9dddad22391a2dbf9c8d2b6048e519343ca1925a9c6f0800a020000000665516365ac513180144a0290db27000000000006ab655151ab5138b187010000000007ab5363abac516a9e5cd98a", "53ac", 0, 478591320, "e8d89a302ae626898d4775d103867a8d9e81f4fd387af07212adab99946311ef");
-        run_test_sighash("57a5a04c0278c8c8e243d2df4bb716f81d41ac41e2df153e7096f5682380c4f441888d9d260300000004ab63ab6afdbe4203525dff42a7b1e628fe22bccaa5edbb34d8ab02faff198e085580ea5fcdb0c61b0000000002ac6affffffff03375e6c05000000000663ab516a6a513cb6260400000000007ca328020000000006516a636a52ab94701cc7", "0053ac5152", 0, -550925626, "b7ca991ab2e20d0158168df2d3dd842a57ab4a3b67cca8f45b07c4b7d1d11126");
-        run_test_sighash("7e27c42d0279c1a05eeb9b9faedcc9be0cab6303bde351a19e5cbb26dd0d594b9d74f40d2b020000000200518c8689a08a01e862d5c4dcb294a2331912ff11c13785be7dce3092f154a005624970f84e0200000000500cf5a601e74c1f0000000000076aab52636a6a5200000000", "6500006a5351", 0, 449533391, "535ba819d74770d4d613ee19369001576f98837e18e1777b8246238ff2381dd0");
-        run_test_sighash("2b3470dd028083910117f86614cdcfb459ee56d876572510be4df24c72e8f58c70d5f5948b03000000066aab65635265da2c3aac9d42c9baafd4b655c2f3efc181784d8cba5418e053482132ee798408ba43ccf90300000000ffffffff047dda4703000000000765516a52ac53009384a603000000000651636a63ab6a8cf57a03000000000352ab6a8cf6a405000000000952636a6a6565525100661e09cb", "ac520063ac6a6a52", 1, 1405647183, "9b360c3310d55c845ef537125662b9fe56840c72136891274e9fedfef56f9bb5");
-        run_test_sighash("3a5644a9010f199f253f858d65782d3caec0ac64c3262b56893022b9796086275c9d4d097b02000000009d168f7603a67b30050000000007ac51536a0053acd9d88a050000000007655363535263ab3cf1f403000000000352ac6a00000000", "005363536565acac6a", 0, -1383947195, "6390ab0963cf611e0cea35a71dc958b494b084e6fd71d22217fdc5524787ade6");
-        run_test_sighash("bda1ff6804a3c228b7a12799a4c20917301dd501c67847d35da497533a606701ad31bf9d5e0300000001ac16a6c5d03cf516cd7364e4cbbf5aeccd62f8fd03cb6675883a0636a7daeb650423cb1291010000000500656553ac4a63c30b6a835606909c9efbae1b2597e9db020c5ecfc0642da6dc583fba4e84167539a8020000000865525353515200acffffffff990807720a5803c305b7da08a9f24b92abe343c42ac9e917a84e1f335aad785d00000000026a52ffffffff04981f20030000000001ab8c762200000000000253ab690b9605000000000151ce88b301000000000753526a6a51006500000000", "000052ac52530000", 1, -1809193140, "5299b0fb7fc16f40a5d6b337e71fcd1eb04d2600aefd22c06fe9c71fe0b0ba54");
-        run_test_sighash("db4904e6026b6dd8d898f278c6428a176410d1ffbde75a4fa37cda12263108ccd4ca6137440100000007656a0000515263ffffffff1db7d5005c1c40da0ed17b74cf6b2a6ee2c33c9e0bacda76c0da2017dcac2fc70200000004abab6a53ffffffff0454cf2103000000000153463aef000000000009ab6a630065ab52636387e0ed050000000000e8d16f05000000000352ac63e4521b22", "", 1, 1027042424, "48315a95e49277ab6a2d561ee4626820b7bab919eea372b6bf4e9931ab221d04");
-        run_test_sighash("dca31ad10461ead74751e83d9a81dcee08db778d3d79ad9a6d079cfdb93919ac1b0b61871102000000086500525365ab51ac7f7e9aed78e1ef8d213d40a1c50145403d196019985c837ffe83836222fe3e5955e177e70100000006525152525300ffffffff5e98482883cc08a6fe946f674cca479822f0576a43bf4113de9cbf414ca628060100000006ac53516a5253ffffffff07490b0b898198ec16c23b75d606e14fa16aa3107ef9818594f72d5776805ec502000000036a0052ffffffff01932a2803000000000865ab6551ac6a516a2687aa06", "635300ac", 2, -1880362326, "74d6a2fa7866fd8b74b2e34693e2d6fd690410384b7afdcd6461b1ae71d265ce");
-        run_test_sighash("e14e1a9f0442ab44dfc5f6d945ad1ff8a376bc966aad5515421e96ddbe49e529614995cafc03000000055165515165fffffffff97582b8290e5a5cfeb2b0f018882dbe1b43f60b7f45e4dd21dbd3a8b0cfca3b0200000000daa267726fe075db282d694b9fee7d6216d17a8c1f00b2229085495c5dc5b260c8f8cd5d000000000363ac6affffffffaab083d22d0465471c896a438c6ac3abf4d383ae79420617a8e0ba8b9baa872b010000000963526563ac5363ababd948b5ce022113440200000000076a636552006a53229017040000000000e6f62ac8", "526353636a65", 3, -485265025, "1bc8ad76f9b7c366c5d052dc479d6a8a2015566d3a42e93ab12f727692c89d65");
-        run_test_sighash("69df842a04c1410bfca10896467ce664cfa31c681a5dac10106b34d4b9d4d6d0dc1eac01c1000000000551536a5165269835ca4ad7268667b16d0a2df154ec81e304290d5ed69e0069b43f8c89e673328005e200000000076a5153006aacabffffffffc9314bd80b176488f3d634360fcba90c3a659e74a52e100ac91d3897072e3509010000000765abac51636363ffffffff0e0768b13f10f0fbd2fa3f68e4b4841809b3b5ba0e53987c3aaffcf09eee12bf0300000008ac535263526a53ac514f4c2402da8fab0400000000001ef15201000000000451526a52d0ec9aca", "525365ac52", 1, 313967049, "a72a760b361af41832d2c667c7488dc9702091918d11e344afc234a4aea3ec44");
-        run_test_sighash("e4fec9f10378a95199c1dd23c6228732c9de0d7997bf1c83918a5cfd36012476c0c3cba24002000000085165536500ac0000ad08ab93fb49d77d12a7ccdbb596bc5110876451b53a79fdce43104ff1c316ad63501de801000000046a6352ab76af9908463444aeecd32516a04dd5803e02680ed7f16307242a794024d93287595250f4000000000089807279041a82e603000000000200521429100200000000055253636a63f20b940400000000004049ed04000000000500ab5265ab43dfaf7d", "6563526aac", 2, -1923470368, "32f3c012eca9a823bebb9b282240aec40ca65df9f38da43b1dcfa0cac0c0df7e");
-        run_test_sighash("4000d3600100b7a3ff5b41ec8d6ccdc8b2775ad034765bad505192f05d1f55d2bc39d0cbe10100000007ab5165ac6a5163ffffffff034949150100000000026a6a92c9f6000000000008ab6553ab6aab635200e697040000000007636a5353525365237ae7d2", "52000063", 0, -880046683, "c76146f68f43037289aaeb2bacf47408cddc0fb326b350eb4f5ef6f0f8564793");
-        run_test_sighash("eabc0aa701fe489c0e4e6222d72b52f083166b49d63ad1410fb98caed027b6a71c02ab830c03000000075253ab63530065ffffffff01a5dc0b05000000000253533e820177", "", 0, 954499283, "1d849b92eedb9bf26bd4ced52ce9cb0595164295b0526842ab1096001fcd31b1");
-        run_test_sighash("d48d55d304aad0139783b44789a771539d052db565379f668def5084daba0dfd348f7dcf6b00000000006826f59e5ffba0dd0ccbac89c1e2d69a346531d7f995dea2ca6d7e6d9225d81aec257c6003000000096a655200ac656552acffffffffa188ffbd5365cae844c8e0dea6213c4d1b2407274ae287b769ab0bf293e049eb0300000005ac6a6aab51ad1c407c5b116ca8f65ed496b476183f85f072c5f8a0193a4273e2015b1cc288bf03e9e2030000000252abffffffff04076f44040000000006655353abab53be6500050000000003ac65ac3c15040500000000095100ab536353516a52ed3aba04000000000900ac53ab53636aabac00000000", "5253526563acac", 2, -1506108646, "bbee17c8582514744bab5df50012c94b0db4aff5984d2e13a8d09421674404e2");
-        run_test_sighash("9746f45b039bfe723258fdb6be77eb85917af808211eb9d43b15475ee0b01253d33fc3bfc502000000065163006a655312b12562dc9c54e11299210266428632a7d0ee31d04dfc7375dcad2da6e9c11947ced0e000000000009074095a5ac4df057554566dd04740c61490e1d3826000ad9d8f777a93373c8dddc4918a00000000025351ffffffff01287564030000000004636a00ab00000000", "52", 2, -1380411075, "84af1623366c4db68d81f452b86346832344734492b9c23fbb89015e516c60b2");
-        run_test_sighash("df0a32ae01c4672fd1abd0b2623aae0a1a8256028df57e532f9a472d1a9ceb194267b6ee190200000009536a6a51516a525251b545f9e803469a2302000000000465526500810631040000000000441f5b050000000006530051006aaceb183c76", "536a635252ac6a", 0, 1601138113, "9a0435996cc58bdba09643927fe48c1fc908d491a050abbef8daec87f323c58f");
-        run_test_sighash("b1c0b71804dff30812b92eefb533ac77c4b9fdb9ab2f77120a76128d7da43ad70c20bbfb990200000002536392693e6001bc59411aebf15a3dc62a6566ec71a302141b0c730a3ecc8de5d76538b30f55010000000665535252ac514b740c6271fb9fe69fdf82bf98b459a7faa8a3b62f3af34943ad55df4881e0d93d3ce0ac0200000000c4158866eb9fb73da252102d1e64a3ce611b52e873533be43e6883137d0aaa0f63966f060000000001abffffffff04a605b604000000000851006a656a630052f49a0300000000000252515a94e1050000000009abac65ab0052abab00fd8dd002000000000651535163526a2566852d", "ac5363", 0, -1718831517, "b0dc030661783dd9939e4bf1a6dfcba809da2017e1b315a6312e5942d714cf05");
-        run_test_sighash("3657e4260304ccdc19936e47bdf058d36167ee3d4eb145c52b224eff04c9eb5d1b4e434dfc0000000001ab58aefe57707c66328d3cceef2e6f56ab6b7465e587410c5f73555a513ace2b232793a74400000000036a006522e69d3a785b61ad41a635d59b3a06b2780a92173f85f8ed428491d0aaa436619baa9c4501000000046351abab2609629902eb7793050000000000a1b967040000000003525353a34d6192", "516a", 0, -1761874713, "0a2ff41f6d155d8d0e37cd9438f3b270df9f9214cda8e95c76d5a239ca189df2");
-        run_test_sighash("a0eb6dc402994e493c787b45d1f946d267b09c596c5edde043e620ce3d59e95b2b5b93d43002000000096a5252526aac63ab6555694287a279e29ee491c177a801cd685b8744a2eab83824255a3bcd08fc0e3ea13fb8820000000009abab6365ab52ab0063ffffffff029e424a040000000008acab53ab516a636a23830f0400000000016adf49c1f9", "ac0065ac6500005252", 1, 669294500, "e05e3d383631a7ed1b78210c13c2eb26564e5577db7ddfcea2583c7c014091d4");
-        run_test_sighash("6e67c0d3027701ef71082204c85ed63c700ef1400c65efb62ce3580d187fb348376a23e9710200000001655b91369d3155ba916a0bc6fe4f5d94cad461d899bb8aaac3699a755838bfc229d6828920010000000765536353526a52ffffffff04c0c792000000000005650052535372f79e000000000001527fc0ee010000000005ac5300ab65d1b3e902000000000251aba942b278", "6a5151", 0, 1741407676, "e657e2c8ec4ebc769ddd3198a83267b47d4f2a419fc737e813812acefad92ff7");
-        run_test_sighash("8f53639901f1d643e01fc631f632b7a16e831d846a0184cdcda289b8fa7767f0c292eb221a00000000046a53abacffffffff037a2daa01000000000553ac6a6a51eac349020000000005ac526552638421b3040000000007006a005100ac63048a1492", "ac65", 0, 1033685559, "da86c260d42a692358f46893d6f91563985d86eeb9ea9e21cd38c2d8ffcfcc4d");
-        run_test_sighash("b3cad3a7041c2c17d90a2cd994f6c37307753fa3635e9ef05ab8b1ff121ca11239a0902e700300000009ab635300006aac5163ffffffffcec91722c7468156dce4664f3c783afef147f0e6f80739c83b5f09d5a09a57040200000004516a6552ffffffff969d1c6daf8ef53a70b7cdf1b4102fb3240055a8eaeaed2489617cd84cfd56cf020000000352ab53ffffffff46598b6579494a77b593681c33422a99559b9993d77ca2fa97833508b0c169f80200000009655300655365516351ffffffff04d7ddf800000000000853536a65ac6351ab09f3420300000000056aab65abac33589d04000000000952656a65655151acac944d6f0400000000006a8004ba", "005165", 1, 1035865506, "fe1dc9e8554deecf8f50c417c670b839cc9d650722ebaaf36572418756075d58");
-        run_test_sighash("cf781855040a755f5ba85eef93837236b34a5d3daeb2dbbdcf58bb811828d806ed05754ab8010000000351ac53ffffffffda1e264727cf55c67f06ebcc56dfe7fa12ac2a994fecd0180ce09ee15c480f7d00000000096351516a51acac00ab53dd49ff9f334befd6d6f87f1a832cddfd826a90b78fd8cf19a52cb8287788af94e939d6020000000700525251ac526310d54a7e8900ed633f0f6f0841145aae7ee0cbbb1e2a0cae724ee4558dbabfdc58ba6855010000000552536a53abfd1b101102c51f910500000000096300656a525252656a300bee010000000009ac52005263635151abe19235c9", "53005365", 2, 1422854188, "d5981bd4467817c1330da72ddb8760d6c2556cd809264b2d85e6d274609fc3a3");
-    }
-
-    #[test]
-    #[cfg(feature="bitcoinconsensus")]
-    fn test_transaction_verify () {
-        use hex::decode as hex_decode;
-        use std::collections::HashMap;
-        use blockdata::script;
-        // a random recent segwit transaction from blockchain using both old and segwit inputs
-        let mut spending: Transaction = deserialize(hex_decode("020000000001031cfbc8f54fbfa4a33a30068841371f80dbfe166211242213188428f437445c91000000006a47304402206fbcec8d2d2e740d824d3d36cc345b37d9f65d665a99f5bd5c9e8d42270a03a8022013959632492332200c2908459547bf8dbf97c65ab1a28dec377d6f1d41d3d63e012103d7279dfb90ce17fe139ba60a7c41ddf605b25e1c07a4ddcb9dfef4e7d6710f48feffffff476222484f5e35b3f0e43f65fc76e21d8be7818dd6a989c160b1e5039b7835fc00000000171600140914414d3c94af70ac7e25407b0689e0baa10c77feffffffa83d954a62568bbc99cc644c62eb7383d7c2a2563041a0aeb891a6a4055895570000000017160014795d04cc2d4f31480d9a3710993fbd80d04301dffeffffff06fef72f000000000017a91476fd7035cd26f1a32a5ab979e056713aac25796887a5000f00000000001976a914b8332d502a529571c6af4be66399cd33379071c588ac3fda0500000000001976a914fc1d692f8de10ae33295f090bea5fe49527d975c88ac522e1b00000000001976a914808406b54d1044c429ac54c0e189b0d8061667e088ac6eb68501000000001976a914dfab6085f3a8fb3e6710206a5a959313c5618f4d88acbba20000000000001976a914eb3026552d7e3f3073457d0bee5d4757de48160d88ac0002483045022100bee24b63212939d33d513e767bc79300051f7a0d433c3fcf1e0e3bf03b9eb1d70220588dc45a9ce3a939103b4459ce47500b64e23ab118dfc03c9caa7d6bfc32b9c601210354fd80328da0f9ae6eef2b3a81f74f9a6f66761fadf96f1d1d22b1fd6845876402483045022100e29c7e3a5efc10da6269e5fc20b6a1cb8beb92130cc52c67e46ef40aaa5cac5f0220644dd1b049727d991aece98a105563416e10a5ac4221abac7d16931842d5c322012103960b87412d6e169f30e12106bdf70122aabb9eb61f455518322a18b920a4dfa887d30700")
-            .unwrap().as_slice()).unwrap();
-        let spent1: Transaction = deserialize(hex_decode("020000000001040aacd2c49f5f3c0968cfa8caf9d5761436d95385252e3abb4de8f5dcf8a582f20000000017160014bcadb2baea98af0d9a902e53a7e9adff43b191e9feffffff96cd3c93cac3db114aafe753122bd7d1afa5aa4155ae04b3256344ecca69d72001000000171600141d9984579ceb5c67ebfbfb47124f056662fe7adbfeffffffc878dd74d3a44072eae6178bb94b9253177db1a5aaa6d068eb0e4db7631762e20000000017160014df2a48cdc53dae1aba7aa71cb1f9de089d75aac3feffffffe49f99275bc8363f5f593f4eec371c51f62c34ff11cc6d8d778787d340d6896c0100000017160014229b3b297a0587e03375ab4174ef56eeb0968735feffffff03360d0f00000000001976a9149f44b06f6ee92ddbc4686f71afe528c09727a5c788ac24281b00000000001976a9140277b4f68ff20307a2a9f9b4487a38b501eb955888ac227c0000000000001976a9148020cd422f55eef8747a9d418f5441030f7c9c7788ac0247304402204aa3bd9682f9a8e101505f6358aacd1749ecf53a62b8370b97d59243b3d6984f02200384ad449870b0e6e89c92505880411285ecd41cf11e7439b973f13bad97e53901210205b392ffcb83124b1c7ce6dd594688198ef600d34500a7f3552d67947bbe392802473044022033dfd8d190a4ae36b9f60999b217c775b96eb10dee3a1ff50fb6a75325719106022005872e4e36d194e49ced2ebcf8bb9d843d842e7b7e0eb042f4028396088d292f012103c9d7cbf369410b090480de2aa15c6c73d91b9ffa7d88b90724614b70be41e98e0247304402207d952de9e59e4684efed069797e3e2d993e9f98ec8a9ccd599de43005fe3f713022076d190cc93d9513fc061b1ba565afac574e02027c9efbfa1d7b71ab8dbb21e0501210313ad44bc030cc6cb111798c2bf3d2139418d751c1e79ec4e837ce360cc03b97a024730440220029e75edb5e9413eb98d684d62a077b17fa5b7cc19349c1e8cc6c4733b7b7452022048d4b9cae594f03741029ff841e35996ef233701c1ea9aa55c301362ea2e2f68012103590657108a72feb8dc1dec022cf6a230bb23dc7aaa52f4032384853b9f8388baf9d20700")
-            .unwrap().as_slice()).unwrap();
-        let spent2: Transaction = deserialize(hex_decode("0200000000010166c3d39490dc827a2594c7b17b7d37445e1f4b372179649cd2ce4475e3641bbb0100000017160014e69aa750e9bff1aca1e32e57328b641b611fc817fdffffff01e87c5d010000000017a914f3890da1b99e44cd3d52f7bcea6a1351658ea7be87024830450221009eb97597953dc288de30060ba02d4e91b2bde1af2ecf679c7f5ab5989549aa8002202a98f8c3bd1a5a31c0d72950dd6e2e3870c6c5819a6c3db740e91ebbbc5ef4800121023f3d3b8e74b807e32217dea2c75c8d0bd46b8665b3a2d9b3cb310959de52a09bc9d20700")
-            .unwrap().as_slice()).unwrap();
-        let spent3: Transaction = deserialize(hex_decode("01000000027a1120a30cef95422638e8dab9dedf720ec614b1b21e451a4957a5969afb869d000000006a47304402200ecc318a829a6cad4aa9db152adbf09b0cd2de36f47b53f5dade3bc7ef086ca702205722cda7404edd6012eedd79b2d6f24c0a0c657df1a442d0a2166614fb164a4701210372f4b97b34e9c408741cd1fc97bcc7ffdda6941213ccfde1cb4075c0f17aab06ffffffffc23b43e5a18e5a66087c0d5e64d58e8e21fcf83ce3f5e4f7ecb902b0e80a7fb6010000006b483045022100f10076a0ea4b4cf8816ed27a1065883efca230933bf2ff81d5db6258691ff75202206b001ef87624e76244377f57f0c84bc5127d0dd3f6e0ef28b276f176badb223a01210309a3a61776afd39de4ed29b622cd399d99ecd942909c36a8696cfd22fc5b5a1affffffff0200127a000000000017a914f895e1dd9b29cb228e9b06a15204e3b57feaf7cc8769311d09000000001976a9144d00da12aaa51849d2583ae64525d4a06cd70fde88ac00000000")
-            .unwrap().as_slice()).unwrap();
-
-        let mut spent = HashMap::new();
-        spent.insert(spent1.txid(), spent1);
-        spent.insert(spent2.txid(), spent2);
-        spent.insert(spent3.txid(), spent3);
-        let mut spent2 = spent.clone();
-        let mut spent3 = spent.clone();
-
-        spending.verify(|point: &OutPoint| {
-            if let Some(tx) = spent.remove(&point.txid) {
-                return tx.output.get(point.vout as usize).cloned();
-            }
-            None
-        }).unwrap();
-
-        // test that we fail with repeated use of same input
-        let mut double_spending = spending.clone();
-        let re_use = double_spending.input[0].clone();
-        double_spending.input.push (re_use);
-
-        assert!(double_spending.verify(|point: &OutPoint| {
-            if let Some(tx) = spent2.remove(&point.txid) {
-                return tx.output.get(point.vout as usize).cloned();
-            }
-            None
-        }).is_err());
-
-        // test that we get a failure if we corrupt a signature
-        spending.input[1].witness[0][10] = 42;
-        match spending.verify(|point: &OutPoint| {
-            if let Some(tx) = spent3.remove(&point.txid) {
-                return tx.output.get(point.vout as usize).cloned();
-            }
-            None
-        }).err().unwrap() {
-            script::Error::BitcoinConsensus(_) => {},
-            _ => panic!("Wrong error type"),
-        }
-    }
-}
-
diff --git a/src/consensus/encode.rs b/src/consensus/encode.rs
deleted file mode 100644
index 402a4b51..00000000
--- a/src/consensus/encode.rs
+++ /dev/null
@@ -1,932 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Consensus-encodable types
-//!
-//! This is basically a replacement of the `Encodable` trait which does
-//! normalization for endianness, etc., to ensure that the encoding
-//! matches for endianness, etc., to ensure that the encoding matches
-//! the network consensus encoding.
-//!
-//! Essentially, anything that must go on the -disk- or -network- must
-//! be encoded using the `Encodable` trait, since this data
-//! must be the same for all systems. Any data going to the -user-, e.g.
-//! over JSONRPC, should use the ordinary `Encodable` trait. (This
-//! should also be the same across systems, of course, but has some
-//! critical differences from the network format, e.g. scripts come
-//! with an opcode decode, hashes are big-endian, numbers are typically
-//! big-endian decimals, etc.)
-//!
-
-use std::{fmt, error, io, mem, u32};
-use std::borrow::Cow;
-use std::io::{Cursor, Read, Write};
-use hashes::hex::ToHex;
-
-use hashes::{sha256d, Hash};
-use hash_types::{BlockHash, FilterHash, TxMerkleNode};
-
-use util::endian;
-use util::psbt;
-
-use blockdata::transaction::{TxOut, Transaction, TxIn};
-use network::message_blockdata::Inventory;
-use network::address::Address;
-
-/// Encoding error
-#[derive(Debug)]
-pub enum Error {
-    /// And I/O error
-    Io(io::Error),
-    /// PSBT-related error
-    Psbt(psbt::Error),
-    /// Network magic was not expected
-    UnexpectedNetworkMagic {
-        /// The expected network magic
-        expected: u32,
-        /// The unexpected network magic
-        actual: u32,
-    },
-    /// Tried to allocate an oversized vector
-    OversizedVectorAllocation{
-        /// The capacity requested
-        requested: usize,
-        /// The maximum capacity
-        max: usize,
-    },
-    /// Checksum was invalid
-    InvalidChecksum {
-        /// The expected checksum
-        expected: [u8; 4],
-        /// The invalid checksum
-        actual: [u8; 4],
-    },
-    /// VarInt was encoded in a non-minimal way
-    NonMinimalVarInt,
-    /// Network magic was unknown
-    UnknownNetworkMagic(u32),
-    /// Parsing error
-    ParseFailed(&'static str),
-    /// Unsupported Segwit flag
-    UnsupportedSegwitFlag(u8),
-    /// Unrecognized network command
-    UnrecognizedNetworkCommand(String),
-    /// Invalid Inventory type
-    UnknownInventoryType(u32),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::Io(ref e) => write!(f, "I/O error: {}", e),
-            Error::Psbt(ref e) => write!(f, "PSBT error: {}", e),
-            Error::UnexpectedNetworkMagic { expected: ref e, actual: ref a } => write!(f,
-                "unexpected network magic: expected {}, actual {}", e, a),
-            Error::OversizedVectorAllocation { requested: ref r, max: ref m } => write!(f,
-                "allocation of oversized vector: requested {}, maximum {}", r, m),
-            Error::InvalidChecksum { expected: ref e, actual: ref a } => write!(f,
-                "invalid checksum: expected {}, actual {}", e.to_hex(), a.to_hex()),
-            Error::NonMinimalVarInt => write!(f, "non-minimal varint"),
-            Error::UnknownNetworkMagic(ref m) => write!(f, "unknown network magic: {}", m),
-            Error::ParseFailed(ref e) => write!(f, "parse failed: {}", e),
-            Error::UnsupportedSegwitFlag(ref swflag) => write!(f,
-                "unsupported segwit version: {}", swflag),
-            Error::UnrecognizedNetworkCommand(ref nwcmd) => write!(f,
-                "unrecognized network command: {}", nwcmd),
-            Error::UnknownInventoryType(ref tp) => write!(f, "Unknown Inventory type: {}", tp),
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Io(ref e) => Some(e),
-            Error::Psbt(ref e) => Some(e),
-            Error::UnexpectedNetworkMagic { .. }
-            | Error::OversizedVectorAllocation { .. }
-            | Error::InvalidChecksum { .. }
-            | Error::NonMinimalVarInt
-            | Error::UnknownNetworkMagic(..)
-            | Error::ParseFailed(..)
-            | Error::UnsupportedSegwitFlag(..)
-            | Error::UnrecognizedNetworkCommand(..)
-            | Error::UnknownInventoryType(..) => None,
-        }
-    }
-
-    fn description(&self) -> &str {
-        "Bitcoin encoding error"
-    }
-}
-
-#[doc(hidden)]
-
-#[doc(hidden)]
-impl From<io::Error> for Error {
-    fn from(error: io::Error) -> Self {
-        Error::Io(error)
-    }
-}
-
-#[doc(hidden)]
-impl From<psbt::Error> for Error {
-    fn from(e: psbt::Error) -> Error {
-        Error::Psbt(e)
-    }
-}
-
-/// Encode an object into a vector
-pub fn serialize<T: Encodable + ?Sized>(data: &T) -> Vec<u8> {
-    let mut encoder = Cursor::new(vec![]);
-    data.consensus_encode(&mut encoder).unwrap();
-    encoder.into_inner()
-}
-
-/// Encode an object into a hex-encoded string
-pub fn serialize_hex<T: Encodable + ?Sized>(data: &T) -> String {
-    serialize(data)[..].to_hex()
-}
-
-/// Deserialize an object from a vector, will error if said deserialization
-/// doesn't consume the entire vector.
-pub fn deserialize<'a, T: Decodable>(data: &'a [u8]) -> Result<T, Error> {
-    let (rv, consumed) = deserialize_partial(data)?;
-
-    // Fail if data are not consumed entirely.
-    if consumed == data.len() {
-        Ok(rv)
-    } else {
-        Err(Error::ParseFailed("data not consumed entirely when explicitly deserializing"))
-    }
-}
-
-/// Deserialize an object from a vector, but will not report an error if said deserialization
-/// doesn't consume the entire vector.
-pub fn deserialize_partial<'a, T: Decodable>(
-    data: &'a [u8],
-) -> Result<(T, usize), Error> {
-    let mut decoder = Cursor::new(data);
-    let rv = Decodable::consensus_decode(&mut decoder)?;
-    let consumed = decoder.position() as usize;
-
-    Ok((rv, consumed))
-}
-
-
-/// Extensions of `Write` to encode data as per Bitcoin consensus
-pub trait WriteExt {
-    /// Output a 64-bit uint
-    fn emit_u64(&mut self, v: u64) -> Result<(), Error>;
-    /// Output a 32-bit uint
-    fn emit_u32(&mut self, v: u32) -> Result<(), Error>;
-    /// Output a 16-bit uint
-    fn emit_u16(&mut self, v: u16) -> Result<(), Error>;
-    /// Output a 8-bit uint
-    fn emit_u8(&mut self, v: u8) -> Result<(), Error>;
-
-    /// Output a 64-bit int
-    fn emit_i64(&mut self, v: i64) -> Result<(), Error>;
-    /// Output a 32-bit int
-    fn emit_i32(&mut self, v: i32) -> Result<(), Error>;
-    /// Output a 16-bit int
-    fn emit_i16(&mut self, v: i16) -> Result<(), Error>;
-    /// Output a 8-bit int
-    fn emit_i8(&mut self, v: i8) -> Result<(), Error>;
-
-    /// Output a boolean
-    fn emit_bool(&mut self, v: bool) -> Result<(), Error>;
-
-    /// Output a byte slice
-    fn emit_slice(&mut self, v: &[u8]) -> Result<(), Error>;
-}
-
-/// Extensions of `Read` to decode data as per Bitcoin consensus
-pub trait ReadExt {
-    /// Read a 64-bit uint
-    fn read_u64(&mut self) -> Result<u64, Error>;
-    /// Read a 32-bit uint
-    fn read_u32(&mut self) -> Result<u32, Error>;
-    /// Read a 16-bit uint
-    fn read_u16(&mut self) -> Result<u16, Error>;
-    /// Read a 8-bit uint
-    fn read_u8(&mut self) -> Result<u8, Error>;
-
-    /// Read a 64-bit int
-    fn read_i64(&mut self) -> Result<i64, Error>;
-    /// Read a 32-bit int
-    fn read_i32(&mut self) -> Result<i32, Error>;
-    /// Read a 16-bit int
-    fn read_i16(&mut self) -> Result<i16, Error>;
-    /// Read a 8-bit int
-    fn read_i8(&mut self) -> Result<i8, Error>;
-
-    /// Read a boolean
-    fn read_bool(&mut self) -> Result<bool, Error>;
-
-    /// Read a byte slice
-    fn read_slice(&mut self, slice: &mut [u8]) -> Result<(), Error>;
-}
-
-macro_rules! encoder_fn {
-    ($name:ident, $val_type:ty, $writefn:ident) => {
-        #[inline]
-        fn $name(&mut self, v: $val_type) -> Result<(), Error> {
-            self.write_all(&endian::$writefn(v)).map_err(Error::Io)
-        }
-    }
-}
-
-macro_rules! decoder_fn {
-    ($name:ident, $val_type:ty, $readfn:ident, $byte_len: expr) => {
-        #[inline]
-        fn $name(&mut self) -> Result<$val_type, Error> {
-            assert_eq!(::std::mem::size_of::<$val_type>(), $byte_len); // size_of isn't a constfn in 1.22
-            let mut val = [0; $byte_len];
-            self.read_exact(&mut val[..]).map_err(Error::Io)?;
-            Ok(endian::$readfn(&val))
-        }
-    }
-}
-
-impl<W: Write> WriteExt for W {
-    encoder_fn!(emit_u64, u64, u64_to_array_le);
-    encoder_fn!(emit_u32, u32, u32_to_array_le);
-    encoder_fn!(emit_u16, u16, u16_to_array_le);
-    encoder_fn!(emit_i64, i64, i64_to_array_le);
-    encoder_fn!(emit_i32, i32, i32_to_array_le);
-    encoder_fn!(emit_i16, i16, i16_to_array_le);
-
-    #[inline]
-    fn emit_i8(&mut self, v: i8) -> Result<(), Error> {
-        self.write_all(&[v as u8]).map_err(Error::Io)
-    }
-    #[inline]
-    fn emit_u8(&mut self, v: u8) -> Result<(), Error> {
-        self.write_all(&[v]).map_err(Error::Io)
-    }
-    #[inline]
-    fn emit_bool(&mut self, v: bool) -> Result<(), Error> {
-        self.write_all(&[if v {1} else {0}]).map_err(Error::Io)
-    }
-    #[inline]
-    fn emit_slice(&mut self, v: &[u8]) -> Result<(), Error> {
-        self.write_all(v).map_err(Error::Io)
-    }
-}
-
-impl<R: Read> ReadExt for R {
-    decoder_fn!(read_u64, u64, slice_to_u64_le, 8);
-    decoder_fn!(read_u32, u32, slice_to_u32_le, 4);
-    decoder_fn!(read_u16, u16, slice_to_u16_le, 2);
-    decoder_fn!(read_i64, i64, slice_to_i64_le, 8);
-    decoder_fn!(read_i32, i32, slice_to_i32_le, 4);
-    decoder_fn!(read_i16, i16, slice_to_i16_le, 2);
-
-    #[inline]
-    fn read_u8(&mut self) -> Result<u8, Error> {
-        let mut slice = [0u8; 1];
-        self.read_exact(&mut slice)?;
-        Ok(slice[0])
-    }
-    #[inline]
-    fn read_i8(&mut self) -> Result<i8, Error> {
-        let mut slice = [0u8; 1];
-        self.read_exact(&mut slice)?;
-        Ok(slice[0] as i8)
-    }
-    #[inline]
-    fn read_bool(&mut self) -> Result<bool, Error> {
-        ReadExt::read_i8(self).map(|bit| bit != 0)
-    }
-    #[inline]
-    fn read_slice(&mut self, slice: &mut [u8]) -> Result<(), Error> {
-        self.read_exact(slice).map_err(Error::Io)
-    }
-}
-
-/// Maximum size, in bytes, of a vector we are allowed to decode
-pub const MAX_VEC_SIZE: usize = 4_000_000;
-
-/// Data which can be encoded in a consensus-consistent way
-pub trait Encodable {
-    /// Encode an object with a well-defined format, should only ever error if
-    /// the underlying `Write` errors. Returns the number of bytes written on
-    /// success
-    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error>;
-}
-
-/// Data which can be encoded in a consensus-consistent way
-pub trait Decodable: Sized {
-    /// Decode an object with a well-defined format
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error>;
-}
-
-/// A variable-length unsigned integer
-#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
-pub struct VarInt(pub u64);
-
-/// Data which must be preceded by a 4-byte checksum
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct CheckedData(pub Vec<u8>);
-
-// Primitive types
-macro_rules! impl_int_encodable{
-    ($ty:ident, $meth_dec:ident, $meth_enc:ident) => (
-        impl Decodable for $ty {
-            #[inline]
-            fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-                ReadExt::$meth_dec(&mut d).map($ty::from_le)
-            }
-        }
-
-        impl Encodable for $ty {
-            #[inline]
-            fn consensus_encode<S: WriteExt>(
-                &self,
-                mut s: S,
-            ) -> Result<usize, self::Error> {
-                s.$meth_enc(self.to_le())?;
-                Ok(mem::size_of::<$ty>())
-            }
-        }
-    )
-}
-
-impl_int_encodable!(u8,  read_u8,  emit_u8);
-impl_int_encodable!(u16, read_u16, emit_u16);
-impl_int_encodable!(u32, read_u32, emit_u32);
-impl_int_encodable!(u64, read_u64, emit_u64);
-impl_int_encodable!(i8,  read_i8,  emit_i8);
-impl_int_encodable!(i16, read_i16, emit_i16);
-impl_int_encodable!(i32, read_i32, emit_i32);
-impl_int_encodable!(i64, read_i64, emit_i64);
-
-impl VarInt {
-    /// Gets the length of this VarInt when encoded.
-    /// Returns 1 for 0...0xFC, 3 for 0xFD...(2^16-1), 5 for 0x10000...(2^32-1),
-    /// and 9 otherwise.
-    #[inline]
-    pub fn len(&self) -> usize {
-        match self.0 {
-            0...0xFC             => { 1 }
-            0xFD...0xFFFF        => { 3 }
-            0x10000...0xFFFFFFFF => { 5 }
-            _                    => { 9 }
-        }
-    }
-}
-
-impl Encodable for VarInt {
-    #[inline]
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
-        match self.0 {
-            0...0xFC => {
-                (self.0 as u8).consensus_encode(s)?;
-                Ok(1)
-            },
-            0xFD...0xFFFF => {
-                s.emit_u8(0xFD)?;
-                (self.0 as u16).consensus_encode(s)?;
-                Ok(3)
-            },
-            0x10000...0xFFFFFFFF => {
-                s.emit_u8(0xFE)?;
-                (self.0 as u32).consensus_encode(s)?;
-                Ok(5)
-            },
-            _ => {
-                s.emit_u8(0xFF)?;
-                (self.0 as u64).consensus_encode(s)?;
-                Ok(9)
-            },
-        }
-    }
-}
-
-impl Decodable for VarInt {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-        let n = ReadExt::read_u8(&mut d)?;
-        match n {
-            0xFF => {
-                let x = ReadExt::read_u64(&mut d)?;
-                if x < 0x100000000 {
-                    Err(self::Error::NonMinimalVarInt)
-                } else {
-                    Ok(VarInt(x))
-                }
-            }
-            0xFE => {
-                let x = ReadExt::read_u32(&mut d)?;
-                if x < 0x10000 {
-                    Err(self::Error::NonMinimalVarInt)
-                } else {
-                    Ok(VarInt(x as u64))
-                }
-            }
-            0xFD => {
-                let x = ReadExt::read_u16(&mut d)?;
-                if x < 0xFD {
-                    Err(self::Error::NonMinimalVarInt)
-                } else {
-                    Ok(VarInt(x as u64))
-                }
-            }
-            n => Ok(VarInt(n as u64))
-        }
-    }
-}
-
-
-// Booleans
-impl Encodable for bool {
-    #[inline]
-    fn consensus_encode<S: WriteExt>(&self, mut s: S) -> Result<usize, Error> {
-        s.emit_u8(if *self {1} else {0})?;
-        Ok(1)
-    }
-}
-
-impl Decodable for bool {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<bool, Error> {
-        ReadExt::read_u8(&mut d).map(|n| n != 0)
-    }
-}
-
-// Strings
-impl Encodable for String {
-    #[inline]
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
-        let b = self.as_bytes();
-        let vi_len = VarInt(b.len() as u64).consensus_encode(&mut s)?;
-        s.emit_slice(&b)?;
-        Ok(vi_len + b.len())
-    }
-}
-
-impl Decodable for String {
-    #[inline]
-    fn consensus_decode<D: io::Read>(d: D) -> Result<String, Error> {
-        String::from_utf8(Decodable::consensus_decode(d)?)
-            .map_err(|_| self::Error::ParseFailed("String was not valid UTF8"))
-    }
-}
-
-// Cow<'static, str>
-impl Encodable for Cow<'static, str> {
-    #[inline]
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
-        let b = self.as_bytes();
-        let vi_len = VarInt(b.len() as u64).consensus_encode(&mut s)?;
-        s.emit_slice(&b)?;
-        Ok(vi_len + b.len())
-    }
-}
-
-impl Decodable for Cow<'static, str> {
-    #[inline]
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Cow<'static, str>, Error> {
-        String::from_utf8(Decodable::consensus_decode(d)?)
-            .map_err(|_| self::Error::ParseFailed("String was not valid UTF8"))
-            .map(Cow::Owned)
-    }
-}
-
-
-// Arrays
-macro_rules! impl_array {
-    ( $size:expr ) => (
-        impl Encodable for [u8; $size] {
-            #[inline]
-            fn consensus_encode<S: WriteExt>(
-                &self,
-                mut s: S,
-            ) -> Result<usize, Error> {
-                s.emit_slice(&self[..])?;
-                Ok(self.len())
-            }
-        }
-
-        impl Decodable for [u8; $size] {
-            #[inline]
-            fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-                let mut ret = [0; $size];
-                d.read_slice(&mut ret)?;
-                Ok(ret)
-            }
-        }
-    );
-}
-
-impl_array!(2);
-impl_array!(4);
-impl_array!(8);
-impl_array!(12);
-impl_array!(16);
-impl_array!(32);
-impl_array!(33);
-
-impl Decodable for [u16; 8] {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-        let mut res = [0; 8];
-        for i in 0..8 {
-            res[i] = Decodable::consensus_decode(&mut d)?;
-        }
-        Ok(res)
-    }
-}
-
-impl Encodable for [u16; 8] {
-    #[inline]
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
-        for c in self.iter() { c.consensus_encode(&mut s)?; }
-        Ok(16)
-    }
-}
-
-// 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 += 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 Vec<$type> {
-            #[inline]
-            fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-                let len = 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)
-            }
-        }
-    }
-}
-impl_vec!(BlockHash);
-impl_vec!(FilterHash);
-impl_vec!(TxMerkleNode);
-impl_vec!(Transaction);
-impl_vec!(TxOut);
-impl_vec!(TxIn);
-impl_vec!(Inventory);
-impl_vec!(Vec<u8>);
-impl_vec!((u32, Address));
-impl_vec!(u64);
-
-impl Encodable for Vec<u8> {
-    #[inline]
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
-        let vi_len = VarInt(self.len() as u64).consensus_encode(&mut s)?;
-        s.emit_slice(&self)?;
-        Ok(vi_len + self.len())
-    }
-}
-
-impl Decodable for Vec<u8> {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-        let len = VarInt::consensus_decode(&mut d)?.0 as usize;
-        if len > MAX_VEC_SIZE {
-            return Err(self::Error::OversizedVectorAllocation { requested: len, max: MAX_VEC_SIZE })
-        }
-        let mut ret = Vec::with_capacity(len);
-        ret.resize(len, 0);
-        d.read_slice(&mut ret)?;
-        Ok(ret)
-    }
-}
-
-impl Encodable for Box<[u8]> {
-    #[inline]
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
-        let vi_len = VarInt(self.len() as u64).consensus_encode(&mut s)?;
-        s.emit_slice(&self)?;
-        Ok(vi_len + self.len())
-    }
-}
-
-impl Decodable for Box<[u8]> {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-        let len = VarInt::consensus_decode(&mut d)?.0;
-        let len = len as usize;
-        if len > MAX_VEC_SIZE {
-            return Err(self::Error::OversizedVectorAllocation { requested: len, max: MAX_VEC_SIZE })
-        }
-        let mut ret = Vec::with_capacity(len);
-        ret.resize(len, 0);
-        d.read_slice(&mut ret)?;
-        Ok(ret.into_boxed_slice())
-    }
-}
-
-
-/// Do a double-SHA256 on some data and return the first 4 bytes
-fn sha2_checksum(data: &[u8]) -> [u8; 4] {
-    let checksum = <sha256d::Hash as Hash>::hash(data);
-    [checksum[0], checksum[1], checksum[2], checksum[3]]
-}
-
-// Checked data
-impl Encodable for CheckedData {
-    #[inline]
-    fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
-        (self.0.len() as u32).consensus_encode(&mut s)?;
-        sha2_checksum(&self.0).consensus_encode(&mut s)?;
-        s.emit_slice(&self.0)?;
-        Ok(8 + self.0.len())
-    }
-}
-
-impl Decodable for CheckedData {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-        let len = u32::consensus_decode(&mut d)?;
-        if len > MAX_VEC_SIZE as u32 {
-            return Err(self::Error::OversizedVectorAllocation {
-                requested: len as usize,
-                max: MAX_VEC_SIZE
-            });
-        }
-        let checksum = <[u8; 4]>::consensus_decode(&mut d)?;
-        let mut ret = Vec::with_capacity(len as usize);
-        ret.resize(len as usize, 0);
-        d.read_slice(&mut ret)?;
-        let expected_checksum = sha2_checksum(&ret);
-        if expected_checksum != checksum {
-            Err(self::Error::InvalidChecksum {
-                expected: expected_checksum,
-                actual: checksum,
-            })
-        } else {
-            Ok(CheckedData(ret))
-        }
-    }
-}
-
-// Tuples
-macro_rules! tuple_encode {
-    ($($x:ident),*) => (
-        impl <$($x: Encodable),*> Encodable for ($($x),*) {
-            #[inline]
-            #[allow(non_snake_case)]
-            fn consensus_encode<S: io::Write>(
-                &self,
-                mut s: S,
-            ) -> Result<usize, self::Error> {
-                let &($(ref $x),*) = self;
-                let mut len = 0;
-                $(len += $x.consensus_encode(&mut s)?;)*
-                Ok(len)
-            }
-        }
-
-        impl<$($x: Decodable),*> Decodable for ($($x),*) {
-            #[inline]
-            #[allow(non_snake_case)]
-            fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, Error> {
-                Ok(($({let $x = Decodable::consensus_decode(&mut d)?; $x }),*))
-            }
-        }
-    );
-}
-
-tuple_encode!(T0, T1);
-tuple_encode!(T0, T1, T2, T3);
-tuple_encode!(T0, T1, T2, T3, T4, T5);
-tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
-
-impl Encodable for sha256d::Hash {
-    fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
-        self.into_inner().consensus_encode(s)
-    }
-}
-
-impl Decodable for sha256d::Hash {
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-        Ok(Self::from_inner(<<Self as Hash>::Inner>::consensus_decode(d)?))
-    }
-}
-
-// Tests
-#[cfg(test)]
-mod tests {
-    use super::{CheckedData, VarInt};
-
-    use super::{deserialize, serialize, Error};
-
-    #[test]
-    fn serialize_int_test() {
-        // bool
-        assert_eq!(serialize(&false), vec![0u8]);
-        assert_eq!(serialize(&true), vec![1u8]);
-        // u8
-        assert_eq!(serialize(&1u8), vec![1u8]);
-        assert_eq!(serialize(&0u8), vec![0u8]);
-        assert_eq!(serialize(&255u8), vec![255u8]);
-        // u16
-        assert_eq!(serialize(&1u16), vec![1u8, 0]);
-        assert_eq!(serialize(&256u16), vec![0u8, 1]);
-        assert_eq!(serialize(&5000u16), vec![136u8, 19]);
-        // u32
-        assert_eq!(serialize(&1u32), vec![1u8, 0, 0, 0]);
-        assert_eq!(serialize(&256u32), vec![0u8, 1, 0, 0]);
-        assert_eq!(serialize(&5000u32), vec![136u8, 19, 0, 0]);
-        assert_eq!(serialize(&500000u32), vec![32u8, 161, 7, 0]);
-        assert_eq!(serialize(&168430090u32), vec![10u8, 10, 10, 10]);
-        // i32
-        assert_eq!(serialize(&-1i32), vec![255u8, 255, 255, 255]);
-        assert_eq!(serialize(&-256i32), vec![0u8, 255, 255, 255]);
-        assert_eq!(serialize(&-5000i32), vec![120u8, 236, 255, 255]);
-        assert_eq!(serialize(&-500000i32), vec![224u8, 94, 248, 255]);
-        assert_eq!(serialize(&-168430090i32), vec![246u8, 245, 245, 245]);
-        assert_eq!(serialize(&1i32), vec![1u8, 0, 0, 0]);
-        assert_eq!(serialize(&256i32), vec![0u8, 1, 0, 0]);
-        assert_eq!(serialize(&5000i32), vec![136u8, 19, 0, 0]);
-        assert_eq!(serialize(&500000i32), vec![32u8, 161, 7, 0]);
-        assert_eq!(serialize(&168430090i32), vec![10u8, 10, 10, 10]);
-        // u64
-        assert_eq!(serialize(&1u64), vec![1u8, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(serialize(&256u64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(serialize(&5000u64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(serialize(&500000u64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
-        assert_eq!(serialize(&723401728380766730u64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
-        // i64
-        assert_eq!(serialize(&-1i64), vec![255u8, 255, 255, 255, 255, 255, 255, 255]);
-        assert_eq!(serialize(&-256i64), vec![0u8, 255, 255, 255, 255, 255, 255, 255]);
-        assert_eq!(serialize(&-5000i64), vec![120u8, 236, 255, 255, 255, 255, 255, 255]);
-        assert_eq!(serialize(&-500000i64), vec![224u8, 94, 248, 255, 255, 255, 255, 255]);
-        assert_eq!(serialize(&-723401728380766730i64), vec![246u8, 245, 245, 245, 245, 245, 245, 245]);
-        assert_eq!(serialize(&1i64), vec![1u8, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(serialize(&256i64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(serialize(&5000i64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(serialize(&500000i64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
-        assert_eq!(serialize(&723401728380766730i64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
-    }
-
-    #[test]
-    fn serialize_varint_test() {
-        assert_eq!(serialize(&VarInt(10)), vec![10u8]);
-        assert_eq!(serialize(&VarInt(0xFC)), vec![0xFCu8]);
-        assert_eq!(serialize(&VarInt(0xFD)), vec![0xFDu8, 0xFD, 0]);
-        assert_eq!(serialize(&VarInt(0xFFF)), vec![0xFDu8, 0xFF, 0xF]);
-        assert_eq!(serialize(&VarInt(0xF0F0F0F)), vec![0xFEu8, 0xF, 0xF, 0xF, 0xF]);
-        assert_eq!(serialize(&VarInt(0xF0F0F0F0F0E0)), vec![0xFFu8, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0, 0]);
-    }
-
-    #[test]
-    fn deserialize_nonminimal_vec() {
-        match deserialize::<Vec<u8>>(&[0xfd, 0x00, 0x00]) {
-            Err(Error::NonMinimalVarInt) => {},
-            x => panic!(x)
-        }
-        match deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]) {
-            Err(Error::NonMinimalVarInt) => {},
-            x => panic!(x)
-        }
-        match deserialize::<Vec<u8>>(&[0xfe, 0xff, 0x00, 0x00, 0x00]) {
-            Err(Error::NonMinimalVarInt) => {},
-            x => panic!(x)
-        }
-        match deserialize::<Vec<u8>>(&[0xfe, 0xff, 0xff, 0x00, 0x00]) {
-            Err(Error::NonMinimalVarInt) => {},
-            x => panic!(x)
-        }
-        match deserialize::<Vec<u8>>(&[0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) {
-            Err(Error::NonMinimalVarInt) => {},
-            x => panic!(x)
-        }
-        match deserialize::<Vec<u8>>(&[0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00]) {
-            Err(Error::NonMinimalVarInt) => {},
-            x => panic!(x)
-        }
-
-        let mut vec_256 = vec![0; 259];
-        vec_256[0] = 0xfd;
-        vec_256[1] = 0x00;
-        vec_256[2] = 0x01;
-        assert!(deserialize::<Vec<u8>>(&vec_256).is_ok());
-
-        let mut vec_253 = vec![0; 256];
-        vec_253[0] = 0xfd;
-        vec_253[1] = 0xfd;
-        vec_253[2] = 0x00;
-        assert!(deserialize::<Vec<u8>>(&vec_253).is_ok());
-    }
-
-    #[test]
-    fn serialize_checkeddata_test() {
-        let cd = CheckedData(vec![1u8, 2, 3, 4, 5]);
-        assert_eq!(serialize(&cd), vec![5, 0, 0, 0, 162, 107, 175, 90, 1, 2, 3, 4, 5]);
-    }
-
-    #[test]
-    fn serialize_vector_test() {
-        assert_eq!(serialize(&vec![1u8, 2, 3]), vec![3u8, 1, 2, 3]);
-        // TODO: test vectors of more interesting objects
-    }
-
-    #[test]
-    fn serialize_strbuf_test() {
-        assert_eq!(serialize(&"Andrew".to_string()), vec![6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]);
-    }
-
-    #[test]
-    fn deserialize_int_test() {
-        // bool
-        assert!((deserialize(&[58u8, 0]) as Result<bool, _>).is_err());
-        assert_eq!(deserialize(&[58u8]).ok(), Some(true));
-        assert_eq!(deserialize(&[1u8]).ok(), Some(true));
-        assert_eq!(deserialize(&[0u8]).ok(), Some(false));
-        assert!((deserialize(&[0u8, 1]) as Result<bool, _>).is_err());
-
-        // u8
-        assert_eq!(deserialize(&[58u8]).ok(), Some(58u8));
-
-        // u16
-        assert_eq!(deserialize(&[0x01u8, 0x02]).ok(), Some(0x0201u16));
-        assert_eq!(deserialize(&[0xABu8, 0xCD]).ok(), Some(0xCDABu16));
-        assert_eq!(deserialize(&[0xA0u8, 0x0D]).ok(), Some(0xDA0u16));
-        let failure16: Result<u16, _> = deserialize(&[1u8]);
-        assert!(failure16.is_err());
-
-        // u32
-        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABu32));
-        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD]).ok(), Some(0xCDAB0DA0u32));
-        let failure32: Result<u32, _> = deserialize(&[1u8, 2, 3]);
-        assert!(failure32.is_err());
-        // TODO: test negative numbers
-        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABi32));
-        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0x2D]).ok(), Some(0x2DAB0DA0i32));
-        let failurei32: Result<i32, _> = deserialize(&[1u8, 2, 3]);
-        assert!(failurei32.is_err());
-
-        // u64
-        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABu64));
-        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(), Some(0x99000099CDAB0DA0u64));
-        let failure64: Result<u64, _> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
-        assert!(failure64.is_err());
-        // TODO: test negative numbers
-        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABi64));
-        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(), Some(-0x66ffff663254f260i64));
-        let failurei64: Result<i64, _> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
-        assert!(failurei64.is_err());
-    }
-
-    #[test]
-    fn deserialize_vec_test() {
-        assert_eq!(deserialize(&[3u8, 2, 3, 4]).ok(), Some(vec![2u8, 3, 4]));
-        assert!((deserialize(&[4u8, 2, 3, 4, 5, 6]) as Result<Vec<u8>, _>).is_err());
-        // found by cargo fuzz
-        assert!(deserialize::<Vec<u64>>(&[0xff,0xff,0xff,0xff,0x6b,0x6b,0x6b,0x6b,0x6b,0x6b,0x6b,0x6b,0x6b,0x6b,0x6b,0x6b,0xa,0xa,0x3a]).is_err());
-    }
-
-    #[test]
-    fn deserialize_strbuf_test() {
-        assert_eq!(deserialize(&[6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]).ok(), Some("Andrew".to_string()));
-        assert_eq!(
-            deserialize(&[6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]).ok(),
-            Some(::std::borrow::Cow::Borrowed("Andrew"))
-        );
-    }
-
-    #[test]
-    fn deserialize_checkeddata_test() {
-        let cd: Result<CheckedData, _> = deserialize(&[5u8, 0, 0, 0, 162, 107, 175, 90, 1, 2, 3, 4, 5]);
-        assert_eq!(cd.ok(), Some(CheckedData(vec![1u8, 2, 3, 4, 5])));
-    }
-}
-
diff --git a/src/consensus/mod.rs b/src/consensus/mod.rs
deleted file mode 100644
index 1e302333..00000000
--- a/src/consensus/mod.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-//! Consensus
-//!
-//! This module defines structures, functions, and traits which are needed to
-//! conform to Bitcoin consensus.
-//!
-
-pub mod encode;
-pub mod params;
-
-pub use self::encode::{Encodable, Decodable, WriteExt, ReadExt};
-pub use self::encode::{serialize, deserialize, deserialize_partial};
-pub use self::params::Params;
diff --git a/src/consensus/params.rs b/src/consensus/params.rs
deleted file mode 100644
index a1311fa1..00000000
--- a/src/consensus/params.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Consensus parameters
-//!
-//! This module provides predefined set of parameters for different chains.
-//!
-
-use network::constants::Network;
-use util::uint::Uint256;
-
-/// Lowest possible difficulty for Mainnet.
-const MAX_BITS_BITCOIN: Uint256 = Uint256([
-    0xffffffffffffffffu64,
-    0xffffffffffffffffu64,
-    0xffffffffffffffffu64,
-    0x00000000ffffffffu64,
-]);
-/// Lowest possible difficulty for Testnet.
-const MAX_BITS_TESTNET: Uint256 = Uint256([
-    0xffffffffffffffffu64,
-    0xffffffffffffffffu64,
-    0xffffffffffffffffu64,
-    0x00000000ffffffffu64,
-]);
-/// Lowest possible difficulty for Regtest.
-const MAX_BITS_REGTEST: Uint256 = Uint256([
-    0xffffffffffffffffu64,
-    0xffffffffffffffffu64,
-    0xffffffffffffffffu64,
-    0x7fffffffffffffffu64,
-]);
-
-#[derive(Debug, Clone)]
-/// Parameters that influence chain consensus.
-pub struct Params {
-    /// Network for which parameters are valid.
-    pub network: Network,
-    /// Time when BIP16 becomes active.
-    pub bip16_time: u32,
-    /// Block height at which BIP34 becomes active.
-    pub bip34_height: u32,
-    /// Block height at which BIP65 becomes active.
-    pub bip65_height: u32,
-    /// Block height at which BIP66 becomes active.
-    pub bip66_height: u32,
-    /// Minimum blocks including miner confirmation of the total of 2016 blocks in a retargeting period,
-    /// (nPowTargetTimespan / nPowTargetSpacing) which is also used for BIP9 deployments.
-    /// Examples: 1916 for 95%, 1512 for testchains.
-    pub rule_change_activation_threshold: u32,
-    /// Number of blocks with the same set of rules.
-    pub miner_confirmation_window: u32,
-    /// Proof of work limit value. It contains the lowest possible difficulty.
-    pub pow_limit: Uint256,
-    /// Expected amount of time to mine one block.
-    pub pow_target_spacing: u64,
-    /// Difficulty recalculation interval.
-    pub pow_target_timespan: u64,
-    /// Determines whether minimal difficulty may be used for blocks or not.
-    pub allow_min_difficulty_blocks: bool,
-    /// Determines whether retargeting is disabled for this network or not.
-    pub no_pow_retargeting: bool,
-}
-
-impl Params {
-    /// Creates parameters set for the given network.
-    pub fn new(network: Network) -> Self {
-        match network {
-            Network::Bitcoin => Params {
-                network: Network::Bitcoin,
-                bip16_time: 1333238400,                 // Apr 1 2012
-                bip34_height: 227931, // 000000000000024b89b42a942fe0d9fea3bb44ab7bd1b19115dd6a759c0808b8
-                bip65_height: 388381, // 000000000000000004c2b624ed5d7756c508d90fd0da2c7c679febfa6c4735f0
-                bip66_height: 363725, // 00000000000000000379eaa19dce8c9b722d46ae6a57c2f1a988119488b50931
-                rule_change_activation_threshold: 1916, // 95%
-                miner_confirmation_window: 2016,
-                pow_limit: MAX_BITS_BITCOIN,
-                pow_target_spacing: 10 * 60,            // 10 minutes.
-                pow_target_timespan: 14 * 24 * 60 * 60, // 2 weeks.
-                allow_min_difficulty_blocks: false,
-                no_pow_retargeting: false,
-            },
-            Network::Testnet => Params {
-                network: Network::Testnet,
-                bip16_time: 1333238400,                 // Apr 1 2012
-                bip34_height: 21111, // 0000000023b3a96d3484e5abb3755c413e7d41500f8e2a5c3f0dd01299cd8ef8
-                bip65_height: 581885, // 00000000007f6655f22f98e72ed80d8b06dc761d5da09df0fa1dc4be4f861eb6
-                bip66_height: 330776, // 000000002104c8c45e99a8853285a3b592602a3ccde2b832481da85e9e4ba182
-                rule_change_activation_threshold: 1512, // 75%
-                miner_confirmation_window: 2016,
-                pow_limit: MAX_BITS_TESTNET,
-                pow_target_spacing: 10 * 60,            // 10 minutes.
-                pow_target_timespan: 14 * 24 * 60 * 60, // 2 weeks.
-                allow_min_difficulty_blocks: true,
-                no_pow_retargeting: false,
-            },
-            Network::Regtest => Params {
-                network: Network::Regtest,
-                bip16_time: 1333238400,  // Apr 1 2012
-                bip34_height: 100000000, // not activated on regtest
-                bip65_height: 1351,
-                bip66_height: 1251,                    // used only in rpc tests
-                rule_change_activation_threshold: 108, // 75%
-                miner_confirmation_window: 144,
-                pow_limit: MAX_BITS_REGTEST,
-                pow_target_spacing: 10 * 60,            // 10 minutes.
-                pow_target_timespan: 14 * 24 * 60 * 60, // 2 weeks.
-                allow_min_difficulty_blocks: true,
-                no_pow_retargeting: true,
-            },
-        }
-    }
-
-    /// Calculates the number of blocks between difficulty adjustments.
-    pub fn difficulty_adjustment_interval(&self) -> u64 {
-        self.pow_target_timespan / self.pow_target_spacing
-    }
-}
diff --git a/src/hash_types.rs b/src/hash_types.rs
deleted file mode 100644
index 514c5309..00000000
--- a/src/hash_types.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! 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 std::io;
-
-use consensus::encode::{Encodable, Decodable, Error};
-use hashes::{sha256, sha256d, hash160, Hash};
-use hashes::hex::{ToHex, FromHex};
-
-macro_rules! impl_hashencode {
-    ($hashtype:ident) => {
-        impl Encodable for $hashtype {
-            fn consensus_encode<S: io::Write>(&self, s: S) -> Result<usize, Error> {
-                self.0.consensus_encode(s)
-            }
-        }
-
-        impl Decodable for $hashtype {
-            fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
-                Ok(Self::from_inner(<<$hashtype as Hash>::Inner>::consensus_decode(d)?))
-            }
-        }
-    }
-}
-
-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");
-
-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_newtype!(TxMerkleNode, sha256d::Hash, 32, doc="A hash of the Merkle tree branch or root for transactions");
-hash_newtype!(WitnessMerkleNode, sha256d::Hash, 32, doc="A hash corresponding to the Merkle tree root for witness data");
-hash_newtype!(WitnessCommitment, sha256d::Hash, 32, doc="A hash corresponding to the witness structure commitment in the coinbase transaction");
-hash_newtype!(XpubIdentifier, hash160::Hash, 20, doc="XpubIdentifier as defined in BIP-32.");
-
-hash_newtype!(FilterHash, sha256d::Hash, 32, doc="Bloom filter souble-SHA256 locator hash, as defined in BIP-168");
-
-
-impl_hashencode!(Txid);
-impl_hashencode!(Wtxid);
-impl_hashencode!(SigHash);
-impl_hashencode!(BlockHash);
-impl_hashencode!(TxMerkleNode);
-impl_hashencode!(WitnessMerkleNode);
-impl_hashencode!(FilterHash);
diff --git a/src/internal_macros.rs b/src/internal_macros.rs
deleted file mode 100644
index 362a2290..00000000
--- a/src/internal_macros.rs
+++ /dev/null
@@ -1,799 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Internal Macros
-//!
-//! Macros meant to be used inside the Rust Bitcoin library
-
-macro_rules! impl_consensus_encoding {
-    ($thing:ident, $($field:ident),+) => (
-        impl ::consensus::Encodable for $thing {
-            #[inline]
-            fn consensus_encode<S: ::std::io::Write>(
-                &self,
-                mut s: S,
-            ) -> Result<usize, ::consensus::encode::Error> {
-                let mut len = 0;
-                $(len += self.$field.consensus_encode(&mut s)?;)+
-                Ok(len)
-            }
-        }
-
-        impl ::consensus::Decodable for $thing {
-            #[inline]
-            fn consensus_decode<D: ::std::io::Read>(
-                mut d: D,
-            ) -> Result<$thing, ::consensus::encode::Error> {
-                Ok($thing {
-                    $($field: ::consensus::Decodable::consensus_decode(&mut d)?),+
-                })
-            }
-        }
-    );
-}
-
-macro_rules! impl_array_newtype {
-    ($thing:ident, $ty:ty, $len:expr) => {
-        impl $thing {
-            #[inline]
-            /// Converts the object to a raw pointer
-            pub fn as_ptr(&self) -> *const $ty {
-                let &$thing(ref dat) = self;
-                dat.as_ptr()
-            }
-
-            #[inline]
-            /// Converts the object to a mutable raw pointer
-            pub fn as_mut_ptr(&mut self) -> *mut $ty {
-                let &mut $thing(ref mut dat) = self;
-                dat.as_mut_ptr()
-            }
-
-            #[inline]
-            /// Returns the length of the object as an array
-            pub fn len(&self) -> usize { $len }
-
-            #[inline]
-            /// Returns whether the object, as an array, is empty. Always false.
-            pub fn is_empty(&self) -> bool { false }
-
-            #[inline]
-            /// Returns the underlying bytes.
-            pub fn as_bytes(&self) -> &[$ty; $len] { &self.0 }
-
-            #[inline]
-            /// Returns the underlying bytes.
-            pub fn to_bytes(&self) -> [$ty; $len] { self.0.clone() }
-
-            #[inline]
-            /// Returns the underlying bytes.
-            pub fn into_bytes(self) -> [$ty; $len] { self.0 }
-        }
-
-        impl<'a> From<&'a [$ty]> for $thing {
-            fn from(data: &'a [$ty]) -> $thing {
-                assert_eq!(data.len(), $len);
-                let mut ret = [0; $len];
-                ret.copy_from_slice(&data[..]);
-                $thing(ret)
-            }
-        }
-
-        impl ::std::ops::Index<usize> for $thing {
-            type Output = $ty;
-
-            #[inline]
-            fn index(&self, index: usize) -> &$ty {
-                let &$thing(ref dat) = self;
-                &dat[index]
-            }
-        }
-
-        impl_index_newtype!($thing, $ty);
-
-        impl PartialEq for $thing {
-            #[inline]
-            fn eq(&self, other: &$thing) -> bool {
-                &self[..] == &other[..]
-            }
-        }
-
-        impl Eq for $thing {}
-
-        impl PartialOrd for $thing {
-            #[inline]
-            fn partial_cmp(&self, other: &$thing) -> Option<::std::cmp::Ordering> {
-                Some(self.cmp(&other))
-            }
-        }
-
-        impl Ord for $thing {
-            #[inline]
-            fn cmp(&self, other: &$thing) -> ::std::cmp::Ordering {
-                // manually implement comparison to get little-endian ordering
-                // (we need this for our numeric types; non-numeric ones shouldn't
-                // be ordered anyway except to put them in BTrees or whatever, and
-                // they don't care how we order as long as we're consistent).
-                for i in 0..$len {
-                    if self[$len - 1 - i] < other[$len - 1 - i] { return ::std::cmp::Ordering::Less; }
-                    if self[$len - 1 - i] > other[$len - 1 - i] { return ::std::cmp::Ordering::Greater; }
-                }
-                ::std::cmp::Ordering::Equal
-            }
-        }
-
-        #[cfg_attr(feature = "clippy", allow(expl_impl_clone_on_copy))] // we don't define the `struct`, we have to explicitly impl
-        impl Clone for $thing {
-            #[inline]
-            fn clone(&self) -> $thing {
-                $thing::from(&self[..])
-            }
-        }
-
-        impl Copy for $thing {}
-
-        impl ::std::hash::Hash for $thing {
-            #[inline]
-            fn hash<H>(&self, state: &mut H)
-                where H: ::std::hash::Hasher
-            {
-                (&self[..]).hash(state);
-            }
-
-            fn hash_slice<H>(data: &[$thing], state: &mut H)
-                where H: ::std::hash::Hasher
-            {
-                for d in data.iter() {
-                    (&d[..]).hash(state);
-                }
-            }
-        }
-    }
-}
-
-macro_rules! impl_array_newtype_show {
-    ($thing:ident) => {
-        impl ::std::fmt::Debug for $thing {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                write!(f, concat!(stringify!($thing), "({:?})"), &self[..])
-            }
-        }
-    }
-}
-
-macro_rules! impl_index_newtype {
-    ($thing:ident, $ty:ty) => {
-        impl ::std::ops::Index<::std::ops::Range<usize>> for $thing {
-            type Output = [$ty];
-
-            #[inline]
-            fn index(&self, index: ::std::ops::Range<usize>) -> &[$ty] {
-                &self.0[index]
-            }
-        }
-
-        impl ::std::ops::Index<::std::ops::RangeTo<usize>> for $thing {
-            type Output = [$ty];
-
-            #[inline]
-            fn index(&self, index: ::std::ops::RangeTo<usize>) -> &[$ty] {
-                &self.0[index]
-            }
-        }
-
-        impl ::std::ops::Index<::std::ops::RangeFrom<usize>> for $thing {
-            type Output = [$ty];
-
-            #[inline]
-            fn index(&self, index: ::std::ops::RangeFrom<usize>) -> &[$ty] {
-                &self.0[index]
-            }
-        }
-
-        impl ::std::ops::Index<::std::ops::RangeFull> for $thing {
-            type Output = [$ty];
-
-            #[inline]
-            fn index(&self, _: ::std::ops::RangeFull) -> &[$ty] {
-                &self.0[..]
-            }
-        }
-
-    }
-}
-
-macro_rules! display_from_debug {
-    ($thing:ident) => {
-        impl ::std::fmt::Display for $thing {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-                ::std::fmt::Debug::fmt(self, f)
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-macro_rules! hex_script (($s:expr) => (::blockdata::script::Script::from(::hex::decode($s).unwrap())));
-
-#[cfg(test)]
-macro_rules! hex_hash (($h:ident, $s:expr) => ($h::from_slice(&::hex::decode($s).unwrap()).unwrap()));
-
-macro_rules! serde_struct_impl {
-    ($name:ident, $($fe:ident),*) => (
-        #[cfg(feature = "serde")]
-        impl<'de> $crate::serde::Deserialize<'de> for $name {
-            fn deserialize<D>(deserializer: D) -> Result<$name, D::Error>
-            where
-                D: $crate::serde::de::Deserializer<'de>,
-            {
-                use $crate::std::fmt::{self, Formatter};
-                use $crate::serde::de::IgnoredAny;
-
-                #[allow(non_camel_case_types)]
-                enum Enum { Unknown__Field, $($fe),* }
-
-                struct EnumVisitor;
-                impl<'de> $crate::serde::de::Visitor<'de> for EnumVisitor {
-                    type Value = Enum;
-
-                    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                        formatter.write_str("a field name")
-                    }
-
-                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        match v {
-                            $(
-                            stringify!($fe) => Ok(Enum::$fe)
-                            ),*,
-                            _ => Ok(Enum::Unknown__Field)
-                        }
-                    }
-                }
-
-                impl<'de> $crate::serde::Deserialize<'de> for Enum {
-                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                    where
-                        D: ::serde::de::Deserializer<'de>,
-                    {
-                        deserializer.deserialize_str(EnumVisitor)
-                    }
-                }
-
-                struct Visitor;
-
-                impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
-                    type Value = $name;
-
-                    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                        formatter.write_str("a struct")
-                    }
-
-                    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-                    where
-                        A: $crate::serde::de::MapAccess<'de>,
-                    {
-                        use $crate::serde::de::Error;
-
-                        $(let mut $fe = None;)*
-
-                        loop {
-                            match map.next_key::<Enum>()? {
-                                Some(Enum::Unknown__Field) => {
-                                    map.next_value::<IgnoredAny>()?;
-                                }
-                                $(
-                                    Some(Enum::$fe) => {
-                                        $fe = Some(map.next_value()?);
-                                    }
-                                )*
-                                None => { break; }
-                            }
-                        }
-
-                        $(
-                            let $fe = match $fe {
-                                Some(x) => x,
-                                None => return Err(A::Error::missing_field(stringify!($fe))),
-                            };
-                        )*
-
-                        let ret = $name {
-                            $($fe: $fe),*
-                        };
-
-                        Ok(ret)
-                    }
-                }
-                // end type defs
-
-                static FIELDS: &'static [&'static str] = &[$(stringify!($fe)),*];
-
-                deserializer.deserialize_struct(stringify!($name), FIELDS, Visitor)
-            }
-        }
-
-        #[cfg(feature = "serde")]
-        impl<'de> $crate::serde::Serialize for $name {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: $crate::serde::Serializer,
-            {
-                use $crate::serde::ser::SerializeStruct;
-
-                // Only used to get the struct length.
-                static FIELDS: &'static [&'static str] = &[$(stringify!($fe)),*];
-
-                let mut st = serializer.serialize_struct(stringify!($name), FIELDS.len())?;
-
-                $(
-                    st.serialize_field(stringify!($fe), &self.$fe)?;
-                )*
-
-                st.end()
-            }
-        }
-    )
-}
-
-macro_rules! serde_string_impl {
-    ($name:ident, $expecting:expr) => {
-        #[cfg(feature = "serde")]
-        impl<'de> $crate::serde::Deserialize<'de> for $name {
-            fn deserialize<D>(deserializer: D) -> Result<$name, D::Error>
-            where
-                D: $crate::serde::de::Deserializer<'de>,
-            {
-                use $crate::std::fmt::{self, Formatter};
-                use $crate::std::str::FromStr;
-
-                struct Visitor;
-                impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
-                    type Value = $name;
-
-                    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                        formatter.write_str($expecting)
-                    }
-
-                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        $name::from_str(v).map_err(E::custom)
-                    }
-
-                    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        self.visit_str(v)
-                    }
-
-                    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        self.visit_str(&v)
-                    }
-                }
-
-                deserializer.deserialize_str(Visitor)
-            }
-        }
-
-        #[cfg(feature = "serde")]
-        impl<'de> $crate::serde::Serialize for $name {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: $crate::serde::Serializer,
-            {
-                serializer.collect_str(&self)
-            }
-        }
-    };
-}
-
-/// 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 {
-    ($name:ident, $expecting:expr, $($fe:ident),*) => (
-        #[cfg(feature = "serde")]
-        impl<'de> $crate::serde::Deserialize<'de> for $name {
-            fn deserialize<D>(deserializer: D) -> Result<$name, D::Error>
-            where
-                D: $crate::serde::de::Deserializer<'de>,
-            {
-                if deserializer.is_human_readable() {
-                    use $crate::std::fmt::{self, Formatter};
-                    use $crate::std::str::FromStr;
-
-                    struct Visitor;
-                    impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
-                        type Value = $name;
-
-                        fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                            formatter.write_str($expecting)
-                        }
-
-                        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                        where
-                            E: $crate::serde::de::Error,
-                        {
-                            $name::from_str(v).map_err(E::custom)
-                        }
-
-                        fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
-                        where
-                            E: $crate::serde::de::Error,
-                        {
-                            self.visit_str(v)
-                        }
-
-                        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-                        where
-                            E: $crate::serde::de::Error,
-                        {
-                            self.visit_str(&v)
-                        }
-                    }
-
-                    deserializer.deserialize_str(Visitor)
-                } else {
-                    use $crate::std::fmt::{self, Formatter};
-                    use $crate::serde::de::IgnoredAny;
-
-                    #[allow(non_camel_case_types)]
-                    enum Enum { Unknown__Field, $($fe),* }
-
-                    struct EnumVisitor;
-                    impl<'de> $crate::serde::de::Visitor<'de> for EnumVisitor {
-                        type Value = Enum;
-
-                        fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                            formatter.write_str("a field name")
-                        }
-
-                        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                        where
-                            E: $crate::serde::de::Error,
-                        {
-                            match v {
-                                $(
-                                stringify!($fe) => Ok(Enum::$fe)
-                                ),*,
-                                _ => Ok(Enum::Unknown__Field)
-                            }
-                        }
-                    }
-
-                    impl<'de> $crate::serde::Deserialize<'de> for Enum {
-                        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                        where
-                            D: $crate::serde::de::Deserializer<'de>,
-                        {
-                            deserializer.deserialize_str(EnumVisitor)
-                        }
-                    }
-
-                    struct Visitor;
-
-                    impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
-                        type Value = $name;
-
-                        fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                            formatter.write_str("a struct")
-                        }
-
-                        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-                        where
-                            A: $crate::serde::de::MapAccess<'de>,
-                        {
-                            use $crate::serde::de::Error;
-
-                            $(let mut $fe = None;)*
-
-                            loop {
-                                match map.next_key::<Enum>()? {
-                                    Some(Enum::Unknown__Field) => {
-                                        map.next_value::<IgnoredAny>()?;
-                                    }
-                                    $(
-                                        Some(Enum::$fe) => {
-                                            $fe = Some(map.next_value()?);
-                                        }
-                                    )*
-                                    None => { break; }
-                                }
-                            }
-
-                            $(
-                                let $fe = match $fe {
-                                    Some(x) => x,
-                                    None => return Err(A::Error::missing_field(stringify!($fe))),
-                                };
-                            )*
-
-                            let ret = $name {
-                                $($fe: $fe),*
-                            };
-
-                            Ok(ret)
-                        }
-                    }
-                    // end type defs
-
-                    static FIELDS: &'static [&'static str] = &[$(stringify!($fe)),*];
-
-                    deserializer.deserialize_struct(stringify!($name), FIELDS, Visitor)
-                }
-            }
-        }
-
-        #[cfg(feature = "serde")]
-        impl<'de> $crate::serde::Serialize for $name {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: $crate::serde::Serializer,
-            {
-                if serializer.is_human_readable() {
-                    serializer.collect_str(&self)
-                } else {
-                    use $crate::serde::ser::SerializeStruct;
-
-                    // Only used to get the struct length.
-                    static FIELDS: &'static [&'static str] = &[$(stringify!($fe)),*];
-
-                    let mut st = serializer.serialize_struct(stringify!($name), FIELDS.len())?;
-
-                    $(
-                        st.serialize_field(stringify!($fe), &self.$fe)?;
-                    )*
-
-                    st.end()
-                }
-            }
-        }
-    )
-}
-
-/// Implements several traits for byte-based newtypes.
-/// Implements:
-/// - std::fmt::LowerHex (implies hashes::hex::ToHex)
-/// - std::fmt::Display
-/// - std::str::FromStr
-/// - hashes::hex::FromHex
-macro_rules! impl_bytes_newtype {
-    ($t:ident, $len:expr) => (
-
-        impl ::std::fmt::LowerHex for $t {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                for &ch in self.0.iter() {
-                    write!(f, "{:02x}", ch)?;
-                }
-                Ok(())
-            }
-        }
-
-        impl ::std::fmt::Display for $t {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                fmt::LowerHex::fmt(self, f)
-            }
-        }
-
-        impl ::hashes::hex::FromHex for $t {
-            fn from_byte_iter<I>(iter: I) -> Result<Self, ::hashes::hex::Error>
-                where I: Iterator<Item=Result<u8, ::hashes::hex::Error>> +
-                    ExactSizeIterator +
-                    DoubleEndedIterator,
-            {
-                if iter.len() == $len {
-                    let mut ret = [0; $len];
-                    for (n, byte) in iter.enumerate() {
-                        ret[n] = byte?;
-                    }
-                    Ok($t(ret))
-                } else {
-                    Err(::hashes::hex::Error::InvalidLength(2 * $len, 2 * iter.len()))
-                }
-            }
-        }
-
-        impl ::std::str::FromStr for $t {
-            type Err = ::hashes::hex::Error;
-            fn from_str(s: &str) -> Result<Self, Self::Err> {
-                hex::FromHex::from_hex(s)
-            }
-        }
-
-        #[cfg(feature="serde")]
-        impl ::serde::Serialize for $t {
-            fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-                if s.is_human_readable() {
-                    s.serialize_str(&::hashes::hex::ToHex::to_hex(self))
-                } else {
-                    s.serialize_bytes(&self[..])
-                }
-            }
-        }
-
-        #[cfg(feature="serde")]
-        impl<'de> ::serde::Deserialize<'de> for $t {
-            fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<$t, D::Error> {
-                if d.is_human_readable() {
-                    struct HexVisitor;
-
-                    impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
-                        type Value = $t;
-
-                        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) {
-                                ::hashes::hex::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,
-                        {
-                            ::hashes::hex::FromHex::from_hex(v).map_err(E::custom)
-                        }
-                    }
-
-                    d.deserialize_str(HexVisitor)
-                } else {
-                    struct BytesVisitor;
-
-                    impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
-                        type Value = $t;
-
-                        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() != $len {
-                                Err(E::invalid_length(v.len(), &stringify!($len)))
-                            } else {
-                                let mut ret = [0; $len];
-                                ret.copy_from_slice(v);
-                                Ok($t(ret))
-                            }
-                        }
-                    }
-
-                    d.deserialize_bytes(BytesVisitor)
-                }
-            }
-        }
-    )
-}
-
-macro_rules! user_enum {
-    (
-        $(#[$attr:meta])*
-        pub enum $name:ident {
-            $(#[$doc:meta]
-              $elem:ident <-> $txt:expr),*
-        }
-    ) => (
-        $(#[$attr])*
-        pub enum $name {
-            $(#[$doc] $elem),*
-        }
-
-        impl ::std::fmt::Debug for $name {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                f.pad(match *self {
-                    $($name::$elem => $txt),*
-                })
-            }
-        }
-
-        impl ::std::fmt::Display for $name {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                f.pad(match *self {
-                    $($name::$elem => $txt),*
-                })
-            }
-        }
-
-        impl ::std::str::FromStr for $name {
-            type Err = ::std::io::Error;
-            #[inline]
-            fn from_str(s: &str) -> Result<Self, Self::Err> {
-                match s {
-                    $($txt => Ok($name::$elem)),*,
-                    _ => Err(::std::io::Error::new(
-                        ::std::io::ErrorKind::InvalidInput,
-                        format!("Unknown network (type {})", s),
-                    )),
-                }
-            }
-        }
-
-        #[cfg(feature = "serde")]
-        impl<'de> $crate::serde::Deserialize<'de> for $name {
-            #[inline]
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: $crate::serde::Deserializer<'de>,
-            {
-                use $crate::std::fmt::{self, Formatter};
-
-                struct Visitor;
-                impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
-                    type Value = $name;
-
-                    fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
-                        formatter.write_str("an enum value")
-                    }
-
-                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        static FIELDS: &'static [&'static str] = &[$(stringify!($txt)),*];
-
-                        $( if v == $txt { Ok($name::$elem) } )else*
-                        else {
-                            Err(E::unknown_variant(v, FIELDS))
-                        }
-                    }
-
-                    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        self.visit_str(v)
-                    }
-
-                    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-                    where
-                        E: $crate::serde::de::Error,
-                    {
-                        self.visit_str(&v)
-                    }
-
-                }
-
-                deserializer.deserialize_str(Visitor)
-            }
-        }
-
-        #[cfg(feature = "serde")]
-        impl ::serde::Serialize for $name {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: ::serde::Serializer,
-            {
-                serializer.collect_str(&self)
-            }
-        }
-    );
-}
diff --git a/src/lib.rs b/src/lib.rs
deleted file mode 100644
index 6ba26f92..00000000
--- a/src/lib.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! # Rust Bitcoin Library
-//!
-//! This is a library for which supports the Bitcoin network protocol and associated
-//! primitives. It is designed for Rust programs built to work with the Bitcoin
-//! network.
-//!
-//! It is also written entirely in Rust to illustrate the benefits of strong type
-//! safety, including ownership and lifetime, for financial and/or cryptographic
-//! software.
-//!
-
-#![crate_name = "bitcoin"]
-#![crate_type = "dylib"]
-#![crate_type = "rlib"]
-
-// Experimental features we need
-#![cfg_attr(all(test, feature = "unstable"), feature(test))]
-
-// Clippy whitelist
-#![cfg_attr(feature = "clippy", allow(needless_range_loop))] // suggests making a big mess of array newtypes
-#![cfg_attr(feature = "clippy", allow(extend_from_slice))]   // `extend_from_slice` only available since 1.6
-
-// Coding conventions
-#![forbid(unsafe_code)]
-#![deny(non_upper_case_globals)]
-#![deny(non_camel_case_types)]
-#![deny(non_snake_case)]
-#![deny(unused_mut)]
-#![deny(dead_code)]
-#![deny(unused_imports)]
-#![deny(missing_docs)]
-#![forbid(unsafe_code)]
-
-// In general, rust is absolutely horrid at supporting users doing things like,
-// for example, compiling Rust code for real environments. Disable useless lints
-// that don't do anything but annoy us and cant actually ever be resolved.
-#![allow(bare_trait_objects)]
-#![allow(ellipsis_inclusive_range_patterns)]
-
-// Re-exported dependencies.
-#[macro_use] pub extern crate bitcoin_hashes as hashes;
-pub extern crate secp256k1;
-pub extern crate bech32;
-
-#[cfg(any(test, feature = "serde"))] extern crate hex;
-#[cfg(feature = "serde")] extern crate serde;
-#[cfg(all(test, feature = "serde"))] #[macro_use] extern crate serde_derive; // for 1.22.0 compat
-#[cfg(all(test, feature = "serde"))] extern crate serde_json;
-#[cfg(all(test, feature = "serde"))] extern crate serde_test;
-#[cfg(all(test, feature = "unstable"))] extern crate test;
-#[cfg(feature="bitcoinconsensus")] extern crate bitcoinconsensus;
-
-#[cfg(target_pointer_width = "16")]
-compile_error!("rust-bitcoin cannot be used on 16-bit architectures");
-
-#[cfg(test)]
-#[macro_use]
-mod test_macros;
-#[macro_use]
-mod internal_macros;
-#[macro_use]
-pub mod network;
-pub mod blockdata;
-pub mod util;
-pub mod consensus;
-// Do not remove: required in order to get hash types implementation macros to work correctly
-#[allow(unused_imports)]
-pub mod hash_types;
-
-pub use hash_types::*;
-pub use blockdata::block::Block;
-pub use blockdata::block::BlockHeader;
-pub use blockdata::script::Script;
-pub use blockdata::transaction::Transaction;
-pub use blockdata::transaction::TxIn;
-pub use blockdata::transaction::TxOut;
-pub use blockdata::transaction::OutPoint;
-pub use blockdata::transaction::SigHashType;
-pub use consensus::encode::VarInt;
-pub use network::constants::Network;
-pub use util::Error;
-pub use util::address::Address;
-pub use util::address::AddressType;
-pub use util::amount::Amount;
-pub use util::amount::SignedAmount;
-pub use util::hash::BitcoinHash;
-pub use util::key::PrivateKey;
-pub use util::key::PublicKey;
-pub use util::merkleblock::MerkleBlock;
diff --git a/src/network/address.rs b/src/network/address.rs
deleted file mode 100644
index f9dcbf0b..00000000
--- a/src/network/address.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Bitcoin network addresses
-//!
-//! This module defines the structures and functions needed to encode
-//! network addresses in Bitcoin messages.
-//!
-
-use std::io;
-use std::fmt;
-use std::net::{SocketAddr, Ipv6Addr, SocketAddrV4, SocketAddrV6};
-
-use network::constants::ServiceFlags;
-use consensus::encode::{self, Decodable, Encodable};
-
-/// A message which can be sent on the Bitcoin network
-#[derive(Clone, PartialEq, Eq, Hash)]
-pub struct Address {
-    /// Services provided by the peer whose address this is
-    pub services: ServiceFlags,
-    /// Network byte-order ipv6 address, or ipv4-mapped ipv6 address
-    pub address: [u16; 8],
-    /// Network port
-    pub port: u16
-}
-
-const ONION : [u16; 3] = [0xFD87, 0xD87E, 0xEB43];
-
-impl Address {
-    /// Create an address message for a socket
-    pub fn new (socket :&SocketAddr, services: ServiceFlags) -> Address {
-        let (address, port) = match socket {
-            &SocketAddr::V4(ref addr) => (addr.ip().to_ipv6_mapped().segments(), addr.port()),
-            &SocketAddr::V6(ref addr) => (addr.ip().segments(), addr.port())
-        };
-        Address { address: address, port: port, services: services }
-    }
-
-    /// extract socket address from an address message
-    /// This will return io::Error ErrorKind::AddrNotAvailable if the message contains a Tor address.
-    pub fn socket_addr (&self) -> Result<SocketAddr, io::Error> {
-        let addr = &self.address;
-        if addr[0..3] == ONION {
-            return Err(io::Error::from(io::ErrorKind::AddrNotAvailable));
-        }
-        let ipv6 = Ipv6Addr::new(
-            addr[0],addr[1],addr[2],addr[3],
-            addr[4],addr[5],addr[6],addr[7]
-        );
-        if let Some(ipv4) = ipv6.to_ipv4() {
-            Ok(SocketAddr::V4(SocketAddrV4::new(ipv4, self.port)))
-        }
-        else {
-            Ok(SocketAddr::V6(SocketAddrV6::new(ipv6, self.port, 0, 0)))
-        }
-    }
-}
-
-fn addr_to_be(addr: [u16; 8]) -> [u16; 8] {
-    [addr[0].to_be(), addr[1].to_be(), addr[2].to_be(), addr[3].to_be(),
-     addr[4].to_be(), addr[5].to_be(), addr[6].to_be(), addr[7].to_be()]
-}
-
-impl Encodable for Address {
-    #[inline]
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let len = self.services.consensus_encode(&mut s)?
-            + addr_to_be(self.address).consensus_encode(&mut s)?
-            + self.port.to_be().consensus_encode(s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for Address {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        Ok(Address {
-            services: Decodable::consensus_decode(&mut d)?,
-            address: addr_to_be(Decodable::consensus_decode(&mut d)?),
-            port: u16::from_be(Decodable::consensus_decode(d)?)
-        })
-    }
-}
-
-impl fmt::Debug for Address {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let ipv6 = Ipv6Addr::from(self.address);
-
-        match ipv6.to_ipv4() {
-            Some(addr) => write!(f, "Address {{services: {}, address: {}, port: {}}}", 
-                self.services, addr, self.port),
-            None => write!(f, "Address {{services: {}, address: {}, port: {}}}", 
-                self.services, ipv6, self.port)
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::str::FromStr;
-    use super::Address;
-    use network::constants::ServiceFlags;
-    use std::net::{SocketAddr, IpAddr, Ipv4Addr, Ipv6Addr};
-
-    use consensus::encode::{deserialize, serialize};
-
-    #[test]
-    fn serialize_address_test() {
-        assert_eq!(serialize(&Address {
-            services: ServiceFlags::NETWORK,
-            address: [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001],
-            port: 8333
-        }),
-        vec![1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-             0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1, 0x20, 0x8d]);
-    }
-
-    #[test]
-    fn debug_format_test() {
-        assert_eq!(
-            format!("The address is: {:?}", Address {
-                services: ServiceFlags::NETWORK.add(ServiceFlags::WITNESS),
-                address: [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001],
-                port: 8333
-            }), 
-            "The address is: Address {services: ServiceFlags(NETWORK|WITNESS), address: 10.0.0.1, port: 8333}"
-        );
-
-        assert_eq!(
-            format!("The address is: {:?}", Address {
-                services: ServiceFlags::NETWORK_LIMITED,
-                address: [0xFD87, 0xD87E, 0xEB43, 0, 0, 0xffff, 0x0a00, 0x0001],
-                port: 8333
-            }), 
-            "The address is: Address {services: ServiceFlags(NETWORK_LIMITED), address: fd87:d87e:eb43::ffff:a00:1, port: 8333}"
-        );
-    }
-
-    #[test]
-    fn deserialize_address_test() {
-        let mut addr: Result<Address, _> = deserialize(&[1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                                       0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0,
-                                                       0, 1, 0x20, 0x8d]);
-        assert!(addr.is_ok());
-        let full = addr.unwrap();
-        assert!(match full.socket_addr().unwrap() {
-                    SocketAddr::V4(_) => true,
-                    _ => false
-                }
-            );
-        assert_eq!(full.services, ServiceFlags::NETWORK);
-        assert_eq!(full.address, [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001]);
-        assert_eq!(full.port, 8333);
-
-        addr = deserialize(&[1u8, 0, 0, 0, 0, 0, 0, 0, 0,
-                             0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1]);
-        assert!(addr.is_err());
-    }
-
-    #[test]
-    fn test_socket_addr () {
-        let s4 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(111,222,123,4)), 5555);
-        let a4 = Address::new(&s4, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
-        assert_eq!(a4.socket_addr().unwrap(), s4);
-        let s6 = SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0x1111, 0x2222, 0x3333, 0x4444,
-        0x5555, 0x6666, 0x7777, 0x8888)), 9999);
-        let a6 = Address::new(&s6, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
-        assert_eq!(a6.socket_addr().unwrap(), s6);
-    }
-
-    #[test]
-    fn onion_test () {
-        let onionaddr = SocketAddr::new(
-            IpAddr::V6(
-            Ipv6Addr::from_str("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").unwrap()), 1111);
-        let addr = Address::new(&onionaddr, ServiceFlags::NONE);
-        assert!(addr.socket_addr().is_err());
-    }
-}
-
diff --git a/src/network/constants.rs b/src/network/constants.rs
deleted file mode 100644
index 8724398a..00000000
--- a/src/network/constants.rs
+++ /dev/null
@@ -1,360 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Network constants
-//!
-//! This module provides various constants relating to the Bitcoin network
-//! protocol, such as protocol versioning and magic header bytes.
-//!
-//! The [`Network`][1] type implements the [`Decodable`][2] and
-//! [`Encodable`][3] traits and encodes the magic bytes of the given
-//! network
-//!
-//! [1]: enum.Network.html
-//! [2]: ../../consensus/encode/trait.Decodable.html
-//! [3]: ../../consensus/encode/trait.Encodable.html
-//!
-//! # Example: encoding a network's magic bytes
-//!
-//! ```rust
-//! use bitcoin::network::constants::Network;
-//! use bitcoin::consensus::encode::serialize;
-//!
-//! let network = Network::Bitcoin;
-//! let bytes = serialize(&network.magic());
-//!
-//! assert_eq!(&bytes[..], &[0xF9, 0xBE, 0xB4, 0xD9]);
-//! ```
-
-use std::{fmt, io, ops};
-
-use consensus::encode::{self, Encodable, Decodable};
-
-/// Version of the protocol as appearing in network message headers
-pub const PROTOCOL_VERSION: u32 = 70001;
-
-user_enum! {
-    /// The cryptocurrency to act on
-    #[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Clone, Hash)]
-    pub enum Network {
-        /// Classic Bitcoin
-        Bitcoin <-> "bitcoin",
-        /// Bitcoin's testnet
-        Testnet <-> "testnet",
-        /// Bitcoin's regtest
-        Regtest <-> "regtest"
-    }
-}
-
-impl Network {
-    /// Creates a `Network` from the magic bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin::network::constants::Network;
-    ///
-    /// assert_eq!(Some(Network::Bitcoin), Network::from_magic(0xD9B4BEF9));
-    /// assert_eq!(None, Network::from_magic(0xFFFFFFFF));
-    /// ```
-    pub fn from_magic(magic: u32) -> Option<Network> {
-        // Note: any new entries here must be added to `magic` below
-        match magic {
-            0xD9B4BEF9 => Some(Network::Bitcoin),
-            0x0709110B => Some(Network::Testnet),
-            0xDAB5BFFA => Some(Network::Regtest),
-            _ => None
-        }
-    }
-
-    /// Return the network magic bytes, which should be encoded little-endian
-    /// at the start of every message
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bitcoin::network::constants::Network;
-    ///
-    /// let network = Network::Bitcoin;
-    /// assert_eq!(network.magic(), 0xD9B4BEF9);
-    /// ```
-    pub fn magic(&self) -> u32 {
-        // Note: any new entries here must be added to `from_magic` above
-        match *self {
-            Network::Bitcoin => 0xD9B4BEF9,
-            Network::Testnet => 0x0709110B,
-            Network::Regtest => 0xDAB5BFFA,
-        }
-    }
-}
-
-/// Flags to indicate which network services a node supports.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct ServiceFlags(u64);
-
-impl ServiceFlags {
-    /// NONE means no services supported.
-    pub const NONE: ServiceFlags = ServiceFlags(0);
-
-    /// NETWORK means that the node is capable of serving the complete block chain. It is currently
-    /// set by all Bitcoin Core non pruned nodes, and is unset by SPV clients or other light
-    /// clients.
-    pub const NETWORK: ServiceFlags = ServiceFlags(1 << 0);
-
-    /// GETUTXO means the node is capable of responding to the getutxo protocol request.  Bitcoin
-    /// Core does not support this but a patch set called Bitcoin XT does.
-    /// See BIP 64 for details on how this is implemented.
-    pub const GETUTXO: ServiceFlags = ServiceFlags(1 << 1);
-
-    /// BLOOM means the node is capable and willing to handle bloom-filtered connections.  Bitcoin
-    /// Core nodes used to support this by default, without advertising this bit, but no longer do
-    /// as of protocol version 70011 (= NO_BLOOM_VERSION)
-    pub const BLOOM: ServiceFlags = ServiceFlags(1 << 2);
-
-    /// WITNESS indicates that a node can be asked for blocks and transactions including witness
-    /// data.
-    pub const WITNESS: ServiceFlags = ServiceFlags(1 << 3);
-    
-    /// COMPACT_FILTERS means the node will service basic block filter requests.
-    /// See BIP157 and BIP158 for details on how this is implemented.
-    pub const COMPACT_FILTERS: ServiceFlags = ServiceFlags(1 << 6);
-
-    /// NETWORK_LIMITED means the same as NODE_NETWORK with the limitation of only serving the last
-    /// 288 (2 day) blocks.
-    /// See BIP159 for details on how this is implemented.
-    pub const NETWORK_LIMITED: ServiceFlags = ServiceFlags(1 << 10);
-
-    // NOTE: When adding new flags, remember to update the Display impl accordingly.
-
-    /// Add [ServiceFlags] together.
-    ///
-    /// Returns itself.
-    pub fn add(&mut self, other: ServiceFlags) -> ServiceFlags {
-        self.0 |= other.0;
-        *self
-    }
-
-    /// Remove [ServiceFlags] from this.
-    ///
-    /// Returns itself.
-    pub fn remove(&mut self, other: ServiceFlags) -> ServiceFlags {
-        self.0 ^= other.0;
-        *self
-    }
-
-    /// Check whether [ServiceFlags] are included in this one.
-    pub fn has(&self, flags: ServiceFlags) -> bool {
-        (self.0 | flags.0) == self.0
-    }
-
-    /// Get the integer representation of this [ServiceFlags].
-    pub fn as_u64(&self) -> u64 {
-        self.0
-    }
-}
-
-impl fmt::LowerHex for ServiceFlags {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::LowerHex::fmt(&self.0, f)
-    }
-}
-
-impl fmt::UpperHex for ServiceFlags {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::UpperHex::fmt(&self.0, f)
-    }
-}
-
-impl fmt::Display for ServiceFlags {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if *self == ServiceFlags::NONE {
-            return write!(f, "ServiceFlags(NONE)");
-        }
-
-        let mut flags = self.clone();
-        let mut first = true;
-        macro_rules! write_flag {
-            ($f:ident) => {
-                if flags.has(ServiceFlags::$f) {
-                    if !first {
-                        write!(f, "|")?;
-                    }
-                    first = false;
-                    write!(f, stringify!($f))?;
-                    flags.remove(ServiceFlags::$f);
-                }
-            }
-        }
-        write!(f, "ServiceFlags(")?;
-        write_flag!(NETWORK);
-        write_flag!(GETUTXO);
-        write_flag!(BLOOM);
-        write_flag!(WITNESS);
-        write_flag!(COMPACT_FILTERS);
-        write_flag!(NETWORK_LIMITED);
-        // If there are unknown flags left, we append them in hex.
-        if flags != ServiceFlags::NONE {
-            if !first {
-                write!(f, "|")?;
-            }
-            write!(f, "0x{:x}", flags)?;
-        }
-        write!(f, ")")
-    }
-}
-
-impl From<u64> for ServiceFlags {
-    fn from(f: u64) -> Self {
-        ServiceFlags(f)
-    }
-}
-
-impl Into<u64> for ServiceFlags {
-    fn into(self) -> u64 {
-        self.0
-    }
-}
-
-impl ops::BitOr for ServiceFlags {
-    type Output = Self;
-
-    fn bitor(mut self, rhs: Self) -> Self {
-        self.add(rhs)
-    }
-}
-
-impl ops::BitOrAssign for ServiceFlags {
-    fn bitor_assign(&mut self, rhs: Self) {
-        self.add(rhs);
-    }
-}
-
-impl ops::BitXor for ServiceFlags {
-    type Output = Self;
-
-    fn bitxor(mut self, rhs: Self) -> Self {
-        self.remove(rhs)
-    }
-}
-
-impl ops::BitXorAssign for ServiceFlags {
-    fn bitxor_assign(&mut self, rhs: Self) {
-        self.remove(rhs);
-    }
-}
-
-impl Encodable for ServiceFlags {
-    #[inline]
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        self.0.consensus_encode(&mut s)
-    }
-}
-
-impl Decodable for ServiceFlags {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        Ok(ServiceFlags(Decodable::consensus_decode(&mut d)?))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Network, ServiceFlags};
-    use consensus::encode::{deserialize, serialize};
-
-    #[test]
-    fn serialize_test() {
-        assert_eq!(
-            serialize(&Network::Bitcoin.magic()),
-            &[0xf9, 0xbe, 0xb4, 0xd9]
-        );
-        assert_eq!(
-            serialize(&Network::Testnet.magic()),
-            &[0x0b, 0x11, 0x09, 0x07]
-        );
-        assert_eq!(
-            serialize(&Network::Regtest.magic()),
-            &[0xfa, 0xbf, 0xb5, 0xda]
-        );
-
-        assert_eq!(
-            deserialize(&[0xf9, 0xbe, 0xb4, 0xd9]).ok(),
-            Some(Network::Bitcoin.magic())
-        );
-        assert_eq!(
-            deserialize(&[0x0b, 0x11, 0x09, 0x07]).ok(),
-            Some(Network::Testnet.magic())
-        );
-        assert_eq!(
-            deserialize(&[0xfa, 0xbf, 0xb5, 0xda]).ok(),
-            Some(Network::Regtest.magic())
-        );
-    }
-
-    #[test]
-    fn string_test() {
-        assert_eq!(Network::Bitcoin.to_string(), "bitcoin");
-        assert_eq!(Network::Testnet.to_string(), "testnet");
-        assert_eq!(Network::Regtest.to_string(), "regtest");
-
-        assert_eq!("bitcoin".parse::<Network>().unwrap(), Network::Bitcoin);
-        assert_eq!("testnet".parse::<Network>().unwrap(), Network::Testnet);
-        assert_eq!("regtest".parse::<Network>().unwrap(), Network::Regtest);
-        assert!("fakenet".parse::<Network>().is_err());
-    }
-
-    #[test]
-    fn service_flags_test() {
-        let all = [
-            ServiceFlags::NETWORK,
-            ServiceFlags::GETUTXO,
-            ServiceFlags::BLOOM,
-            ServiceFlags::WITNESS,
-            ServiceFlags::COMPACT_FILTERS,
-            ServiceFlags::NETWORK_LIMITED,
-        ];
-
-        let mut flags = ServiceFlags::NONE;
-        for f in all.iter() {
-            assert!(!flags.has(*f));
-        }
-
-        flags |= ServiceFlags::WITNESS;
-        assert_eq!(flags, ServiceFlags::WITNESS);
-
-        let mut flags2 = flags | ServiceFlags::GETUTXO;
-        for f in all.iter() {
-            assert_eq!(flags2.has(*f), *f == ServiceFlags::WITNESS || *f == ServiceFlags::GETUTXO);
-        }
-
-        flags2 ^= ServiceFlags::WITNESS;
-        assert_eq!(flags2, ServiceFlags::GETUTXO);
-        
-        flags2 |= ServiceFlags::COMPACT_FILTERS;
-        flags2 ^= ServiceFlags::GETUTXO;
-        assert_eq!(flags2, ServiceFlags::COMPACT_FILTERS);
-
-        // Test formatting.
-        assert_eq!("ServiceFlags(NONE)", ServiceFlags::NONE.to_string());
-        assert_eq!("ServiceFlags(WITNESS)", ServiceFlags::WITNESS.to_string());
-        let flag = ServiceFlags::WITNESS | ServiceFlags::BLOOM | ServiceFlags::NETWORK;
-        assert_eq!("ServiceFlags(NETWORK|BLOOM|WITNESS)", flag.to_string());
-        let flag = ServiceFlags::WITNESS | 0xf0.into();
-        assert_eq!("ServiceFlags(WITNESS|COMPACT_FILTERS|0xb0)", flag.to_string());
-    }
-}
-
diff --git a/src/network/message.rs b/src/network/message.rs
deleted file mode 100644
index 82c74060..00000000
--- a/src/network/message.rs
+++ /dev/null
@@ -1,535 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Network message
-//!
-//! This module defines the `Message` traits which are used
-//! for (de)serializing Bitcoin objects for transmission on the network. It
-//! also defines (de)serialization routines for many primitives.
-//!
-
-use std::{io, iter, mem, fmt};
-use std::borrow::Cow;
-use std::io::Cursor;
-
-use blockdata::block;
-use blockdata::transaction;
-use network::address::Address;
-use network::message_network;
-use network::message_blockdata;
-use network::message_filter;
-use consensus::encode::{CheckedData, Decodable, Encodable, VarInt};
-use consensus::{encode, serialize};
-use consensus::encode::MAX_VEC_SIZE;
-
-/// Serializer for command string
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct CommandString(Cow<'static, str>);
-
-impl fmt::Display for CommandString {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(self.0.as_ref())
-    }
-}
-
-impl From<&'static str> for CommandString {
-    fn from(f: &'static str) -> Self {
-        CommandString(f.into())
-    }
-}
-
-impl From<String> for CommandString {
-    fn from(f: String) -> Self {
-        CommandString(f.into())
-    }
-}
-
-impl AsRef<str> for CommandString {
-    fn as_ref(&self) -> &str {
-        self.0.as_ref()
-    }
-}
-
-impl Encodable for CommandString {
-    #[inline]
-    fn consensus_encode<S: io::Write>(
-        &self,
-        s: S,
-    ) -> Result<usize, encode::Error> {
-        let mut rawbytes = [0u8; 12];
-        let strbytes = self.0.as_bytes();
-        if strbytes.len() > 12 {
-            return Err(encode::Error::UnrecognizedNetworkCommand(self.0.clone().into_owned()));
-        }
-        for x in 0..strbytes.len() {
-            rawbytes[x] = strbytes[x];
-        }
-        rawbytes.consensus_encode(s)
-    }
-}
-
-impl Decodable for CommandString {
-    #[inline]
-    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
-        let rawbytes: [u8; 12] = Decodable::consensus_decode(d)?;
-        let rv = iter::FromIterator::from_iter(
-            rawbytes
-                .iter()
-                .filter_map(|&u| if u > 0 { Some(u as char) } else { None })
-        );
-        Ok(CommandString(rv))
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-/// A Network message
-pub struct RawNetworkMessage {
-    /// Magic bytes to identify the network these messages are meant for
-    pub magic: u32,
-    /// The actual message data
-    pub payload: NetworkMessage
-}
-
-#[derive(Clone, PartialEq, Eq, Debug)]
-/// A Network message payload. Proper documentation is available on at
-/// [Bitcoin Wiki: Protocol Specification](https://en.bitcoin.it/wiki/Protocol_specification)
-pub enum NetworkMessage {
-    /// `version`
-    Version(message_network::VersionMessage),
-    /// `verack`
-    Verack,
-    /// `addr`
-    Addr(Vec<(u32, Address)>),
-    /// `inv`
-    Inv(Vec<message_blockdata::Inventory>),
-    /// `getdata`
-    GetData(Vec<message_blockdata::Inventory>),
-    /// `notfound`
-    NotFound(Vec<message_blockdata::Inventory>),
-    /// `getblocks`
-    GetBlocks(message_blockdata::GetBlocksMessage),
-    /// `getheaders`
-    GetHeaders(message_blockdata::GetHeadersMessage),
-    /// `mempool`
-    MemPool,
-    /// tx
-    Tx(transaction::Transaction),
-    /// `block`
-    Block(block::Block),
-    /// `headers`
-    Headers(Vec<block::BlockHeader>),
-    /// `sendheaders`
-    SendHeaders,
-    /// `getaddr`
-    GetAddr,
-    // TODO: checkorder,
-    // TODO: submitorder,
-    // TODO: reply,
-    /// `ping`
-    Ping(u64),
-    /// `pong`
-    Pong(u64),
-    // TODO: bloom filtering
-    /// BIP157 getcfilters
-    GetCFilters(message_filter::GetCFilters),
-    /// BIP157 cfilter
-    CFilter(message_filter::CFilter),
-    /// BIP157 getcfheaders
-    GetCFHeaders(message_filter::GetCFHeaders),
-    /// BIP157 cfheaders
-    CFHeaders(message_filter::CFHeaders),
-    /// BIP157 getcfcheckpt
-    GetCFCheckpt(message_filter::GetCFCheckpt),
-    /// BIP157 cfcheckpt
-    CFCheckpt(message_filter::CFCheckpt),
-    /// `alert`
-    Alert(Vec<u8>),
-    /// `reject`
-    Reject(message_network::Reject)
-}
-
-impl NetworkMessage {
-    /// Return the message command. This is useful for debug outputs.
-    pub fn cmd(&self) -> &'static str {
-        match *self {
-            NetworkMessage::Version(_) => "version",
-            NetworkMessage::Verack     => "verack",
-            NetworkMessage::Addr(_)    => "addr",
-            NetworkMessage::Inv(_)     => "inv",
-            NetworkMessage::GetData(_) => "getdata",
-            NetworkMessage::NotFound(_) => "notfound",
-            NetworkMessage::GetBlocks(_) => "getblocks",
-            NetworkMessage::GetHeaders(_) => "getheaders",
-            NetworkMessage::MemPool    => "mempool",
-            NetworkMessage::Tx(_)      => "tx",
-            NetworkMessage::Block(_)   => "block",
-            NetworkMessage::Headers(_) => "headers",
-            NetworkMessage::SendHeaders => "sendheaders",
-            NetworkMessage::GetAddr    => "getaddr",
-            NetworkMessage::Ping(_)    => "ping",
-            NetworkMessage::Pong(_)    => "pong",
-            NetworkMessage::GetCFilters(_) => "getcfilters",
-            NetworkMessage::CFilter(_) => "cfilter",
-            NetworkMessage::GetCFHeaders(_) => "getcfheaders",
-            NetworkMessage::CFHeaders(_) => "cfheaders",
-            NetworkMessage::GetCFCheckpt(_) => "getcfcheckpt",
-            NetworkMessage::CFCheckpt(_) => "cfcheckpt",
-            NetworkMessage::Alert(_)    => "alert",
-            NetworkMessage::Reject(_)    => "reject",
-        }
-    }
-
-    /// Return the CommandString for the message command.
-    pub fn command(&self) -> CommandString {
-        self.cmd().into()
-    }
-}
-
-impl RawNetworkMessage {
-    /// Return the message command. This is useful for debug outputs.
-    pub fn cmd(&self) -> &'static str {
-        self.payload.cmd()
-    }
-
-    /// Return the CommandString for the message command.
-    pub fn command(&self) -> CommandString {
-        self.payload.command()
-    }
-}
-
-struct HeaderSerializationWrapper<'a>(&'a Vec<block::BlockHeader>);
-
-impl<'a> Encodable for HeaderSerializationWrapper<'a> {
-    #[inline]
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let mut len = 0;
-        len += VarInt(self.0.len() as u64).consensus_encode(&mut s)?;
-        for header in self.0.iter() {
-            len += header.consensus_encode(&mut s)?;
-            len += 0u8.consensus_encode(&mut s)?;
-        }
-        Ok(len)
-    }
-}
-
-impl Encodable for RawNetworkMessage {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let mut len = 0;
-        len += self.magic.consensus_encode(&mut s)?;
-        len += self.command().consensus_encode(&mut s)?;
-        len += CheckedData(match self.payload {
-            NetworkMessage::Version(ref dat) => serialize(dat),
-            NetworkMessage::Addr(ref dat)    => serialize(dat),
-            NetworkMessage::Inv(ref dat)     => serialize(dat),
-            NetworkMessage::GetData(ref dat) => serialize(dat),
-            NetworkMessage::NotFound(ref dat) => serialize(dat),
-            NetworkMessage::GetBlocks(ref dat) => serialize(dat),
-            NetworkMessage::GetHeaders(ref dat) => serialize(dat),
-            NetworkMessage::Tx(ref dat)      => serialize(dat),
-            NetworkMessage::Block(ref dat)   => serialize(dat),
-            NetworkMessage::Headers(ref dat) => serialize(&HeaderSerializationWrapper(dat)),
-            NetworkMessage::Ping(ref dat)    => serialize(dat),
-            NetworkMessage::Pong(ref dat)    => serialize(dat),
-            NetworkMessage::GetCFilters(ref dat) => serialize(dat),
-            NetworkMessage::CFilter(ref dat) => serialize(dat),
-            NetworkMessage::GetCFHeaders(ref dat) => serialize(dat),
-            NetworkMessage::CFHeaders(ref dat) => serialize(dat),
-            NetworkMessage::GetCFCheckpt(ref dat) => serialize(dat),
-            NetworkMessage::CFCheckpt(ref dat) => serialize(dat),
-            NetworkMessage::Alert(ref dat)    => serialize(dat),
-            NetworkMessage::Reject(ref dat) => serialize(dat),
-            NetworkMessage::Verack
-            | NetworkMessage::SendHeaders
-            | NetworkMessage::MemPool
-            | NetworkMessage::GetAddr => vec![],
-        }).consensus_encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-struct HeaderDeserializationWrapper(Vec<block::BlockHeader>);
-
-impl Decodable for HeaderDeserializationWrapper {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let len = VarInt::consensus_decode(&mut d)?.0;
-        let byte_size = (len as usize)
-                            .checked_mul(mem::size_of::<block::BlockHeader>())
-                            .ok_or(encode::Error::ParseFailed("Invalid length"))?;
-        if byte_size > MAX_VEC_SIZE {
-            return Err(encode::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)?);
-            if u8::consensus_decode(&mut d)? != 0u8 {
-                return Err(encode::Error::ParseFailed("Headers message should not contain transactions"));
-            }
-        }
-        Ok(HeaderDeserializationWrapper(ret))
-    }
-}
-
-impl Decodable for RawNetworkMessage {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let magic = Decodable::consensus_decode(&mut d)?;
-        let cmd = CommandString::consensus_decode(&mut d)?.0;
-        let raw_payload = CheckedData::consensus_decode(&mut d)?.0;
-
-        let mut mem_d = Cursor::new(raw_payload);
-        let payload = match &cmd[..] {
-            "version" => NetworkMessage::Version(Decodable::consensus_decode(&mut mem_d)?),
-            "verack"  => NetworkMessage::Verack,
-            "addr"    => NetworkMessage::Addr(Decodable::consensus_decode(&mut mem_d)?),
-            "inv"     => NetworkMessage::Inv(Decodable::consensus_decode(&mut mem_d)?),
-            "getdata" => NetworkMessage::GetData(Decodable::consensus_decode(&mut mem_d)?),
-            "notfound" => NetworkMessage::NotFound(Decodable::consensus_decode(&mut mem_d)?),
-            "getblocks" => NetworkMessage::GetBlocks(Decodable::consensus_decode(&mut mem_d)?),
-            "getheaders" => NetworkMessage::GetHeaders(Decodable::consensus_decode(&mut mem_d)?),
-            "mempool" => NetworkMessage::MemPool,
-            "block"   => NetworkMessage::Block(Decodable::consensus_decode(&mut mem_d)?),
-            "headers" => NetworkMessage::Headers(
-                HeaderDeserializationWrapper::consensus_decode(&mut mem_d)?.0
-            ),
-            "sendheaders" => NetworkMessage::SendHeaders,
-            "getaddr" => NetworkMessage::GetAddr,
-            "ping"    => NetworkMessage::Ping(Decodable::consensus_decode(&mut mem_d)?),
-            "pong"    => NetworkMessage::Pong(Decodable::consensus_decode(&mut mem_d)?),
-            "tx"      => NetworkMessage::Tx(Decodable::consensus_decode(&mut mem_d)?),
-            "getcfilters" => NetworkMessage::GetCFilters(Decodable::consensus_decode(&mut mem_d)?),
-            "cfilter" => NetworkMessage::CFilter(Decodable::consensus_decode(&mut mem_d)?),
-            "getcfheaders" => NetworkMessage::GetCFHeaders(Decodable::consensus_decode(&mut mem_d)?),
-            "cfheaders" => NetworkMessage::CFHeaders(Decodable::consensus_decode(&mut mem_d)?),
-            "getcfcheckpt" => NetworkMessage::GetCFCheckpt(Decodable::consensus_decode(&mut mem_d)?),
-            "cfcheckpt" => NetworkMessage::CFCheckpt(Decodable::consensus_decode(&mut mem_d)?),
-            "reject" => NetworkMessage::Reject(Decodable::consensus_decode(&mut mem_d)?),
-            "alert"   => NetworkMessage::Alert(Decodable::consensus_decode(&mut mem_d)?),
-            _ => return Err(encode::Error::UnrecognizedNetworkCommand(cmd.into_owned())),
-        };
-        Ok(RawNetworkMessage {
-            magic: magic,
-            payload: payload
-        })
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::io;
-    use super::{RawNetworkMessage, NetworkMessage, CommandString};
-    use network::constants::ServiceFlags;
-    use consensus::encode::{Encodable, deserialize, deserialize_partial, serialize};
-    use hex::decode as hex_decode;
-    use hashes::sha256d::Hash;
-    use hashes::Hash as HashTrait;
-    use network::address::Address;
-    use super::message_network::{Reject, RejectReason, VersionMessage};
-    use network::message_blockdata::{Inventory, GetBlocksMessage, GetHeadersMessage};
-    use blockdata::block::{Block, BlockHeader};
-    use network::message_filter::{GetCFilters, CFilter, GetCFHeaders, CFHeaders, GetCFCheckpt, CFCheckpt};
-    use blockdata::transaction::Transaction;
-
-    fn hash(slice: [u8;32]) -> Hash {
-        Hash::from_slice(&slice).unwrap()
-    }
-
-    #[test]
-    fn full_round_ser_der_raw_network_message_test() {
-        // TODO: Impl Rand traits here to easily generate random values.
-        let version_msg: VersionMessage = deserialize(&hex_decode("721101000100000000000000e6e0845300000000010000000000000000000000000000000000ffff0000000000000100000000000000fd87d87eeb4364f22cf54dca59412db7208d47d920cffce83ee8102f5361746f7368693a302e392e39392f2c9f040001").unwrap()).unwrap();
-        let tx: Transaction = deserialize(&hex_decode("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap()).unwrap();
-        let block: Block = deserialize(&hex_decode("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").unwrap()).unwrap();
-        let header: BlockHeader = deserialize(&hex_decode("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914cd74d6e49ffff001d323b3a7b").unwrap()).unwrap();
-
-        let msgs = vec![
-            NetworkMessage::Version(version_msg),
-            NetworkMessage::Verack,
-            NetworkMessage::Addr(vec![(45, Address::new(&([123,255,000,100], 833).into(), ServiceFlags::NETWORK))]),
-            NetworkMessage::Inv(vec![Inventory::Block(hash([8u8; 32]).into())]),
-            NetworkMessage::GetData(vec![Inventory::Transaction(hash([45u8; 32]).into())]),
-            NetworkMessage::NotFound(vec![Inventory::Error]),
-            NetworkMessage::GetBlocks(GetBlocksMessage::new(vec![hash([1u8; 32]).into(), hash([4u8; 32]).into()], hash([5u8; 32]).into())),
-            NetworkMessage::GetHeaders(GetHeadersMessage::new(vec![hash([10u8; 32]).into(), hash([40u8; 32]).into()], hash([50u8; 32]).into())),
-            NetworkMessage::MemPool,
-            NetworkMessage::Tx(tx),
-            NetworkMessage::Block(block),
-            NetworkMessage::Headers(vec![header]),
-            NetworkMessage::SendHeaders,
-            NetworkMessage::GetAddr,
-            NetworkMessage::Ping(15),
-            NetworkMessage::Pong(23),
-            NetworkMessage::GetCFilters(GetCFilters{filter_type: 2, start_height: 52, stop_hash: hash([42u8; 32]).into()}),
-            NetworkMessage::CFilter(CFilter{filter_type: 7, block_hash: hash([25u8; 32]).into(), filter: vec![1,2,3]}),
-            NetworkMessage::GetCFHeaders(GetCFHeaders{filter_type: 4, start_height: 102, stop_hash: hash([47u8; 32]).into()}),
-            NetworkMessage::CFHeaders(CFHeaders{filter_type: 13, stop_hash: hash([53u8; 32]).into(), previous_filter: hash([12u8; 32]).into(), filter_hashes: vec![hash([4u8; 32]).into(), hash([12u8; 32]).into()]}),
-            NetworkMessage::GetCFCheckpt(GetCFCheckpt{filter_type: 17, stop_hash: hash([25u8; 32]).into()}),
-            NetworkMessage::CFCheckpt(CFCheckpt{filter_type: 27, stop_hash: hash([77u8; 32]).into(), filter_headers: vec![hash([3u8; 32]).into(), hash([99u8; 32]).into()]}),
-            NetworkMessage::Alert(vec![45,66,3,2,6,8,9,12,3,130]),
-            NetworkMessage::Reject(Reject{message: "Test reject".into(), ccode: RejectReason::Duplicate, reason: "Cause".into(), hash: hash([255u8; 32])}),
-        ];
-
-        for msg in msgs {
-            let raw_msg = RawNetworkMessage {magic: 57, payload: msg};
-            assert_eq!(deserialize::<RawNetworkMessage>(&serialize(&raw_msg)).unwrap(), raw_msg);
-        }
-
-    }
-
-    #[test]
-    fn serialize_commandstring_test() {
-        let cs = CommandString("Andrew".into());
-        assert_eq!(serialize(&cs), vec![0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
-
-        // Test oversized one.
-        let mut encoder = io::Cursor::new(vec![]);
-        assert!(CommandString("AndrewAndrewA".into()).consensus_encode(&mut encoder).is_err());
-    }
-
-    #[test]
-    fn deserialize_commandstring_test() {
-        let cs: Result<CommandString, _> = deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
-        assert!(cs.is_ok());
-        assert_eq!(cs.as_ref().unwrap().to_string(), "Andrew".to_owned());
-        assert_eq!(cs.unwrap(), "Andrew".into());
-
-        let short_cs: Result<CommandString, _> = deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0]);
-        assert!(short_cs.is_err());
-    }
-
-    #[test]
-    fn serialize_verack_test() {
-        assert_eq!(serialize(&RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::Verack }),
-                             vec![0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x61,
-                                  0x63, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                                  0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
-    }
-
-    #[test]
-    fn serialize_ping_test() {
-        assert_eq!(serialize(&RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::Ping(100) }),
-                             vec![0xf9, 0xbe, 0xb4, 0xd9, 0x70, 0x69, 0x6e, 0x67,
-                                  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                                  0x08, 0x00, 0x00, 0x00, 0x24, 0x67, 0xf1, 0x1d,
-                                  0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
-    }
-
-
-    #[test]
-    fn serialize_mempool_test() {
-        assert_eq!(serialize(&RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::MemPool }),
-                             vec![0xf9, 0xbe, 0xb4, 0xd9, 0x6d, 0x65, 0x6d, 0x70,
-                                  0x6f, 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00,
-                                  0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
-    }
-
-    #[test]
-    fn serialize_getaddr_test() {
-        assert_eq!(serialize(&RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::GetAddr }),
-                             vec![0xf9, 0xbe, 0xb4, 0xd9, 0x67, 0x65, 0x74, 0x61,
-                                  0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
-                                  0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
-    }
-
-    #[test]
-    fn deserialize_getaddr_test() {
-        let msg = deserialize(
-            &[0xf9, 0xbe, 0xb4, 0xd9, 0x67, 0x65, 0x74, 0x61,
-                0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
-        let preimage = RawNetworkMessage { magic: 0xd9b4bef9, payload: NetworkMessage::GetAddr };
-        assert!(msg.is_ok());
-        let msg : RawNetworkMessage = msg.unwrap();
-        assert_eq!(preimage.magic, msg.magic);
-        assert_eq!(preimage.payload, msg.payload);
-    }
-
-    #[test]
-    fn deserialize_version_test() {
-        let msg = deserialize::<RawNetworkMessage>(
-            &[  0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
-                0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
-                0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-                0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
-                0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
-                0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
-                0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01 ]);
-
-        assert!(msg.is_ok());
-        let msg = msg.unwrap();
-        assert_eq!(msg.magic, 0xd9b4bef9);
-        if let NetworkMessage::Version(version_msg) = msg.payload {
-            assert_eq!(version_msg.version, 70015);
-            assert_eq!(version_msg.services, ServiceFlags::NETWORK | ServiceFlags::BLOOM | ServiceFlags::WITNESS | ServiceFlags::NETWORK_LIMITED);
-            assert_eq!(version_msg.timestamp, 1548554224);
-            assert_eq!(version_msg.nonce, 13952548347456104954);
-            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
-            assert_eq!(version_msg.start_height, 560275);
-            assert_eq!(version_msg.relay, true);
-        } else {
-            panic!("Wrong message type");
-        }
-    }
-
-    #[test]
-    fn deserialize_partial_message_test() {
-        let data = [  0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
-            0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
-            0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-            0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
-            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
-            0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
-            0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01, 0, 0 ];
-        let msg = deserialize_partial::<RawNetworkMessage>(&data);
-        assert!(msg.is_ok());
-
-        let (msg, consumed) = msg.unwrap();
-        assert_eq!(consumed, data.to_vec().len() - 2);
-        assert_eq!(msg.magic, 0xd9b4bef9);
-        if let NetworkMessage::Version(version_msg) = msg.payload {
-            assert_eq!(version_msg.version, 70015);
-            assert_eq!(version_msg.services, ServiceFlags::NETWORK | ServiceFlags::BLOOM | ServiceFlags::WITNESS | ServiceFlags::NETWORK_LIMITED);
-            assert_eq!(version_msg.timestamp, 1548554224);
-            assert_eq!(version_msg.nonce, 13952548347456104954);
-            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
-            assert_eq!(version_msg.start_height, 560275);
-            assert_eq!(version_msg.relay, true);
-        } else {
-            panic!("Wrong message type");
-        }
-    }
-}
diff --git a/src/network/message_blockdata.rs b/src/network/message_blockdata.rs
deleted file mode 100644
index a758c3c4..00000000
--- a/src/network/message_blockdata.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Blockdata network messages
-//!
-//! This module describes network messages which are used for passing
-//! Bitcoin data (blocks and transactions) around.
-//!
-
-use std::io;
-
-use hashes::sha256d;
-
-use network::constants;
-use consensus::encode::{self, Decodable, Encodable};
-use hash_types::{BlockHash, Txid, Wtxid};
-
-/// An inventory item.
-#[derive(PartialEq, Eq, Clone, Debug, Copy, Hash)]
-pub enum Inventory {
-    /// Error --- these inventories can be ignored
-    Error,
-    /// Transaction
-    Transaction(Txid),
-    /// Block
-    Block(BlockHash),
-    /// Witness Transaction
-    WitnessTransaction(Wtxid),
-    /// Witness Block
-    WitnessBlock(BlockHash),
-}
-
-impl Encodable for Inventory {
-    #[inline]
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        macro_rules! encode_inv {
-            ($code:expr, $item:expr) => {
-                u32::consensus_encode(&$code, &mut s)? +
-                $item.consensus_encode(&mut s)?
-            }
-        }
-        Ok(match *self {
-            Inventory::Error => encode_inv!(0, sha256d::Hash::default()),
-            Inventory::Transaction(ref t) => encode_inv!(1, t),
-            Inventory::Block(ref b) => encode_inv!(2, b),
-            Inventory::WitnessTransaction(ref t) => encode_inv!(0x40000001, t),
-            Inventory::WitnessBlock(ref b) => encode_inv!(0x40000002, b),
-        })
-    }
-}
-
-impl Decodable for Inventory {
-    #[inline]
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let inv_type: u32 = Decodable::consensus_decode(&mut d)?;
-        Ok(match inv_type {
-            0 => Inventory::Error,
-            1 => Inventory::Transaction(Decodable::consensus_decode(&mut d)?),
-            2 => Inventory::Block(Decodable::consensus_decode(&mut d)?),
-            0x40000001 => Inventory::WitnessTransaction(Decodable::consensus_decode(&mut d)?),
-            0x40000002 => Inventory::WitnessBlock(Decodable::consensus_decode(&mut d)?),
-            tp => return Err(encode::Error::UnknownInventoryType(tp)),
-        })
-    }
-}
-
-// Some simple messages
-
-/// The `getblocks` message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct GetBlocksMessage {
-    /// The protocol version
-    pub version: u32,
-    /// Locator hashes --- ordered newest to oldest. The remote peer will
-    /// reply with its longest known chain, starting from a locator hash
-    /// if possible and block 1 otherwise.
-    pub locator_hashes: Vec<BlockHash>,
-    /// References the block to stop at, or zero to just fetch the maximum 500 blocks
-    pub stop_hash: BlockHash,
-}
-
-/// The `getheaders` message
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct GetHeadersMessage {
-    /// The protocol version
-    pub version: u32,
-    /// Locator hashes --- ordered newest to oldest. The remote peer will
-    /// reply with its longest known chain, starting from a locator hash
-    /// if possible and block 1 otherwise.
-    pub locator_hashes: Vec<BlockHash>,
-    /// References the header to stop at, or zero to just fetch the maximum 2000 headers
-    pub stop_hash: BlockHash
-}
-
-impl GetBlocksMessage {
-    /// Construct a new `getblocks` message
-    pub fn new(locator_hashes: Vec<BlockHash>, stop_hash: BlockHash) -> GetBlocksMessage {
-        GetBlocksMessage {
-            version: constants::PROTOCOL_VERSION,
-            locator_hashes: locator_hashes.clone(),
-            stop_hash: stop_hash
-        }
-    }
-}
-
-impl_consensus_encoding!(GetBlocksMessage, version, locator_hashes, stop_hash);
-
-impl GetHeadersMessage {
-    /// Construct a new `getheaders` message
-    pub fn new(locator_hashes: Vec<BlockHash>, stop_hash: BlockHash) -> GetHeadersMessage {
-        GetHeadersMessage {
-            version: constants::PROTOCOL_VERSION,
-            locator_hashes: locator_hashes,
-            stop_hash: stop_hash
-        }
-    }
-}
-
-impl_consensus_encoding!(GetHeadersMessage, version, locator_hashes, stop_hash);
-
-#[cfg(test)]
-mod tests {
-    use super::{GetHeadersMessage, GetBlocksMessage};
-
-    use hex::decode as hex_decode;
-
-    use consensus::encode::{deserialize, serialize};
-    use std::default::Default;
-
-    #[test]
-    fn getblocks_message_test() {
-        let from_sat = hex_decode("72110100014a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b0000000000000000000000000000000000000000000000000000000000000000").unwrap();
-        let genhash = hex_decode("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b").unwrap();
-
-        let decode: Result<GetBlocksMessage, _> = deserialize(&from_sat);
-        assert!(decode.is_ok());
-        let real_decode = decode.unwrap();
-        assert_eq!(real_decode.version, 70002);
-        assert_eq!(real_decode.locator_hashes.len(), 1);
-        assert_eq!(serialize(&real_decode.locator_hashes[0]), genhash);
-        assert_eq!(real_decode.stop_hash, Default::default());
-
-        assert_eq!(serialize(&real_decode), from_sat);
-    }
-
-    #[test]
-    fn getheaders_message_test() {
-        let from_sat = hex_decode("72110100014a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b0000000000000000000000000000000000000000000000000000000000000000").unwrap();
-        let genhash = hex_decode("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b").unwrap();
-
-        let decode: Result<GetHeadersMessage, _> = deserialize(&from_sat);
-        assert!(decode.is_ok());
-        let real_decode = decode.unwrap();
-        assert_eq!(real_decode.version, 70002);
-        assert_eq!(real_decode.locator_hashes.len(), 1);
-        assert_eq!(serialize(&real_decode.locator_hashes[0]), genhash);
-        assert_eq!(real_decode.stop_hash, Default::default());
-
-        assert_eq!(serialize(&real_decode), from_sat);
-    }
-}
-
diff --git a/src/network/mod.rs b/src/network/mod.rs
deleted file mode 100644
index 4ba6d16a..00000000
--- a/src/network/mod.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Network Support
-//!
-//! This module defines support for (de)serialization and network transport 
-//! of Bitcoin data and network messages.
-//!
-
-use std::fmt;
-use std::io;
-use std::error;
-
-pub mod constants;
-
-pub mod address;
-pub use self::address::Address;
-pub mod message;
-pub mod message_blockdata;
-pub mod message_network;
-pub mod message_filter;
-pub mod stream_reader;
-
-/// Network error
-#[derive(Debug)]
-pub enum Error {
-    /// And I/O error
-    Io(io::Error),
-    /// Socket mutex was poisoned
-    SocketMutexPoisoned,
-    /// Not connected to peer
-    SocketNotConnectedToPeer,
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::Io(ref e) => fmt::Display::fmt(e, f),
-            Error::SocketMutexPoisoned | Error::SocketNotConnectedToPeer => f.write_str(error::Error::description(self)),
-        }
-    }
-}
-
-#[doc(hidden)]
-impl From<io::Error> for Error {
-    fn from(err: io::Error) -> Self {
-        Error::Io(err)
-    }
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::Io(ref e) => e.description(),
-            Error::SocketMutexPoisoned => "socket mutex was poisoned",
-            Error::SocketNotConnectedToPeer => "not connected to peer",
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Io(ref e) => Some(e),
-            Error::SocketMutexPoisoned | Error::SocketNotConnectedToPeer => None,
-        }
-    }
-}
diff --git a/src/network/stream_reader.rs b/src/network/stream_reader.rs
deleted file mode 100644
index 78923a76..00000000
--- a/src/network/stream_reader.rs
+++ /dev/null
@@ -1,347 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Stream reader
-//!
-//! This module defines `StreamReader` struct and its implementation which is used
-//! for parsing incoming stream into separate `RawNetworkMessage`s, handling assembling
-//! messages from multiple packets or dealing with partial or multiple messages in the stream
-//! (like can happen with reading from TCP socket)
-//!
-
-use std::fmt;
-use std::io::{self, Read};
-
-use consensus::{encode, Decodable};
-
-/// Struct used to configure stream reader function
-pub struct StreamReader<R: Read> {
-    /// Stream to read from
-    pub stream: R,
-    /// I/O buffer
-    data: Vec<u8>,
-    /// Buffer containing unparsed message part
-    unparsed: Vec<u8>
-}
-
-impl<R: Read> fmt::Debug for StreamReader<R> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "StreamReader with buffer_size={} and unparsed content {:?}",
-               self.data.capacity(), self.unparsed)
-    }
-}
-
-impl<R: Read> StreamReader<R> {
-    /// Constructs new stream reader for a given input stream `stream` with
-    /// optional parameter `buffer_size` determining reading buffer size
-    pub fn new(stream: R, buffer_size: Option<usize>) -> StreamReader<R> {
-        StreamReader {
-            stream,
-            data: vec![0u8; buffer_size.unwrap_or(64 * 1024)],
-            unparsed: vec![]
-        }
-    }
-
-    /// Reads stream and parses next message from its current input,
-    /// also taking into account previously unparsed partial message (if there was such).
-    pub fn read_next<D: Decodable>(&mut self) -> Result<D, encode::Error> {
-        loop {
-            match encode::deserialize_partial::<D>(&self.unparsed) {
-                // In this case we just have an incomplete data, so we need to read more
-                Err(encode::Error::Io(ref err)) if err.kind () == io::ErrorKind::UnexpectedEof => {
-                    let count = self.stream.read(&mut self.data)?;
-                    if count > 0 {
-                        self.unparsed.extend(self.data[0..count].iter());
-                    }
-                    else {
-                        return Err(encode::Error::Io(io::Error::from(io::ErrorKind::UnexpectedEof)));
-                    }
-                },
-                Err(err) => return Err(err),
-                // We have successfully read from the buffer
-                Ok((message, index)) => {
-                    self.unparsed.drain(..index);
-                    return Ok(message)
-                },
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::thread;
-    use std::time::Duration;
-    use std::io::{self, BufReader, Write};
-    use std::net::{TcpListener, TcpStream, Shutdown};
-    use std::thread::JoinHandle;
-    use network::constants::ServiceFlags;
-
-    use super::StreamReader;
-    use network::message::{NetworkMessage, RawNetworkMessage};
-
-    // First, let's define some byte arrays for sample messages - dumps are taken from live
-    // Bitcoin Core node v0.17.1 with Wireshark
-    const MSG_VERSION: [u8; 126] = [
-        0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x73,
-        0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
-        0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-        0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
-        0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
-        0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
-        0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01
-    ];
-
-    const MSG_VERACK: [u8; 24] = [
-        0xf9, 0xbe, 0xb4, 0xd9, 0x76, 0x65, 0x72, 0x61,
-        0x63, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2
-    ];
-
-    const MSG_PING: [u8; 32] = [
-        0xf9, 0xbe, 0xb4, 0xd9, 0x70, 0x69, 0x6e, 0x67,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x08, 0x00, 0x00, 0x00, 0x24, 0x67, 0xf1, 0x1d,
-        0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    ];
-
-    const MSG_ALERT: [u8; 192] = [
-        0xf9, 0xbe, 0xb4, 0xd9, 0x61, 0x6c, 0x65, 0x72,
-        0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0xa8, 0x00, 0x00, 0x00, 0x1b, 0xf9, 0xaa, 0xea,
-        0x60, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
-        0x7f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
-        0x7f, 0xfe, 0xff, 0xff, 0x7f, 0x01, 0xff, 0xff,
-        0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-        0xff, 0x7f, 0x00, 0xff, 0xff, 0xff, 0x7f, 0x00,
-        0x2f, 0x55, 0x52, 0x47, 0x45, 0x4e, 0x54, 0x3a,
-        0x20, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x20, 0x6b,
-        0x65, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x72,
-        0x6f, 0x6d, 0x69, 0x73, 0x65, 0x64, 0x2c, 0x20,
-        0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x20,
-        0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64,
-        0x00, 0x46, 0x30, 0x44, 0x02, 0x20, 0x65, 0x3f,
-        0xeb, 0xd6, 0x41, 0x0f, 0x47, 0x0f, 0x6b, 0xae,
-        0x11, 0xca, 0xd1, 0x9c, 0x48, 0x41, 0x3b, 0xec,
-        0xb1, 0xac, 0x2c, 0x17, 0xf9, 0x08, 0xfd, 0x0f,
-        0xd5, 0x3b, 0xdc, 0x3a, 0xbd, 0x52, 0x02, 0x20,
-        0x6d, 0x0e, 0x9c, 0x96, 0xfe, 0x88, 0xd4, 0xa0,
-        0xf0, 0x1e, 0xd9, 0xde, 0xda, 0xe2, 0xb6, 0xf9,
-        0xe0, 0x0d, 0xa9, 0x4c, 0xad, 0x0f, 0xec, 0xaa,
-        0xe6, 0x6e, 0xcf, 0x68, 0x9b, 0xf7, 0x1b, 0x50
-    ];
-
-    // Helper functions that checks parsed versions of the messages from the byte arrays above
-    fn check_version_msg(msg: &RawNetworkMessage) {
-        assert_eq!(msg.magic, 0xd9b4bef9);
-        if let NetworkMessage::Version(ref version_msg) = msg.payload {
-            assert_eq!(version_msg.version, 70015);
-            assert_eq!(version_msg.services, ServiceFlags::NETWORK | ServiceFlags::BLOOM | ServiceFlags::WITNESS | ServiceFlags::NETWORK_LIMITED);
-            assert_eq!(version_msg.timestamp, 1548554224);
-            assert_eq!(version_msg.nonce, 13952548347456104954);
-            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
-            assert_eq!(version_msg.start_height, 560275);
-            assert_eq!(version_msg.relay, true);
-        } else {
-            panic!("Wrong message type: expected VersionMessage");
-        }
-    }
-
-    fn check_alert_msg(msg: &RawNetworkMessage) {
-        assert_eq!(msg.magic, 0xd9b4bef9);
-        if let NetworkMessage::Alert(ref alert) = msg.payload {
-            assert_eq!(alert.clone(), [
-                0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
-                0x7f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
-                0x7f, 0xfe, 0xff, 0xff, 0x7f, 0x01, 0xff, 0xff,
-                0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
-                0xff, 0x7f, 0x00, 0xff, 0xff, 0xff, 0x7f, 0x00,
-                0x2f, 0x55, 0x52, 0x47, 0x45, 0x4e, 0x54, 0x3a,
-                0x20, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x20, 0x6b,
-                0x65, 0x79, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x72,
-                0x6f, 0x6d, 0x69, 0x73, 0x65, 0x64, 0x2c, 0x20,
-                0x75, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x20,
-                0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64,
-                0x00,
-            ].to_vec());
-        } else {
-            panic!("Wrong message type: expected AlertMessage");
-        }
-    }
-
-    #[test]
-    fn parse_multipartmsg_test() {
-        let stream = io::empty();
-        let mut reader = StreamReader::new(stream, None);
-        reader.unparsed = MSG_ALERT[..24].to_vec();
-        let message: Result<RawNetworkMessage, _> = reader.read_next();
-        assert!(message.is_err());
-        assert_eq!(reader.unparsed.len(), 24);
-
-        reader.unparsed = MSG_ALERT.to_vec();
-        let message = reader.read_next().unwrap();
-        assert_eq!(reader.unparsed.len(), 0);
-
-        check_alert_msg(&message);
-    }
-
-    #[test]
-    fn read_singlemsg_test() {
-        let stream = MSG_VERSION[..].to_vec();
-        let stream = stream.as_slice();
-        let message = StreamReader::new(stream, None).read_next().unwrap();
-        check_version_msg(&message);
-    }
-
-    #[test]
-    fn read_doublemsgs_test() {
-        let mut stream = MSG_VERSION.to_vec();
-        stream.extend(&MSG_PING);
-        let stream = stream.as_slice();
-        let mut reader = StreamReader::new(stream, None);
-        let message = reader.read_next().unwrap();
-        check_version_msg(&message);
-
-        let msg: RawNetworkMessage = reader.read_next().unwrap();
-        assert_eq!(msg.magic, 0xd9b4bef9);
-        if let NetworkMessage::Ping(nonce) = msg.payload {
-            assert_eq!(nonce, 100);
-        } else {
-            panic!("Wrong message type, expected PingMessage");
-        }
-    }
-
-    // Helper function that set ups emulation of client-server TCP connection for
-    // testing message transfer via TCP packets
-    fn serve_tcp(pieces: Vec<Vec<u8>>) -> (JoinHandle<()>, BufReader<TcpStream>) {
-        // 1. Creating server part (emulating Bitcoin Core node)
-        let listener = TcpListener::bind(format!("127.0.0.1:{}", 0)).unwrap();
-        let port = listener.local_addr().unwrap().port();
-        // 2. Spawning thread that will be writing our messages to the TCP Stream at the server side
-        // in async mode
-        let handle = thread::spawn(move || {
-            for ostream in listener.incoming() {
-                let mut ostream = ostream.unwrap();
-
-                for piece in pieces {
-                    ostream.write(&piece[..]).unwrap();
-                    ostream.flush().unwrap();
-                    thread::sleep(Duration::from_secs(1));
-                }
-
-                ostream.shutdown(Shutdown::Both).unwrap();
-                break;
-            }
-        });
-
-        // 3. Creating client side of the TCP socket connection
-        thread::sleep(Duration::from_secs(1));
-        let istream = TcpStream::connect(format!("127.0.0.1:{}", port)).unwrap();
-        let reader = BufReader::new(istream);
-
-        return (handle, reader)
-    }
-
-    #[test]
-    fn read_multipartmsg_test() {
-        // Setting up TCP connection emulation
-        let (handle, istream) = serve_tcp(vec![
-            // single message split in two parts to emulate real network conditions
-            MSG_VERSION[..24].to_vec(), MSG_VERSION[24..].to_vec()
-        ]);
-        let stream = istream;
-        let mut reader = StreamReader::new(stream, None);
-
-        // Reading and checking the whole message back
-        let message = reader.read_next().unwrap();
-        check_version_msg(&message);
-
-        // Waiting TCP server thread to terminate
-        handle.join().unwrap();
-    }
-
-    #[test]
-    fn read_sequencemsg_test() {
-        // Setting up TCP connection emulation
-        let (handle, istream) = serve_tcp(vec![
-            // Real-world Bitcoin core communication case for /Satoshi:0.17.1/
-            MSG_VERSION[..23].to_vec(), MSG_VERSION[23..].to_vec(),
-            MSG_VERACK.to_vec(),
-            MSG_ALERT[..24].to_vec(), MSG_ALERT[24..].to_vec()
-        ]);
-        let stream = istream;
-        let mut reader = StreamReader::new(stream, None);
-
-        // Reading and checking the first message (Version)
-        let message = reader.read_next().unwrap();
-        check_version_msg(&message);
-
-        // Reading and checking the second message (Verack)
-        let msg: RawNetworkMessage = reader.read_next().unwrap();
-        assert_eq!(msg.magic, 0xd9b4bef9);
-        assert_eq!(msg.payload, NetworkMessage::Verack, "Wrong message type, expected VerackMessage");
-
-        // Reading and checking the third message (Alert)
-        let msg = reader.read_next().unwrap();
-        check_alert_msg(&msg);
-
-        // Waiting TCP server thread to terminate
-        handle.join().unwrap();
-    }
-
-    #[test]
-    fn read_block_from_file_test() {
-        use std::io;
-        use consensus::serialize;
-        use hex::decode as hex_decode;
-        use Block;
-
-        let normal_data = hex_decode("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914cd74d6e49ffff001d323b3a7b0201000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0804ffff001d026e04ffffffff0100f2052a0100000043410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac00000000010000000321f75f3139a013f50f315b23b0c9a2b6eac31e2bec98e5891c924664889942260000000049483045022100cb2c6b346a978ab8c61b18b5e9397755cbd17d6eb2fe0083ef32e067fa6c785a02206ce44e613f31d9a6b0517e46f3db1576e9812cc98d159bfdaf759a5014081b5c01ffffffff79cda0945903627c3da1f85fc95d0b8ee3e76ae0cfdc9a65d09744b1f8fc85430000000049483045022047957cdd957cfd0becd642f6b84d82f49b6cb4c51a91f49246908af7c3cfdf4a022100e96b46621f1bffcf5ea5982f88cef651e9354f5791602369bf5a82a6cd61a62501fffffffffe09f5fe3ffbf5ee97a54eb5e5069e9da6b4856ee86fc52938c2f979b0f38e82000000004847304402204165be9a4cbab8049e1af9723b96199bfd3e85f44c6b4c0177e3962686b26073022028f638da23fc003760861ad481ead4099312c60030d4cb57820ce4d33812a5ce01ffffffff01009d966b01000000434104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac00000000").unwrap();
-        let cutoff_data = hex_decode("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914cd74d6e49ffff001d323b3a7b0201000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0804ffff001d026e04ffffffff0100f2052a0100000043410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac00000000010000000321f75f3139a013f50f315b23b0c9a2b6eac31e2bec98e5891c924664889942260000000049483045022100cb2c6b346a978ab8c61b18b5e9397755cbd17d6eb2fe0083ef32e067fa6c785a02206ce44e613f31d9a6b0517e46f3db1576e9812cc98d159bfdaf759a5014081b5c01ffffffff79cda0945903627c3da1f85fc95d0b8ee3e76ae0cfdc9a65d09744b1f8fc85430000000049483045022047957cdd957cfd0becd642f6b84d82f49b6cb4c51a91f49246908af7c3cfdf4a022100e96b46621f1bffcf5ea5982f88cef651e9354f5791602369bf5a82a6cd61a62501fffffffffe09f5fe3ffbf5ee97a54eb5e5069e9da6b4856ee86fc52938c2f979b0f38e82000000004847304402204165be9a4cbab8049e1af9723b96199bfd3e85f44c6b4c0177e3962686b26073022028f638da23fc003760861ad481ead4099312c60030d4cb57820ce4d33812a5ce01ffffffff01009d966b01000000434104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").unwrap();
-        let prevhash = hex_decode("4ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000").unwrap();
-        let merkle = hex_decode("bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914c").unwrap();
-
-        let stream = io::BufReader::new(&normal_data[..]);
-        let mut reader = StreamReader::new(stream, None);
-        let normal_block = reader.read_next::<Block>();
-
-        let stream = io::BufReader::new(&cutoff_data[..]);
-        let mut reader = StreamReader::new(stream, None);
-        let cutoff_block = reader.read_next::<Block>();
-
-        assert!(normal_block.is_ok());
-        assert!(cutoff_block.is_err());
-        let block = normal_block.unwrap();
-        assert_eq!(block.header.version, 1);
-        assert_eq!(serialize(&block.header.prev_blockhash), prevhash);
-        assert_eq!(serialize(&block.header.merkle_root), merkle);
-        assert_eq!(block.header.time, 1231965655);
-        assert_eq!(block.header.bits, 486604799);
-        assert_eq!(block.header.nonce, 2067413810);
-
-        // should be also ok for a non-witness block as commitment is optional in that case
-        assert!(block.check_witness_commitment());
-    }
-}
diff --git a/src/test_macros.rs b/src/test_macros.rs
deleted file mode 100644
index 11c46229..00000000
--- a/src/test_macros.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Macros
-//!
-//! Internal macros used for unit tests
-
-#[cfg(feature = "serde")]
-macro_rules! serde_round_trip (
-    ($var:expr) => ({
-        use serde_json;
-
-        let encoded = serde_json::to_value(&$var).unwrap();
-        let decoded = serde_json::from_value(encoded).unwrap();
-        assert_eq!($var, decoded);
-    })
-);
-
diff --git a/src/util/address.rs b/src/util/address.rs
deleted file mode 100644
index 7ad2d32b..00000000
--- a/src/util/address.rs
+++ /dev/null
@@ -1,749 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-// 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/>.
-//
-
-//! Addresses
-//!
-//! Support for ordinary base58 Bitcoin addresses and private keys
-//!
-//! # Example: creating a new address from a randomly-generated key pair
-//!
-//! ```rust
-//! extern crate secp256k1;
-//! extern crate bitcoin;
-//!
-//! use bitcoin::network::constants::Network;
-//! use bitcoin::util::address::Address;
-//! use bitcoin::util::key;
-//! use secp256k1::Secp256k1;
-//! use secp256k1::rand::thread_rng;
-//!
-//! fn main() {
-//!     // Generate random key pair
-//!     let s = Secp256k1::new();
-//!     let public_key = key::PublicKey {
-//!         compressed: true,
-//!         key: s.generate_keypair(&mut thread_rng()).1,
-//!     };
-//!
-//!     // Generate pay-to-pubkey-hash address
-//!     let address = Address::p2pkh(&public_key, Network::Bitcoin);
-//! }
-//! ```
-
-use std::fmt::{self, Display, Formatter};
-use std::str::FromStr;
-
-use bech32;
-use hashes::Hash;
-
-use hash_types::{PubkeyHash, WPubkeyHash, ScriptHash, WScriptHash};
-use blockdata::opcodes;
-use blockdata::script;
-use network::constants::Network;
-use util::base58;
-use util::key;
-
-/// Address error.
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    /// Base58 encoding error
-    Base58(base58::Error),
-    /// Bech32 encoding error
-    Bech32(bech32::Error),
-    /// The bech32 payload was empty
-    EmptyBech32Payload,
-    /// Script version must be 0 to 16 inclusive
-    InvalidWitnessVersion(u8),
-    /// The witness program must be between 2 and 40 bytes in length.
-    InvalidWitnessProgramLength(usize),
-    /// A v0 witness program must be either of length 20 or 32.
-    InvalidSegwitV0ProgramLength(usize),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::Base58(ref e) => write!(f, "base58: {}", e),
-            Error::Bech32(ref e) => write!(f, "bech32: {}", e),
-            Error::EmptyBech32Payload => write!(f, "the bech32 payload was empty"),
-            Error::InvalidWitnessVersion(v) => write!(f, "invalid witness script version: {}", v),
-            Error::InvalidWitnessProgramLength(l) => write!(
-                f,
-                "the witness program must be between 2 and 40 bytes in length: lengh={}",
-                l
-            ),
-            Error::InvalidSegwitV0ProgramLength(l) => write!(
-                f,
-                "a v0 witness program must be either of length 20 or 32 bytes: length={}",
-                l
-            ),
-        }
-    }
-}
-
-impl ::std::error::Error for Error {
-    fn cause(&self) -> Option<&::std::error::Error> {
-        match *self {
-            Error::Base58(ref e) => Some(e),
-            Error::Bech32(ref e) => Some(e),
-            _ => None,
-        }
-    }
-
-    fn description(&self) -> &'static str {
-        "std::error::Error::description is deprecated"
-    }
-}
-
-#[doc(hidden)]
-impl From<base58::Error> for Error {
-    fn from(e: base58::Error) -> Error {
-        Error::Base58(e)
-    }
-}
-
-#[doc(hidden)]
-impl From<bech32::Error> for Error {
-    fn from(e: bech32::Error) -> Error {
-        Error::Bech32(e)
-    }
-}
-
-/// The different types of addresses.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum AddressType {
-    /// pay-to-pubkey-hash
-    P2pkh,
-    /// pay-to-script-hash
-    P2sh,
-    /// pay-to-witness-pubkey-hash
-    P2wpkh,
-    /// pay-to-witness-script-hash
-    P2wsh,
-}
-
-impl fmt::Display for AddressType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(match *self {
-            AddressType::P2pkh => "p2pkh",
-            AddressType::P2sh => "p2sh",
-            AddressType::P2wpkh => "p2wpkh",
-            AddressType::P2wsh => "p2wsh",
-        })
-    }
-}
-
-impl FromStr for AddressType {
-    type Err = ();
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "p2pkh" => Ok(AddressType::P2pkh),
-            "p2sh" => Ok(AddressType::P2sh),
-            "p2wpkh" => Ok(AddressType::P2wpkh),
-            "p2wsh" => Ok(AddressType::P2wsh),
-            _ => Err(()),
-        }
-    }
-}
-
-/// The method used to produce an address
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Payload {
-    /// pay-to-pkhash address
-    PubkeyHash(PubkeyHash),
-    /// P2SH address
-    ScriptHash(ScriptHash),
-    /// Segwit address
-    WitnessProgram {
-        /// The witness program version
-        version: bech32::u5,
-        /// The witness program
-        program: Vec<u8>,
-    },
-}
-
-impl Payload {
-    /// Get a [Payload] from an output script (scriptPubkey).
-    pub fn from_script(script: &script::Script) -> Option<Payload> {
-        Some(if script.is_p2pkh() {
-            Payload::PubkeyHash(PubkeyHash::from_slice(&script.as_bytes()[3..23]).unwrap())
-        } else if script.is_p2sh() {
-            Payload::ScriptHash(ScriptHash::from_slice(&script.as_bytes()[2..22]).unwrap())
-        } else if script.is_witness_program() {
-            // We can unwrap the u5 check and assume script length
-            // because [Script::is_witness_program] makes sure of this.
-            Payload::WitnessProgram {
-                version: {
-                    // Since we passed the [is_witness_program] check,
-                    // the first byte is either 0x00 or 0x50 + version.
-                    let mut verop = script.as_bytes()[0];
-                    if verop > 0x50 {
-                        verop -= 0x50;
-                    }
-                    bech32::u5::try_from_u8(verop).expect("checked before")
-                },
-                program: script.as_bytes()[2..].to_vec(),
-            }
-        } else {
-            return None;
-        })
-    }
-
-    /// Generates a script pubkey spending to this [Payload].
-    pub fn script_pubkey(&self) -> script::Script {
-        match *self {
-            Payload::PubkeyHash(ref hash) => script::Builder::new()
-                .push_opcode(opcodes::all::OP_DUP)
-                .push_opcode(opcodes::all::OP_HASH160)
-                .push_slice(&hash[..])
-                .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_opcode(opcodes::all::OP_EQUAL),
-            Payload::WitnessProgram {
-                version: ver,
-                program: ref prog,
-            } => {
-                assert!(ver.to_u8() <= 16);
-                let mut verop = ver.to_u8();
-                if verop > 0 {
-                    verop = 0x50 + verop;
-                }
-                script::Builder::new().push_opcode(verop.into()).push_slice(&prog)
-            }
-        }
-        .into_script()
-    }
-}
-
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-/// A Bitcoin address
-pub struct Address {
-    /// The type of the address
-    pub payload: Payload,
-    /// The network on which this address is usable
-    pub network: Network,
-}
-serde_string_impl!(Address, "a Bitcoin address");
-
-impl Address {
-    /// Creates a pay to (compressed) public key hash address from a public key
-    /// This is the preferred non-witness type address
-    #[inline]
-    pub fn p2pkh(pk: &key::PublicKey, network: Network) -> Address {
-        let mut hash_engine = PubkeyHash::engine();
-        pk.write_into(&mut hash_engine);
-
-        Address {
-            network: network,
-            payload: Payload::PubkeyHash(PubkeyHash::from_engine(hash_engine)),
-        }
-    }
-
-    /// Creates a pay to script hash P2SH address from a script
-    /// This address type was introduced with BIP16 and is the popular type to implement multi-sig these days.
-    #[inline]
-    pub fn p2sh(script: &script::Script, network: Network) -> Address {
-        Address {
-            network: network,
-            payload: Payload::ScriptHash(ScriptHash::hash(&script[..])),
-        }
-    }
-
-    /// 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
-    pub fn p2wpkh(pk: &key::PublicKey, network: Network) -> Address {
-        let mut hash_engine = WPubkeyHash::engine();
-        pk.write_into(&mut hash_engine);
-
-        Address {
-            network: network,
-            payload: Payload::WitnessProgram {
-                version: bech32::u5::try_from_u8(0).expect("0<32"),
-                program: WPubkeyHash::from_engine(hash_engine)[..].to_vec(),
-            },
-        }
-    }
-
-    /// 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
-    pub fn p2shwpkh(pk: &key::PublicKey, network: Network) -> Address {
-        let mut hash_engine = WPubkeyHash::engine();
-        pk.write_into(&mut hash_engine);
-
-        let builder = script::Builder::new()
-            .push_int(0)
-            .push_slice(&WPubkeyHash::from_engine(hash_engine)[..]);
-
-        Address {
-            network: network,
-            payload: Payload::ScriptHash(ScriptHash::hash(builder.into_script().as_bytes())),
-        }
-    }
-
-    /// Create a witness pay to script hash address
-    pub fn p2wsh(script: &script::Script, network: Network) -> Address {
-        Address {
-            network: network,
-            payload: Payload::WitnessProgram {
-                version: bech32::u5::try_from_u8(0).expect("0<32"),
-                program: WScriptHash::hash(&script[..])[..].to_vec(),
-            },
-        }
-    }
-
-    /// Create a pay to script address that embeds a witness pay to script hash address
-    /// This is a segwit address type that looks familiar (as p2sh) to legacy clients
-    pub fn p2shwsh(script: &script::Script, network: Network) -> Address {
-        let ws = script::Builder::new()
-            .push_int(0)
-            .push_slice(&WScriptHash::hash(&script[..])[..])
-            .into_script();
-
-        Address {
-            network: network,
-            payload: Payload::ScriptHash(ScriptHash::hash(&ws[..])),
-        }
-    }
-
-    /// Get the address type of the address.
-    /// None if unknown or non-standard.
-    pub fn address_type(&self) -> Option<AddressType> {
-        match self.payload {
-            Payload::PubkeyHash(_) => Some(AddressType::P2pkh),
-            Payload::ScriptHash(_) => Some(AddressType::P2sh),
-            Payload::WitnessProgram {
-                version: ver,
-                program: ref prog,
-            } => {
-                // BIP-141 p2wpkh or p2wsh addresses.
-                match ver.to_u8() {
-                    0 => match prog.len() {
-                        20 => Some(AddressType::P2wpkh),
-                        32 => Some(AddressType::P2wsh),
-                        _ => None,
-                    },
-                    _ => None,
-                }
-            }
-        }
-    }
-
-    /// Check whether or not the address is following Bitcoin
-    /// standardness rules.
-    ///
-    /// Segwit addresses with unassigned witness versions or non-standard
-    /// program sizes are considered non-standard.
-    pub fn is_standard(&self) -> bool {
-        self.address_type().is_some()
-    }
-
-    /// Get an [Address] from an output script (scriptPubkey).
-    pub fn from_script(script: &script::Script, network: Network) -> Option<Address> {
-        Some(Address {
-            payload: Payload::from_script(script)?,
-            network: network,
-        })
-    }
-
-    /// Generates a script pubkey spending to this address
-    pub fn script_pubkey(&self) -> script::Script {
-        self.payload.script_pubkey()
-    }
-}
-
-impl Display for Address {
-    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
-        match self.payload {
-            Payload::PubkeyHash(ref hash) => {
-                let mut prefixed = [0; 21];
-                prefixed[0] = match self.network {
-                    Network::Bitcoin => 0,
-                    Network::Testnet | Network::Regtest => 111,
-                };
-                prefixed[1..].copy_from_slice(&hash[..]);
-                base58::check_encode_slice_to_fmt(fmt, &prefixed[..])
-            }
-            Payload::ScriptHash(ref hash) => {
-                let mut prefixed = [0; 21];
-                prefixed[0] = match self.network {
-                    Network::Bitcoin => 5,
-                    Network::Testnet | Network::Regtest => 196,
-                };
-                prefixed[1..].copy_from_slice(&hash[..]);
-                base58::check_encode_slice_to_fmt(fmt, &prefixed[..])
-            }
-            Payload::WitnessProgram {
-                version: ver,
-                program: ref prog,
-            } => {
-                let hrp = match self.network {
-                    Network::Bitcoin => "bc",
-                    Network::Testnet => "tb",
-                    Network::Regtest => "bcrt",
-                };
-                let mut bech32_writer = bech32::Bech32Writer::new(hrp, fmt)?;
-                bech32::WriteBase32::write_u5(&mut bech32_writer, ver)?;
-                bech32::ToBase32::write_base32(&prog, &mut bech32_writer)
-            }
-        }
-    }
-}
-
-/// Extract the bech32 prefix.
-/// Returns the same slice when no prefix is found.
-fn find_bech32_prefix(bech32: &str) -> &str {
-    // Split at the last occurrence of the separator character '1'.
-    match bech32.rfind("1") {
-        None => bech32,
-        Some(sep) => bech32.split_at(sep).0,
-    }
-}
-
-impl FromStr for Address {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Address, Error> {
-        // try bech32
-        let bech32_network = match find_bech32_prefix(s) {
-            // note that upper or lowercase is allowed but NOT mixed case
-            "bc" | "BC" => Some(Network::Bitcoin),
-            "tb" | "TB" => Some(Network::Testnet),
-            "bcrt" | "BCRT" => Some(Network::Regtest),
-            _ => None,
-        };
-        if let Some(network) = bech32_network {
-            // decode as bech32
-            let (_, payload) = bech32::decode(s)?;
-            if payload.len() == 0 {
-                return Err(Error::EmptyBech32Payload);
-            }
-
-            // Get the script version and program (converted from 5-bit to 8-bit)
-            let (version, program): (bech32::u5, Vec<u8>) = {
-                let (v, p5) = payload.split_at(1);
-                (v[0], bech32::FromBase32::from_base32(p5)?)
-            };
-
-            // Generic segwit checks.
-            if version.to_u8() > 16 {
-                return Err(Error::InvalidWitnessVersion(version.to_u8()));
-            }
-            if program.len() < 2 || program.len() > 40 {
-                return Err(Error::InvalidWitnessProgramLength(program.len()));
-            }
-
-            // Specific segwit v0 check.
-            if version.to_u8() == 0 && (program.len() != 20 && program.len() != 32) {
-                return Err(Error::InvalidSegwitV0ProgramLength(program.len()));
-            }
-
-            return Ok(Address {
-                payload: Payload::WitnessProgram {
-                    version: version,
-                    program: program,
-                },
-                network: network,
-            });
-        }
-
-        // Base58
-        if s.len() > 50 {
-            return Err(Error::Base58(base58::Error::InvalidLength(s.len() * 11 / 15)));
-        }
-        let data = base58::from_check(s)?;
-        if data.len() != 21 {
-            return Err(Error::Base58(base58::Error::InvalidLength(data.len())));
-        }
-
-        let (network, payload) = match data[0] {
-            0 => (
-                Network::Bitcoin,
-                Payload::PubkeyHash(PubkeyHash::from_slice(&data[1..]).unwrap()),
-            ),
-            5 => (
-                Network::Bitcoin,
-                Payload::ScriptHash(ScriptHash::from_slice(&data[1..]).unwrap()),
-            ),
-            111 => (
-                Network::Testnet,
-                Payload::PubkeyHash(PubkeyHash::from_slice(&data[1..]).unwrap()),
-            ),
-            196 => (
-                Network::Testnet,
-                Payload::ScriptHash(ScriptHash::from_slice(&data[1..]).unwrap()),
-            ),
-            x => return Err(Error::Base58(base58::Error::InvalidVersion(vec![x]))),
-        };
-
-        Ok(Address {
-            network: network,
-            payload: payload,
-        })
-    }
-}
-
-impl ::std::fmt::Debug for Address {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        write!(f, "{}", self.to_string())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::str::FromStr;
-    use std::string::ToString;
-
-    use hashes::Hash;
-    use hex::{decode as hex_decode, encode as hex_encode};
-
-    use blockdata::script::Script;
-    use network::constants::Network::{Bitcoin, Testnet};
-    use util::key::PublicKey;
-
-    use super::*;
-
-    macro_rules! hex (($hex:expr) => (hex_decode($hex).unwrap()));
-    macro_rules! hex_key (($hex:expr) => (PublicKey::from_slice(&hex!($hex)).unwrap()));
-    macro_rules! hex_script (($hex:expr) => (Script::from(hex!($hex))));
-    macro_rules! hex_pubkeyhash (($hex:expr) => (PubkeyHash::from_slice(&hex!($hex)).unwrap()));
-    macro_rules! hex_scripthash (($hex:expr) => (ScriptHash::from_slice(&hex!($hex)).unwrap()));
-
-    fn roundtrips(addr: &Address) {
-        assert_eq!(
-            Address::from_str(&addr.to_string()).unwrap(),
-            *addr,
-            "string round-trip failed for {}",
-            addr,
-        );
-        assert_eq!(
-            Address::from_script(&addr.script_pubkey(), addr.network).as_ref(),
-            Some(addr),
-            "script round-trip failed for {}",
-            addr,
-        );
-        //TODO: add serde roundtrip after no-strason PR
-    }
-
-    #[test]
-    fn test_p2pkh_address_58() {
-        let addr = Address {
-            network: Bitcoin,
-            payload: Payload::PubkeyHash(hex_pubkeyhash!("162c5ea71c0b23f5b9022ef047c4a86470a5b070")),
-        };
-
-        assert_eq!(
-            addr.script_pubkey(),
-            hex_script!("76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac")
-        );
-        assert_eq!(&addr.to_string(), "132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM");
-        assert_eq!(addr.address_type(), Some(AddressType::P2pkh));
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_p2pkh_from_key() {
-        let key = hex_key!("048d5141948c1702e8c95f438815794b87f706a8d4cd2bffad1dc1570971032c9b6042a0431ded2478b5c9cf2d81c124a5e57347a3c63ef0e7716cf54d613ba183");
-        let addr = Address::p2pkh(&key, Bitcoin);
-        assert_eq!(&addr.to_string(), "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY");
-
-        let key = hex_key!(&"03df154ebfcf29d29cc10d5c2565018bce2d9edbab267c31d2caf44a63056cf99f");
-        let addr = Address::p2pkh(&key, Testnet);
-        assert_eq!(&addr.to_string(), "mqkhEMH6NCeYjFybv7pvFC22MFeaNT9AQC");
-        assert_eq!(addr.address_type(), Some(AddressType::P2pkh));
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_p2sh_address_58() {
-        let addr = Address {
-            network: Bitcoin,
-            payload: Payload::ScriptHash(hex_scripthash!("162c5ea71c0b23f5b9022ef047c4a86470a5b070")),
-        };
-
-        assert_eq!(
-            addr.script_pubkey(),
-            hex_script!("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087")
-        );
-        assert_eq!(&addr.to_string(), "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k");
-        assert_eq!(addr.address_type(), Some(AddressType::P2sh));
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_p2sh_parse() {
-        let script = hex_script!("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae");
-        let addr = Address::p2sh(&script, Testnet);
-
-        assert_eq!(&addr.to_string(), "2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr");
-        assert_eq!(addr.address_type(), Some(AddressType::P2sh));
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_p2wpkh() {
-        // stolen from Bitcoin transaction: b3c8c2b6cfc335abbcb2c7823a8453f55d64b2b5125a9a61e8737230cdb8ce20
-        let key = hex_key!("033bc8c83c52df5712229a2f72206d90192366c36428cb0c12b6af98324d97bfbc");
-        let addr = Address::p2wpkh(&key, Bitcoin);
-        assert_eq!(&addr.to_string(), "bc1qvzvkjn4q3nszqxrv3nraga2r822xjty3ykvkuw");
-        assert_eq!(addr.address_type(), Some(AddressType::P2wpkh));
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_p2wsh() {
-        // stolen from Bitcoin transaction 5df912fda4becb1c29e928bec8d64d93e9ba8efa9b5b405bd683c86fd2c65667
-        let script = hex_script!("52210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae");
-        let addr = Address::p2wsh(&script, Bitcoin);
-        assert_eq!(
-            &addr.to_string(),
-            "bc1qwqdg6squsna38e46795at95yu9atm8azzmyvckulcc7kytlcckxswvvzej"
-        );
-        assert_eq!(addr.address_type(), Some(AddressType::P2wsh));
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_p2shwpkh() {
-        // stolen from Bitcoin transaction: ad3fd9c6b52e752ba21425435ff3dd361d6ac271531fc1d2144843a9f550ad01
-        let key = hex_key!("026c468be64d22761c30cd2f12cbc7de255d592d7904b1bab07236897cc4c2e766");
-        let addr = Address::p2shwpkh(&key, Bitcoin);
-        assert_eq!(&addr.to_string(), "3QBRmWNqqBGme9er7fMkGqtZtp4gjMFxhE");
-        assert_eq!(addr.address_type(), Some(AddressType::P2sh));
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_p2shwsh() {
-        // stolen from Bitcoin transaction f9ee2be4df05041d0e0a35d7caa3157495ca4f93b233234c9967b6901dacf7a9
-        let script = hex_script!("522103e5529d8eaa3d559903adb2e881eb06c86ac2574ffa503c45f4e942e2a693b33e2102e5f10fcdcdbab211e0af6a481f5532536ec61a5fdbf7183770cf8680fe729d8152ae");
-        let addr = Address::p2shwsh(&script, Bitcoin);
-        assert_eq!(&addr.to_string(), "36EqgNnsWW94SreZgBWc1ANC6wpFZwirHr");
-        assert_eq!(addr.address_type(), Some(AddressType::P2sh));
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_non_existent_segwit_version() {
-        let version = 13;
-        // 40-byte program
-        let program = hex!(
-            "654f6ea368e0acdfd92976b7c2103a1b26313f430654f6ea368e0acdfd92976b7c2103a1b26313f4"
-        );
-        let addr = Address {
-            payload: Payload::WitnessProgram {
-                version: bech32::u5::try_from_u8(version).expect("0<32"),
-                program: program,
-            },
-            network: Network::Bitcoin,
-        };
-        roundtrips(&addr);
-    }
-
-    #[test]
-    fn test_bip173_vectors() {
-        let valid_vectors = [
-            ("BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4", "0014751e76e8199196d454941c45d1b3a323f1433bd6"),
-            ("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7", "00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262"),
-            ("bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k7grplx", "5128751e76e8199196d454941c45d1b3a323f1433bd6751e76e8199196d454941c45d1b3a323f1433bd6"),
-            ("BC1SW50QA3JX3S", "6002751e"),
-            ("bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj", "5210751e76e8199196d454941c45d1b3a323"),
-            ("tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy", "0020000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433"),
-        ];
-        for vector in &valid_vectors {
-            let addr: Address = vector.0.parse().unwrap();
-            assert_eq!(&hex_encode(addr.script_pubkey().as_bytes()), vector.1);
-            roundtrips(&addr);
-        }
-
-        let invalid_vectors = [
-            "tc1qw508d6qejxtdg4y5r3zarvary0c5xw7kg3g4ty",
-            "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5",
-            "BC13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2",
-            "bc1rw5uspcuh",
-            "bc10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90",
-            "BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P",
-            "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7",
-            "bc1zw508d6qejxtdg4y5r3zarvaryvqyzf3du",
-            "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv",
-            "bc1gmk9yu",
-        ];
-        for vector in &invalid_vectors {
-            assert!(vector.parse::<Address>().is_err());
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    fn test_json_serialize() {
-        use serde_json;
-
-        let addr = Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM").unwrap();
-        let json = serde_json::to_value(&addr).unwrap();
-        assert_eq!(
-            json,
-            serde_json::Value::String("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM".to_owned())
-        );
-        let into: Address = serde_json::from_value(json).unwrap();
-        assert_eq!(addr.to_string(), into.to_string());
-        assert_eq!(
-            into.script_pubkey(),
-            hex_script!("76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac")
-        );
-
-        let addr = Address::from_str("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k").unwrap();
-        let json = serde_json::to_value(&addr).unwrap();
-        assert_eq!(
-            json,
-            serde_json::Value::String("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k".to_owned())
-        );
-        let into: Address = serde_json::from_value(json).unwrap();
-        assert_eq!(addr.to_string(), into.to_string());
-        assert_eq!(
-            into.script_pubkey(),
-            hex_script!("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087")
-        );
-
-        let addr =
-            Address::from_str("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7")
-                .unwrap();
-        let json = serde_json::to_value(&addr).unwrap();
-        assert_eq!(
-            json,
-            serde_json::Value::String(
-                "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7".to_owned()
-            )
-        );
-        let into: Address = serde_json::from_value(json).unwrap();
-        assert_eq!(addr.to_string(), into.to_string());
-        assert_eq!(
-            into.script_pubkey(),
-            hex_script!("00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262")
-        );
-
-        let addr = Address::from_str("bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl").unwrap();
-        let json = serde_json::to_value(&addr).unwrap();
-        assert_eq!(
-            json,
-            serde_json::Value::String("bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl".to_owned())
-        );
-        let into: Address = serde_json::from_value(json).unwrap();
-        assert_eq!(addr.to_string(), into.to_string());
-        assert_eq!(
-            into.script_pubkey(),
-            hex_script!("001454d26dddb59c7073c6a197946ea1841951fa7a74")
-        );
-    }
-}
diff --git a/src/util/amount.rs b/src/util/amount.rs
deleted file mode 100644
index 7d3c0f76..00000000
--- a/src/util/amount.rs
+++ /dev/null
@@ -1,1347 +0,0 @@
-// 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/>.
-//
-
-//! Amounts
-//!
-//! This module mainly introduces the [Amount] and [SignedAmount] types.
-//! We refer to the documentation on the types for more information.
-//!
-
-use std::default;
-use std::error;
-use std::fmt::{self, Write};
-use std::ops;
-use std::str::FromStr;
-
-/// A set of denominations in which amounts can be expressed.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub enum Denomination {
-    /// BTC
-    Bitcoin,
-    /// mBTC
-    MilliBitcoin,
-    /// uBTC
-    MicroBitcoin,
-    /// bits
-    Bit,
-    /// satoshi
-    Satoshi,
-    /// msat
-    MilliSatoshi,
-}
-
-impl Denomination {
-    /// The number of decimal places more than a satoshi.
-    fn precision(self) -> i32 {
-        match self {
-            Denomination::Bitcoin => -8,
-            Denomination::MilliBitcoin => -5,
-            Denomination::MicroBitcoin => -2,
-            Denomination::Bit => -2,
-            Denomination::Satoshi => 0,
-            Denomination::MilliSatoshi => 3,
-        }
-    }
-}
-
-impl fmt::Display for Denomination {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(match *self {
-            Denomination::Bitcoin => "BTC",
-            Denomination::MilliBitcoin => "mBTC",
-            Denomination::MicroBitcoin => "uBTC",
-            Denomination::Bit => "bits",
-            Denomination::Satoshi => "satoshi",
-            Denomination::MilliSatoshi => "msat",
-        })
-    }
-}
-
-impl FromStr for Denomination {
-    type Err = ParseAmountError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "BTC" => Ok(Denomination::Bitcoin),
-            "mBTC" => Ok(Denomination::MilliBitcoin),
-            "uBTC" => Ok(Denomination::MicroBitcoin),
-            "bits" => Ok(Denomination::Bit),
-            "satoshi" => Ok(Denomination::Satoshi),
-            "sat" => Ok(Denomination::Satoshi),
-            "msat" => Ok(Denomination::MilliSatoshi),
-            d => Err(ParseAmountError::UnknownDenomination(d.to_owned())),
-        }
-    }
-}
-
-/// An error during amount parsing.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ParseAmountError {
-    /// Amount is negative.
-    Negative,
-    /// Amount is too big to fit inside the type.
-    TooBig,
-    /// Amount has higher precision than supported by the type.
-    TooPrecise,
-    /// Invalid number format.
-    InvalidFormat,
-    /// Input string was too large.
-    InputTooLarge,
-    /// Invalid character in input.
-    InvalidCharacter(char),
-    /// The denomination was unknown.
-    UnknownDenomination(String),
-}
-
-impl fmt::Display for ParseAmountError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let desc = ::std::error::Error::description(self);
-        match *self {
-            ParseAmountError::InvalidCharacter(c) => write!(f, "{}: {}", desc, c),
-            ParseAmountError::UnknownDenomination(ref d) => write!(f, "{}: {}", desc, d),
-            _ => f.write_str(desc),
-        }
-    }
-}
-
-impl error::Error for ParseAmountError {
-    fn cause(&self) -> Option<&error::Error> {
-        None
-    }
-
-    fn description(&self) -> &'static str {
-        match *self {
-            ParseAmountError::Negative => "amount is negative",
-            ParseAmountError::TooBig => "amount is too big",
-            ParseAmountError::TooPrecise => "amount has a too high precision",
-            ParseAmountError::InvalidFormat => "invalid number format",
-            ParseAmountError::InputTooLarge => "input string was too large",
-            ParseAmountError::InvalidCharacter(_) => "invalid character in input",
-            ParseAmountError::UnknownDenomination(_) => "unknown denomination",
-        }
-    }
-}
-
-
-fn is_too_precise(s: &str, precision: usize) -> bool {
-    s.contains(".") || precision >= s.len() || s.chars().rev().take(precision).any(|d| d != '0')
-}
-
-/// Parse decimal string in the given denomination into a satoshi value and a
-/// bool indicator for a negative amount.
-fn parse_signed_to_satoshi(
-    mut s: &str,
-    denom: Denomination,
-) -> Result<(bool, u64), ParseAmountError> {
-    if s.len() == 0 {
-        return Err(ParseAmountError::InvalidFormat);
-    }
-    if s.len() > 50 {
-        return Err(ParseAmountError::InputTooLarge);
-    }
-
-    let is_negative = s.chars().next().unwrap() == '-';
-    if is_negative {
-        if s.len() == 1 {
-            return Err(ParseAmountError::InvalidFormat);
-        }
-        s = &s[1..];
-    }
-
-    let max_decimals = {
-        // The difference in precision between native (satoshi)
-        // and desired denomination.
-        let precision_diff = -denom.precision();
-        if precision_diff < 0 {
-            // If precision diff is negative, this means we are parsing
-            // into a less precise amount. That is not allowed unless
-            // there are no decimals and the last digits are zeroes as
-            // many as the difference in precision.
-            let last_n = precision_diff.abs() as usize;
-            if is_too_precise(s, last_n) {
-                return Err(ParseAmountError::TooPrecise);
-            }
-            s = &s[0..s.len() - last_n];
-            0
-        } else {
-            precision_diff
-        }
-    };
-
-    let mut decimals = None;
-    let mut value: u64 = 0; // as satoshis
-    for c in s.chars() {
-        match c {
-            '0'...'9' => {
-                // Do `value = 10 * value + digit`, catching overflows.
-                match 10_u64.checked_mul(value) {
-                    None => return Err(ParseAmountError::TooBig),
-                    Some(val) => match val.checked_add((c as u8 - b'0') as u64) {
-                        None => return Err(ParseAmountError::TooBig),
-                        Some(val) => value = val,
-                    },
-                }
-                // Increment the decimal digit counter if past decimal.
-                decimals = match decimals {
-                    None => None,
-                    Some(d) if d < max_decimals => Some(d + 1),
-                    _ => return Err(ParseAmountError::TooPrecise),
-                };
-            }
-            '.' => match decimals {
-                None => decimals = Some(0),
-                // Double decimal dot.
-                _ => return Err(ParseAmountError::InvalidFormat),
-            },
-            c => return Err(ParseAmountError::InvalidCharacter(c)),
-        }
-    }
-
-    // Decimally shift left by `max_decimals - decimals`.
-    let scale_factor = max_decimals - decimals.unwrap_or(0);
-    for _ in 0..scale_factor {
-        value = match 10_u64.checked_mul(value) {
-            Some(v) => v,
-            None => return Err(ParseAmountError::TooBig),
-        };
-    }
-
-    Ok((is_negative, value))
-}
-
-/// Format the given satoshi amount in the given denomination.
-///
-/// Does not include the denomination.
-fn fmt_satoshi_in(
-    satoshi: u64,
-    negative: bool,
-    f: &mut fmt::Write,
-    denom: Denomination,
-) -> fmt::Result {
-    if negative {
-        f.write_str("-")?;
-    }
-
-    if denom.precision() > 0 {
-        // add zeroes in the end
-        let width = denom.precision() as usize;
-        write!(f, "{}{:0width$}", satoshi, 0, width = width)?;
-    } else if denom.precision() < 0 {
-        // need to inject a comma in the number
-        let nb_decimals = denom.precision().abs() as usize;
-        let real = format!("{:0width$}", satoshi, width = nb_decimals);
-        if real.len() == nb_decimals {
-            write!(f, "0.{}", &real[real.len() - nb_decimals..])?;
-        } else {
-            write!(
-                f,
-                "{}.{}",
-                &real[0..(real.len() - nb_decimals)],
-                &real[real.len() - nb_decimals..]
-            )?;
-        }
-    } else {
-        // denom.precision() == 0
-        write!(f, "{}", satoshi)?;
-    }
-    Ok(())
-}
-
-/// Amount
-///
-/// The [Amount] type can be used to express Bitcoin amounts that supports
-/// arithmetic and conversion to various denominations.
-///
-///
-/// Warning!
-///
-/// This type implements several arithmetic operations from [std::ops].
-/// To prevent errors due to overflow or underflow when using these operations,
-/// it is advised to instead use the checked arithmetic methods whose names
-/// start with `checked_`.  The operations from [std::ops] that [Amount]
-/// implements will panic when overflow or underflow occurs.  Also note that
-/// since the internal representation of amounts is unsigned, subtracting below
-/// zero is considered an underflow and will cause a panic if you're not using
-/// the checked arithmetic methods.
-///
-#[derive(Copy, Clone, Hash)]
-pub struct Amount(u64);
-
-impl Amount {
-    /// The zero amount.
-    pub const ZERO: Amount = Amount(0);
-    /// Exactly one satoshi.
-    pub const ONE_SAT: Amount = Amount(1);
-    /// Exactly one bitcoin.
-    pub const ONE_BTC: Amount = Amount(100_000_000);
-
-    /// Create an [Amount] with satoshi precision and the given number of satoshis.
-    pub fn from_sat(satoshi: u64) -> Amount {
-        Amount(satoshi)
-    }
-
-    /// Get the number of satoshis in this [Amount].
-    pub fn as_sat(self) -> u64 {
-        self.0
-    }
-
-    /// The maximum value of an [Amount].
-    pub fn max_value() -> Amount {
-        Amount(u64::max_value())
-    }
-
-    /// The minimum value of an [Amount].
-    pub fn min_value() -> Amount {
-        Amount(u64::min_value())
-    }
-
-    /// Convert from a value expressing bitcoins to an [Amount].
-    pub fn from_btc(btc: f64) -> Result<Amount, ParseAmountError> {
-        Amount::from_float_in(btc, Denomination::Bitcoin)
-    }
-
-    /// Parse a decimal string as a value in the given denomination.
-    ///
-    /// Note: This only parses the value string.  If you want to parse a value
-    /// with denomination, use [FromStr].
-    pub fn from_str_in(s: &str, denom: Denomination) -> Result<Amount, ParseAmountError> {
-        let (negative, satoshi) = parse_signed_to_satoshi(s, denom)?;
-        if negative {
-            return Err(ParseAmountError::Negative);
-        }
-        if satoshi > i64::max_value() as u64 {
-            return Err(ParseAmountError::TooBig);
-        }
-        Ok(Amount::from_sat(satoshi))
-    }
-
-    /// Parses amounts with denomination suffix like they are produced with
-    /// [to_string_with_denomination] or with [fmt::Display].
-    /// If you want to parse only the amount without the denomination,
-    /// use [from_str_in].
-    pub fn from_str_with_denomination(s: &str) -> Result<Amount, ParseAmountError> {
-        let mut split = s.splitn(3, " ");
-        let amt_str = split.next().unwrap();
-        let denom_str = split.next().ok_or(ParseAmountError::InvalidFormat)?;
-        if split.next().is_some() {
-            return Err(ParseAmountError::InvalidFormat);
-        }
-
-        Ok(Amount::from_str_in(amt_str, denom_str.parse()?)?)
-    }
-
-    /// Express this [Amount] as a floating-point value in the given denomination.
-    ///
-    /// Please be aware of the risk of using floating-point numbers.
-    pub fn to_float_in(&self, denom: Denomination) -> f64 {
-        f64::from_str(&self.to_string_in(denom)).unwrap()
-    }
-
-    /// Express this [Amount] as a floating-point value in Bitcoin.
-    ///
-    /// Equivalent to `to_float_in(Denomination::Bitcoin)`.
-    ///
-    /// Please be aware of the risk of using floating-point numbers.
-    pub fn as_btc(&self) -> f64 {
-        self.to_float_in(Denomination::Bitcoin)
-    }
-
-    /// Convert this [Amount] in floating-point notation with a given
-    /// denomination.
-    /// Can return error if the amount is too big, too precise or negative.
-    ///
-    /// Please be aware of the risk of using floating-point numbers.
-    pub fn from_float_in(value: f64, denom: Denomination) -> Result<Amount, ParseAmountError> {
-        if value < 0.0 {
-            return Err(ParseAmountError::Negative);
-        }
-        // This is inefficient, but the safest way to deal with this. The parsing logic is safe.
-        // Any performance-critical application should not be dealing with floats.
-        Amount::from_str_in(&value.to_string(), denom)
-    }
-
-    /// Format the value of this [Amount] in the given denomination.
-    ///
-    /// Does not include the denomination.
-    pub fn fmt_value_in(&self, f: &mut fmt::Write, denom: Denomination) -> fmt::Result {
-        fmt_satoshi_in(self.as_sat(), false, f, denom)
-    }
-
-    /// Get a string number of this [Amount] in the given denomination.
-    ///
-    /// Does not include the denomination.
-    pub fn to_string_in(&self, denom: Denomination) -> String {
-        let mut buf = String::new();
-        self.fmt_value_in(&mut buf, denom).unwrap();
-        buf
-    }
-
-    /// Get a formatted string of this [Amount] in the given denomination,
-    /// suffixed with the abbreviation for the denomination.
-    pub fn to_string_with_denomination(&self, denom: Denomination) -> String {
-        let mut buf = String::new();
-        self.fmt_value_in(&mut buf, denom).unwrap();
-        write!(buf, " {}", denom).unwrap();
-        buf
-    }
-
-    // Some arithmetic that doesn't fit in `std::ops` traits.
-
-    /// Checked addition.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_add(self, rhs: Amount) -> Option<Amount> {
-        self.0.checked_add(rhs.0).map(Amount)
-    }
-
-    /// Checked subtraction.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_sub(self, rhs: Amount) -> Option<Amount> {
-        self.0.checked_sub(rhs.0).map(Amount)
-    }
-
-    /// Checked multiplication.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_mul(self, rhs: u64) -> Option<Amount> {
-        self.0.checked_mul(rhs).map(Amount)
-    }
-
-    /// Checked integer division.
-    /// Be aware that integer division loses the remainder if no exact division
-    /// can be made.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_div(self, rhs: u64) -> Option<Amount> {
-        self.0.checked_div(rhs).map(Amount)
-    }
-
-    /// Checked remainder.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_rem(self, rhs: u64) -> Option<Amount> {
-        self.0.checked_rem(rhs).map(Amount)
-    }
-
-    /// Convert to a signed amount.
-    pub fn to_signed(self) -> Result<SignedAmount, ParseAmountError> {
-        if self.as_sat() > SignedAmount::max_value().as_sat() as u64 {
-            Err(ParseAmountError::TooBig)
-        } else {
-            Ok(SignedAmount::from_sat(self.as_sat() as i64))
-        }
-    }
-}
-
-impl default::Default for Amount {
-    fn default() -> Self {
-        Amount::ZERO
-    }
-}
-
-impl PartialEq for Amount {
-    fn eq(&self, other: &Amount) -> bool {
-        PartialEq::eq(&self.0, &other.0)
-    }
-}
-impl Eq for Amount {}
-
-impl PartialOrd for Amount {
-    fn partial_cmp(&self, other: &Amount) -> Option<::std::cmp::Ordering> {
-        PartialOrd::partial_cmp(&self.0, &other.0)
-    }
-}
-
-impl Ord for Amount {
-    fn cmp(&self, other: &Amount) -> ::std::cmp::Ordering {
-        Ord::cmp(&self.0, &other.0)
-    }
-}
-
-impl fmt::Debug for Amount {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Amount({} satoshi)", self.as_sat())
-    }
-}
-
-// No one should depend on a binding contract for Display for this type.
-// Just using Bitcoin denominated string.
-impl fmt::Display for Amount {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.fmt_value_in(f, Denomination::Bitcoin)?;
-        write!(f, " {}", Denomination::Bitcoin)
-    }
-}
-
-impl ops::Add for Amount {
-    type Output = Amount;
-
-    fn add(self, rhs: Amount) -> Self::Output {
-        self.checked_add(rhs).expect("Amount addition error")
-    }
-}
-
-impl ops::AddAssign for Amount {
-    fn add_assign(&mut self, other: Amount) {
-        *self = *self + other
-    }
-}
-
-impl ops::Sub for Amount {
-    type Output = Amount;
-
-    fn sub(self, rhs: Amount) -> Self::Output {
-        self.checked_sub(rhs).expect("Amount subtraction error")
-    }
-}
-
-impl ops::SubAssign for Amount {
-    fn sub_assign(&mut self, other: Amount) {
-        *self = *self - other
-    }
-}
-
-impl ops::Rem<u64> for Amount {
-    type Output = Amount;
-
-    fn rem(self, modulus: u64) -> Self {
-        self.checked_rem(modulus).expect("Amount remainder error")
-    }
-}
-
-impl ops::RemAssign<u64> for Amount {
-    fn rem_assign(&mut self, modulus: u64) {
-        *self = *self % modulus
-    }
-}
-
-impl ops::Mul<u64> for Amount {
-    type Output = Amount;
-
-    fn mul(self, rhs: u64) -> Self::Output {
-        self.checked_mul(rhs).expect("Amount multiplication error")
-    }
-}
-
-impl ops::MulAssign<u64> for Amount {
-    fn mul_assign(&mut self, rhs: u64) {
-        *self = *self * rhs
-    }
-}
-
-impl ops::Div<u64> for Amount {
-    type Output = Amount;
-
-    fn div(self, rhs: u64) -> Self::Output {
-        self.checked_div(rhs).expect("Amount division error")
-    }
-}
-
-impl ops::DivAssign<u64> for Amount {
-    fn div_assign(&mut self, rhs: u64) {
-        *self = *self / rhs
-    }
-}
-
-impl FromStr for Amount {
-    type Err = ParseAmountError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Amount::from_str_with_denomination(s)
-    }
-}
-
-/// SignedAmount
-///
-/// The [SignedAmount] type can be used to express Bitcoin amounts that supports
-/// arithmetic and conversion to various denominations.
-///
-///
-/// Warning!
-///
-/// This type implements several arithmetic operations from [std::ops].
-/// To prevent errors due to overflow or underflow when using these operations,
-/// it is advised to instead use the checked arithmetic methods whose names
-/// start with `checked_`.  The operations from [std::ops] that [Amount]
-/// implements will panic when overflow or underflow occurs.
-///
-#[derive(Copy, Clone, Hash)]
-pub struct SignedAmount(i64);
-
-impl SignedAmount {
-    /// The zero amount.
-    pub const ZERO: SignedAmount = SignedAmount(0);
-    /// Exactly one satoshi.
-    pub const ONE_SAT: SignedAmount = SignedAmount(1);
-    /// Exactly one bitcoin.
-    pub const ONE_BTC: SignedAmount = SignedAmount(100_000_000);
-
-    /// Create an [SignedAmount] with satoshi precision and the given number of satoshis.
-    pub fn from_sat(satoshi: i64) -> SignedAmount {
-        SignedAmount(satoshi)
-    }
-
-    /// Get the number of satoshis in this [SignedAmount].
-    pub fn as_sat(self) -> i64 {
-        self.0
-    }
-
-    /// The maximum value of an [SignedAmount].
-    pub fn max_value() -> SignedAmount {
-        SignedAmount(i64::max_value())
-    }
-
-    /// The minimum value of an [SignedAmount].
-    pub fn min_value() -> SignedAmount {
-        SignedAmount(i64::min_value())
-    }
-
-    /// Convert from a value expressing bitcoins to an [SignedAmount].
-    pub fn from_btc(btc: f64) -> Result<SignedAmount, ParseAmountError> {
-        SignedAmount::from_float_in(btc, Denomination::Bitcoin)
-    }
-
-    /// Parse a decimal string as a value in the given denomination.
-    ///
-    /// Note: This only parses the value string.  If you want to parse a value
-    /// with denomination, use [FromStr].
-    pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
-        let (negative, satoshi) = parse_signed_to_satoshi(s, denom)?;
-        if satoshi > i64::max_value() as u64 {
-            return Err(ParseAmountError::TooBig);
-        }
-        Ok(match negative {
-            true => SignedAmount(-1 * satoshi as i64),
-            false => SignedAmount(satoshi as i64),
-        })
-    }
-
-    /// Parses amounts with denomination suffix like they are produced with
-    /// [to_string_with_denomination] or with [fmt::Display].
-    /// If you want to parse only the amount without the denomination,
-    /// use [from_str_in].
-    pub fn from_str_with_denomination(s: &str) -> Result<SignedAmount, ParseAmountError> {
-        let mut split = s.splitn(3, " ");
-        let amt_str = split.next().unwrap();
-        let denom_str = split.next().ok_or(ParseAmountError::InvalidFormat)?;
-        if split.next().is_some() {
-            return Err(ParseAmountError::InvalidFormat);
-        }
-
-        Ok(SignedAmount::from_str_in(amt_str, denom_str.parse()?)?)
-    }
-
-    /// Express this [SignedAmount] as a floating-point value in the given denomination.
-    ///
-    /// Please be aware of the risk of using floating-point numbers.
-    pub fn to_float_in(&self, denom: Denomination) -> f64 {
-        f64::from_str(&self.to_string_in(denom)).unwrap()
-    }
-
-    /// Express this [SignedAmount] as a floating-point value in Bitcoin.
-    ///
-    /// Equivalent to `to_float_in(Denomination::Bitcoin)`.
-    ///
-    /// Please be aware of the risk of using floating-point numbers.
-    pub fn as_btc(&self) -> f64 {
-        self.to_float_in(Denomination::Bitcoin)
-    }
-
-    /// Convert this [SignedAmount] in floating-point notation with a given
-    /// denomination.
-    /// Can return error if the amount is too big, too precise or negative.
-    ///
-    /// Please be aware of the risk of using floating-point numbers.
-    pub fn from_float_in(
-        value: f64,
-        denom: Denomination,
-    ) -> Result<SignedAmount, ParseAmountError> {
-        // This is inefficient, but the safest way to deal with this. The parsing logic is safe.
-        // Any performance-critical application should not be dealing with floats.
-        SignedAmount::from_str_in(&value.to_string(), denom)
-    }
-
-    /// Format the value of this [SignedAmount] in the given denomination.
-    ///
-    /// Does not include the denomination.
-    pub fn fmt_value_in(&self, f: &mut fmt::Write, denom: Denomination) -> fmt::Result {
-        fmt_satoshi_in(self.as_sat().abs() as u64, self.is_negative(), f, denom)
-    }
-
-    /// Get a string number of this [SignedAmount] in the given denomination.
-    ///
-    /// Does not include the denomination.
-    pub fn to_string_in(&self, denom: Denomination) -> String {
-        let mut buf = String::new();
-        self.fmt_value_in(&mut buf, denom).unwrap();
-        buf
-    }
-
-    /// Get a formatted string of this [SignedAmount] in the given denomination,
-    /// suffixed with the abbreviation for the denomination.
-    pub fn to_string_with_denomination(&self, denom: Denomination) -> String {
-        let mut buf = String::new();
-        self.fmt_value_in(&mut buf, denom).unwrap();
-        write!(buf, " {}", denom).unwrap();
-        buf
-    }
-
-    // Some arithmetic that doesn't fit in `std::ops` traits.
-
-    /// Get the absolute value of this [SignedAmount].
-    pub fn abs(self) -> SignedAmount {
-        SignedAmount(self.0.abs())
-    }
-
-    /// Returns a number representing sign of this [SignedAmount].
-    ///
-    /// - `0` if the amount is zero
-    /// - `1` if the amount is positive
-    /// - `-1` if the amount is negative
-    pub fn signum(self) -> i64 {
-        self.0.signum()
-    }
-
-    /// Returns `true` if this [SignedAmount] is positive and `false` if
-    /// this [SignedAmount] is zero or negative.
-    pub fn is_positive(self) -> bool {
-        self.0.is_positive()
-    }
-
-    /// Returns `true` if this [SignedAmount] is negative and `false` if
-    /// this [SignedAmount] is zero or positive.
-    pub fn is_negative(self) -> bool {
-        self.0.is_negative()
-    }
-
-    /// Checked addition.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
-        self.0.checked_add(rhs.0).map(SignedAmount)
-    }
-
-    /// Checked subtraction.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
-        self.0.checked_sub(rhs.0).map(SignedAmount)
-    }
-
-    /// Checked multiplication.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
-        self.0.checked_mul(rhs).map(SignedAmount)
-    }
-
-    /// Checked integer division.
-    /// Be aware that integer division loses the remainder if no exact division
-    /// can be made.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_div(self, rhs: i64) -> Option<SignedAmount> {
-        self.0.checked_div(rhs).map(SignedAmount)
-    }
-
-    /// Checked remainder.
-    /// Returns [None] if overflow occurred.
-    pub fn checked_rem(self, rhs: i64) -> Option<SignedAmount> {
-        self.0.checked_rem(rhs).map(SignedAmount)
-    }
-
-    /// Subtraction that doesn't allow negative [SignedAmount]s.
-    /// Returns [None] if either [self], [rhs] or the result is strictly negative.
-    pub fn positive_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
-        if self.is_negative() || rhs.is_negative() || rhs > self {
-            None
-        } else {
-            self.checked_sub(rhs)
-        }
-    }
-
-    /// Convert to an unsigned amount.
-    pub fn to_unsigned(self) -> Result<Amount, ParseAmountError> {
-        if self.is_negative() {
-            Err(ParseAmountError::Negative)
-        } else {
-            Ok(Amount::from_sat(self.as_sat() as u64))
-        }
-    }
-}
-
-impl default::Default for SignedAmount {
-    fn default() -> Self {
-        SignedAmount::ZERO
-    }
-}
-
-impl PartialEq for SignedAmount {
-    fn eq(&self, other: &SignedAmount) -> bool {
-        PartialEq::eq(&self.0, &other.0)
-    }
-}
-impl Eq for SignedAmount {}
-
-impl PartialOrd for SignedAmount {
-    fn partial_cmp(&self, other: &SignedAmount) -> Option<::std::cmp::Ordering> {
-        PartialOrd::partial_cmp(&self.0, &other.0)
-    }
-}
-
-impl Ord for SignedAmount {
-    fn cmp(&self, other: &SignedAmount) -> ::std::cmp::Ordering {
-        Ord::cmp(&self.0, &other.0)
-    }
-}
-
-impl fmt::Debug for SignedAmount {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "SignedAmount({} satoshi)", self.as_sat())
-    }
-}
-
-// No one should depend on a binding contract for Display for this type.
-// Just using Bitcoin denominated string.
-impl fmt::Display for SignedAmount {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.fmt_value_in(f, Denomination::Bitcoin)?;
-        write!(f, " {}", Denomination::Bitcoin)
-    }
-}
-
-impl ops::Add for SignedAmount {
-    type Output = SignedAmount;
-
-    fn add(self, rhs: SignedAmount) -> Self::Output {
-        self.checked_add(rhs).expect("SignedAmount addition error")
-    }
-}
-
-impl ops::AddAssign for SignedAmount {
-    fn add_assign(&mut self, other: SignedAmount) {
-        *self = *self + other
-    }
-}
-
-impl ops::Sub for SignedAmount {
-    type Output = SignedAmount;
-
-    fn sub(self, rhs: SignedAmount) -> Self::Output {
-        self.checked_sub(rhs).expect("SignedAmount subtraction error")
-    }
-}
-
-impl ops::SubAssign for SignedAmount {
-    fn sub_assign(&mut self, other: SignedAmount) {
-        *self = *self - other
-    }
-}
-
-impl ops::Rem<i64> for SignedAmount {
-    type Output = SignedAmount;
-
-    fn rem(self, modulus: i64) -> Self {
-        self.checked_rem(modulus).expect("SignedAmount remainder error")
-    }
-}
-
-impl ops::RemAssign<i64> for SignedAmount {
-    fn rem_assign(&mut self, modulus: i64) {
-        *self = *self % modulus
-    }
-}
-
-impl ops::Mul<i64> for SignedAmount {
-    type Output = SignedAmount;
-
-    fn mul(self, rhs: i64) -> Self::Output {
-        self.checked_mul(rhs).expect("SignedAmount multiplication error")
-    }
-}
-
-impl ops::MulAssign<i64> for SignedAmount {
-    fn mul_assign(&mut self, rhs: i64) {
-        *self = *self * rhs
-    }
-}
-
-impl ops::Div<i64> for SignedAmount {
-    type Output = SignedAmount;
-
-    fn div(self, rhs: i64) -> Self::Output {
-        self.checked_div(rhs).expect("SignedAmount division error")
-    }
-}
-
-impl ops::DivAssign<i64> for SignedAmount {
-    fn div_assign(&mut self, rhs: i64) {
-        *self = *self / rhs
-    }
-}
-
-impl FromStr for SignedAmount {
-    type Err = ParseAmountError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        SignedAmount::from_str_with_denomination(s)
-    }
-}
-
-#[cfg(feature = "serde")]
-pub mod serde {
-    // methods are implementation of a standardized serde-specific signature
-    #![allow(missing_docs)]
-
-    //! This module adds serde serialization and deserialization support for Amounts.
-    //! Since there is not a default way to serialize and deserialize Amounts, multiple
-    //! ways are supported and it's up to the user to decide which serialiation to use.
-    //! The provided modules can be used as follows:
-    //!
-    //! ```rust,ignore
-    //! use serde::{Serialize, Deserialize};
-    //! use bitcoin::Amount;
-    //!
-    //! #[derive(Serialize, Deserialize)]
-    //! pub struct HasAmount {
-    //!     #[serde(with = "bitcoin::util::amount::serde::as_btc")]
-    //!     pub amount: Amount,
-    //! }
-    //! ```
-
-    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-    use util::amount::{Amount, Denomination, SignedAmount};
-
-    /// This trait is used only to avoid code duplication and naming collisions
-    /// of the different serde serialization crates.
-    pub trait SerdeAmount: Copy + Sized {
-        fn ser_sat<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error>;
-        fn des_sat<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error>;
-        fn ser_btc<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error>;
-        fn des_btc<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error>;
-    }
-
-    impl SerdeAmount for Amount {
-        fn ser_sat<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
-            u64::serialize(&self.as_sat(), s)
-        }
-        fn des_sat<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error> {
-            Ok(Amount::from_sat(u64::deserialize(d)?))
-        }
-        fn ser_btc<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
-            f64::serialize(&self.to_float_in(Denomination::Bitcoin), s)
-        }
-        fn des_btc<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error> {
-            use serde::de::Error;
-            Ok(Amount::from_btc(f64::deserialize(d)?).map_err(D::Error::custom)?)
-        }
-    }
-
-    impl SerdeAmount for SignedAmount {
-        fn ser_sat<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
-            i64::serialize(&self.as_sat(), s)
-        }
-        fn des_sat<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error> {
-            Ok(SignedAmount::from_sat(i64::deserialize(d)?))
-        }
-        fn ser_btc<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
-            f64::serialize(&self.to_float_in(Denomination::Bitcoin), s)
-        }
-        fn des_btc<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error> {
-            use serde::de::Error;
-            Ok(SignedAmount::from_btc(f64::deserialize(d)?).map_err(D::Error::custom)?)
-        }
-    }
-
-    pub mod as_sat {
-        //! Serialize and deserialize [Amount] as real numbers denominated in satoshi.
-        //! Use with `#[serde(with = "amount::serde::as_sat")]`.
-
-        use serde::{Deserializer, Serializer};
-        use util::amount::serde::SerdeAmount;
-
-        pub fn serialize<A: SerdeAmount, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error> {
-            a.ser_sat(s)
-        }
-
-        pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(d: D) -> Result<A, D::Error> {
-            A::des_sat(d)
-        }
-
-        pub mod opt {
-            //! Serialize and deserialize [Optoin<Amount>] as real numbers denominated in satoshi.
-            //! Use with `#[serde(default, with = "amount::serde::as_sat::opt")]`.
-
-            use serde::{Deserializer, Serializer};
-            use util::amount::serde::SerdeAmount;
-
-            pub fn serialize<A: SerdeAmount, S: Serializer>(
-                a: &Option<A>,
-                s: S,
-            ) -> Result<S::Ok, S::Error> {
-                match *a {
-                    Some(a) => a.ser_sat(s),
-                    None => s.serialize_none(),
-                }
-            }
-
-            pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(
-                d: D,
-            ) -> Result<Option<A>, D::Error> {
-                Ok(Some(A::des_sat(d)?))
-            }
-        }
-    }
-
-    pub mod as_btc {
-        //! Serialize and deserialize [Amount] as JSON numbers denominated in BTC.
-        //! Use with `#[serde(with = "amount::serde::as_btc")]`.
-
-        use serde::{Deserializer, Serializer};
-        use util::amount::serde::SerdeAmount;
-
-        pub fn serialize<A: SerdeAmount, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error> {
-            a.ser_btc(s)
-        }
-
-        pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(d: D) -> Result<A, D::Error> {
-            A::des_btc(d)
-        }
-
-        pub mod opt {
-            //! Serialize and deserialize [Option<Amount>] as JSON numbers denominated in BTC.
-            //! Use with `#[serde(default, with = "amount::serde::as_btc::opt")]`.
-
-            use serde::{Deserializer, Serializer};
-            use util::amount::serde::SerdeAmount;
-
-            pub fn serialize<A: SerdeAmount, S: Serializer>(
-                a: &Option<A>,
-                s: S,
-            ) -> Result<S::Ok, S::Error> {
-                match *a {
-                    Some(a) => a.ser_btc(s),
-                    None => s.serialize_none(),
-                }
-            }
-
-            pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(
-                d: D,
-            ) -> Result<Option<A>, D::Error> {
-                Ok(Some(A::des_btc(d)?))
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::panic;
-    use std::str::FromStr;
-
-    #[cfg(feature = "serde")]
-    use serde_test;
-
-    #[test]
-    fn add_sub_mul_div() {
-        let sat = Amount::from_sat;
-        let ssat = SignedAmount::from_sat;
-
-        assert_eq!(sat(15) + sat(15), sat(30));
-        assert_eq!(sat(15) - sat(15), sat(0));
-        assert_eq!(sat(14) * 3, sat(42));
-        assert_eq!(sat(14) / 2, sat(7));
-        assert_eq!(sat(14) % 3, sat(2));
-        assert_eq!(ssat(15) - ssat(20), ssat(-5));
-        assert_eq!(ssat(-14) * 3, ssat(-42));
-        assert_eq!(ssat(-14) / 2, ssat(-7));
-        assert_eq!(ssat(-14) % 3, ssat(-2));
-
-        let mut b = ssat(-5);
-        b += ssat(13);
-        assert_eq!(b, ssat(8));
-        b -= ssat(3);
-        assert_eq!(b, ssat(5));
-        b *= 6;
-        assert_eq!(b, ssat(30));
-        b /= 3;
-        assert_eq!(b, ssat(10));
-        b %= 3;
-        assert_eq!(b, ssat(1));
-
-        // panic on overflow
-        let result = panic::catch_unwind(|| Amount::max_value() + Amount::from_sat(1));
-        assert!(result.is_err());
-        let result = panic::catch_unwind(|| Amount::from_sat(8446744073709551615) * 3);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn checked_arithmetic() {
-        let sat = Amount::from_sat;
-        let ssat = SignedAmount::from_sat;
-
-        assert_eq!(sat(42).checked_add(sat(1)), Some(sat(43)));
-        assert_eq!(SignedAmount::max_value().checked_add(ssat(1)), None);
-        assert_eq!(SignedAmount::min_value().checked_sub(ssat(1)), None);
-        assert_eq!(Amount::max_value().checked_add(sat(1)), None);
-        assert_eq!(Amount::min_value().checked_sub(sat(1)), None);
-
-        assert_eq!(sat(5).checked_sub(sat(3)), Some(sat(2)));
-        assert_eq!(sat(5).checked_sub(sat(6)), None);
-        assert_eq!(ssat(5).checked_sub(ssat(6)), Some(ssat(-1)));
-        assert_eq!(sat(5).checked_rem(2), Some(sat(1)));
-
-        assert_eq!(sat(5).checked_div(2), Some(sat(2))); // integer division
-        assert_eq!(ssat(-6).checked_div(2), Some(ssat(-3)));
-
-        assert_eq!(ssat(-5).positive_sub(ssat(3)), None);
-        assert_eq!(ssat(5).positive_sub(ssat(-3)), None);
-        assert_eq!(ssat(3).positive_sub(ssat(5)), None);
-        assert_eq!(ssat(3).positive_sub(ssat(3)), Some(ssat(0)));
-        assert_eq!(ssat(5).positive_sub(ssat(3)), Some(ssat(2)));
-    }
-
-    #[test]
-    fn floating_point() {
-        use super::Denomination as D;
-        let f = Amount::from_float_in;
-        let sf = SignedAmount::from_float_in;
-        let sat = Amount::from_sat;
-        let ssat = SignedAmount::from_sat;
-
-        assert_eq!(f(11.22, D::Bitcoin), Ok(sat(1122000000)));
-        assert_eq!(sf(-11.22, D::MilliBitcoin), Ok(ssat(-1122000)));
-        assert_eq!(f(11.22, D::Bit), Ok(sat(1122)));
-        assert_eq!(sf(-1000.0, D::MilliSatoshi), Ok(ssat(-1)));
-        assert_eq!(f(0.0001234, D::Bitcoin), Ok(sat(12340)));
-        assert_eq!(sf(-0.00012345, D::Bitcoin), Ok(ssat(-12345)));
-
-        assert_eq!(f(-100.0, D::MilliSatoshi), Err(ParseAmountError::Negative));
-        assert_eq!(f(11.22, D::Satoshi), Err(ParseAmountError::TooPrecise));
-        assert_eq!(sf(-100.0, D::MilliSatoshi), Err(ParseAmountError::TooPrecise));
-        assert_eq!(sf(-100.0, D::MilliSatoshi), Err(ParseAmountError::TooPrecise));
-        assert_eq!(f(42.123456781, D::Bitcoin), Err(ParseAmountError::TooPrecise));
-        assert_eq!(sf(-184467440738.0, D::Bitcoin), Err(ParseAmountError::TooBig));
-        assert_eq!(f(18446744073709551617.0, D::Satoshi), Err(ParseAmountError::TooBig));
-        assert_eq!(
-            f(SignedAmount::max_value().to_float_in(D::Satoshi) + 1.0, D::Satoshi),
-            Err(ParseAmountError::TooBig)
-        );
-        assert_eq!(
-            f(Amount::max_value().to_float_in(D::Satoshi) + 1.0, D::Satoshi),
-            Err(ParseAmountError::TooBig)
-        );
-
-        let btc = move |f| SignedAmount::from_btc(f).unwrap();
-        assert_eq!(btc(2.5).to_float_in(D::Bitcoin), 2.5);
-        assert_eq!(btc(-2.5).to_float_in(D::MilliBitcoin), -2500.0);
-        assert_eq!(btc(2.5).to_float_in(D::Satoshi), 250000000.0);
-        assert_eq!(btc(-2.5).to_float_in(D::MilliSatoshi), -250000000000.0);
-
-        let btc = move |f| Amount::from_btc(f).unwrap();
-        assert_eq!(&btc(0.0012).to_float_in(D::Bitcoin).to_string(), "0.0012")
-    }
-
-    #[test]
-    fn parsing() {
-        use super::ParseAmountError as E;
-        let btc = Denomination::Bitcoin;
-        let p = Amount::from_str_in;
-        let sp = SignedAmount::from_str_in;
-
-        assert_eq!(p("x", btc), Err(E::InvalidCharacter('x')));
-        assert_eq!(p("-", btc), Err(E::InvalidFormat));
-        assert_eq!(sp("-", btc), Err(E::InvalidFormat));
-        assert_eq!(p("-1.0x", btc), Err(E::InvalidCharacter('x')));
-        assert_eq!(p("0.0 ", btc), Err(ParseAmountError::InvalidCharacter(' ')));
-        assert_eq!(p("0.000.000", btc), Err(E::InvalidFormat));
-        let more_than_max = format!("1{}", Amount::max_value());
-        assert_eq!(p(&more_than_max, btc), Err(E::TooBig));
-        assert_eq!(p("0.000000042", btc), Err(E::TooPrecise));
-
-        assert_eq!(p("1", btc), Ok(Amount::from_sat(1_000_000_00)));
-        assert_eq!(sp("-.5", btc), Ok(SignedAmount::from_sat(-500_000_00)));
-        assert_eq!(p("1.1", btc), Ok(Amount::from_sat(1_100_000_00)));
-        assert_eq!(
-            p("12345678901.12345678", btc),
-            Ok(Amount::from_sat(12_345_678_901__123_456_78))
-        );
-        assert_eq!(p("12.000", Denomination::MilliSatoshi), Err(E::TooPrecise));
-    }
-
-    #[test]
-    fn to_string() {
-        use super::Denomination as D;
-
-        assert_eq!(Amount::ONE_BTC.to_string_in(D::Bitcoin), "1.00000000");
-        assert_eq!(Amount::ONE_BTC.to_string_in(D::Satoshi), "100000000");
-        assert_eq!(Amount::ONE_SAT.to_string_in(D::Bitcoin), "0.00000001");
-        assert_eq!(SignedAmount::from_sat(-42).to_string_in(D::Bitcoin), "-0.00000042");
-
-        assert_eq!(Amount::ONE_BTC.to_string_with_denomination(D::Bitcoin), "1.00000000 BTC");
-        assert_eq!(Amount::ONE_SAT.to_string_with_denomination(D::MilliSatoshi), "1000 msat");
-        assert_eq!(
-            SignedAmount::ONE_BTC.to_string_with_denomination(D::Satoshi),
-            "100000000 satoshi"
-        );
-        assert_eq!(Amount::ONE_SAT.to_string_with_denomination(D::Bitcoin), "0.00000001 BTC");
-        assert_eq!(
-            SignedAmount::from_sat(-42).to_string_with_denomination(D::Bitcoin),
-            "-0.00000042 BTC"
-        );
-    }
-
-    #[test]
-    fn from_str() {
-        use super::ParseAmountError as E;
-        let p = Amount::from_str;
-        let sp = SignedAmount::from_str;
-
-        assert_eq!(p("x BTC"), Err(E::InvalidCharacter('x')));
-        assert_eq!(p("5 BTC BTC"), Err(E::InvalidFormat));
-        assert_eq!(p("5 5 BTC"), Err(E::InvalidFormat));
-
-        assert_eq!(p("5 BCH"), Err(E::UnknownDenomination("BCH".to_owned())));
-
-        assert_eq!(p("-1 BTC"), Err(E::Negative));
-        assert_eq!(p("-0.0 BTC"), Err(E::Negative));
-        assert_eq!(p("0.123456789 BTC"), Err(E::TooPrecise));
-        assert_eq!(sp("-0.1 satoshi"), Err(E::TooPrecise));
-        assert_eq!(p("0.123456 mBTC"), Err(E::TooPrecise));
-        assert_eq!(sp("-1.001 bits"), Err(E::TooPrecise));
-        assert_eq!(sp("-200000000000 BTC"), Err(E::TooBig));
-        assert_eq!(p("18446744073709551616 sat"), Err(E::TooBig));
-
-        assert_eq!(sp("0 msat"), Err(E::TooPrecise));
-        assert_eq!(sp("-0 msat"), Err(E::TooPrecise));
-        assert_eq!(sp("000 msat"), Err(E::TooPrecise));
-        assert_eq!(sp("-000 msat"), Err(E::TooPrecise));
-        assert_eq!(p("0 msat"), Err(E::TooPrecise));
-        assert_eq!(p("-0 msat"), Err(E::TooPrecise));
-        assert_eq!(p("000 msat"), Err(E::TooPrecise));
-        assert_eq!(p("-000 msat"), Err(E::TooPrecise));
-
-        assert_eq!(p(".5 bits"), Ok(Amount::from_sat(50)));
-        assert_eq!(sp("-.5 bits"), Ok(SignedAmount::from_sat(-50)));
-        assert_eq!(p("0.00253583 BTC"), Ok(Amount::from_sat(253583)));
-        assert_eq!(sp("-5 satoshi"), Ok(SignedAmount::from_sat(-5)));
-        assert_eq!(p("0.10000000 BTC"), Ok(Amount::from_sat(100_000_00)));
-        assert_eq!(sp("-100 bits"), Ok(SignedAmount::from_sat(-10_000)));
-    }
-
-    #[test]
-    fn to_string_with_denomination_from_str_roundtrip() {
-        use super::Denomination as D;
-
-        let amt = Amount::from_sat(42);
-        let denom = Amount::to_string_with_denomination;
-        assert_eq!(Amount::from_str(&denom(&amt, D::Bitcoin)), Ok(amt));
-        assert_eq!(Amount::from_str(&denom(&amt, D::MilliBitcoin)), Ok(amt));
-        assert_eq!(Amount::from_str(&denom(&amt, D::MicroBitcoin)), Ok(amt));
-        assert_eq!(Amount::from_str(&denom(&amt, D::Bit)), Ok(amt));
-        assert_eq!(Amount::from_str(&denom(&amt, D::Satoshi)), Ok(amt));
-        assert_eq!(Amount::from_str(&denom(&amt, D::MilliSatoshi)), Ok(amt));
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn serde_as_sat() {
-
-        #[derive(Serialize, Deserialize, PartialEq, Debug)]
-        struct T {
-            #[serde(with = "::util::amount::serde::as_sat")]
-            pub amt: Amount,
-            #[serde(with = "::util::amount::serde::as_sat")]
-            pub samt: SignedAmount,
-        }
-
-        serde_test::assert_tokens(
-            &T {
-                amt: Amount::from_sat(123456789),
-                samt: SignedAmount::from_sat(-123456789),
-            },
-            &[
-                serde_test::Token::Struct {
-                    name: "T",
-                    len: 2,
-                },
-                serde_test::Token::Str("amt"),
-                serde_test::Token::U64(123456789),
-                serde_test::Token::Str("samt"),
-                serde_test::Token::I64(-123456789),
-                serde_test::Token::StructEnd,
-            ],
-        );
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn serde_as_btc() {
-        use serde_json;
-
-        #[derive(Serialize, Deserialize, PartialEq, Debug)]
-        struct T {
-            #[serde(with = "::util::amount::serde::as_btc")]
-            pub amt: Amount,
-            #[serde(with = "::util::amount::serde::as_btc")]
-            pub samt: SignedAmount,
-        }
-
-        let orig = T {
-            amt: Amount::from_sat(21_000_000__000_000_01),
-            samt: SignedAmount::from_sat(-21_000_000__000_000_01),
-        };
-
-        let json = "{\"amt\": 21000000.00000001, \
-                    \"samt\": -21000000.00000001}";
-        let t: T = serde_json::from_str(&json).unwrap();
-        assert_eq!(t, orig);
-
-        let value: serde_json::Value = serde_json::from_str(&json).unwrap();
-        assert_eq!(t, serde_json::from_value(value).unwrap());
-
-        // errors
-        let t: Result<T, serde_json::Error> =
-            serde_json::from_str("{\"amt\": 1000000.000000001, \"samt\": 1}");
-        assert!(t.unwrap_err().to_string().contains(&ParseAmountError::TooPrecise.to_string()));
-        let t: Result<T, serde_json::Error> = serde_json::from_str("{\"amt\": -1, \"samt\": 1}");
-        assert!(t.unwrap_err().to_string().contains(&ParseAmountError::Negative.to_string()));
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn serde_as_btc_opt() {
-        use serde_json;
-
-        #[derive(Serialize, Deserialize, PartialEq, Debug)]
-        struct T {
-            #[serde(default, with = "::util::amount::serde::as_btc::opt")]
-            pub amt: Option<Amount>,
-            #[serde(default, with = "::util::amount::serde::as_btc::opt")]
-            pub samt: Option<SignedAmount>,
-        }
-
-        let with = T {
-            amt: Some(Amount::from_sat(2__500_000_00)),
-            samt: Some(SignedAmount::from_sat(-2__500_000_00)),
-        };
-        let without = T {
-            amt: None,
-            samt: None,
-        };
-
-        let t: T = serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
-        assert_eq!(t, with);
-
-        let t: T = serde_json::from_str("{}").unwrap();
-        assert_eq!(t, without);
-
-        let value_with: serde_json::Value =
-            serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
-        assert_eq!(with, serde_json::from_value(value_with).unwrap());
-
-        let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
-        assert_eq!(without, serde_json::from_value(value_without).unwrap());
-    }
-}
diff --git a/src/util/base58.rs b/src/util/base58.rs
deleted file mode 100644
index 2a268eac..00000000
--- a/src/util/base58.rs
+++ /dev/null
@@ -1,307 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Base58 encoder and decoder
-
-use std::{error, fmt, str, slice, iter};
-
-use hashes::{sha256d, Hash};
-
-use util::endian;
-
-/// An error that might occur during base58 decoding
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum Error {
-    /// Invalid character encountered
-    BadByte(u8),
-    /// Checksum was not correct (expected, actual)
-    BadChecksum(u32, u32),
-    /// The length (in bytes) of the object was not correct
-    /// Note that if the length is excessively long the provided length may be
-    /// an estimate (and the checksum step may be skipped).
-    InvalidLength(usize),
-    /// Version byte(s) were not recognized
-    InvalidVersion(Vec<u8>),
-    /// Checked data was less than 4 bytes
-    TooShort(usize),
-    /// Any other error
-    Other(String)
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::BadByte(b) => write!(f, "invalid base58 character 0x{:x}", b),
-            Error::BadChecksum(exp, actual) => write!(f, "base58ck checksum 0x{:x} does not match expected 0x{:x}", actual, exp),
-            Error::InvalidLength(ell) => write!(f, "length {} invalid for this base58 type", ell),
-            Error::InvalidVersion(ref v) => write!(f, "version {:?} invalid for this base58 type", v),
-            Error::TooShort(_) => write!(f, "base58ck data not even long enough for a checksum"),
-            Error::Other(ref s) => f.write_str(s)
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn cause(&self) -> Option<&error::Error> { None }
-    fn description(&self) -> &'static str {
-        match *self {
-            Error::BadByte(_) => "invalid b58 character",
-            Error::BadChecksum(_, _) => "invalid b58ck checksum",
-            Error::InvalidLength(_) => "invalid length for b58 type",
-            Error::InvalidVersion(_) => "invalid version for b58 type",
-            Error::TooShort(_) => "b58ck data less than 4 bytes",
-            Error::Other(_) => "unknown b58 error"
-        }
-    }
-}
-
-/// Vector-like object that holds the first 100 elements on the stack. If more space is needed it
-/// will be allocated on the heap.
-struct SmallVec<T> {
-    len: usize,
-    stack: [T; 100],
-    heap: Vec<T>,
-}
-
-impl<T: Default + Copy> SmallVec<T> {
-    pub fn new() -> SmallVec<T> {
-        SmallVec {
-            len: 0,
-            stack: [T::default(); 100],
-            heap: Vec::new(),
-        }
-    }
-
-    pub fn push(&mut self, val: T) {
-        if self.len < 100 {
-            self.stack[self.len] = val;
-            self.len += 1;
-        } else {
-            self.heap.push(val);
-        }
-    }
-
-    pub fn iter(&self) -> iter::Chain<slice::Iter<T>, slice::Iter<T>> {
-        // If len<100 then we just append an empty vec
-        self.stack[0..self.len].iter().chain(self.heap.iter())
-    }
-
-    pub fn iter_mut(&mut self) -> iter::Chain<slice::IterMut<T>, slice::IterMut<T>> {
-        // If len<100 then we just append an empty vec
-        self.stack[0..self.len].iter_mut().chain(self.heap.iter_mut())
-    }
-}
-
-static BASE58_CHARS: &'static [u8] = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-
-static BASE58_DIGITS: [Option<u8>; 128] = [
-    None,     None,     None,     None,     None,     None,     None,     None,     // 0-7
-    None,     None,     None,     None,     None,     None,     None,     None,     // 8-15
-    None,     None,     None,     None,     None,     None,     None,     None,     // 16-23
-    None,     None,     None,     None,     None,     None,     None,     None,     // 24-31
-    None,     None,     None,     None,     None,     None,     None,     None,     // 32-39
-    None,     None,     None,     None,     None,     None,     None,     None,     // 40-47
-    None,     Some(0),  Some(1),  Some(2),  Some(3),  Some(4),  Some(5),  Some(6),  // 48-55
-    Some(7),  Some(8),  None,     None,     None,     None,     None,     None,     // 56-63
-    None,     Some(9),  Some(10), Some(11), Some(12), Some(13), Some(14), Some(15), // 64-71
-    Some(16), None,     Some(17), Some(18), Some(19), Some(20), Some(21), None,     // 72-79
-    Some(22), Some(23), Some(24), Some(25), Some(26), Some(27), Some(28), Some(29), // 80-87
-    Some(30), Some(31), Some(32), None,     None,     None,     None,     None,     // 88-95
-    None,     Some(33), Some(34), Some(35), Some(36), Some(37), Some(38), Some(39), // 96-103
-    Some(40), Some(41), Some(42), Some(43), None,     Some(44), Some(45), Some(46), // 104-111
-    Some(47), Some(48), Some(49), Some(50), Some(51), Some(52), Some(53), Some(54), // 112-119
-    Some(55), Some(56), Some(57), None,     None,     None,     None,     None,     // 120-127
-];
-
-/// Decode base58-encoded string into a byte vector
-pub fn from(data: &str) -> Result<Vec<u8>, Error> {
-    // 11/15 is just over log_256(58)
-    let mut scratch = vec![0u8; 1 + data.len() * 11 / 15];
-    // Build in base 256
-    for d58 in data.bytes() {
-        // Compute "X = X * 58 + next_digit" in base 256
-        if d58 as usize > BASE58_DIGITS.len() {
-            return Err(Error::BadByte(d58));
-        }
-        let mut carry = match BASE58_DIGITS[d58 as usize] {
-            Some(d58) => d58 as u32,
-            None => { return Err(Error::BadByte(d58)); }
-        };
-        for d256 in scratch.iter_mut().rev() {
-            carry += *d256 as u32 * 58;
-            *d256 = carry as u8;
-            carry /= 256;
-        }
-        assert_eq!(carry, 0);
-    }
-
-    // Copy leading zeroes directly
-    let mut ret: Vec<u8> = data.bytes().take_while(|&x| x == BASE58_CHARS[0])
-                                       .map(|_| 0)
-                                       .collect();
-    // Copy rest of string
-    ret.extend(scratch.into_iter().skip_while(|&x| x == 0));
-    Ok(ret)
-}
-
-/// Decode a base58check-encoded string
-pub fn from_check(data: &str) -> Result<Vec<u8>, Error> {
-    let mut ret: Vec<u8> = from(data)?;
-    if ret.len() < 4 {
-        return Err(Error::TooShort(ret.len()));
-    }
-    let ck_start = ret.len() - 4;
-    let expected = endian::slice_to_u32_le(&sha256d::Hash::hash(&ret[..ck_start])[..4]);
-    let actual = endian::slice_to_u32_le(&ret[ck_start..(ck_start + 4)]);
-    if expected != actual {
-        return Err(Error::BadChecksum(expected, actual));
-    }
-
-    ret.truncate(ck_start);
-    Ok(ret)
-}
-
-fn format_iter<I, W>(writer: &mut W, data: I) -> Result<(), fmt::Error>
-where
-    I: Iterator<Item = u8> + Clone,
-    W: fmt::Write
-{
-    let mut ret = SmallVec::new();
-
-    let mut leading_zero_count = 0;
-    let mut leading_zeroes = true;
-    // Build string in little endian with 0-58 in place of characters...
-    for d256 in data {
-        let mut carry = d256 as usize;
-        if leading_zeroes && carry == 0 {
-            leading_zero_count += 1;
-        } else {
-            leading_zeroes = false;
-        }
-
-        for ch in ret.iter_mut() {
-            let new_ch = *ch as usize * 256 + carry;
-            *ch = (new_ch % 58) as u8;
-            carry = new_ch / 58;
-        }
-        while carry > 0 {
-            ret.push((carry % 58) as u8);
-            carry /= 58;
-        }
-    }
-
-    // ... then reverse it and convert to chars
-    for _ in 0..leading_zero_count {
-        ret.push(0);
-    }
-
-    for ch in ret.iter().rev() {
-        writer.write_char(BASE58_CHARS[*ch as usize] as char)?;
-    }
-
-    Ok(())
-}
-
-fn encode_iter<I>(data: I) -> String
-where
-    I: Iterator<Item = u8> + Clone,
-{
-    let mut ret = String::new();
-    format_iter(&mut ret, data).expect("writing into string shouldn't fail");
-    ret
-}
-
-
-/// Directly encode a slice as base58
-pub fn encode_slice(data: &[u8]) -> String {
-    encode_iter(data.iter().cloned())
-}
-
-/// Obtain a string with the base58check encoding of a slice
-/// (Tack the first 4 256-digits of the object's Bitcoin hash onto the end.)
-pub fn check_encode_slice(data: &[u8]) -> String {
-    let checksum = sha256d::Hash::hash(&data);
-    encode_iter(
-        data.iter()
-            .cloned()
-            .chain(checksum[0..4].iter().cloned())
-    )
-}
-
-/// Obtain a string with the base58check encoding of a slice
-/// (Tack the first 4 256-digits of the object's Bitcoin hash onto the end.)
-pub fn check_encode_slice_to_fmt(fmt: &mut fmt::Formatter, data: &[u8]) -> fmt::Result {
-    let checksum = sha256d::Hash::hash(&data);
-    let iter = data.iter()
-        .cloned()
-        .chain(checksum[0..4].iter().cloned());
-    format_iter(fmt, iter)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use hex::decode as hex_decode;
-
-    #[test]
-    fn test_base58_encode() {
-        // Basics
-        assert_eq!(&encode_slice(&[0][..]), "1");
-        assert_eq!(&encode_slice(&[1][..]), "2");
-        assert_eq!(&encode_slice(&[58][..]), "21");
-        assert_eq!(&encode_slice(&[13, 36][..]), "211");
-
-        // Leading zeroes
-        assert_eq!(&encode_slice(&[0, 13, 36][..]), "1211");
-        assert_eq!(&encode_slice(&[0, 0, 0, 0, 13, 36][..]), "1111211");
-
-        // Long input (>100 bytes => has to use heap)
-        let res = encode_slice(&"BitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBit\
-        coinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoin".as_bytes());
-        let exp = "ZqC5ZdfpZRi7fjA8hbhX5pEE96MdH9hEaC1YouxscPtbJF16qVWksHWR4wwvx7MotFcs2ChbJqK8KJ9X\
-        wZznwWn1JFDhhTmGo9v6GjAVikzCsBWZehu7bm22xL8b5zBR5AsBygYRwbFJsNwNkjpyFuDKwmsUTKvkULCvucPJrN5\
-        QUdxpGakhqkZFL7RU4yT";
-        assert_eq!(&res, exp);
-
-        // Addresses
-        let addr = hex_decode("00f8917303bfa8ef24f292e8fa1419b20460ba064d").unwrap();
-        assert_eq!(&check_encode_slice(&addr[..]), "1PfJpZsjreyVrqeoAfabrRwwjQyoSQMmHH");
-      }
-
-      #[test]
-      fn test_base58_decode() {
-        // Basics
-        assert_eq!(from("1").ok(), Some(vec![0u8]));
-        assert_eq!(from("2").ok(), Some(vec![1u8]));
-        assert_eq!(from("21").ok(), Some(vec![58u8]));
-        assert_eq!(from("211").ok(), Some(vec![13u8, 36]));
-
-        // Leading zeroes
-        assert_eq!(from("1211").ok(), Some(vec![0u8, 13, 36]));
-        assert_eq!(from("111211").ok(), Some(vec![0u8, 0, 0, 13, 36]));
-
-        // Addresses
-        assert_eq!(from_check("1PfJpZsjreyVrqeoAfabrRwwjQyoSQMmHH").ok(),
-                   Some(hex_decode("00f8917303bfa8ef24f292e8fa1419b20460ba064d").unwrap()))
-    }
-
-    #[test]
-    fn test_base58_roundtrip() {
-        let s = "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs";
-        let v: Vec<u8> = from_check(s).unwrap();
-        assert_eq!(check_encode_slice(&v[..]), s);
-        assert_eq!(from_check(&check_encode_slice(&v[..])).ok(), Some(v));
-    }
-}
-
diff --git a/src/util/bip143.rs b/src/util/bip143.rs
deleted file mode 100644
index 742a53f2..00000000
--- a/src/util/bip143.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2018 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-// 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/>.
-//
-
-//! BIP143 Implementation
-//!
-//! Implementation of BIP143 Segwit-style signatures. Should be sufficient
-//! to create signatures for Segwit transactions (which should be pushed into
-//! the appropriate place in the `Transaction::witness` array) or bcash
-//! signatures, which are placed in the scriptSig.
-//!
-
-use hashes::Hash;
-use hash_types::SigHash;
-use blockdata::script::Script;
-use blockdata::transaction::{Transaction, TxIn};
-use consensus::encode::Encodable;
-
-/// Parts of a sighash which are common across inputs or signatures, and which are
-/// sufficient (in conjunction with a private key) to sign the transaction
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct SighashComponents {
-    tx_version: u32,
-    tx_locktime: u32,
-    /// Hash of all the previous outputs
-    pub hash_prevouts: SigHash,
-    /// Hash of all the input sequence nos
-    pub hash_sequence: SigHash,
-    /// Hash of all the outputs in this transaction
-    pub hash_outputs: SigHash,
-}
-
-impl SighashComponents {
-    /// Compute the sighash components from an unsigned transaction and auxiliary
-    /// information about its inputs.
-    /// For the generated sighashes to be valid, no fields in the transaction may change except for
-    /// script_sig and witnesses.
-    pub fn new(tx: &Transaction) -> SighashComponents {
-        let hash_prevouts = {
-            let mut enc = SigHash::engine();
-            for txin in &tx.input {
-                txin.previous_output.consensus_encode(&mut enc).unwrap();
-            }
-            SigHash::from_engine(enc)
-        };
-
-        let hash_sequence = {
-            let mut enc = SigHash::engine();
-            for txin in &tx.input {
-                txin.sequence.consensus_encode(&mut enc).unwrap();
-            }
-            SigHash::from_engine(enc)
-        };
-
-        let hash_outputs = {
-            let mut enc = SigHash::engine();
-            for txout in &tx.output {
-                txout.consensus_encode(&mut enc).unwrap();
-            }
-            SigHash::from_engine(enc)
-        };
-
-        SighashComponents {
-            tx_version: tx.version,
-            tx_locktime: tx.lock_time,
-            hash_prevouts: hash_prevouts,
-            hash_sequence: hash_sequence,
-            hash_outputs: hash_outputs,
-        }
-    }
-
-    /// Compute the BIP143 sighash for a `SIGHASH_ALL` signature for the given
-    /// input.
-    pub fn sighash_all(&self, txin: &TxIn, script_code: &Script, value: u64) -> SigHash {
-        let mut enc = SigHash::engine();
-        self.tx_version.consensus_encode(&mut enc).unwrap();
-        self.hash_prevouts.consensus_encode(&mut enc).unwrap();
-        self.hash_sequence.consensus_encode(&mut enc).unwrap();
-        txin
-            .previous_output
-            .consensus_encode(&mut enc)
-            .unwrap();
-        script_code.consensus_encode(&mut enc).unwrap();
-        value.consensus_encode(&mut enc).unwrap();
-        txin.sequence.consensus_encode(&mut enc).unwrap();
-        self.hash_outputs.consensus_encode(&mut enc).unwrap();
-        self.tx_locktime.consensus_encode(&mut enc).unwrap();
-        1u32.consensus_encode(&mut enc).unwrap(); // hashtype
-        SigHash::from_engine(enc)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use hash_types::SigHash;
-    use blockdata::script::Script;
-    use blockdata::transaction::Transaction;
-    use consensus::encode::deserialize;
-    use network::constants::Network;
-    use util::address::Address;
-    use util::key::PublicKey;
-    use hashes::hex::FromHex;
-    use hex;
-
-    use super::*;
-
-    fn p2pkh_hex(pk: &str) -> Script {
-        let pk = hex::decode(pk).unwrap();
-        let pk = PublicKey::from_slice(pk.as_slice()).unwrap();
-        let witness_script = Address::p2pkh(&pk, Network::Bitcoin).script_pubkey();
-        witness_script
-    }
-
-    #[test]
-    fn bip143_p2wpkh() {
-        let tx = deserialize::<Transaction>(
-            &Vec::<u8>::from_hex(
-                "0100000002fff7f7881a8099afa6940d42d1e7f6362bec38171ea3edf433541db4e4ad969f000000\
-                0000eeffffffef51e1b804cc89d182d279655c3aa89e815b1b309fe287d9b2b55d57b90ec68a01000000\
-                00ffffffff02202cb206000000001976a9148280b37df378db99f66f85c95a783a76ac7a6d5988ac9093\
-                510d000000001976a9143bde42dbee7e4dbe6a21b2d50ce2f0167faa815988ac11000000",
-            ).unwrap()[..],
-        ).unwrap();
-
-        let witness_script = p2pkh_hex("025476c2e83188368da1ff3e292e7acafcdb3566bb0ad253f62fc70f07aeee6357");
-        let value = 600_000_000;
-
-        let comp = SighashComponents::new(&tx);
-        assert_eq!(
-            comp,
-            SighashComponents {
-                tx_version: 1,
-                tx_locktime: 17,
-                hash_prevouts: hex_hash!(
-                    SigHash, "96b827c8483d4e9b96712b6713a7b68d6e8003a781feba36c31143470b4efd37"
-                ),
-                hash_sequence: hex_hash!(
-                    SigHash, "52b0a642eea2fb7ae638c36f6252b6750293dbe574a806984b8e4d8548339a3b"
-                ),
-                hash_outputs: hex_hash!(
-                    SigHash, "863ef3e1a92afbfdb97f31ad0fc7683ee943e9abcf2501590ff8f6551f47e5e5"
-                ),
-            }
-        );
-
-        assert_eq!(
-            comp.sighash_all(&tx.input[1], &witness_script, value),
-            hex_hash!(SigHash, "c37af31116d1b27caf68aae9e3ac82f1477929014d5b917657d0eb49478cb670")
-        );
-    }
-
-    #[test]
-    fn bip143_p2wpkh_nested_in_p2sh() {
-        let tx = deserialize::<Transaction>(
-            &Vec::<u8>::from_hex(
-                "0100000001db6b1b20aa0fd7b23880be2ecbd4a98130974cf4748fb66092ac4d3ceb1a5477010000\
-                0000feffffff02b8b4eb0b000000001976a914a457b684d7f0d539a46a45bbc043f35b59d0d96388ac00\
-                08af2f000000001976a914fd270b1ee6abcaea97fea7ad0402e8bd8ad6d77c88ac92040000",
-            ).unwrap()[..],
-        ).unwrap();
-
-        let witness_script = p2pkh_hex("03ad1d8e89212f0b92c74d23bb710c00662ad1470198ac48c43f7d6f93a2a26873");
-        let value = 1_000_000_000;
-
-        let comp = SighashComponents::new(&tx);
-        assert_eq!(
-            comp,
-            SighashComponents {
-                tx_version: 1,
-                tx_locktime: 1170,
-                hash_prevouts: hex_hash!(
-                    SigHash, "b0287b4a252ac05af83d2dcef00ba313af78a3e9c329afa216eb3aa2a7b4613a"
-                ),
-                hash_sequence: hex_hash!(
-                    SigHash, "18606b350cd8bf565266bc352f0caddcf01e8fa789dd8a15386327cf8cabe198"
-                ),
-                hash_outputs: hex_hash!(
-                    SigHash, "de984f44532e2173ca0d64314fcefe6d30da6f8cf27bafa706da61df8a226c83"
-                ),
-            }
-        );
-
-        assert_eq!(
-            comp.sighash_all(&tx.input[0], &witness_script, value),
-            hex_hash!(SigHash, "64f3b0f4dd2bb3aa1ce8566d220cc74dda9df97d8490cc81d89d735c92e59fb6")
-        );
-    }
-
-    #[test]
-    fn bip143_p2wsh_nested_in_p2sh() {
-        let tx = deserialize::<Transaction>(
-            &Vec::<u8>::from_hex(
-            "010000000136641869ca081e70f394c6948e8af409e18b619df2ed74aa106c1ca29787b96e0100000000\
-             ffffffff0200e9a435000000001976a914389ffce9cd9ae88dcc0631e88a821ffdbe9bfe2688acc0832f\
-             05000000001976a9147480a33f950689af511e6e84c138dbbd3c3ee41588ac00000000").unwrap()[..],
-        ).unwrap();
-
-        let witness_script = hex_script!(
-            "56210307b8ae49ac90a048e9b53357a2354b3334e9c8bee813ecb98e99a7e07e8c3ba32103b28f0c28\
-             bfab54554ae8c658ac5c3e0ce6e79ad336331f78c428dd43eea8449b21034b8113d703413d57761b8b\
-             9781957b8c0ac1dfe69f492580ca4195f50376ba4a21033400f6afecb833092a9a21cfdf1ed1376e58\
-             c5d1f47de74683123987e967a8f42103a6d48b1131e94ba04d9737d61acdaa1322008af9602b3b1486\
-             2c07a1789aac162102d8b661b0b3302ee2f162b09e07a55ad5dfbe673a9f01d9f0c19617681024306b\
-             56ae"
-        );
-        let value = 987654321;
-
-        let comp = SighashComponents::new(&tx);
-        assert_eq!(
-            comp,
-            SighashComponents {
-                tx_version: 1,
-                tx_locktime: 0,
-                hash_prevouts: hex_hash!(
-                    SigHash, "74afdc312af5183c4198a40ca3c1a275b485496dd3929bca388c4b5e31f7aaa0"
-                ),
-                hash_sequence: hex_hash!(
-                    SigHash, "3bb13029ce7b1f559ef5e747fcac439f1455a2ec7c5f09b72290795e70665044"
-                ),
-                hash_outputs: hex_hash!(
-                    SigHash, "bc4d309071414bed932f98832b27b4d76dad7e6c1346f487a8fdbb8eb90307cc"
-                ),
-            }
-        );
-
-        assert_eq!(
-            comp.sighash_all(&tx.input[0], &witness_script, value),
-            hex_hash!(SigHash, "185c0be5263dce5b4bb50a047973c1b6272bfbd0103a89444597dc40b248ee7c")
-        );
-    }
-}
diff --git a/src/util/bip158.rs b/src/util/bip158.rs
deleted file mode 100644
index 1d71d01d..00000000
--- a/src/util/bip158.rs
+++ /dev/null
@@ -1,704 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2019 by
-//   The rust-bitcoin 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 module was largely copied from https://github.com/rust-bitcoin/murmel/blob/master/src/blockfilter.rs
-// on 11. June 2019 which is licensed under Apache, that file specifically
-// was written entirely by Tamas Blummer, who is re-licensing its contents here as CC0.
-
-//!
-//! # BIP158 Compact Block Filters for Light Clients
-//!
-//! Implements a structure for compact filters on block data, for use in the BIP 157 light client protocol.
-//! The filter construction proposed is an alternative to Bloom filters, as used in BIP 37,
-//! that minimizes filter size by using Golomb-Rice coding for compression.
-//!
-//!  USE :
-//!   // create a block filter for a block (server side)
-//!
-//!   fn get_script_for_coin (coin: &OutPoint) -> Result<Script, BlockFilterError> {
-//!     // get utxo ...
-//!   }
-//!
-//!   let filter = BlockFilter::new_script_filter (&block, get_script_for_coin)?;
-//!
-//!   // or create a filter from known raw data
-//!   let filter = BlockFilter::new(content);
-//!
-//!   // read and evaluate a filter
-//!
-//!   let query: Iterator<Item=Script> = // .. some scripts you care about
-//!   if filter.match_any (&block_hash, &mut query.map(|s| s.as_bytes())) {
-//!     // get this block
-//!   }
-//!
-//!
-
-use std::{cmp, fmt, io};
-use std::collections::HashSet;
-use std::error;
-use std::fmt::{Display, Formatter};
-use std::io::Cursor;
-
-use hashes::{Hash, siphash24};
-use hash_types::{BlockHash, FilterHash};
-
-use blockdata::block::Block;
-use blockdata::script::Script;
-use blockdata::transaction::OutPoint;
-use consensus::{Decodable, Encodable};
-use consensus::encode::VarInt;
-use util::endian;
-use util::hash::BitcoinHash;
-
-/// Golomb encoding parameter as in BIP-158, see also https://gist.github.com/sipa/576d5f09c3b86c3b1b75598d799fc845
-const P: u8 = 19;
-const M: u64 = 784931;
-
-/// Errors for blockfilter
-#[derive(Debug)]
-pub enum Error {
-    /// missing UTXO, can not calculate script filter
-    UtxoMissing(OutPoint),
-    /// some IO error reading or writing binary serialization of the filter
-    Io(io::Error),
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::UtxoMissing(_) => "unresolved UTXO",
-            Error::Io(_) => "IO Error"
-        }
-    }
-}
-
-impl Display for Error {
-    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
-        match *self {
-            Error::UtxoMissing(ref coin) => write!(f, "unresolved UTXO {}", coin),
-            Error::Io(ref io) => write!(f, "{}", io)
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(io: io::Error) -> Self {
-        Error::Io(io)
-    }
-}
-
-
-/// a computed or read block filter
-pub struct BlockFilter {
-    /// Golomb encoded filter
-    pub content: Vec<u8>
-}
-
-impl BlockFilter {
-    /// compute this filter's id in a chain of filters
-    pub fn filter_id(&self, previous_filter_id: &FilterHash) -> FilterHash {
-        let filter_hash = FilterHash::hash(self.content.as_slice());
-        let mut header_data = [0u8; 64];
-        header_data[0..32].copy_from_slice(&filter_hash[..]);
-        header_data[32..64].copy_from_slice(&previous_filter_id[..]);
-        FilterHash::hash(&header_data)
-    }
-
-    /// create a new filter from pre-computed data
-    pub fn new (content: &[u8]) -> BlockFilter {
-        BlockFilter { content: content.to_vec() }
-    }
-
-    /// Compute a SCRIPT_FILTER that contains spent and output scripts
-    pub fn new_script_filter<M>(block: &Block, script_for_coin: M) -> Result<BlockFilter, Error>
-        where M: Fn(&OutPoint) -> Result<Script, Error> {
-        let mut out = Cursor::new(Vec::new());
-        {
-            let mut writer = BlockFilterWriter::new(&mut out, block);
-            writer.add_output_scripts();
-            writer.add_input_scripts(script_for_coin)?;
-            writer.finish()?;
-        }
-        Ok(BlockFilter { content: out.into_inner() })
-    }
-
-    /// match any query pattern
-    pub fn match_any(&self, block_hash: &BlockHash, query: &mut Iterator<Item=&[u8]>) -> Result<bool, Error> {
-        let filter_reader = BlockFilterReader::new(block_hash);
-        filter_reader.match_any(&mut Cursor::new(self.content.as_slice()), query)
-    }
-
-    /// match all query pattern
-    pub fn match_all(&self, block_hash: &BlockHash, query: &mut Iterator<Item=&[u8]>) -> Result<bool, Error> {
-        let filter_reader = BlockFilterReader::new(block_hash);
-        filter_reader.match_all(&mut Cursor::new(self.content.as_slice()), query)
-    }
-}
-
-/// Compiles and writes a block filter
-pub struct BlockFilterWriter<'a> {
-    block: &'a Block,
-    writer: GCSFilterWriter<'a>,
-}
-
-impl<'a> BlockFilterWriter<'a> {
-    /// Create a block filter writer
-    pub fn new(writer: &'a mut io::Write, block: &'a Block) -> BlockFilterWriter<'a> {
-        let block_hash_as_int = block.bitcoin_hash().into_inner();
-        let k0 = endian::slice_to_u64_le(&block_hash_as_int[0..8]);
-        let k1 = endian::slice_to_u64_le(&block_hash_as_int[8..16]);
-        let writer = GCSFilterWriter::new(writer, k0, k1, M, P);
-        BlockFilterWriter { block, writer }
-    }
-
-    /// Add output scripts of the block - excluding OP_RETURN scripts
-    pub fn add_output_scripts(&mut self) {
-        for transaction in &self.block.txdata {
-            for output in &transaction.output {
-                if !output.script_pubkey.is_op_return() {
-                    self.add_element(output.script_pubkey.as_bytes());
-                }
-            }
-        }
-    }
-
-    /// Add consumed output scripts of a block to filter
-    pub fn add_input_scripts<M>(&mut self, script_for_coin: M) -> Result<(), Error>
-        where M: Fn(&OutPoint) -> Result<Script, Error> {
-        for script in self.block.txdata.iter()
-            .skip(1) // skip coinbase
-            .flat_map(|t| t.input.iter().map(|i| &i.previous_output))
-            .map(script_for_coin) {
-            match script {
-                Ok(script) => self.add_element(script.as_bytes()),
-                Err(e) => return Err(e)
-            }
-        }
-        Ok(())
-    }
-
-    /// Add arbitrary element to a filter
-    pub fn add_element(&mut self, data: &[u8]) {
-        self.writer.add_element(data);
-    }
-
-    /// Write block filter
-    pub fn finish(&mut self) -> Result<usize, io::Error> {
-        self.writer.finish()
-    }
-}
-
-
-/// Reads and interpret a block filter
-pub struct BlockFilterReader {
-    reader: GCSFilterReader
-}
-
-impl BlockFilterReader {
-    /// Create a block filter reader
-    pub fn new(block_hash: &BlockHash) -> BlockFilterReader {
-        let block_hash_as_int = block_hash.into_inner();
-        let k0 = endian::slice_to_u64_le(&block_hash_as_int[0..8]);
-        let k1 = endian::slice_to_u64_le(&block_hash_as_int[8..16]);
-        BlockFilterReader { reader: GCSFilterReader::new(k0, k1, M, P) }
-    }
-
-    /// match any query pattern
-    pub fn match_any(&self, reader: &mut io::Read, query: &mut Iterator<Item=&[u8]>) -> Result<bool, Error> {
-        self.reader.match_any(reader, query)
-    }
-
-    /// match all query pattern
-    pub fn match_all(&self, reader: &mut io::Read, query: &mut Iterator<Item=&[u8]>) -> Result<bool, Error> {
-        self.reader.match_all(reader, query)
-    }
-}
-
-
-/// Golomb-Rice encoded filter reader
-pub struct GCSFilterReader {
-    filter: GCSFilter,
-    m: u64
-}
-
-impl GCSFilterReader {
-    /// Create a new filter reader with specific seed to siphash
-    pub fn new(k0: u64, k1: u64, m: u64, p: u8) -> GCSFilterReader {
-        GCSFilterReader { filter: GCSFilter::new(k0, k1, p), m }
-    }
-
-    /// match any query pattern
-    pub fn match_any(&self, reader: &mut io::Read, query: &mut Iterator<Item=&[u8]>) -> Result<bool, Error> {
-        let mut decoder = reader;
-        let n_elements: VarInt = Decodable::consensus_decode(&mut decoder).unwrap_or(VarInt(0));
-        let ref mut reader = decoder;
-        // map hashes to [0, n_elements << grp]
-        let nm = n_elements.0 * self.m;
-        let mut mapped = query.map(|e| map_to_range(self.filter.hash(e), nm)).collect::<Vec<_>>();
-        // sort
-        mapped.sort();
-        if mapped.is_empty() {
-            return Ok(true);
-        }
-        if n_elements.0 == 0 {
-            return Ok(false);
-        }
-
-        // find first match in two sorted arrays in one read pass
-        let mut reader = BitStreamReader::new(reader);
-        let mut data = self.filter.golomb_rice_decode(&mut reader)?;
-        let mut remaining = n_elements.0 - 1;
-        for p in mapped {
-            loop {
-                if data == p {
-                    return Ok(true);
-                } else if data < p {
-                    if remaining > 0 {
-                        data += self.filter.golomb_rice_decode(&mut reader)?;
-                        remaining -= 1;
-                    } else {
-                        return Ok(false);
-                    }
-                } else {
-                    break;
-                }
-            }
-        }
-        Ok(false)
-    }
-
-    /// match all query pattern
-    pub fn match_all(&self, reader: &mut io::Read, query: &mut Iterator<Item=&[u8]>) -> Result<bool, Error> {
-        let mut decoder = reader;
-        let n_elements: VarInt = Decodable::consensus_decode(&mut decoder).unwrap_or(VarInt(0));
-        let ref mut reader = decoder;
-        // map hashes to [0, n_elements << grp]
-        let nm = n_elements.0 * self.m;
-        let mut mapped = query.map(|e| map_to_range(self.filter.hash(e), nm)).collect::<Vec<_>>();
-        // sort
-        mapped.sort();
-        mapped.dedup();
-        if mapped.is_empty() {
-            return Ok(true);
-        }
-        if n_elements.0 == 0 {
-            return Ok(false);
-        }
-
-        // figure if all mapped are there in one read pass
-        let mut reader = BitStreamReader::new(reader);
-        let mut data = self.filter.golomb_rice_decode(&mut reader)?;
-        let mut remaining = n_elements.0 - 1;
-        for p in mapped {
-            loop {
-                if data == p {
-                    break;
-                } else if data < p {
-                    if remaining > 0 {
-                        data += self.filter.golomb_rice_decode(&mut reader)?;
-                        remaining -= 1;
-                    } else {
-                        return Ok(false);
-                    }
-                } else {
-                    return Ok(false);
-                }
-            }
-        }
-        Ok(true)
-    }
-}
-
-// fast reduction of hash to [0, nm) range
-fn map_to_range(hash: u64, nm: u64) -> u64 {
-    // Use this once we upgrade to rustc >= 1.26
-    // ((hash as u128 * nm as u128) >> 64) as u64
-
-    #[inline]
-    fn l(n: u64) -> u64 { n & 0xffffffff }
-    #[inline]
-    fn h(n: u64) -> u64 { n >> 32 }
-
-    let a = h(hash);
-    let b = l(hash);
-    let c = h(nm);
-    let d = l(nm);
-
-    a * c + h(a * d + c * b + h(b * d))
-}
-
-/// Colomb-Rice encoded filter writer
-pub struct GCSFilterWriter<'a> {
-    filter: GCSFilter,
-    writer: &'a mut io::Write,
-    elements: HashSet<Vec<u8>>,
-    m: u64
-}
-
-impl<'a> GCSFilterWriter<'a> {
-    /// Create a new GCS writer wrapping a generic writer, with specific seed to siphash
-    pub fn new(writer: &'a mut io::Write, k0: u64, k1: u64, m: u64, p: u8) -> GCSFilterWriter<'a> {
-        GCSFilterWriter {
-            filter: GCSFilter::new(k0, k1, p),
-            writer,
-            elements: HashSet::new(),
-            m
-        }
-    }
-
-    /// Add some data to the filter
-    pub fn add_element(&mut self, element: &[u8]) {
-        if !element.is_empty() {
-            self.elements.insert(element.to_vec());
-        }
-    }
-
-    /// write the filter to the wrapped writer
-    pub fn finish(&mut self) -> Result<usize, io::Error> {
-        let nm = self.elements.len() as u64 * self.m;
-
-        // map hashes to [0, n_elements * M)
-        let mut mapped: Vec<_> = self.elements.iter()
-            .map(|e| map_to_range(self.filter.hash(e.as_slice()), nm)).collect();
-        mapped.sort();
-
-        // write number of elements as varint
-        let mut encoder = io::Cursor::new(Vec::new());
-        VarInt(mapped.len() as u64).consensus_encode(&mut encoder).unwrap();
-        let mut wrote = self.writer.write(encoder.into_inner().as_slice())?;
-
-        // write out deltas of sorted values into a Golonb-Rice coded bit stream
-        let mut writer = BitStreamWriter::new(self.writer);
-        let mut last = 0;
-        for data in mapped {
-            wrote += self.filter.golomb_rice_encode(&mut writer, data - last)?;
-            last = data;
-        }
-        wrote += writer.flush()?;
-        Ok(wrote)
-    }
-}
-
-/// Golomb Coded Set Filter
-struct GCSFilter {
-    k0: u64, // sip hash key
-    k1: u64, // sip hash key
-    p: u8
-}
-
-impl GCSFilter {
-    /// Create a new filter
-    fn new(k0: u64, k1: u64, p: u8) -> GCSFilter {
-        GCSFilter { k0, k1, p }
-    }
-
-    /// Golomb-Rice encode a number n to a bit stream (Parameter 2^k)
-    fn golomb_rice_encode(&self, writer: &mut BitStreamWriter, n: u64) -> Result<usize, io::Error> {
-        let mut wrote = 0;
-        let mut q = n >> self.p;
-        while q > 0 {
-            let nbits = cmp::min(q, 64);
-            wrote += writer.write(!0u64, nbits as u8)?;
-            q -= nbits;
-        }
-        wrote += writer.write(0, 1)?;
-        wrote += writer.write(n, self.p)?;
-        Ok(wrote)
-    }
-
-    /// Golomb-Rice decode a number from a bit stream (Parameter 2^k)
-    fn golomb_rice_decode(&self, reader: &mut BitStreamReader) -> Result<u64, io::Error> {
-        let mut q = 0u64;
-        while reader.read(1)? == 1 {
-            q += 1;
-        }
-        let r = reader.read(self.p)?;
-        return Ok((q << self.p) + r);
-    }
-
-    /// Hash an arbitrary slice with siphash using parameters of this filter
-    fn hash(&self, element: &[u8]) -> u64 {
-        siphash24::Hash::hash_to_u64_with_keys(self.k0, self.k1, element)
-    }
-}
-
-/// Bitwise stream reader
-pub struct BitStreamReader<'a> {
-    buffer: [u8; 1],
-    offset: u8,
-    reader: &'a mut io::Read,
-}
-
-impl<'a> BitStreamReader<'a> {
-    /// Create a new BitStreamReader that reads bitwise from a given reader
-    pub fn new(reader: &'a mut io::Read) -> BitStreamReader {
-        BitStreamReader {
-            buffer: [0u8],
-            reader: reader,
-            offset: 8,
-        }
-    }
-
-    /// Read nbit bits
-    pub fn read(&mut self, mut nbits: u8) -> Result<u64, io::Error> {
-        if nbits > 64 {
-            return Err(io::Error::new(io::ErrorKind::Other, "can not read more than 64 bits at once"));
-        }
-        let mut data = 0u64;
-        while nbits > 0 {
-            if self.offset == 8 {
-                self.reader.read_exact(&mut self.buffer)?;
-                self.offset = 0;
-            }
-            let bits = cmp::min(8 - self.offset, nbits);
-            data <<= bits;
-            data |= ((self.buffer[0] << self.offset) >> (8 - bits)) as u64;
-            self.offset += bits;
-            nbits -= bits;
-        }
-        Ok(data)
-    }
-}
-
-/// Bitwise stream writer
-pub struct BitStreamWriter<'a> {
-    buffer: [u8; 1],
-    offset: u8,
-    writer: &'a mut io::Write,
-}
-
-impl<'a> BitStreamWriter<'a> {
-    /// Create a new BitStreamWriter that writes bitwise to a given writer
-    pub fn new(writer: &'a mut io::Write) -> BitStreamWriter {
-        BitStreamWriter {
-            buffer: [0u8],
-            writer: writer,
-            offset: 0,
-        }
-    }
-
-    /// Write nbits bits from data
-    pub fn write(&mut self, data: u64, mut nbits: u8) -> Result<usize, io::Error> {
-        if nbits > 64 {
-            return Err(io::Error::new(io::ErrorKind::Other, "can not write more than 64 bits at once"));
-        }
-        let mut wrote = 0;
-        while nbits > 0 {
-            let bits = cmp::min(8 - self.offset, nbits);
-            self.buffer[0] |= ((data << (64 - nbits)) >> (64 - 8 + self.offset)) as u8;
-            self.offset += bits;
-            nbits -= bits;
-            if self.offset == 8 {
-                wrote += self.flush()?;
-            }
-        }
-        Ok(wrote)
-    }
-
-    /// flush bits not yet written
-    pub fn flush(&mut self) -> Result<usize, io::Error> {
-        if self.offset > 0 {
-            self.writer.write_all(&self.buffer)?;
-            self.buffer[0] = 0u8;
-            self.offset = 0;
-            Ok(1)
-        } else {
-            Ok(0)
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::collections::{HashSet, HashMap};
-    use std::io::Cursor;
-
-    use hash_types::BlockHash;
-    use hashes::hex::FromHex;
-
-    use super::*;
-
-    extern crate hex;
-    extern crate serde_json;
-    use self::serde_json::{Value};
-
-    use consensus::encode::deserialize;
-
-    #[test]
-    fn test_blockfilters() {
-
-        // test vectors from: https://github.com/jimpo/bitcoin/blob/c7efb652f3543b001b4dd22186a354605b14f47e/src/test/data/blockfilters.json
-        let data = r#"
-        [
-            ["Block Height,Block Hash,Block,[Prev Output Scripts for Block],Previous Basic Header,Basic Filter,Basic Header,Notes"],
-            [0,"000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943","0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff001d1aa4ae180101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000",[],"0000000000000000000000000000000000000000000000000000000000000000","019dfca8","21584579b7eb08997773e5aeff3a7f932700042d0ed2a6129012b7d7ae81b750","Genesis block"],
-            [2,"000000006c02c8ea6e4ff69651f7fcde348fb9d557a06e6957b65552002a7820","0100000006128e87be8b1b4dea47a7247d5528d2702c96826c7a648497e773b800000000e241352e3bec0a95a6217e10c3abb54adfa05abb12c126695595580fb92e222032e7494dffff001d00d235340101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e0432e7494d010e062f503253482fffffffff0100f2052a010000002321038a7f6ef1c8ca0c588aa53fa860128077c9e6c11e6830f4d7ee4e763a56b7718fac00000000",[],"d7bdac13a59d745b1add0d2ce852f1a0442e8945fc1bf3848d3cbffd88c24fe1","0174a170","186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0",""],
-            [3,"000000008b896e272758da5297bcd98fdc6d97c9b765ecec401e286dc1fdbe10","0100000020782a005255b657696ea057d5b98f34defcf75196f64f6eeac8026c0000000041ba5afc532aae03151b8aa87b65e1594f97504a768e010c98c0add79216247186e7494dffff001d058dc2b60101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e0486e7494d0151062f503253482fffffffff0100f2052a01000000232103f6d9ff4c12959445ca5549c811683bf9c88e637b222dd2e0311154c4c85cf423ac00000000",[],"186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0","016cf7a0","8d63aadf5ab7257cb6d2316a57b16f517bff1c6388f124ec4c04af1212729d2a",""],
-            [15007,"0000000038c44c703bae0f98cdd6bf30922326340a5996cc692aaae8bacf47ad","0100000002394092aa378fe35d7e9ac79c869b975c4de4374cd75eb5484b0e1e00000000eb9b8670abd44ad6c55cee18e3020fb0c6519e7004b01a16e9164867531b67afc33bc94fffff001d123f10050101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e04c33bc94f0115062f503253482fffffffff0100f2052a01000000232103f268e9ae07e0f8cb2f6e901d87c510d650b97230c0365b021df8f467363cafb1ac00000000",[],"18b5c2b0146d2d09d24fb00ff5b52bd0742f36c9e65527abdb9de30c027a4748","013c3710","07384b01311867949e0c046607c66b7a766d338474bb67f66c8ae9dbd454b20e","Tx has non-standard OP_RETURN output followed by opcodes"],
-            [49291,"0000000018b07dca1b28b4b5a119f6d6e71698ce1ed96f143f54179ce177a19c","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",["5221033423007d8f263819a2e42becaaf5b06f34cb09919e06304349d950668209eaed21021d69e2b68c3960903b702af7829fadcd80bd89b158150c85c4a75b2c8cb9c39452ae","52210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821021d69e2b68c3960903b702af7829fadcd80bd89b158150c85c4a75b2c8cb9c39452ae","522102a7ae1e0971fc1689bd66d2a7296da3a1662fd21a53c9e38979e0f090a375c12d21022adb62335f41eb4e27056ac37d462cda5ad783fa8e0e526ed79c752475db285d52ae","52210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821022adb62335f41eb4e27056ac37d462cda5ad783fa8e0e526ed79c752475db285d52ae","512103b9d1d0e2b4355ec3cdef7c11a5c0beff9e8b8d8372ab4b4e0aaf30e80173001951ae","76a9149144761ebaccd5b4bbdc2a35453585b5637b2f8588ac","522103f1848b40621c5d48471d9784c8174ca060555891ace6d2b03c58eece946b1a9121020ee5d32b54d429c152fdc7b1db84f2074b0564d35400d89d11870f9273ec140c52ae","76a914f4fa1cc7de742d135ea82c17adf0bb9cf5f4fb8388ac"],"ed47705334f4643892ca46396eb3f4196a5e30880589e4009ef38eae895d4a13","0afbc2920af1b027f31f87b592276eb4c32094bb4d3697021b4c6380","b6d98692cec5145f67585f3434ec3c2b3030182e1cb3ec58b855c5c164dfaaa3","Tx pays to empty output script"],
-            [180480,"00000000fd3ceb2404ff07a785c7fdcc76619edc8ed61bd25134eaa22084366a","020000006058aa080a655aa991a444bd7d1f2defd9a3bbe68aabb69030cf3b4e00000000d2e826bfd7ef0beaa891a7eedbc92cd6a544a6cb61c7bdaa436762eb2123ef9790f5f552ffff001d0002c90f0501000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e0300c102024608062f503253482fffffffff01c0c6072a01000000232102e769e60137a4df6b0df8ebd387cca44c4c57ae74cc0114a8e8317c8f3bfd85e9ac00000000010000000381a0802911a01ffb025c4dea0bc77963e8c1bb46313b71164c53f72f37fe5248010000000151ffffffffc904b267833d215e2128bd9575242232ac2bc311550c7fc1f0ef6f264b40d14c010000000151ffffffffdf0915666649dba81886519c531649b7b02180b4af67d6885e871299e9d5f775000000000151ffffffff0180817dcb00000000232103bb52138972c48a132fc1f637858c5189607dd0f7fe40c4f20f6ad65f2d389ba4ac0000000001000000018da38b434fba82d66052af74fc5e4e94301b114d9bc03f819dc876398404c8b4010000006c493046022100fe738b7580dc5fb5168e51fc61b5aed211125eb71068031009a22d9bbad752c5022100be5086baa384d40bcab0fa586e4f728397388d86e18b66cc417dc4f7fa4f9878012103f233299455134caa2687bdf15cb0becdfb03bd0ff2ff38e65ec6b7834295c34fffffffff022ebc1400000000001976a9147779b7fba1c1e06b717069b80ca170e8b04458a488ac9879c40f000000001976a9142a0307cd925dbb66b534c4db33003dd18c57015788ac0000000001000000026139a62e3422a602de36c873a225c1d3ca5aeee598539ceecb9f0dc8d1ad0f83010000006b483045022100ad9f32b4a0a2ddc19b5a74eba78123e57616f1b3cfd72ce68c03ea35a3dda1f002200dbd22aa6da17213df5e70dfc3b2611d40f70c98ed9626aa5e2cde9d97461f0a012103ddb295d2f1e8319187738fb4b230fdd9aa29d0e01647f69f6d770b9ab24eea90ffffffff983c82c87cf020040d671956525014d5c2b28c6d948c85e1a522362c0059eeae010000006b4830450221009ca544274c786d30a5d5d25e17759201ea16d3aedddf0b9e9721246f7ef6b32e02202cfa5564b6e87dfd9fd98957820e4d4e6238baeb0f65fe305d91506bb13f5f4f012103c99113deac0d5d044e3ac0346abc02501542af8c8d3759f1382c72ff84e704f7ffffffff02c0c62d00000000001976a914ae19d27efe12f5a886dc79af37ad6805db6f922d88ac70ce2000000000001976a9143b8d051d37a07ea1042067e93efe63dbf73920b988ac000000000100000002be566e8cd9933f0c75c4a82c027f7d0c544d5c101d0607ef6ae5d07b98e7f1dc000000006b483045022036a8cdfd5ea7ebc06c2bfb6e4f942bbf9a1caeded41680d11a3a9f5d8284abad022100cacb92a5be3f39e8bc14db1710910ef7b395fa1e18f45d41c28d914fcdde33be012102bf59abf110b5131fae0a3ce1ec379329b4c896a6ae5d443edb68529cc2bc7816ffffffff96cf67645b76ceb23fe922874847456a15feee1655082ff32d25a6bf2c0dfc90000000006a47304402203471ca2001784a5ac0abab583581f2613523da47ec5f53df833c117b5abd81500220618a2847723d57324f2984678db556dbca1a72230fc7e39df04c2239942ba942012102925c9794fd7bb9f8b29e207d5fc491b1150135a21f505041858889fa4edf436fffffffff026c840f00000000001976a914797fb8777d7991d8284d88bfd421ce520f0f843188ac00ca9a3b000000001976a9146d10f3f592699265d10b106eda37c3ce793f7a8588ac00000000",["","","","76a9142903b138c24be9e070b3e73ec495d77a204615e788ac","76a91433a1941fd9a37b9821d376f5a51bd4b52fa50e2888ac","76a914e4374e8155d0865742ca12b8d4d14d41b57d682f88ac","76a914001fa7459a6cfc64bdc178ba7e7a21603bb2568f88ac","76a914f6039952bc2b307aeec5371bfb96b66078ec17f688ac"],"d34ef98386f413769502808d4bac5f20f8dfd5bffc9eedafaa71de0eb1f01489","0db414c859a07e8205876354a210a75042d0463404913d61a8e068e58a3ae2aa080026","c582d51c0ca365e3fcf36c51cb646d7f83a67e867cb4743fd2128e3e022b700c","Tx spends from empty output script"],
-            [926485,"000000000000015d6077a411a8f5cc95caf775ccf11c54e27df75ce58d187313","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",["a914feb8a29635c56d9cd913122f90678756bf23887687","76a914c01a7ca16b47be50cbdbc60724f701d52d75156688ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac"],"8f13b9a9c85611635b47906c3053ac53cfcec7211455d4cb0d63dc9acc13d472","09027acea61b6cc3fb33f5d52f7d088a6b2f75d234e89ca800","546c574a0472144bcaf9b6aeabf26372ad87c7af7d1ee0dbfae5e099abeae49c","Duplicate pushdata 913bcc2be49cb534c20474c4dee1e9c4c317e7eb"],
-            [987876,"0000000000000c00901f2049055e2a437c819d79a3d54fd63e6af796cd7b8a79","000000202694f74969fdb542090e95a56bc8aa2d646e27033850e32f1c5f000000000000f7e53676b3f12d5beb524ed617f2d25f5a93b5f4f52c1ba2678260d72712f8dd0a6dfe5740257e1a4b1768960101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1603e4120ff9c30a1c216900002f424d4920546573742fffffff0001205fa012000000001e76a914c486de584a735ec2f22da7cd9681614681f92173d83d0aa68688ac00000000",[],"fe4d230dbb0f4fec9bed23a5283e08baf996e3f32b93f52c7de1f641ddfd04ad","010c0b40","0965a544743bbfa36f254446e75630c09404b3d164a261892372977538928ed5","Coinbase tx has unparseable output script"],
-            [1263442,"000000006f27ddfe1dd680044a34548f41bed47eba9e6f0b310da21423bc5f33","000000201c8d1a529c39a396db2db234d5ec152fa651a2872966daccbde028b400000000083f14492679151dbfaa1a825ef4c18518e780c1f91044180280a7d33f4a98ff5f45765aaddc001d38333b9a02010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff230352471300fe5f45765afe94690a000963676d696e6572343208000000000000000000ffffffff024423a804000000001976a914f2c25ac3d59f3d674b1d1d0a25c27339aaac0ba688ac0000000000000000266a24aa21a9edcb26cb3052426b9ebb4d19c819ef87c19677bbf3a7c46ef0855bd1b2abe83491012000000000000000000000000000000000000000000000000000000000000000000000000002000000000101d20978463906ba4ff5e7192494b88dd5eb0de85d900ab253af909106faa22cc5010000000004000000014777ff000000000016001446c29eabe8208a33aa1023c741fa79aa92e881ff0347304402207d7ca96134f2bcfdd6b536536fdd39ad17793632016936f777ebb32c22943fda02206014d2fb8a6aa58279797f861042ba604ebd2f8f61e5bddbd9d3be5a245047b201004b632103eeaeba7ce5dc2470221e9517fb498e8d6bd4e73b85b8be655196972eb9ccd5566754b2752103a40b74d43df244799d041f32ce1ad515a6cd99501701540e38750d883ae21d3a68ac00000000",["002027a5000c7917f785d8fc6e5a55adfca8717ecb973ebb7743849ff956d896a7ed"],"31d66d516a9eda7de865df29f6ef6cb8e4bf9309e5dac899968a9a62a5df61e3","0385acb4f0fe889ef0","4e6d564c2a2452065c205dd7eb2791124e0c4e0dbb064c410c24968572589dec","Includes witness data"],
-            [1414221,"0000000000000027b2b3b3381f114f674f481544ff2be37ae3788d7e078383b1","000000204ea88307a7959d8207968f152bedca5a93aefab253f1fb2cfb032a400000000070cebb14ec6dbc27a9dfd066d9849a4d3bac5f674665f73a5fe1de01a022a0c851fda85bf05f4c19a779d1450102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff18034d94154d696e6572476174653030310d000000f238f401ffffffff01c817a804000000000000000000",[],"5e5e12d90693c8e936f01847859404c67482439681928353ca1296982042864e","00","021e8882ef5a0ed932edeebbecfeda1d7ce528ec7b3daa27641acf1189d7b5dc","Empty data"]
-        ]
-        "#;
-
-        let testdata = serde_json::from_str::<Value>(data).unwrap().as_array().unwrap().clone();
-        for t in testdata.iter().skip(1) {
-            let block_hash = BlockHash::from_hex(&t.get(1).unwrap().as_str().unwrap()).unwrap();
-            let block: Block = deserialize(hex::decode(&t.get(2).unwrap().as_str().unwrap().as_bytes()).unwrap().as_slice()).unwrap();
-            assert_eq!(block.bitcoin_hash(), block_hash);
-            let scripts = t.get(3).unwrap().as_array().unwrap();
-            let previous_filter_id = FilterHash::from_hex(&t.get(4).unwrap().as_str().unwrap()).unwrap();
-            let filter_content = hex::decode(&t.get(5).unwrap().as_str().unwrap().as_bytes()).unwrap();
-            let filter_id = FilterHash::from_hex(&t.get(6).unwrap().as_str().unwrap()).unwrap();
-
-            let mut txmap = HashMap::new();
-            let mut si = scripts.iter();
-            for tx in block.txdata.iter().skip(1) {
-                for input in tx.input.iter() {
-                    txmap.insert(input.previous_output.clone(), Script::from(hex::decode(si.next().unwrap().as_str().unwrap()).unwrap()));
-                }
-            }
-
-            let filter = BlockFilter::new_script_filter(&block,
-                                        |o| if let Some(s) = txmap.get(o) {
-                                            Ok(s.clone())
-                                        } else {
-                                            Err(Error::UtxoMissing(o.clone()))
-                                        }).unwrap();
-
-            let test_filter = BlockFilter::new(filter_content.as_slice());
-
-            assert_eq!(test_filter.content, filter.content);
-
-            let block_hash = &block.header.bitcoin_hash();
-            assert!(filter.match_all(block_hash, &mut txmap.iter()
-                .filter_map(|(_, s)| if !s.is_empty() { Some(s.as_bytes()) } else { None })).unwrap());
-
-            for (_, script) in &txmap {
-                let query = vec![script];
-                if !script.is_empty () {
-                    assert!(filter.match_any(&block_hash, &mut query.iter()
-                        .map(|s| s.as_bytes())).unwrap());
-                }
-            }
-
-            assert_eq!(filter_id, filter.filter_id(&previous_filter_id));
-        }
-    }
-
-    #[test]
-    fn test_filter () {
-        let mut patterns = HashSet::new();
-
-        patterns.insert(hex::decode("000000").unwrap());
-        patterns.insert(hex::decode("111111").unwrap());
-        patterns.insert(hex::decode("222222").unwrap());
-        patterns.insert(hex::decode("333333").unwrap());
-        patterns.insert(hex::decode("444444").unwrap());
-        patterns.insert(hex::decode("555555").unwrap());
-        patterns.insert(hex::decode("666666").unwrap());
-        patterns.insert(hex::decode("777777").unwrap());
-        patterns.insert(hex::decode("888888").unwrap());
-        patterns.insert(hex::decode("999999").unwrap());
-        patterns.insert(hex::decode("aaaaaa").unwrap());
-        patterns.insert(hex::decode("bbbbbb").unwrap());
-        patterns.insert(hex::decode("cccccc").unwrap());
-        patterns.insert(hex::decode("dddddd").unwrap());
-        patterns.insert(hex::decode("eeeeee").unwrap());
-        patterns.insert(hex::decode("ffffff").unwrap());
-
-        let mut out = Cursor::new(Vec::new());
-        {
-            let mut writer = GCSFilterWriter::new(&mut out, 0, 0, M, P);
-            for p in &patterns {
-                writer.add_element(p.as_slice());
-            }
-            writer.finish().unwrap();
-        }
-
-        let bytes = out.into_inner();
-
-        {
-            let mut query = Vec::new();
-            query.push(hex::decode("abcdef").unwrap());
-            query.push(hex::decode("eeeeee").unwrap());
-
-            let reader = GCSFilterReader::new(0, 0, M, P);
-            let mut input = Cursor::new(bytes.clone());
-            assert!(reader.match_any(&mut input, &mut query.iter().map(|v| v.as_slice())).unwrap());
-        }
-        {
-            let mut query = Vec::new();
-            query.push(hex::decode("abcdef").unwrap());
-            query.push(hex::decode("123456").unwrap());
-
-            let reader = GCSFilterReader::new(0, 0, M, P);
-            let mut input = Cursor::new(bytes.clone());
-            assert!(!reader.match_any(&mut input, &mut query.iter().map(|v| v.as_slice())).unwrap());
-        }
-        {
-            let reader = GCSFilterReader::new(0, 0, M, P);
-            let mut query = Vec::new();
-            for p in &patterns {
-                query.push(p.clone());
-            }
-            let mut input = Cursor::new(bytes.clone());
-            assert!(reader.match_all(&mut input, &mut query.iter().map(|v| v.as_slice())).unwrap());
-        }
-        {
-            let reader = GCSFilterReader::new(0, 0, M, P);
-            let mut query = Vec::new();
-            for p in &patterns {
-                query.push(p.clone());
-            }
-            query.push(hex::decode("abcdef").unwrap());
-            let mut input = Cursor::new(bytes.clone());
-            assert!(!reader.match_all(&mut input, &mut query.iter().map(|v| v.as_slice())).unwrap());
-        }
-    }
-
-    #[test]
-    fn test_bit_stream() {
-        let mut out = Cursor::new(Vec::new());
-        {
-            let mut writer = BitStreamWriter::new(&mut out);
-            writer.write(0, 1).unwrap(); // 0
-            writer.write(2, 2).unwrap(); // 10
-            writer.write(6, 3).unwrap(); // 110
-            writer.write(11, 4).unwrap(); // 1011
-            writer.write(1, 5).unwrap(); // 00001
-            writer.write(32, 6).unwrap(); // 100000
-            writer.write(7, 7).unwrap(); // 0000111
-            writer.flush().unwrap();
-        }
-        let bytes = out.into_inner();
-        assert_eq!("01011010110000110000000001110000", format!("{:08b}{:08b}{:08b}{:08b}", bytes[0], bytes[1], bytes[2], bytes[3]));
-        {
-            let mut input = Cursor::new(bytes);
-            let mut reader = BitStreamReader::new(&mut input);
-            assert_eq!(reader.read(1).unwrap(), 0);
-            assert_eq!(reader.read(2).unwrap(), 2);
-            assert_eq!(reader.read(3).unwrap(), 6);
-            assert_eq!(reader.read(4).unwrap(), 11);
-            assert_eq!(reader.read(5).unwrap(), 1);
-            assert_eq!(reader.read(6).unwrap(), 32);
-            assert_eq!(reader.read(7).unwrap(), 7);
-            // 4 bits remained
-            assert!(reader.read(5).is_err());
-        }
-    }
-}
diff --git a/src/util/bip32.rs b/src/util/bip32.rs
deleted file mode 100644
index 6228dd24..00000000
--- a/src/util/bip32.rs
+++ /dev/null
@@ -1,980 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-// 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/>.
-//
-
-//! BIP32 Implementation
-//!
-//! Implementation of BIP32 hierarchical deterministic wallets, as defined
-//! at https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
-
-use std::default::Default;
-use std::{error, fmt};
-use std::str::FromStr;
-#[cfg(feature = "serde")] use serde;
-
-use hash_types::XpubIdentifier;
-use hashes::{hex, sha512, Hash, HashEngine, Hmac, HmacEngine};
-use secp256k1::{self, Secp256k1};
-
-use network::constants::Network;
-use util::{base58, endian};
-use util::key::{PublicKey, PrivateKey};
-
-/// A chain code
-pub struct ChainCode([u8; 32]);
-impl_array_newtype!(ChainCode, u8, 32);
-impl_array_newtype_show!(ChainCode);
-impl_bytes_newtype!(ChainCode, 32);
-
-/// A fingerprint
-pub struct Fingerprint([u8; 4]);
-impl_array_newtype!(Fingerprint, u8, 4);
-impl_array_newtype_show!(Fingerprint);
-impl_bytes_newtype!(Fingerprint, 4);
-
-impl Default for Fingerprint {
-    fn default() -> Fingerprint { Fingerprint([0; 4]) }
-}
-
-/// Extended private key
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct ExtendedPrivKey {
-    /// The network this key is to be used on
-    pub network: Network,
-    /// How many derivations this key is from the master (which is 0)
-    pub depth: u8,
-    /// Fingerprint of the parent key (0 for master)
-    pub parent_fingerprint: Fingerprint,
-    /// Child number of the key used to derive from parent (0 for master)
-    pub child_number: ChildNumber,
-    /// Private key
-    pub private_key: PrivateKey,
-    /// Chain code
-    pub chain_code: ChainCode
-}
-serde_string_impl!(ExtendedPrivKey, "a BIP-32 extended private key");
-
-/// Extended public key
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct ExtendedPubKey {
-    /// The network this key is to be used on
-    pub network: Network,
-    /// How many derivations this key is from the master (which is 0)
-    pub depth: u8,
-    /// Fingerprint of the parent key
-    pub parent_fingerprint: Fingerprint,
-    /// Child number of the key used to derive from parent (0 for master)
-    pub child_number: ChildNumber,
-    /// Public key
-    pub public_key: PublicKey,
-    /// Chain code
-    pub chain_code: ChainCode
-}
-serde_string_impl!(ExtendedPubKey, "a BIP-32 extended public key");
-
-/// A child number for a derived key
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum ChildNumber {
-    /// Non-hardened key
-    Normal {
-        /// Key index, within [0, 2^31 - 1]
-        index: u32
-    },
-    /// Hardened key
-    Hardened {
-        /// Key index, within [0, 2^31 - 1]
-        index: u32
-    },
-}
-
-impl ChildNumber {
-    /// Create a [`Normal`] from an index, returns an error if the index is not within
-    /// [0, 2^31 - 1].
-    ///
-    /// [`Normal`]: #variant.Normal
-    pub fn from_normal_idx(index: u32) -> Result<Self, Error> {
-        if index & (1 << 31) == 0 {
-            Ok(ChildNumber::Normal { index: index })
-        } else {
-            Err(Error::InvalidChildNumber(index))
-        }
-    }
-
-    /// Create a [`Hardened`] from an index, returns an error if the index is not within
-    /// [0, 2^31 - 1].
-    ///
-    /// [`Hardened`]: #variant.Hardened
-    pub fn from_hardened_idx(index: u32) -> Result<Self, Error> {
-        if index & (1 << 31) == 0 {
-            Ok(ChildNumber::Hardened { index: index })
-        } else {
-            Err(Error::InvalidChildNumber(index))
-        }
-    }
-
-    /// Returns `true` if the child number is a [`Normal`] value.
-    ///
-    /// [`Normal`]: #variant.Normal
-    pub fn is_normal(&self) -> bool {
-        !self.is_hardened()
-    }
-
-    /// Returns `true` if the child number is a [`Hardened`] value.
-    ///
-    /// [`Hardened`]: #variant.Hardened
-    pub fn is_hardened(&self) -> bool {
-        match *self {
-            ChildNumber::Hardened {..} => true,
-            ChildNumber::Normal {..} => false,
-        }
-    }
-
-    /// Returns the child number that is a single increment from this one.
-    pub fn increment(self) -> Result<ChildNumber, Error> {
-        match self {
-            ChildNumber::Normal{ index: idx } => ChildNumber::from_normal_idx(idx+1),
-            ChildNumber::Hardened{ index: idx } => ChildNumber::from_hardened_idx(idx+1),
-        }
-    }
-}
-
-impl From<u32> for ChildNumber {
-    fn from(number: u32) -> Self {
-        if number & (1 << 31) != 0 {
-            ChildNumber::Hardened { index: number ^ (1 << 31) }
-        } else {
-            ChildNumber::Normal { index: number }
-        }
-    }
-}
-
-impl From<ChildNumber> for u32 {
-    fn from(cnum: ChildNumber) -> Self {
-        match cnum {
-            ChildNumber::Normal { index } => index,
-            ChildNumber::Hardened { index } => index | (1 << 31),
-        }
-    }
-}
-
-impl fmt::Display for ChildNumber {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ChildNumber::Hardened { index } => write!(f, "{}'", index),
-            ChildNumber::Normal { index } => write!(f, "{}", index),
-        }
-    }
-}
-
-impl FromStr for ChildNumber {
-    type Err = Error;
-
-    fn from_str(inp: &str) -> Result<ChildNumber, Error> {
-        Ok(match inp.chars().last().map_or(false, |l| l == '\'' || l == 'h') {
-            true => ChildNumber::from_hardened_idx(
-                inp[0..inp.len() - 1].parse().map_err(|_| Error::InvalidChildNumberFormat)?
-            )?,
-            false => ChildNumber::from_normal_idx(
-                inp.parse().map_err(|_| Error::InvalidChildNumberFormat)?
-            )?,
-        })
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::Deserialize<'de> for ChildNumber {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        u32::deserialize(deserializer).map(ChildNumber::from)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for ChildNumber {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        u32::from(*self).serialize(serializer)
-    }
-}
-
-/// A BIP-32 derivation path.
-#[derive(Clone, PartialEq, Eq)]
-pub struct DerivationPath(Vec<ChildNumber>);
-impl_index_newtype!(DerivationPath, ChildNumber);
-serde_string_impl!(DerivationPath, "a BIP-32 derivation path");
-
-impl From<Vec<ChildNumber>> for DerivationPath {
-    fn from(numbers: Vec<ChildNumber>) -> Self {
-        DerivationPath(numbers)
-    }
-}
-
-impl Into<Vec<ChildNumber>> for DerivationPath {
-    fn into(self) -> Vec<ChildNumber> {
-        self.0
-    }
-}
-
-impl<'a> From<&'a [ChildNumber]> for DerivationPath {
-    fn from(numbers: &'a [ChildNumber]) -> Self {
-        DerivationPath(numbers.to_vec())
-    }
-}
-
-impl ::std::iter::FromIterator<ChildNumber> for DerivationPath {
-    fn from_iter<T>(iter: T) -> Self where T: IntoIterator<Item = ChildNumber> {
-        DerivationPath(Vec::from_iter(iter))
-    }
-}
-
-impl<'a> ::std::iter::IntoIterator for &'a DerivationPath {
-    type Item = &'a ChildNumber;
-    type IntoIter = ::std::slice::Iter<'a, ChildNumber>;
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.iter()
-    }
-}
-
-impl AsRef<[ChildNumber]> for DerivationPath {
-    fn as_ref(&self) -> &[ChildNumber] {
-        &self.0
-    }
-}
-
-impl FromStr for DerivationPath {
-    type Err = Error;
-
-    fn from_str(path: &str) -> Result<DerivationPath, Error> {
-        let mut parts = path.split("/");
-        // First parts must be `m`.
-        if parts.next().unwrap() != "m" {
-            return Err(Error::InvalidDerivationPathFormat);
-        }
-
-        let ret: Result<Vec<ChildNumber>, Error> = parts.map(str::parse).collect();
-        Ok(DerivationPath(ret?))
-    }
-}
-
-/// An iterator over children of a [DerivationPath].
-///
-/// It is returned by the methods [DerivationPath::children_since],
-/// [DerivationPath::normal_children] and [DerivationPath::hardened_children].
-pub struct DerivationPathIterator<'a> {
-    base: &'a DerivationPath,
-    next_child: Option<ChildNumber>,
-}
-
-impl<'a> DerivationPathIterator<'a> {
-    /// Start a new [DerivationPathIterator] at the given child.
-    pub fn start_from(path: &'a DerivationPath, start: ChildNumber) -> DerivationPathIterator<'a> {
-        DerivationPathIterator {
-            base: path,
-            next_child: Some(start),
-        }
-    }
-}
-
-impl<'a> Iterator for DerivationPathIterator<'a> {
-    type Item = DerivationPath;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.next_child.is_none() {
-            return None;
-        }
-
-        let ret = self.next_child.unwrap();
-        self.next_child = ret.increment().ok();
-        Some(self.base.child(ret))
-    }
-}
-
-impl DerivationPath {
-    /// Create a new [DerivationPath] that is a child of this one.
-    pub fn child(&self, cn: ChildNumber) -> DerivationPath {
-        let mut path = self.0.clone();
-        path.push(cn);
-        DerivationPath(path)
-    }
-
-    /// Convert into a [DerivationPath] that is a child of this one.
-    pub fn into_child(self, cn: ChildNumber) -> DerivationPath {
-        let mut path = self.0;
-        path.push(cn);
-        DerivationPath(path)
-    }
-
-    /// Get an [Iterator] over the children of this [DerivationPath]
-    /// starting with the given [ChildNumber].
-    pub fn children_from(&self, cn: ChildNumber) -> DerivationPathIterator {
-        DerivationPathIterator::start_from(&self, cn)
-    }
-
-    /// Get an [Iterator] over the unhardened children of this [DerivationPath].
-    pub fn normal_children(&self) -> DerivationPathIterator {
-        DerivationPathIterator::start_from(&self, ChildNumber::Normal{ index: 0 })
-    }
-
-    /// Get an [Iterator] over the hardened children of this [DerivationPath].
-    pub fn hardened_children(&self) -> DerivationPathIterator {
-        DerivationPathIterator::start_from(&self, ChildNumber::Hardened{ index: 0 })
-    }
-}
-
-impl fmt::Display for DerivationPath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("m")?;
-        for cn in self.0.iter() {
-            f.write_str("/")?;
-            fmt::Display::fmt(cn, f)?;
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Debug for DerivationPath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self, f)
-    }
-}
-
-/// A BIP32 error
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum Error {
-    /// A pk->pk derivation was attempted on a hardened key
-    CannotDeriveFromHardenedKey,
-    /// A secp256k1 error occurred
-    Ecdsa(secp256k1::Error),
-    /// A child number was provided that was out of range
-    InvalidChildNumber(u32),
-    /// Error creating a master seed --- for application use
-    RngError(String),
-    /// Invalid childnumber format.
-    InvalidChildNumberFormat,
-    /// Invalid derivation path format.
-    InvalidDerivationPathFormat,
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::CannotDeriveFromHardenedKey => f.write_str("cannot derive hardened key from public key"),
-            Error::Ecdsa(ref e) => fmt::Display::fmt(e, f),
-            Error::InvalidChildNumber(ref n) => write!(f, "child number {} is invalid (not within [0, 2^31 - 1])", n),
-            Error::RngError(ref s) => write!(f, "rng error {}", s),
-            Error::InvalidChildNumberFormat => f.write_str("invalid child number format"),
-            Error::InvalidDerivationPathFormat => f.write_str("invalid derivation path format"),
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn cause(&self) -> Option<&error::Error> {
-       if let Error::Ecdsa(ref e) = *self {
-           Some(e)
-       } else {
-           None
-       }
-    }
-
-    fn description(&self) -> &str {
-        match *self {
-            Error::CannotDeriveFromHardenedKey => "cannot derive hardened key from public key",
-            Error::Ecdsa(ref e) => error::Error::description(e),
-            Error::InvalidChildNumber(_) => "child number is invalid",
-            Error::RngError(_) => "rng error",
-            Error::InvalidChildNumberFormat => "invalid child number format",
-            Error::InvalidDerivationPathFormat => "invalid derivation path format",
-        }
-    }
-}
-
-impl From<secp256k1::Error> for Error {
-    fn from(e: secp256k1::Error) -> Error { Error::Ecdsa(e) }
-}
-
-impl ExtendedPrivKey {
-    /// Construct a new master key from a seed value
-    pub fn new_master(network: Network, seed: &[u8]) -> Result<ExtendedPrivKey, Error> {
-        let mut hmac_engine: HmacEngine<sha512::Hash> = HmacEngine::new(b"Bitcoin seed");
-        hmac_engine.input(seed);
-        let hmac_result: Hmac<sha512::Hash> = Hmac::from_engine(hmac_engine);
-
-        Ok(ExtendedPrivKey {
-            network: network,
-            depth: 0,
-            parent_fingerprint: Default::default(),
-            child_number: ChildNumber::from_normal_idx(0)?,
-            private_key: PrivateKey {
-                compressed: true,
-                network: network,
-                key: secp256k1::SecretKey::from_slice(
-                    &hmac_result[..32]
-                ).map_err(Error::Ecdsa)?,
-            },
-            chain_code: ChainCode::from(&hmac_result[32..]),
-        })
-    }
-
-    /// Attempts to derive an extended private key from a path.
-    ///
-    /// The `path` argument can be both of type `DerivationPath` or `Vec<ChildNumber>`.
-    pub fn derive_priv<C: secp256k1::Signing, P: AsRef<[ChildNumber]>>(
-        &self,
-        secp: &Secp256k1<C>,
-        path: &P,
-    ) -> Result<ExtendedPrivKey, Error> {
-        let mut sk: ExtendedPrivKey = *self;
-        for cnum in path.as_ref() {
-            sk = sk.ckd_priv(secp, *cnum)?;
-        }
-        Ok(sk)
-    }
-
-    /// Private->Private child key derivation
-    pub fn ckd_priv<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>, i: ChildNumber) -> Result<ExtendedPrivKey, Error> {
-        let mut hmac_engine: HmacEngine<sha512::Hash> = HmacEngine::new(&self.chain_code[..]);
-        match i {
-            ChildNumber::Normal {..} => {
-                // Non-hardened key: compute public data and use that
-                hmac_engine.input(&PublicKey::from_private_key(secp, &self.private_key).key.serialize()[..]);
-            }
-            ChildNumber::Hardened {..} => {
-                // Hardened key: use only secret data to prevent public derivation
-                hmac_engine.input(&[0u8]);
-                hmac_engine.input(&self.private_key[..]);
-            }
-        }
-
-        hmac_engine.input(&endian::u32_to_array_be(u32::from(i)));
-        let hmac_result: Hmac<sha512::Hash> = Hmac::from_engine(hmac_engine);
-        let mut sk = PrivateKey {
-            compressed: true,
-            network: self.network,
-            key: secp256k1::SecretKey::from_slice(&hmac_result[..32]).map_err(Error::Ecdsa)?,
-        };
-        sk.key.add_assign(&self.private_key[..]).map_err(Error::Ecdsa)?;
-
-        Ok(ExtendedPrivKey {
-            network: self.network,
-            depth: self.depth + 1,
-            parent_fingerprint: self.fingerprint(secp),
-            child_number: i,
-            private_key: sk,
-            chain_code: ChainCode::from(&hmac_result[32..])
-        })
-    }
-
-    /// Returns the HASH160 of the chaincode
-    pub fn identifier<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> XpubIdentifier {
-        ExtendedPubKey::from_private(secp, self).identifier()
-    }
-
-    /// Returns the first four bytes of the identifier
-    pub fn fingerprint<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> Fingerprint {
-        Fingerprint::from(&self.identifier(secp)[0..4])
-    }
-}
-
-impl ExtendedPubKey {
-    /// Derives a public key from a private key
-    pub fn from_private<C: secp256k1::Signing>(secp: &Secp256k1<C>, sk: &ExtendedPrivKey) -> ExtendedPubKey {
-        ExtendedPubKey {
-            network: sk.network,
-            depth: sk.depth,
-            parent_fingerprint: sk.parent_fingerprint,
-            child_number: sk.child_number,
-            public_key: PublicKey::from_private_key(secp, &sk.private_key),
-            chain_code: sk.chain_code
-        }
-    }
-
-    /// Attempts to derive an extended public key from a path.
-    ///
-    /// The `path` argument can be both of type `DerivationPath` or `Vec<ChildNumber>`.
-    pub fn derive_pub<C: secp256k1::Verification, P: AsRef<[ChildNumber]>>(
-        &self,
-        secp: &Secp256k1<C>,
-        path: &P,
-    ) -> Result<ExtendedPubKey, Error> {
-        let mut pk: ExtendedPubKey = *self;
-        for cnum in path.as_ref() {
-            pk = pk.ckd_pub(secp, *cnum)?
-        }
-        Ok(pk)
-    }
-
-    /// Compute the scalar tweak added to this key to get a child key
-    pub fn ckd_pub_tweak(&self, i: ChildNumber) -> Result<(PrivateKey, ChainCode), Error> {
-        match i {
-            ChildNumber::Hardened {..} => {
-                Err(Error::CannotDeriveFromHardenedKey)
-            }
-            ChildNumber::Normal { index: n } => {
-                let mut hmac_engine: HmacEngine<sha512::Hash> = HmacEngine::new(&self.chain_code[..]);
-                hmac_engine.input(&self.public_key.key.serialize()[..]);
-                hmac_engine.input(&endian::u32_to_array_be(n));
-
-                let hmac_result: Hmac<sha512::Hash> = Hmac::from_engine(hmac_engine);
-
-                let private_key = PrivateKey {
-                    compressed: true,
-                    network: self.network,
-                    key: secp256k1::SecretKey::from_slice(&hmac_result[..32])?,
-                };
-                let chain_code = ChainCode::from(&hmac_result[32..]);
-                Ok((private_key, chain_code))
-            }
-        }
-    }
-
-    /// Public->Public child key derivation
-    pub fn ckd_pub<C: secp256k1::Verification>(
-        &self,
-        secp: &Secp256k1<C>,
-        i: ChildNumber,
-    ) -> Result<ExtendedPubKey, Error> {
-        let (sk, chain_code) = self.ckd_pub_tweak(i)?;
-        let mut pk = self.public_key.clone();
-        pk.key.add_exp_assign(secp, &sk[..]).map_err(Error::Ecdsa)?;
-
-        Ok(ExtendedPubKey {
-            network: self.network,
-            depth: self.depth + 1,
-            parent_fingerprint: self.fingerprint(),
-            child_number: i,
-            public_key: pk,
-            chain_code: chain_code
-        })
-    }
-
-    /// Returns the HASH160 of the chaincode
-    pub fn identifier(&self) -> XpubIdentifier {
-        let mut engine = XpubIdentifier::engine();
-        self.public_key.write_into(&mut engine);
-        XpubIdentifier::from_engine(engine)
-    }
-
-    /// Returns the first four bytes of the identifier
-    pub fn fingerprint(&self) -> Fingerprint {
-        Fingerprint::from(&self.identifier()[0..4])
-    }
-}
-
-impl fmt::Display for ExtendedPrivKey {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let mut ret = [0; 78];
-        ret[0..4].copy_from_slice(&match self.network {
-            Network::Bitcoin => [0x04, 0x88, 0xAD, 0xE4],
-            Network::Testnet | Network::Regtest => [0x04, 0x35, 0x83, 0x94],
-        }[..]);
-        ret[4] = self.depth as u8;
-        ret[5..9].copy_from_slice(&self.parent_fingerprint[..]);
-        ret[9..13].copy_from_slice(&endian::u32_to_array_be(u32::from(self.child_number)));
-        ret[13..45].copy_from_slice(&self.chain_code[..]);
-        ret[45] = 0;
-        ret[46..78].copy_from_slice(&self.private_key[..]);
-        fmt.write_str(&base58::check_encode_slice(&ret[..]))
-    }
-}
-
-impl FromStr for ExtendedPrivKey {
-    type Err = base58::Error;
-
-    fn from_str(inp: &str) -> Result<ExtendedPrivKey, base58::Error> {
-        let data = base58::from_check(inp)?;
-
-        if data.len() != 78 {
-            return Err(base58::Error::InvalidLength(data.len()));
-        }
-
-        let cn_int: u32 = endian::slice_to_u32_be(&data[9..13]);
-        let child_number: ChildNumber = ChildNumber::from(cn_int);
-
-        let network = if &data[0..4] == [0x04u8, 0x88, 0xAD, 0xE4] {
-            Network::Bitcoin
-        } else if &data[0..4] == [0x04u8, 0x35, 0x83, 0x94] {
-            Network::Testnet
-        } else {
-            return Err(base58::Error::InvalidVersion((&data[0..4]).to_vec()));
-        };
-
-        Ok(ExtendedPrivKey {
-            network: network,
-            depth: data[4],
-            parent_fingerprint: Fingerprint::from(&data[5..9]),
-            child_number: child_number,
-            chain_code: ChainCode::from(&data[13..45]),
-            private_key: PrivateKey {
-                compressed: true,
-                network: network,
-                key: secp256k1::SecretKey::from_slice(
-                    &data[46..78]
-                ).map_err(|e|
-                        base58::Error::Other(e.to_string())
-                )?,
-            },
-        })
-    }
-}
-
-impl fmt::Display for ExtendedPubKey {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let mut ret = [0; 78];
-        ret[0..4].copy_from_slice(&match self.network {
-            Network::Bitcoin => [0x04u8, 0x88, 0xB2, 0x1E],
-            Network::Testnet | Network::Regtest => [0x04u8, 0x35, 0x87, 0xCF],
-        }[..]);
-        ret[4] = self.depth as u8;
-        ret[5..9].copy_from_slice(&self.parent_fingerprint[..]);
-        ret[9..13].copy_from_slice(&endian::u32_to_array_be(u32::from(self.child_number)));
-        ret[13..45].copy_from_slice(&self.chain_code[..]);
-        ret[45..78].copy_from_slice(&self.public_key.key.serialize()[..]);
-        fmt.write_str(&base58::check_encode_slice(&ret[..]))
-    }
-}
-
-impl FromStr for ExtendedPubKey {
-    type Err = base58::Error;
-
-    fn from_str(inp: &str) -> Result<ExtendedPubKey, base58::Error> {
-        let data = base58::from_check(inp)?;
-
-        if data.len() != 78 {
-            return Err(base58::Error::InvalidLength(data.len()));
-        }
-
-        let cn_int: u32 = endian::slice_to_u32_be(&data[9..13]);
-        let child_number: ChildNumber = ChildNumber::from(cn_int);
-
-        Ok(ExtendedPubKey {
-            network: if &data[0..4] == [0x04u8, 0x88, 0xB2, 0x1E] {
-                Network::Bitcoin
-            } else if &data[0..4] == [0x04u8, 0x35, 0x87, 0xCF] {
-                Network::Testnet
-            } else {
-                return Err(base58::Error::InvalidVersion((&data[0..4]).to_vec()));
-            },
-            depth: data[4],
-            parent_fingerprint: Fingerprint::from(&data[5..9]),
-            child_number: child_number,
-            chain_code: ChainCode::from(&data[13..45]),
-            public_key: PublicKey::from_slice(
-                             &data[45..78]).map_err(|e|
-                                 base58::Error::Other(e.to_string()))?
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use super::ChildNumber::{Hardened, Normal};
-
-    use std::str::FromStr;
-    use std::string::ToString;
-
-    use secp256k1::{self, Secp256k1};
-    use hex::decode as hex_decode;
-
-    use network::constants::Network::{self, Bitcoin};
-
-    #[test]
-    fn test_parse_derivation_path() {
-        assert_eq!(DerivationPath::from_str("42"), Err(Error::InvalidDerivationPathFormat));
-        assert_eq!(DerivationPath::from_str("n/0'/0"), Err(Error::InvalidDerivationPathFormat));
-        assert_eq!(DerivationPath::from_str("4/m/5"), Err(Error::InvalidDerivationPathFormat));
-        assert_eq!(DerivationPath::from_str("m//3/0'"), Err(Error::InvalidChildNumberFormat));
-        assert_eq!(DerivationPath::from_str("m/0h/0x"), Err(Error::InvalidChildNumberFormat));
-        assert_eq!(DerivationPath::from_str("m/2147483648"), Err(Error::InvalidChildNumber(2147483648)));
-
-        assert_eq!(DerivationPath::from_str("m"), Ok(vec![].into()));
-        assert_eq!(
-            DerivationPath::from_str("m/0'"),
-            Ok(vec![ChildNumber::from_hardened_idx(0).unwrap()].into())
-        );
-        assert_eq!(
-            DerivationPath::from_str("m/0'/1"),
-            Ok(vec![ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap()].into())
-        );
-        assert_eq!(
-            DerivationPath::from_str("m/0h/1/2'"),
-            Ok(vec![
-                ChildNumber::from_hardened_idx(0).unwrap(),
-                ChildNumber::from_normal_idx(1).unwrap(),
-                ChildNumber::from_hardened_idx(2).unwrap(),
-            ].into())
-        );
-        assert_eq!(
-            DerivationPath::from_str("m/0'/1/2h/2"),
-            Ok(vec![
-                ChildNumber::from_hardened_idx(0).unwrap(),
-                ChildNumber::from_normal_idx(1).unwrap(),
-                ChildNumber::from_hardened_idx(2).unwrap(),
-                ChildNumber::from_normal_idx(2).unwrap(),
-            ].into())
-        );
-        assert_eq!(
-            DerivationPath::from_str("m/0'/1/2'/2/1000000000"),
-            Ok(vec![
-                ChildNumber::from_hardened_idx(0).unwrap(),
-                ChildNumber::from_normal_idx(1).unwrap(),
-                ChildNumber::from_hardened_idx(2).unwrap(),
-                ChildNumber::from_normal_idx(2).unwrap(),
-                ChildNumber::from_normal_idx(1000000000).unwrap(),
-            ].into())
-        );
-    }
-
-    #[test]
-    fn test_derivation_path_conversion_index() {
-        let path = DerivationPath::from_str("m/0h/1/2'").unwrap();
-        let numbers: Vec<ChildNumber> = path.clone().into();
-        let path2: DerivationPath = numbers.into();
-        assert_eq!(path, path2);
-        assert_eq!(&path[..2], &[ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap()]);
-        let indexed: DerivationPath = path[..2].into();
-        assert_eq!(indexed, DerivationPath::from_str("m/0h/1").unwrap());
-        assert_eq!(indexed.child(ChildNumber::from_hardened_idx(2).unwrap()), path);
-    }
-
-    fn test_path<C: secp256k1::Signing + secp256k1::Verification>(secp: &Secp256k1<C>,
-                 network: Network,
-                 seed: &[u8],
-                 path: DerivationPath,
-                 expected_sk: &str,
-                 expected_pk: &str) {
-
-        let mut sk = ExtendedPrivKey::new_master(network, seed).unwrap();
-        let mut pk = ExtendedPubKey::from_private(secp, &sk);
-
-        // Check derivation convenience method for ExtendedPrivKey
-        assert_eq!(
-            &sk.derive_priv(secp, &path).unwrap().to_string()[..],
-            expected_sk
-        );
-
-        // Check derivation convenience method for ExtendedPubKey, should error
-        // appropriately if any ChildNumber is hardened
-        if path.0.iter().any(|cnum| cnum.is_hardened()) {
-            assert_eq!(
-                pk.derive_pub(secp, &path),
-                Err(Error::CannotDeriveFromHardenedKey)
-            );
-        } else {
-            assert_eq!(
-                &pk.derive_pub(secp, &path).unwrap().to_string()[..],
-                expected_pk
-            );
-        }
-
-        // Derive keys, checking hardened and non-hardened derivation one-by-one
-        for &num in path.0.iter() {
-            sk = sk.ckd_priv(secp, num).unwrap();
-            match num {
-                Normal {..} => {
-                    let pk2 = pk.ckd_pub(secp, num).unwrap();
-                    pk = ExtendedPubKey::from_private(secp, &sk);
-                    assert_eq!(pk, pk2);
-                }
-                Hardened {..} => {
-                    assert_eq!(
-                        pk.ckd_pub(secp, num),
-                        Err(Error::CannotDeriveFromHardenedKey)
-                    );
-                    pk = ExtendedPubKey::from_private(secp, &sk);
-                }
-            }
-        }
-
-        // Check result against expected base58
-        assert_eq!(&sk.to_string()[..], expected_sk);
-        assert_eq!(&pk.to_string()[..], expected_pk);
-        // Check decoded base58 against result
-        let decoded_sk = ExtendedPrivKey::from_str(expected_sk);
-        let decoded_pk = ExtendedPubKey::from_str(expected_pk);
-        assert_eq!(Ok(sk), decoded_sk);
-        assert_eq!(Ok(pk), decoded_pk);
-    }
-
-    #[test]
-    fn test_increment() {
-        let idx = 9345497; // randomly generated, I promise
-        let cn = ChildNumber::from_normal_idx(idx).unwrap();
-        assert_eq!(cn.increment().ok(), Some(ChildNumber::from_normal_idx(idx+1).unwrap()));
-        let cn = ChildNumber::from_hardened_idx(idx).unwrap();
-        assert_eq!(cn.increment().ok(), Some(ChildNumber::from_hardened_idx(idx+1).unwrap()));
-
-        let max = (1<<31)-1;
-        let cn = ChildNumber::from_normal_idx(max).unwrap();
-        assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1<<31)));
-        let cn = ChildNumber::from_hardened_idx(max).unwrap();
-        assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1<<31)));
-
-        let cn = ChildNumber::from_normal_idx(350).unwrap();
-        let path = DerivationPath::from_str("m/42'").unwrap();
-        let mut iter = path.children_from(cn);
-        assert_eq!(iter.next(), Some("m/42'/350".parse().unwrap()));
-        assert_eq!(iter.next(), Some("m/42'/351".parse().unwrap()));
-
-        let path = DerivationPath::from_str("m/42'/350'").unwrap();
-        let mut iter = path.normal_children();
-        assert_eq!(iter.next(), Some("m/42'/350'/0".parse().unwrap()));
-        assert_eq!(iter.next(), Some("m/42'/350'/1".parse().unwrap()));
-
-        let path = DerivationPath::from_str("m/42'/350'").unwrap();
-        let mut iter = path.hardened_children();
-        assert_eq!(iter.next(), Some("m/42'/350'/0'".parse().unwrap()));
-        assert_eq!(iter.next(), Some("m/42'/350'/1'".parse().unwrap()));
-
-        let cn = ChildNumber::from_hardened_idx(42350).unwrap();
-        let path = DerivationPath::from_str("m/42'").unwrap();
-        let mut iter = path.children_from(cn);
-        assert_eq!(iter.next(), Some("m/42'/42350'".parse().unwrap()));
-        assert_eq!(iter.next(), Some("m/42'/42351'".parse().unwrap()));
-
-        let cn = ChildNumber::from_hardened_idx(max).unwrap();
-        let path = DerivationPath::from_str("m/42'").unwrap();
-        let mut iter = path.children_from(cn);
-        assert!(iter.next().is_some());
-        assert!(iter.next().is_none());
-    }
-
-    #[test]
-    fn test_vector_1() {
-        let secp = Secp256k1::new();
-        let seed = hex_decode("000102030405060708090a0b0c0d0e0f").unwrap();
-
-        // m
-        test_path(&secp, Bitcoin, &seed, "m".parse().unwrap(),
-                  "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi",
-                  "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8");
-
-        // m/0h
-        test_path(&secp, Bitcoin, &seed, "m/0h".parse().unwrap(),
-                  "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7",
-                  "xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw");
-
-        // m/0h/1
-        test_path(&secp, Bitcoin, &seed, "m/0h/1".parse().unwrap(),
-                   "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs",
-                   "xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ");
-
-        // m/0h/1/2h
-        test_path(&secp, Bitcoin, &seed, "m/0h/1/2h".parse().unwrap(),
-                  "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM",
-                  "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5");
-
-        // m/0h/1/2h/2
-        test_path(&secp, Bitcoin, &seed, "m/0h/1/2h/2".parse().unwrap(),
-                  "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334",
-                  "xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV");
-
-        // m/0h/1/2h/2/1000000000
-        test_path(&secp, Bitcoin, &seed, "m/0h/1/2h/2/1000000000".parse().unwrap(),
-                  "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76",
-                  "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy");
-    }
-
-    #[test]
-    fn test_vector_2() {
-        let secp = Secp256k1::new();
-        let seed = hex_decode("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542").unwrap();
-
-        // m
-        test_path(&secp, Bitcoin, &seed, "m".parse().unwrap(),
-                  "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U",
-                  "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB");
-
-        // m/0
-        test_path(&secp, Bitcoin, &seed, "m/0".parse().unwrap(),
-                  "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt",
-                  "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH");
-
-        // m/0/2147483647h
-        test_path(&secp, Bitcoin, &seed, "m/0/2147483647h".parse().unwrap(),
-                  "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9",
-                  "xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a");
-
-        // m/0/2147483647h/1
-        test_path(&secp, Bitcoin, &seed, "m/0/2147483647h/1".parse().unwrap(),
-                  "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef",
-                  "xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon");
-
-        // m/0/2147483647h/1/2147483646h
-        test_path(&secp, Bitcoin, &seed, "m/0/2147483647h/1/2147483646h".parse().unwrap(),
-                  "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc",
-                  "xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL");
-
-        // m/0/2147483647h/1/2147483646h/2
-        test_path(&secp, Bitcoin, &seed, "m/0/2147483647h/1/2147483646h/2".parse().unwrap(),
-                  "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j",
-                  "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt");
-    }
-
-    #[test]
-    fn test_vector_3() {
-        let secp = Secp256k1::new();
-        let seed = hex_decode("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be").unwrap();
-
-        // m
-        test_path(&secp, Bitcoin, &seed, "m".parse().unwrap(),
-                  "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6",
-                  "xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhRoP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13");
-
-        // m/0h
-        test_path(&secp, Bitcoin, &seed, "m/0h".parse().unwrap(),
-                  "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L",
-                  "xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y");
-
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    pub fn encode_decode_childnumber() {
-        serde_round_trip!(ChildNumber::from_normal_idx(0).unwrap());
-        serde_round_trip!(ChildNumber::from_normal_idx(1).unwrap());
-        serde_round_trip!(ChildNumber::from_normal_idx((1 << 31) - 1).unwrap());
-        serde_round_trip!(ChildNumber::from_hardened_idx(0).unwrap());
-        serde_round_trip!(ChildNumber::from_hardened_idx(1).unwrap());
-        serde_round_trip!(ChildNumber::from_hardened_idx((1 << 31) - 1).unwrap());
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    pub fn encode_fingerprint_chaincode() {
-        use serde_json;
-        let fp = Fingerprint::from(&[1u8,2,3,42][..]);
-        let cc = ChainCode::from(
-            &[1u8,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2][..]
-        );
-
-        serde_round_trip!(fp);
-        serde_round_trip!(cc);
-
-        assert_eq!("\"0102032a\"", serde_json::to_string(&fp).unwrap());
-        assert_eq!(
-            "\"0102030405060708090001020304050607080900010203040506070809000102\"",
-            serde_json::to_string(&cc).unwrap()
-        );
-        assert_eq!("0102032a", fp.to_string());
-        assert_eq!(
-            "0102030405060708090001020304050607080900010203040506070809000102",
-            cc.to_string()
-        );
-    }
-}
-
diff --git a/src/util/contracthash.rs b/src/util/contracthash.rs
deleted file mode 100644
index 62691915..00000000
--- a/src/util/contracthash.rs
+++ /dev/null
@@ -1,413 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2015 by
-//   Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Pay-to-contract-hash support
-//!
-//! See Appendix A of the Blockstream sidechains whitepaper
-//! at http://blockstream.com/sidechains.pdf for details of
-//! what this does.
-
-use secp256k1::{self, Secp256k1};
-use PrivateKey;
-use PublicKey;
-use hashes::{sha256, Hash, HashEngine, Hmac, HmacEngine};
-use blockdata::{opcodes, script};
-
-use std::{error, fmt};
-
-use hash_types::ScriptHash;
-use network::constants::Network;
-use util::address;
-
-/// Encoding of "pubkey here" in script; from Bitcoin Core `src/script/script.h`
-static PUBKEY: u8 = 0xFE;
-
-/// A contract-hash error
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub enum Error {
-    /// Other secp256k1 related error
-    Secp(secp256k1::Error),
-    /// Script parsing error
-    Script(script::Error),
-    /// Encountered an uncompressed key in a script we were deserializing. The
-    /// reserialization will compress it which might be surprising so we call
-    /// this an error.
-    UncompressedKey,
-    /// Expected a public key when deserializing a script, but we got something else.
-    ExpectedKey,
-    /// Expected some sort of CHECKSIG operator when deserializing a script, but
-    /// we got something else.
-    ExpectedChecksig,
-    /// Did not have enough keys to instantiate a script template
-    TooFewKeys(usize),
-    /// Had too many keys; template does not match key list
-    TooManyKeys(usize)
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::Secp(ref e) => fmt::Display::fmt(&e, f),
-            Error::Script(ref e) => fmt::Display::fmt(&e, f),
-            Error::UncompressedKey => f.write_str("encountered uncompressed secp public key"),
-            Error::ExpectedKey => f.write_str("expected key when deserializing script"),
-            Error::ExpectedChecksig => f.write_str("expected OP_*CHECKSIG* when deserializing script"),
-            Error::TooFewKeys(n) => write!(f, "got {} keys, which was not enough", n),
-            Error::TooManyKeys(n) => write!(f, "got {} keys, which was too many", n)
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Secp(ref e) => Some(e),
-            Error::Script(ref e) => Some(e),
-            _ => None
-        }
-    }
-
-    fn description(&self) -> &'static str {
-        match *self {
-            Error::Secp(_) => "libsecp256k1 error",
-            Error::Script(_) => "script error",
-            Error::UncompressedKey => "encountered uncompressed secp public key",
-            Error::ExpectedKey => "expected key when deserializing script",
-            Error::ExpectedChecksig => "expected OP_*CHECKSIG* when deserializing script",
-            Error::TooFewKeys(_) => "too few keys for template",
-            Error::TooManyKeys(_) => "too many keys for template"
-        }
-    }
-}
-
-/// An element of a script template
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-enum TemplateElement {
-    Op(opcodes::All),
-    Key
-}
-
-/// A script template
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct Template(Vec<TemplateElement>);
-
-impl Template {
-    /// Instantiate a template
-    pub fn to_script(&self, keys: &[PublicKey]) -> Result<script::Script, Error> {
-        let mut key_index = 0;
-        let mut ret = script::Builder::new();
-        for elem in &self.0 {
-            ret = match *elem {
-                TemplateElement::Op(opcode) => ret.push_opcode(opcode),
-                TemplateElement::Key => {
-                    if key_index == keys.len() {
-                        return Err(Error::TooFewKeys(key_index));
-                    }
-                    key_index += 1;
-                    ret.push_key(&keys[key_index - 1])
-                }
-            }
-        }
-        if key_index == keys.len() {
-            Ok(ret.into_script())
-        } else {
-            Err(Error::TooManyKeys(keys.len()))
-        }
-    }
-
-    /// Returns the number of keys this template requires to instantiate
-    pub fn required_keys(&self) -> usize {
-        self.0.iter().filter(|e| **e == TemplateElement::Key).count()
-    }
-
-    /// If the first push in the template is a number, return this number. For the
-    /// common case of standard multisig templates, such a number will exist and
-    /// will represent the number of signatures that are required for the script
-    /// to pass.
-    pub fn first_push_as_number(&self) -> Option<usize> {
-        if !self.0.is_empty() {
-            if let TemplateElement::Op(op) = self.0[0] {
-                if let opcodes::Class::PushNum(n) = op.classify() {
-                    if n >= 0 {
-                        return Some(n as usize);
-                    }
-                }
-            }
-        }
-        None
-    }
-}
-
-impl<'a> From<&'a [u8]> for Template {
-    fn from(slice: &'a [u8]) -> Template {
-        Template(slice.iter().map(|&byte| {
-            if byte == PUBKEY {
-                TemplateElement::Key
-            } else {
-                TemplateElement::Op(opcodes::All::from(byte))
-            }
-        }).collect())
-    }
-}
-
-/// Tweak a single key using some arbitrary data
-pub fn tweak_key<C: secp256k1::Verification>(secp: &Secp256k1<C>, mut key: PublicKey, contract: &[u8]) -> PublicKey {
-    let hmac_result = compute_tweak(&key, contract);
-    key.key.add_exp_assign(secp, &hmac_result[..]).expect("HMAC cannot produce invalid tweak");
-    key
-}
-
-/// Tweak keys using some arbitrary data
-pub fn tweak_keys<C: secp256k1::Verification>(secp: &Secp256k1<C>, keys: &[PublicKey], contract: &[u8]) -> Vec<PublicKey> {
-    keys.iter().cloned().map(|key| tweak_key(secp, key, contract)).collect()
-}
-
-/// Compute a tweak from some given data for the given public key
-pub fn compute_tweak(pk: &PublicKey, contract: &[u8]) -> Hmac<sha256::Hash> {
-    let mut hmac_engine: HmacEngine<sha256::Hash> = if pk.compressed {
-        HmacEngine::new(&pk.key.serialize())
-    } else {
-        HmacEngine::new(&pk.key.serialize_uncompressed())
-    };
-    hmac_engine.input(contract);
-    Hmac::from_engine(hmac_engine)
-}
-
-/// Tweak a secret key using some arbitrary data (calls `compute_tweak` internally)
-pub fn tweak_secret_key<C: secp256k1::Signing>(secp: &Secp256k1<C>, key: &PrivateKey, contract: &[u8]) -> Result<PrivateKey, Error> {
-    // Compute public key
-    let pk = PublicKey::from_private_key(secp, &key);
-    // Compute tweak
-    let hmac_sk = compute_tweak(&pk, contract);
-    // Execute the tweak
-    let mut key = *key;
-    key.key.add_assign(&hmac_sk[..]).map_err(Error::Secp)?;
-    // Return
-    Ok(key)
-}
-
-/// Takes a contract, template and key set and runs through all the steps
-pub fn create_address<C: secp256k1::Verification>(secp: &Secp256k1<C>,
-                      network: Network,
-                      contract: &[u8],
-                      keys: &[PublicKey],
-                      template: &Template)
-                      -> Result<address::Address, Error> {
-    let keys = tweak_keys(secp, keys, contract);
-    let script = template.to_script(&keys)?;
-    Ok(address::Address {
-        network: network,
-        payload: address::Payload::ScriptHash(
-            ScriptHash::hash(&script[..])
-        )
-    })
-}
-
-/// Extract the keys and template from a completed script
-pub fn untemplate(script: &script::Script) -> Result<(Template, Vec<PublicKey>), Error> {
-    let mut ret = script::Builder::new();
-    let mut retkeys = vec![];
-
-    #[derive(Copy, Clone, PartialEq, Eq)]
-    enum Mode {
-        SeekingKeys,
-        CopyingKeys,
-        SeekingCheckMulti
-    }
-
-    let mut mode = Mode::SeekingKeys;
-    for instruction in script.iter(false) {
-        match instruction {
-            script::Instruction::PushBytes(data) => {
-                let n = data.len();
-                ret = match PublicKey::from_slice(data) {
-                    Ok(key) => {
-                        if n == 65 { return Err(Error::UncompressedKey); }
-                        if mode == Mode::SeekingCheckMulti { return Err(Error::ExpectedChecksig); }
-                        retkeys.push(key);
-                        mode = Mode::CopyingKeys;
-                        ret.push_opcode(opcodes::All::from(PUBKEY))
-                    }
-                    Err(_) => {
-                        // Arbitrary pushes are only allowed before we've found any keys.
-                        // Otherwise we have to wait for a N CHECKSIG pair.
-                        match mode {
-                            Mode::SeekingKeys => { ret.push_slice(data) }
-                            Mode::CopyingKeys => { return Err(Error::ExpectedKey); },
-                            Mode::SeekingCheckMulti => { return Err(Error::ExpectedChecksig); }
-                        }
-                    }
-                }
-            }
-            script::Instruction::Op(op) => {
-                match op.classify() {
-                    // CHECKSIG should only come after a list of keys
-                    opcodes::Class::Ordinary(opcodes::Ordinary::OP_CHECKSIG) |
-                    opcodes::Class::Ordinary(opcodes::Ordinary::OP_CHECKSIGVERIFY) => {
-                        if mode == Mode::SeekingKeys { return Err(Error::ExpectedKey); }
-                        mode = Mode::SeekingKeys;
-                    }
-                    // CHECKMULTISIG should only come after a number
-                    opcodes::Class::Ordinary(opcodes::Ordinary::OP_CHECKMULTISIG) |
-                    opcodes::Class::Ordinary(opcodes::Ordinary::OP_CHECKMULTISIGVERIFY) => {
-                        if mode == Mode::SeekingKeys { return Err(Error::ExpectedKey); }
-                        if mode == Mode::CopyingKeys { return Err(Error::ExpectedKey); }
-                        mode = Mode::SeekingKeys;
-                    }
-                    // Numbers after keys mean we expect a CHECKMULTISIG.
-                    opcodes::Class::PushNum(_) => {
-                        if mode == Mode::SeekingCheckMulti { return Err(Error::ExpectedChecksig); }
-                        if mode == Mode::CopyingKeys { mode = Mode::SeekingCheckMulti; }
-                    }
-                    // All other opcodes do nothing
-                    _ => {}
-                }
-                ret = ret.push_opcode(op);
-            }
-            script::Instruction::Error(e) => { return Err(Error::Script(e)); }
-        }
-    }
-    Ok((Template::from(&ret[..]), retkeys))
-}
-
-#[cfg(test)]
-mod tests {
-    use secp256k1::Secp256k1;
-    use hex::decode as hex_decode;
-    use secp256k1::rand::thread_rng;
-    use std::str::FromStr;
-
-    use blockdata::script::Script;
-    use network::constants::Network;
-
-    use super::*;
-    use PublicKey;
-
-    macro_rules! hex (($hex:expr) => (hex_decode($hex).unwrap()));
-    macro_rules! hex_key (($hex:expr) => (PublicKey::from_slice(&hex!($hex)).unwrap()));
-    macro_rules! alpha_template(() => (Template::from(&hex!("55fefefefefefefe57AE")[..])));
-    macro_rules! alpha_keys(() => (
-        &[hex_key!("0269992fb441ae56968e5b77d46a3e53b69f136444ae65a94041fc937bdb28d933"),
-          hex_key!("021df31471281d4478df85bfce08a10aab82601dca949a79950f8ddf7002bd915a"),
-          hex_key!("02174c82021492c2c6dfcbfa4187d10d38bed06afb7fdcd72c880179fddd641ea1"),
-          hex_key!("033f96e43d72c33327b6a4631ccaa6ea07f0b106c88b9dc71c9000bb6044d5e88a"),
-          hex_key!("0313d8748790f2a86fb524579b46ce3c68fedd58d2a738716249a9f7d5458a15c2"),
-          hex_key!("030b632eeb079eb83648886122a04c7bf6d98ab5dfb94cf353ee3e9382a4c2fab0"),
-          hex_key!("02fb54a7fcaa73c307cfd70f3fa66a2e4247a71858ca731396343ad30c7c4009ce")]
-    ));
-
-    #[test]
-    fn sanity() {
-        let secp = Secp256k1::new();
-        let keys = alpha_keys!();
-        // This is the first withdraw ever, in alpha a94f95cc47b444c10449c0eed51d895e4970560c4a1a9d15d46124858abc3afe
-        let contract = hex!("5032534894ffbf32c1f1c0d3089b27c98fd991d5d7329ebd7d711223e2cde5a9417a1fa3e852c576");
-
-        let addr = create_address(&secp, Network::Testnet, &contract, keys, &alpha_template!()).unwrap();
-        assert_eq!(addr.to_string(), "2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr".to_owned());
-    }
-
-    #[test]
-    fn script() {
-        let alpha_keys = alpha_keys!();
-        let alpha_template = alpha_template!();
-
-        let alpha_redeem = Script::from(hex!("55210269992fb441ae56968e5b77d46a3e53b69f136444ae65a94041fc937bdb28d93321021df31471281d4478df85bfce08a10aab82601dca949a79950f8ddf7002bd915a2102174c82021492c2c6dfcbfa4187d10d38bed06afb7fdcd72c880179fddd641ea121033f96e43d72c33327b6a4631ccaa6ea07f0b106c88b9dc71c9000bb6044d5e88a210313d8748790f2a86fb524579b46ce3c68fedd58d2a738716249a9f7d5458a15c221030b632eeb079eb83648886122a04c7bf6d98ab5dfb94cf353ee3e9382a4c2fab02102fb54a7fcaa73c307cfd70f3fa66a2e4247a71858ca731396343ad30c7c4009ce57ae"));
-        let (template, keys) = untemplate(&alpha_redeem).unwrap();
-
-        assert_eq!(keys, alpha_keys);
-        assert_eq!(template, alpha_template);
-    }
-
-    #[test]
-    fn tweak_secret() {
-        let secp = Secp256k1::new();
-        let (sk1, pk1) = secp.generate_keypair(&mut thread_rng());
-        let (sk2, pk2) = secp.generate_keypair(&mut thread_rng());
-        let (sk3, pk3) = secp.generate_keypair(&mut thread_rng());
-
-        let sk1 = PrivateKey {
-            key: sk1,
-            compressed: true,
-            network: Network::Bitcoin,
-        };
-        let sk2 = PrivateKey {
-            key: sk2,
-            compressed: false,
-            network: Network::Bitcoin,
-        };
-        let sk3 = PrivateKey {
-            key: sk3,
-            compressed: true,
-            network: Network::Bitcoin,
-        };
-        let pks = [
-            PublicKey { key: pk1, compressed: true },
-            PublicKey { key: pk2, compressed: false },
-            PublicKey { key: pk3, compressed: true },
-        ];
-        let contract = b"if bottle mt dont remembr drink wont pay";
-
-        // Directly compute tweaks on pubkeys
-        let tweaked_pks = tweak_keys(&secp, &pks, &contract[..]);
-        // Compute tweaks on secret keys
-        let tweaked_pk1 = PublicKey::from_private_key(&secp, &tweak_secret_key(&secp, &sk1, &contract[..]).unwrap());
-        let tweaked_pk2 = PublicKey::from_private_key(&secp, &tweak_secret_key(&secp, &sk2, &contract[..]).unwrap());
-        let tweaked_pk3 = PublicKey::from_private_key(&secp, &tweak_secret_key(&secp, &sk3, &contract[..]).unwrap());
-        // Check equality
-        assert_eq!(tweaked_pks[0], tweaked_pk1);
-        assert_eq!(tweaked_pks[1], tweaked_pk2);
-        assert_eq!(tweaked_pks[2], tweaked_pk3);
-    }
-
-    #[test]
-    fn tweak_fixed_vector() {
-        let secp = Secp256k1::new();
-
-        let pks = [
-            PublicKey::from_str("02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c").unwrap(),
-            PublicKey::from_str("0365c0755ea55ce85d8a1900c68a524dbfd1c0db45ac3b3840dbb10071fe55e7a8").unwrap(),
-            PublicKey::from_str("0202313ca315889b2e69c94cf86901119321c7288139ba53ac022b7af3dc250054").unwrap(),
-        ];
-        let tweaked_pks = [
-            PublicKey::from_str("03b3597221b5982a3f1a77aed50f0015d1b6edfc69023ef7f25cfac0e8af1b2041").unwrap(),
-            PublicKey::from_str("0296ece1fd954f7ae94f8d6bad19fd6d583f5b36335cf13135a3053a22f3c1fb05").unwrap(),
-            PublicKey::from_str("0230bb1ca5dbc7fcf49294c2c3e582e5582eabf7c87e885735dc774da45d610e51").unwrap(),
-        ];
-        let contract = b"if bottle mt dont remembr drink wont pay";
-
-        // Directly compute tweaks on pubkeys
-        assert_eq!(
-            tweak_keys(&secp, &pks, &contract[..]),
-            tweaked_pks
-        );
-    }
-
-    #[test]
-    fn bad_key_number() {
-        let alpha_keys = alpha_keys!();
-        let template_short = Template::from(&hex!("55fefefefefefe57AE")[..]);
-        let template_long = Template::from(&hex!("55fefefefefefefefe57AE")[..]);
-        let template = Template::from(&hex!("55fefefefefefefe57AE")[..]);
-
-        assert_eq!(template_short.required_keys(), 6);
-        assert_eq!(template_long.required_keys(), 8);
-        assert_eq!(template.required_keys(), 7);
-        assert_eq!(template_short.to_script(alpha_keys), Err(Error::TooManyKeys(7)));
-        assert_eq!(template_long.to_script(alpha_keys), Err(Error::TooFewKeys(7)));
-        assert!(template.to_script(alpha_keys).is_ok());
-    }
-}
-
-
diff --git a/src/util/endian.rs b/src/util/endian.rs
deleted file mode 100644
index 8c10b57a..00000000
--- a/src/util/endian.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-macro_rules! define_slice_to_be {
-    ($name: ident, $type: ty) => {
-        #[inline]
-        pub fn $name(slice: &[u8]) -> $type {
-            assert_eq!(slice.len(), ::std::mem::size_of::<$type>());
-            let mut res = 0;
-            for i in 0..::std::mem::size_of::<$type>() {
-                res |= (slice[i] as $type) << (::std::mem::size_of::<$type>() - i - 1)*8;
-            }
-            res
-        }
-    }
-}
-macro_rules! define_slice_to_le {
-    ($name: ident, $type: ty) => {
-        #[inline]
-        pub fn $name(slice: &[u8]) -> $type {
-            assert_eq!(slice.len(), ::std::mem::size_of::<$type>());
-            let mut res = 0;
-            for i in 0..::std::mem::size_of::<$type>() {
-                res |= (slice[i] as $type) << i*8;
-            }
-            res
-        }
-    }
-}
-macro_rules! define_be_to_array {
-    ($name: ident, $type: ty, $byte_len: expr) => {
-        #[inline]
-        pub fn $name(val: $type) -> [u8; $byte_len] {
-            assert_eq!(::std::mem::size_of::<$type>(), $byte_len); // size_of isn't a constfn in 1.22
-            let mut res = [0; $byte_len];
-            for i in 0..$byte_len {
-                res[i] = ((val >> ($byte_len - i - 1)*8) & 0xff) as u8;
-            }
-            res
-        }
-    }
-}
-macro_rules! define_le_to_array {
-    ($name: ident, $type: ty, $byte_len: expr) => {
-        #[inline]
-        pub fn $name(val: $type) -> [u8; $byte_len] {
-            assert_eq!(::std::mem::size_of::<$type>(), $byte_len); // size_of isn't a constfn in 1.22
-            let mut res = [0; $byte_len];
-            for i in 0..$byte_len {
-                res[i] = ((val >> i*8) & 0xff) as u8;
-            }
-            res
-        }
-    }
-}
-
-define_slice_to_be!(slice_to_u32_be, u32);
-define_be_to_array!(u32_to_array_be, u32, 4);
-define_slice_to_le!(slice_to_u16_le, u16);
-define_slice_to_le!(slice_to_u32_le, u32);
-define_slice_to_le!(slice_to_u64_le, u64);
-define_le_to_array!(u16_to_array_le, u16, 2);
-define_le_to_array!(u32_to_array_le, u32, 4);
-define_le_to_array!(u64_to_array_le, u64, 8);
-
-#[inline]
-pub fn i16_to_array_le(val: i16) -> [u8; 2] {
-    u16_to_array_le(val as u16)
-}
-#[inline]
-pub fn slice_to_i16_le(slice: &[u8]) -> i16 {
-    slice_to_u16_le(slice) as i16
-}
-#[inline]
-pub fn slice_to_i32_le(slice: &[u8]) -> i32 {
-    slice_to_u32_le(slice) as i32
-}
-#[inline]
-pub fn i32_to_array_le(val: i32) -> [u8; 4] {
-    u32_to_array_le(val as u32)
-}
-#[inline]
-pub fn slice_to_i64_le(slice: &[u8]) -> i64 {
-    slice_to_u64_le(slice) as i64
-}
-#[inline]
-pub fn i64_to_array_le(val: i64) -> [u8; 8] {
-    u64_to_array_le(val as u64)
-}
-
-macro_rules! define_chunk_slice_to_int {
-    ($name: ident, $type: ty, $converter: ident) => {
-        #[inline]
-        pub fn $name(inp: &[u8], outp: &mut [$type]) {
-            assert_eq!(inp.len(), outp.len() * ::std::mem::size_of::<$type>());
-            for (outp_val, data_bytes) in outp.iter_mut().zip(inp.chunks(::std::mem::size_of::<$type>())) {
-                *outp_val = $converter(data_bytes);
-            }
-        }
-    }
-}
-define_chunk_slice_to_int!(bytes_to_u64_slice_le, u64, slice_to_u64_le);
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn endianness_test() {
-        assert_eq!(slice_to_u32_be(&[0xde, 0xad, 0xbe, 0xef]), 0xdeadbeef);
-        assert_eq!(u32_to_array_be(0xdeadbeef), [0xde, 0xad, 0xbe, 0xef]);
-
-        assert_eq!(slice_to_u16_le(&[0xad, 0xde]), 0xdead);
-        assert_eq!(slice_to_u32_le(&[0xef, 0xbe, 0xad, 0xde]), 0xdeadbeef);
-        assert_eq!(slice_to_u64_le(&[0xef, 0xbe, 0xad, 0xde, 0xfe, 0xca, 0xad, 0x1b]), 0x1badcafedeadbeef);
-        assert_eq!(u16_to_array_le(0xdead), [0xad, 0xde]);
-        assert_eq!(u32_to_array_le(0xdeadbeef), [0xef, 0xbe, 0xad, 0xde]);
-        assert_eq!(u64_to_array_le(0x1badcafedeadbeef), [0xef, 0xbe, 0xad, 0xde, 0xfe, 0xca, 0xad, 0x1b]);
-    }
-
-    #[test]
-    fn endian_chunk_test() {
-        let inp = [0xef, 0xbe, 0xad, 0xde, 0xfe, 0xca, 0xad, 0x1b, 0xfe, 0xca, 0xad, 0x1b, 0xce, 0xfa, 0x01, 0x02];
-        let mut out = [0; 2];
-        bytes_to_u64_slice_le(&inp, &mut out);
-        assert_eq!(out, [0x1badcafedeadbeef, 0x0201face1badcafe]);
-    }
-}
diff --git a/src/util/hash.rs b/src/util/hash.rs
deleted file mode 100644
index 0de4731f..00000000
--- a/src/util/hash.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-// 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/>.
-//
-
-//! Hash functions
-//!
-//! Utility functions related to hashing data, including merkleization
-
-use std::cmp::min;
-use std::io;
-
-use hashes::Hash;
-use consensus::encode::Encodable;
-
-/// Calculates the merkle root of a list of hashes inline
-/// into the allocated slice.
-///
-/// In most cases, you'll want to use [bitcoin_merkle_root] instead.
-pub fn bitcoin_merkle_root_inline<T>(data: &mut [T]) -> T
-    where T: Hash + Encodable,
-          <T as Hash>::Engine: io::Write,
-{
-    // Base case
-    if data.len() < 1 {
-        return Default::default();
-    }
-    if data.len() < 2 {
-        return T::from_inner(data[0].into_inner());
-    }
-    // Recursion
-    for idx in 0..((data.len() + 1) / 2) {
-        let idx1 = 2 * idx;
-        let idx2 = min(idx1 + 1, data.len() - 1);
-        let mut encoder = T::engine();
-        data[idx1].consensus_encode(&mut encoder).unwrap();
-        data[idx2].consensus_encode(&mut encoder).unwrap();
-        data[idx] = T::from_engine(encoder);
-    }
-    let half_len = data.len() / 2 + data.len() % 2;
-    bitcoin_merkle_root_inline(&mut data[0..half_len])
-}
-
-/// Calculates the merkle root of an iterator of hashes.
-pub fn bitcoin_merkle_root<T, I>(mut iter: I) -> T
-    where T: Hash + Encodable,
-          <T as Hash>::Engine: io::Write,
-          I: ExactSizeIterator<Item = T>,
-{
-    // Base case
-    if iter.len() == 0 {
-        return Default::default();
-    }
-    if iter.len() == 1 {
-        return T::from_inner(iter.nth(0).unwrap().into_inner());
-    }
-    // Recursion
-    let half_len = iter.len() / 2 + iter.len() % 2;
-    let mut alloc = Vec::with_capacity(half_len);
-    while let Some(hash1) = iter.next() {
-        // If the size is odd, use the last element twice.
-        let hash2 = iter.next().unwrap_or(hash1);
-        let mut encoder = T::engine();
-        hash1.consensus_encode(&mut encoder).unwrap();
-        hash2.consensus_encode(&mut encoder).unwrap();
-        alloc.push(T::from_engine(encoder));
-    }
-    bitcoin_merkle_root_inline(&mut alloc)
-}
-
-/// Objects which are referred to by hash
-pub trait BitcoinHash<T: Hash> {
-    /// Produces a Sha256dHash which can be used to refer to the object
-    fn bitcoin_hash(&self) -> T;
-}
diff --git a/src/util/key.rs b/src/util/key.rs
deleted file mode 100644
index c9f81faf..00000000
--- a/src/util/key.rs
+++ /dev/null
@@ -1,448 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-// 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/>.
-//
-
-//! Bitcoin Keys
-//!
-//! Keys used in Bitcoin that can be roundtrip (de)serialized.
-//!
-
-use std::fmt::{self, Write};
-use std::{io, ops, error};
-use std::str::FromStr;
-
-use secp256k1::{self, Secp256k1};
-use network::constants::Network;
-use util::base58;
-
-/// A key-related error.
-#[derive(Debug)]
-pub enum Error {
-    /// Base58 encoding error
-    Base58(base58::Error),
-    /// secp256k1-related error
-    Secp256k1(secp256k1::Error),
-}
-
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::Base58(ref e) => write!(f, "base58 error: {}", e),
-            Error::Secp256k1(ref e) => write!(f, "secp256k1 error: {}", e),
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Base58(ref e) => Some(e),
-            Error::Secp256k1(ref e) => Some(e),
-        }
-    }
-
-    fn description(&self) -> &str {
-		"Bitcoin key error"
-    }
-}
-
-#[doc(hidden)]
-impl From<base58::Error> for Error {
-    fn from(e: base58::Error) -> Error {
-        Error::Base58(e)
-    }
-}
-
-#[doc(hidden)]
-impl From<secp256k1::Error> for Error {
-    fn from(e: secp256k1::Error) -> Error {
-        Error::Secp256k1(e)
-    }
-}
-
-/// A Bitcoin ECDSA public key
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct PublicKey {
-    /// Whether this public key should be serialized as compressed
-    pub compressed: bool,
-    /// The actual ECDSA key
-    pub key: secp256k1::PublicKey,
-}
-
-impl PublicKey {
-    /// Write the public key into a writer
-    pub fn write_into<W: io::Write>(&self, mut writer: W) {
-        let write_res: io::Result<()> = if self.compressed {
-            writer.write_all(&self.key.serialize())
-        } else {
-            writer.write_all(&self.key.serialize_uncompressed())
-        };
-        debug_assert!(write_res.is_ok());
-    }
-
-    /// Serialize the public key to bytes
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let mut buf = Vec::new();
-        self.write_into(&mut buf);
-        buf
-    }
-
-    /// Deserialize a public key from a slice
-    pub fn from_slice(data: &[u8]) -> Result<PublicKey, Error> {
-        let compressed: bool = match data.len() {
-            33 => true,
-            65 => false,
-            len =>  { return Err(base58::Error::InvalidLength(len).into()); },
-        };
-
-        Ok(PublicKey {
-            compressed: compressed,
-            key: secp256k1::PublicKey::from_slice(data)?,
-        })
-    }
-
-    /// Computes the public key as supposed to be used with this secret
-    pub fn from_private_key<C: secp256k1::Signing>(secp: &Secp256k1<C>, sk: &PrivateKey) -> PublicKey {
-        sk.public_key(secp)
-    }
-}
-
-impl fmt::Display for PublicKey {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.compressed {
-            for ch in &self.key.serialize()[..] {
-                write!(f, "{:02x}", ch)?;
-            }
-        } else {
-            for ch in &self.key.serialize_uncompressed()[..] {
-                write!(f, "{:02x}", ch)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl FromStr for PublicKey {
-    type Err = Error;
-    fn from_str(s: &str) -> Result<PublicKey, Error> {
-        let key = secp256k1::PublicKey::from_str(s)?;
-        Ok(PublicKey {
-            key: key,
-            compressed: s.len() == 66
-        })
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-/// A Bitcoin ECDSA private key
-pub struct PrivateKey {
-    /// Whether this private key should be serialized as compressed
-    pub compressed: bool,
-    /// The network on which this key should be used
-    pub network: Network,
-    /// The actual ECDSA key
-    pub key: secp256k1::SecretKey,
-}
-
-impl PrivateKey {
-    /// Creates a public key from this private key
-    pub fn public_key<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> PublicKey {
-        PublicKey {
-            compressed: self.compressed,
-            key: secp256k1::PublicKey::from_secret_key(secp, &self.key)
-        }
-    }
-
-    /// Serialize the private key to bytes
-    pub fn to_bytes(&self) -> Vec<u8> {
-        self.key[..].to_vec()
-    }
-
-    /// Format the private key to WIF format.
-    pub fn fmt_wif(&self, fmt: &mut fmt::Write) -> fmt::Result {
-        let mut ret = [0; 34];
-        ret[0] = match self.network {
-            Network::Bitcoin => 128,
-            Network::Testnet | Network::Regtest => 239,
-        };
-        ret[1..33].copy_from_slice(&self.key[..]);
-        let privkey = if self.compressed {
-            ret[33] = 1;
-            base58::check_encode_slice(&ret[..])
-        } else {
-            base58::check_encode_slice(&ret[..33])
-        };
-        fmt.write_str(&privkey)
-    }
-
-    /// Get WIF encoding of this private key.
-    pub fn to_wif(&self) -> String {
-        let mut buf = String::new();
-        buf.write_fmt(format_args!("{}", self)).unwrap();
-        buf.shrink_to_fit();
-        buf
-    }
-
-    /// Parse WIF encoded private key.
-    pub fn from_wif(wif: &str) -> Result<PrivateKey, Error> {
-        let data = base58::from_check(wif)?;
-
-        let compressed = match data.len() {
-            33 => false,
-            34 => true,
-            _ => { return Err(Error::Base58(base58::Error::InvalidLength(data.len()))); }
-        };
-
-        let network = match data[0] {
-            128 => Network::Bitcoin,
-            239 => Network::Testnet,
-            x   => { return Err(Error::Base58(base58::Error::InvalidVersion(vec![x]))); }
-        };
-
-        Ok(PrivateKey {
-            compressed: compressed,
-            network: network,
-            key: secp256k1::SecretKey::from_slice(&data[1..33])?,
-        })
-    }
-}
-
-impl fmt::Display for PrivateKey {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.fmt_wif(f)
-    }
-}
-
-impl fmt::Debug for PrivateKey {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "[private key data]")
-    }
-}
-
-impl FromStr for PrivateKey {
-    type Err = Error;
-    fn from_str(s: &str) -> Result<PrivateKey, Error> {
-        PrivateKey::from_wif(s)
-    }
-}
-
-impl ops::Index<ops::RangeFull> for PrivateKey {
-    type Output = [u8];
-    fn index(&self, _: ops::RangeFull) -> &[u8] {
-        &self.key[..]
-    }
-}
-
-#[cfg(feature = "serde")]
-impl ::serde::Serialize for PrivateKey {
-    fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        s.collect_str(self)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> ::serde::Deserialize<'de> for PrivateKey {
-    fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<PrivateKey, D::Error> {
-        struct WifVisitor;
-
-        impl<'de> ::serde::de::Visitor<'de> for WifVisitor {
-            type Value = PrivateKey;
-
-            fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                formatter.write_str("an ASCII WIF string")
-            }
-
-            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-            where
-                E: ::serde::de::Error,
-            {
-                if let Ok(s) = ::std::str::from_utf8(v) {
-                    PrivateKey::from_str(s).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,
-            {
-                PrivateKey::from_str(v).map_err(E::custom)
-            }
-        }
-
-        d.deserialize_str(WifVisitor)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl ::serde::Serialize for PublicKey {
-    fn serialize<S: ::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        if s.is_human_readable() {
-            s.collect_str(self)
-        } else {
-            if self.compressed {
-                s.serialize_bytes(&self.key.serialize()[..])
-            } else {
-                s.serialize_bytes(&self.key.serialize_uncompressed()[..])
-            }
-        }
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> ::serde::Deserialize<'de> for PublicKey {
-    fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<PublicKey, D::Error> {
-        if d.is_human_readable() {
-            struct HexVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for HexVisitor {
-                type Value = PublicKey;
-
-                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) {
-                        PublicKey::from_str(hex).map_err(E::custom)
-                    } else {
-                        Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
-                    }
-                }
-
-                fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                where
-                    E: ::serde::de::Error,
-                {
-                    PublicKey::from_str(v).map_err(E::custom)
-                }
-            }
-            d.deserialize_str(HexVisitor)
-        } else {
-            struct BytesVisitor;
-
-            impl<'de> ::serde::de::Visitor<'de> for BytesVisitor {
-                type Value = PublicKey;
-
-                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,
-                {
-                    PublicKey::from_slice(v).map_err(E::custom)
-                }
-            }
-
-            d.deserialize_bytes(BytesVisitor)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{PrivateKey, PublicKey};
-    use secp256k1::Secp256k1;
-    use std::str::FromStr;
-    use network::constants::Network::Testnet;
-    use network::constants::Network::Bitcoin;
-    use util::address::Address;
-
-    #[test]
-    fn test_key_derivation() {
-        // testnet compressed
-        let sk = PrivateKey::from_wif("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
-        assert_eq!(sk.network, Testnet);
-        assert_eq!(sk.compressed, true);
-        assert_eq!(&sk.to_wif(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
-
-        let secp = Secp256k1::new();
-        let pk = Address::p2pkh(&sk.public_key(&secp), sk.network);
-        assert_eq!(&pk.to_string(), "mqwpxxvfv3QbM8PU8uBx2jaNt9btQqvQNx");
-
-        // test string conversion
-        assert_eq!(&sk.to_string(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
-        let sk_str =
-            PrivateKey::from_str("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
-        assert_eq!(&sk.to_wif(), &sk_str.to_wif());
-
-        // mainnet uncompressed
-        let sk = PrivateKey::from_wif("5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM9Z2PT2R3").unwrap();
-        assert_eq!(sk.network, Bitcoin);
-        assert_eq!(sk.compressed, false);
-        assert_eq!(&sk.to_wif(), "5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM9Z2PT2R3");
-
-        let secp = Secp256k1::new();
-        let mut pk = sk.public_key(&secp);
-        assert_eq!(pk.compressed, false);
-        assert_eq!(&pk.to_string(), "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133");
-        assert_eq!(pk, PublicKey::from_str("042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133").unwrap());
-        let addr = Address::p2pkh(&pk, sk.network);
-        assert_eq!(&addr.to_string(), "1GhQvF6dL8xa6wBxLnWmHcQsurx9RxiMc8");
-        pk.compressed = true;
-        assert_eq!(&pk.to_string(), "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af");
-        assert_eq!(pk, PublicKey::from_str("032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af").unwrap());
-    }
-
-    #[cfg(feature = "serde")]
-    #[test]
-    fn test_key_serde() {
-        use serde_test::{Configure, Token, assert_tokens};
-
-        static KEY_WIF: &'static str = "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy";
-        static PK_STR: &'static str = "039b6347398505f5ec93826dc61c19f47c66c0283ee9be980e29ce325a0f4679ef";
-        static PK_STR_U: &'static str = "\
-            04\
-            9b6347398505f5ec93826dc61c19f47c66c0283ee9be980e29ce325a0f4679ef\
-            87288ed73ce47fc4f5c79d19ebfa57da7cff3aff6e819e4ee971d86b5e61875d\
-        ";
-        static PK_BYTES: [u8; 33] = [
-            0x03,
-            0x9b, 0x63, 0x47, 0x39, 0x85, 0x05, 0xf5, 0xec,
-            0x93, 0x82, 0x6d, 0xc6, 0x1c, 0x19, 0xf4, 0x7c,
-            0x66, 0xc0, 0x28, 0x3e, 0xe9, 0xbe, 0x98, 0x0e,
-            0x29, 0xce, 0x32, 0x5a, 0x0f, 0x46, 0x79, 0xef,
-        ];
-        static PK_BYTES_U: [u8; 65] = [
-            0x04,
-            0x9b, 0x63, 0x47, 0x39, 0x85, 0x05, 0xf5, 0xec,
-            0x93, 0x82, 0x6d, 0xc6, 0x1c, 0x19, 0xf4, 0x7c,
-            0x66, 0xc0, 0x28, 0x3e, 0xe9, 0xbe, 0x98, 0x0e,
-            0x29, 0xce, 0x32, 0x5a, 0x0f, 0x46, 0x79, 0xef,
-            0x87, 0x28, 0x8e, 0xd7, 0x3c, 0xe4, 0x7f, 0xc4,
-            0xf5, 0xc7, 0x9d, 0x19, 0xeb, 0xfa, 0x57, 0xda,
-            0x7c, 0xff, 0x3a, 0xff, 0x6e, 0x81, 0x9e, 0x4e,
-            0xe9, 0x71, 0xd8, 0x6b, 0x5e, 0x61, 0x87, 0x5d,
-        ];
-
-        let s = Secp256k1::new();
-        let sk = PrivateKey::from_str(&KEY_WIF).unwrap();
-        let pk = PublicKey::from_private_key(&s, &sk);
-        let pk_u = PublicKey {
-            key: pk.key,
-            compressed: false,
-        };
-
-        assert_tokens(&sk, &[Token::BorrowedStr(KEY_WIF)]);
-        assert_tokens(&pk.compact(), &[Token::BorrowedBytes(&PK_BYTES[..])]);
-        assert_tokens(&pk.readable(), &[Token::BorrowedStr(PK_STR)]);
-        assert_tokens(&pk_u.compact(), &[Token::BorrowedBytes(&PK_BYTES_U[..])]);
-        assert_tokens(&pk_u.readable(), &[Token::BorrowedStr(PK_STR_U)]);
-    }
-}
diff --git a/src/util/merkleblock.rs b/src/util/merkleblock.rs
deleted file mode 100644
index 3dca69d8..00000000
--- a/src/util/merkleblock.rs
+++ /dev/null
@@ -1,786 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   John L. Jegutanis
-//
-// 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 code was translated from merkleblock.h, merkleblock.cpp and pmt_tests.cpp
-// Copyright (c) 2009-2010 Satoshi Nakamoto
-// Copyright (c) 2009-2018 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-//! Merkle Block and Partial Merkle Tree
-//!
-//! Support proofs that transaction(s) belong to a block.
-//!
-//! # Examples
-//!
-//! ```rust
-//! extern crate bitcoin;
-//! use bitcoin::hash_types::Txid;
-//! use bitcoin::hashes::hex::FromHex;
-//! use bitcoin::{Block, MerkleBlock};
-//!
-//! # fn main() {
-//! // Get the proof from a bitcoind by running in the terminal:
-//! // $ TXID="5a4ebf66822b0b2d56bd9dc64ece0bc38ee7844a23ff1d7320a88c5fdb2ad3e2"
-//! // $ bitcoin-cli gettxoutproof [\"$TXID\"]
-//! let mb_bytes = Vec::from_hex("01000000ba8b9cda965dd8e536670f9ddec10e53aab14b20bacad27b913719\
-//!     0000000000190760b278fe7b8565fda3b968b918d5fd997f993b23674c0af3b6fde300b38f33a5914ce6ed5b\
-//!     1b01e32f570200000002252bf9d75c4f481ebb6278d708257d1f12beb6dd30301d26c623f789b2ba6fc0e2d3\
-//!     2adb5f8ca820731dff234a84e78ec30bce4ec69dbd562d0b2b8266bf4e5a0105").unwrap();
-//! let mb: MerkleBlock = bitcoin::consensus::deserialize(&mb_bytes).unwrap();
-//!
-//! // Authenticate and extract matched transaction ids
-//! let mut matches: Vec<Txid> = vec![];
-//! let mut index: Vec<u32> = vec![];
-//! assert!(mb.extract_matches(&mut matches, &mut index).is_ok());
-//! assert_eq!(1, matches.len());
-//! assert_eq!(
-//!     Txid::from_hex(
-//!         "5a4ebf66822b0b2d56bd9dc64ece0bc38ee7844a23ff1d7320a88c5fdb2ad3e2").unwrap(),
-//!     matches[0]
-//! );
-//! assert_eq!(1, index.len());
-//! assert_eq!(1, index[0]);
-//! # }
-//! ```
-
-use std::collections::HashSet;
-use std::io;
-
-use hashes::Hash;
-use hash_types::{Txid, TxMerkleNode};
-
-use blockdata::transaction::Transaction;
-use blockdata::constants::{MAX_BLOCK_WEIGHT, MIN_TRANSACTION_WEIGHT};
-use consensus::encode::{self, Decodable, Encodable};
-use util::merkleblock::MerkleBlockError::*;
-use {Block, BlockHeader};
-
-/// An error when verifying the merkle block
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub enum MerkleBlockError {
-    /// When header merkle root don't match to the root calculated from the partial merkle tree
-    MerkleRootMismatch,
-    /// When partial merkle tree contains no transactions
-    NoTransactions,
-    /// When there are too many transactions
-    TooManyTransactions,
-    /// General format error
-    BadFormat(String),
-}
-
-/// Data structure that represents a partial merkle tree.
-///
-/// It represents a subset of the txid's of a known block, in a way that
-/// allows recovery of the list of txid's and the merkle root, in an
-/// authenticated way.
-///
-/// The encoding works as follows: we traverse the tree in depth-first order,
-/// storing a bit for each traversed node, signifying whether the node is the
-/// parent of at least one matched leaf txid (or a matched txid itself). In
-/// case we are at the leaf level, or this bit is 0, its merkle node hash is
-/// stored, and its children are not explored further. Otherwise, no hash is
-/// stored, but we recurse into both (or the only) child branch. During
-/// decoding, the same depth-first traversal is performed, consuming bits and
-/// hashes as they written during encoding.
-///
-/// The serialization is fixed and provides a hard guarantee about the
-/// encoded size:
-///
-///   SIZE <= 10 + ceil(32.25*N)
-///
-/// Where N represents the number of leaf nodes of the partial tree. N itself
-/// is bounded by:
-///
-///   N <= total_transactions
-///   N <= 1 + matched_transactions*tree_height
-///
-/// The serialization format:
-///  - uint32     total_transactions (4 bytes)
-///  - varint     number of hashes   (1-3 bytes)
-///  - uint256[]  hashes in depth-first order (<= 32*N bytes)
-///  - varint     number of bytes of flag bits (1-3 bytes)
-///  - byte[]     flag bits, packed per 8 in a byte, least significant bit first (<= 2*N-1 bits)
-/// The size constraints follow from this.
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct PartialMerkleTree {
-    /// The total number of transactions in the block
-    num_transactions: u32,
-    /// node-is-parent-of-matched-txid bits
-    bits: Vec<bool>,
-    /// Transaction ids and internal hashes
-    hashes: Vec<TxMerkleNode>,
-}
-
-impl PartialMerkleTree {
-    /// Construct a partial merkle tree
-    /// The `txids` are the transaction hashes of the block and the `matches` is the contains flags
-    /// wherever a tx hash should be included in the proof.
-    ///
-    /// Panics when `txids` is empty or when `matches` has a different length
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// extern crate bitcoin;
-    /// use bitcoin::hash_types::Txid;
-    /// use bitcoin::hashes::hex::FromHex;
-    /// use bitcoin::util::merkleblock::PartialMerkleTree;
-    ///
-    /// # fn main() {
-    /// // Block 80000
-    /// let txids: Vec<Txid> = [
-    ///     "c06fbab289f723c6261d3030ddb6be121f7d2508d77862bb1e484f5cd7f92b25",
-    ///     "5a4ebf66822b0b2d56bd9dc64ece0bc38ee7844a23ff1d7320a88c5fdb2ad3e2",
-    /// ]
-    /// .iter()
-    /// .map(|hex| Txid::from_hex(hex).unwrap())
-    /// .collect();
-    ///
-    /// // Select the second transaction
-    /// let matches = vec![false, true];
-    /// let tree = PartialMerkleTree::from_txids(&txids, &matches);
-    /// assert!(tree.extract_matches(&mut vec![], &mut vec![]).is_ok());
-    /// # }
-    /// ```
-    pub fn from_txids(txids: &[Txid], matches: &[bool]) -> Self {
-        // We can never have zero txs in a merkle block, we always need the coinbase tx
-        assert_ne!(txids.len(), 0);
-        assert_eq!(txids.len(), matches.len());
-
-        let mut pmt = PartialMerkleTree {
-            num_transactions: txids.len() as u32,
-            bits: Vec::with_capacity(txids.len()),
-            hashes: vec![],
-        };
-        // calculate height of tree
-        let mut height = 0;
-        while pmt.calc_tree_width(height) > 1 {
-            height += 1;
-        }
-        // traverse the partial tree
-        pmt.traverse_and_build(height, 0, txids, matches);
-        pmt
-    }
-
-    /// Extract the matching txid's represented by this partial merkle tree
-    /// and their respective indices within the partial tree.
-    /// returns the merkle root, or error in case of failure
-    pub fn extract_matches(
-        &self,
-        matches: &mut Vec<Txid>,
-        indexes: &mut Vec<u32>,
-    ) -> Result<TxMerkleNode, MerkleBlockError> {
-        matches.clear();
-        indexes.clear();
-        // An empty set will not work
-        if self.num_transactions == 0 {
-            return Err(NoTransactions);
-        };
-        // check for excessively high numbers of transactions
-        if self.num_transactions > MAX_BLOCK_WEIGHT / MIN_TRANSACTION_WEIGHT {
-            return Err(TooManyTransactions);
-        }
-        // there can never be more hashes provided than one for every txid
-        if self.hashes.len() as u32 > self.num_transactions {
-            return Err(BadFormat(
-                "Proof contains more hashes than transactions".to_owned(),
-            ));
-        };
-        // there must be at least one bit per node in the partial tree, and at least one node per hash
-        if self.bits.len() < self.hashes.len() {
-            return Err(BadFormat("Proof contains less bits than hashes".to_owned()));
-        };
-        // calculate height of tree
-        let mut height = 0;
-        while self.calc_tree_width(height) > 1 {
-            height += 1;
-        }
-        // traverse the partial tree
-        let mut bits_used = 0u32;
-        let mut hash_used = 0u32;
-        let hash_merkle_root =
-            self.traverse_and_extract(height, 0, &mut bits_used, &mut hash_used, matches, indexes)?;
-        // Verify that all bits were consumed (except for the padding caused by
-        // serializing it as a byte sequence)
-        if (bits_used + 7) / 8 != (self.bits.len() as u32 + 7) / 8 {
-            return Err(BadFormat("Not all bit were consumed".to_owned()));
-        }
-        // Verify that all hashes were consumed
-        if hash_used != self.hashes.len() as u32 {
-            return Err(BadFormat("Not all hashes were consumed".to_owned()));
-        }
-        Ok(TxMerkleNode::from_inner(hash_merkle_root.into_inner()))
-    }
-
-    /// Helper function to efficiently calculate the number of nodes at given height
-    /// in the merkle tree
-    #[inline]
-    fn calc_tree_width(&self, height: u32) -> u32 {
-        (self.num_transactions + (1 << height) - 1) >> height
-    }
-
-    /// Calculate the hash of a node in the merkle tree (at leaf level: the txid's themselves)
-    fn calc_hash(&self, height: u32, pos: u32, txids: &[Txid]) -> TxMerkleNode {
-        if height == 0 {
-            // Hash at height 0 is the txid itself
-            TxMerkleNode::from_inner(txids[pos as usize].into_inner())
-        } else {
-            // Calculate left hash
-            let left = self.calc_hash(height - 1, pos * 2, txids);
-            // Calculate right hash if not beyond the end of the array - copy left hash otherwise
-            let right = if pos * 2 + 1 < self.calc_tree_width(height - 1) {
-                self.calc_hash(height - 1, pos * 2 + 1, txids)
-            } else {
-                left
-            };
-            // Combine subhashes
-            PartialMerkleTree::parent_hash(left, right)
-        }
-    }
-
-    /// Recursive function that traverses tree nodes, storing the data as bits and hashes
-    fn traverse_and_build(
-        &mut self,
-        height: u32,
-        pos: u32,
-        txids: &[Txid],
-        matches: &[bool],
-    ) {
-        // Determine whether this node is the parent of at least one matched txid
-        let mut parent_of_match = false;
-        let mut p = pos << height;
-        while p < (pos + 1) << height && p < self.num_transactions {
-            parent_of_match |= matches[p as usize];
-            p += 1;
-        }
-        // Store as flag bit
-        self.bits.push(parent_of_match);
-
-        if height == 0 || !parent_of_match {
-            // If at height 0, or nothing interesting below, store hash and stop
-            let hash = self.calc_hash(height, pos, txids);
-            self.hashes.push(hash.into());
-        } else {
-            // Otherwise, don't store any hash, but descend into the subtrees
-            self.traverse_and_build(height - 1, pos * 2, txids, matches);
-            if pos * 2 + 1 < self.calc_tree_width(height - 1) {
-                self.traverse_and_build(height - 1, pos * 2 + 1, txids, matches);
-            }
-        }
-    }
-
-    /// Recursive function that traverses tree nodes, consuming the bits and hashes produced by
-    /// TraverseAndBuild. It returns the hash of the respective node and its respective index.
-    fn traverse_and_extract(
-        &self,
-        height: u32,
-        pos: u32,
-        bits_used: &mut u32,
-        hash_used: &mut u32,
-        matches: &mut Vec<Txid>,
-        indexes: &mut Vec<u32>,
-    ) -> Result<TxMerkleNode, MerkleBlockError> {
-        if *bits_used as usize >= self.bits.len() {
-            return Err(BadFormat("Overflowed the bits array".to_owned()));
-        }
-        let parent_of_match = self.bits[*bits_used as usize];
-        *bits_used += 1;
-        if height == 0 || !parent_of_match {
-            // If at height 0, or nothing interesting below, use stored hash and do not descend
-            if *hash_used as usize >= self.hashes.len() {
-                return Err(BadFormat("Overflowed the hash array".to_owned()));
-            }
-            let hash = self.hashes[*hash_used as usize];
-            *hash_used += 1;
-            if height == 0 && parent_of_match {
-                // in case of height 0, we have a matched txid
-                matches.push(Txid::from_inner(hash.into_inner()));
-                indexes.push(pos);
-            }
-            Ok(hash)
-        } else {
-            // otherwise, descend into the subtrees to extract matched txids and hashes
-            let left = self.traverse_and_extract(
-                height - 1,
-                pos * 2,
-                bits_used,
-                hash_used,
-                matches,
-                indexes,
-            )?;
-            let right;
-            if pos * 2 + 1 < self.calc_tree_width(height - 1) {
-                right = self.traverse_and_extract(
-                    height - 1,
-                    pos * 2 + 1,
-                    bits_used,
-                    hash_used,
-                    matches,
-                    indexes,
-                )?;
-                if right == left {
-                    // The left and right branches should never be identical, as the transaction
-                    // hashes covered by them must each be unique.
-                    return Err(BadFormat("Found identical transaction hashes".to_owned()));
-                }
-            } else {
-                right = left;
-            }
-            // and combine them before returning
-            Ok(PartialMerkleTree::parent_hash(left, right))
-        }
-    }
-
-    /// Helper method to produce SHA256D(left + right)
-    fn parent_hash(left: TxMerkleNode, right: TxMerkleNode) -> TxMerkleNode {
-        let mut encoder = TxMerkleNode::engine();
-        left.consensus_encode(&mut encoder).unwrap();
-        right.consensus_encode(&mut encoder).unwrap();
-        TxMerkleNode::from_engine(encoder)
-    }
-}
-
-impl Encodable for PartialMerkleTree {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let ret = self.num_transactions.consensus_encode(&mut s)?
-            + self.hashes.consensus_encode(&mut s)?;
-        let mut bytes: Vec<u8> = vec![0; (self.bits.len() + 7) / 8];
-        for p in 0..self.bits.len() {
-            bytes[p / 8] |= (self.bits[p] as u8) << (p % 8) as u8;
-        }
-        Ok(ret + bytes.consensus_encode(s)?)
-    }
-}
-
-impl Decodable for PartialMerkleTree {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let num_transactions: u32 = Decodable::consensus_decode(&mut d)?;
-        let hashes: Vec<TxMerkleNode> = Decodable::consensus_decode(&mut d)?;
-
-        let bytes: Vec<u8> = Decodable::consensus_decode(d)?;
-        let mut bits: Vec<bool> = vec![false; bytes.len() * 8];
-
-        for (p, bit) in bits.iter_mut().enumerate() {
-            *bit = (bytes[p / 8] & (1 << (p % 8) as u8)) != 0;
-        }
-        Ok(PartialMerkleTree {
-            num_transactions,
-            hashes,
-            bits,
-        })
-    }
-}
-
-/// Data structure that represents a block header paired to a partial merkle tree.
-///
-/// NOTE: This assumes that the given Block has *at least* 1 transaction. If the Block has 0 txs,
-/// it will hit an assertion.
-#[derive(PartialEq, Eq, Clone, Debug)]
-pub struct MerkleBlock {
-    /// The block header
-    pub header: BlockHeader,
-    /// Transactions making up a partial merkle tree
-    pub txn: PartialMerkleTree,
-}
-
-impl MerkleBlock {
-    /// Create a MerkleBlock from a block, that should contain proofs for the txids.
-    ///
-    /// The `block` is a full block containing the header and transactions and `match_txids` is a
-    /// set containing the transaction ids that should be included in the partial merkle tree.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// extern crate bitcoin;
-    /// use bitcoin::hash_types::Txid;
-    /// use bitcoin::hashes::hex::FromHex;
-    /// use bitcoin::{Block, MerkleBlock};
-    ///
-    /// # fn main() {
-    /// // Block 80000
-    /// let block_bytes = Vec::from_hex("01000000ba8b9cda965dd8e536670f9ddec10e53aab14b20bacad2\
-    ///     7b9137190000000000190760b278fe7b8565fda3b968b918d5fd997f993b23674c0af3b6fde300b38f33\
-    ///     a5914ce6ed5b1b01e32f5702010000000100000000000000000000000000000000000000000000000000\
-    ///     00000000000000ffffffff0704e6ed5b1b014effffffff0100f2052a01000000434104b68a50eaa0287e\
-    ///     ff855189f949c1c6e5f58b37c88231373d8a59809cbae83059cc6469d65c665ccfd1cfeb75c6e8e19413\
-    ///     bba7fbff9bc762419a76d87b16086eac000000000100000001a6b97044d03da79c005b20ea9c0e1a6d9d\
-    ///     c12d9f7b91a5911c9030a439eed8f5000000004948304502206e21798a42fae0e854281abd38bacd1aee\
-    ///     d3ee3738d9e1446618c4571d1090db022100e2ac980643b0b82c0e88ffdfec6b64e3e6ba35e7ba5fdd7d\
-    ///     5d6cc8d25c6b241501ffffffff0100f2052a010000001976a914404371705fa9bd789a2fcd52d2c580b6\
-    ///     5d35549d88ac00000000").unwrap();
-    /// let block: Block = bitcoin::consensus::deserialize(&block_bytes).unwrap();
-    ///
-    /// // Create a merkle block containing a single transaction
-    /// let txid = Txid::from_hex(
-    ///     "5a4ebf66822b0b2d56bd9dc64ece0bc38ee7844a23ff1d7320a88c5fdb2ad3e2").unwrap();
-    /// let match_txids = vec![txid].into_iter().collect();
-    /// let mb = MerkleBlock::from_block(&block, &match_txids);
-    ///
-    /// // Authenticate and extract matched transaction ids
-    /// let mut matches: Vec<Txid> = vec![];
-    /// let mut index: Vec<u32> = vec![];
-    /// assert!(mb.extract_matches(&mut matches, &mut index).is_ok());
-    /// assert_eq!(txid, matches[0]);
-    /// # }
-    /// ```
-    pub fn from_block(block: &Block, match_txids: &HashSet<Txid>) -> Self {
-        let header = block.header;
-
-        let mut matches: Vec<bool> = Vec::with_capacity(block.txdata.len());
-        let mut hashes: Vec<Txid> = Vec::with_capacity(block.txdata.len());
-
-        for hash in block.txdata.iter().map(Transaction::txid) {
-            matches.push(match_txids.contains(&hash));
-            hashes.push(hash);
-        }
-
-        let pmt = PartialMerkleTree::from_txids(&hashes, &matches);
-        MerkleBlock { header, txn: pmt }
-    }
-
-    /// Extract the matching txid's represented by this partial merkle tree
-    /// and their respective indices within the partial tree.
-    /// returns Ok(()) on success, or error in case of failure
-    pub fn extract_matches(
-        &self,
-        matches: &mut Vec<Txid>,
-        indexes: &mut Vec<u32>,
-    ) -> Result<(), MerkleBlockError> {
-        let merkle_root = self.txn.extract_matches(matches, indexes)?;
-
-        if merkle_root.eq(&self.header.merkle_root) {
-            Ok(())
-        } else {
-            Err(MerkleRootMismatch)
-        }
-    }
-}
-
-impl Encodable for MerkleBlock {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let len = self.header.consensus_encode(&mut s)?
-            + self.txn.consensus_encode(s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for MerkleBlock {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        Ok(MerkleBlock {
-            header: Decodable::consensus_decode(&mut d)?,
-            txn: Decodable::consensus_decode(d)?,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::cmp::min;
-
-    use hashes::Hash;
-    use hashes::hex::{FromHex, ToHex};
-    use hash_types::{Txid, TxMerkleNode};
-    use secp256k1::rand::prelude::*;
-
-    use consensus::encode::{deserialize, serialize};
-    use util::hash::{bitcoin_merkle_root, BitcoinHash};
-    use util::merkleblock::{MerkleBlock, PartialMerkleTree};
-    use {hex, Block};
-
-    #[test]
-    fn pmt_tests() {
-        let mut rng = thread_rng();
-        let tx_counts = vec![1, 4, 7, 17, 56, 100, 127, 256, 312, 513, 1000, 4095];
-
-        for num_tx in tx_counts {
-            // Create some fake tx ids
-            let txids = (1..num_tx + 1) // change to `1..=num_tx` when min Rust >= 1.26.0
-                .map(|i| Txid::from_hex(&format!("{:064x}", i)).unwrap())
-                .collect::<Vec<_>>();
-
-            // Calculate the merkle root and height
-            let hashes = txids.iter().map(|t| t.as_hash());
-            let merkle_root_1: TxMerkleNode = bitcoin_merkle_root(hashes).into();
-            let mut height = 1;
-            let mut ntx = num_tx;
-            while ntx > 1 {
-                ntx = (ntx + 1) / 2;
-                height += 1;
-            }
-
-            // Check with random subsets with inclusion chances 1, 1/2, 1/4, ..., 1/128
-            for att in 1..15 {
-                let mut matches = vec![false; num_tx];
-                let mut match_txid1 = vec![];
-                for j in 0..num_tx {
-                    // Generate `att / 2` random bits
-                    let rand_bits = match att / 2 {
-                        0 => 0,
-                        bits => rng.gen::<u64>() >> (64 - bits),
-                    };
-                    let include = rand_bits == 0;
-                    matches[j] = include;
-
-                    if include {
-                        match_txid1.push(txids[j]);
-                    };
-                }
-
-                // Build the partial merkle tree
-                let pmt1 = PartialMerkleTree::from_txids(&txids, &matches);
-                let serialized = serialize(&pmt1);
-
-                // Verify PartialMerkleTree's size guarantees
-                let n = min(num_tx, 1 + match_txid1.len() * height);
-                assert!(serialized.len() <= 10 + (258 * n + 7) / 8);
-
-                // Deserialize into a tester copy
-                let pmt2: PartialMerkleTree =
-                    deserialize(&serialized).expect("Could not deserialize own data");
-
-                // Extract merkle root and matched txids from copy
-                let mut match_txid2: Vec<Txid> = vec![];
-                let mut indexes = vec![];
-                let merkle_root_2 = pmt2
-                    .extract_matches(&mut match_txid2, &mut indexes)
-                    .expect("Could not extract matches");
-
-                // Check that it has the same merkle root as the original, and a valid one
-                assert_eq!(merkle_root_1, merkle_root_2);
-                assert_ne!(merkle_root_2, TxMerkleNode::default());
-
-                // check that it contains the matched transactions (in the same order!)
-                assert_eq!(match_txid1, match_txid2);
-
-                // check that random bit flips break the authentication
-                for _ in 0..4 {
-                    let mut pmt3: PartialMerkleTree = deserialize(&serialized).unwrap();
-                    pmt3.damage(&mut rng);
-                    let mut match_txid3 = vec![];
-                    let merkle_root_3 = pmt3
-                        .extract_matches(&mut match_txid3, &mut indexes)
-                        .unwrap();
-                    assert_ne!(merkle_root_3, merkle_root_1);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn pmt_malleability() {
-        // Create some fake tx ids with the last 2 hashes repeating
-        let txids: Vec<Txid> = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 10]
-            .iter()
-            .map(|i| Txid::from_hex(&format!("{:064x}", i)).unwrap())
-            .collect();
-
-        let matches = vec![
-            false, false, false, false, false, false, false, false, false, true, true, false,
-        ];
-
-        let tree = PartialMerkleTree::from_txids(&txids, &matches);
-        // Should fail due to duplicate txs found
-        let result = tree.extract_matches(&mut vec![], &mut vec![]);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn merkleblock_serialization() {
-        // Got it by running the rpc call
-        // `gettxoutproof '["220ebc64e21abece964927322cba69180ed853bb187fbc6923bac7d010b9d87a"]'`
-        let mb_hex =
-            "0100000090f0a9f110702f808219ebea1173056042a714bad51b916cb6800000000000005275289558f51c\
-            9966699404ae2294730c3c9f9bda53523ce50e9b95e558da2fdb261b4d4c86041b1ab1bf930900000005fac\
-            7708a6e81b2a986dea60db2663840ed141130848162eb1bd1dee54f309a1b2ee1e12587e497ada70d9bd10d\
-            31e83f0a924825b96cb8d04e8936d793fb60db7ad8b910d0c7ba2369bc7f18bb53d80e1869ba2c32274996c\
-            ebe1ae264bc0e2289189ff0316cdc10511da71da757e553cada9f3b5b1434f3923673adb57d83caac392c38\
-            af156d6fc30b55fad4112df2b95531e68114e9ad10011e72f7b7cfdb025700";
-
-        let mb: MerkleBlock = deserialize(&hex::decode(mb_hex).unwrap()).unwrap();
-        assert_eq!(get_block_13b8a().bitcoin_hash(), mb.header.bitcoin_hash());
-        assert_eq!(
-            mb.header.merkle_root,
-            mb.txn.extract_matches(&mut vec![], &mut vec![]).unwrap()
-        );
-        // Serialize again and check that it matches the original bytes
-        assert_eq!(mb_hex, serialize(&mb).to_hex().as_str());
-    }
-
-    /// Create a CMerkleBlock using a list of txids which will be found in the
-    /// given block.
-    #[test]
-    fn merkleblock_construct_from_txids_found() {
-        let block = get_block_13b8a();
-
-        let txids: Vec<Txid> = [
-            "74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20",
-            "f9fc751cb7dc372406a9f8d738d5e6f8f63bab71986a39cf36ee70ee17036d07",
-        ]
-        .iter()
-        .map(|hex| Txid::from_hex(hex).unwrap())
-        .collect();
-
-        let txid1 = txids[0];
-        let txid2 = txids[1];
-        let txids = txids.into_iter().collect();
-
-        let merkle_block = MerkleBlock::from_block(&block, &txids);
-
-        assert_eq!(merkle_block.header.bitcoin_hash(), block.bitcoin_hash());
-
-        let mut matches: Vec<Txid> = vec![];
-        let mut index: Vec<u32> = vec![];
-
-        assert_eq!(
-            merkle_block
-                .txn
-                .extract_matches(&mut matches, &mut index)
-                .unwrap(),
-            block.header.merkle_root
-        );
-        assert_eq!(matches.len(), 2);
-
-        // Ordered by occurrence in depth-first tree traversal.
-        assert_eq!(matches[0], txid2);
-        assert_eq!(index[0], 1);
-
-        assert_eq!(matches[1], txid1);
-        assert_eq!(index[1], 8);
-    }
-
-    /// Create a CMerkleBlock using a list of txids which will not be found in the given block
-    #[test]
-    fn merkleblock_construct_from_txids_not_found() {
-        let block = get_block_13b8a();
-        let txids = ["c0ffee00003bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"]
-            .iter()
-            .map(|hex| Txid::from_hex(hex).unwrap())
-            .collect();
-
-        let merkle_block = MerkleBlock::from_block(&block, &txids);
-
-        assert_eq!(merkle_block.header.bitcoin_hash(), block.bitcoin_hash());
-
-        let mut matches: Vec<Txid> = vec![];
-        let mut index: Vec<u32> = vec![];
-
-        assert_eq!(
-            merkle_block
-                .txn
-                .extract_matches(&mut matches, &mut index)
-                .unwrap(),
-            block.header.merkle_root
-        );
-        assert_eq!(matches.len(), 0);
-        assert_eq!(index.len(), 0);
-    }
-
-    impl PartialMerkleTree {
-        /// Flip one bit in one of the hashes - this should break the authentication
-        fn damage(&mut self, rng: &mut ThreadRng) {
-            let n = rng.gen_range(0, self.hashes.len());
-            let bit = rng.gen::<u8>();
-            let hashes = &mut self.hashes;
-            let mut hash = hashes[n].into_inner();
-            hash[(bit >> 3) as usize] ^= 1 << (bit & 7);
-            hashes[n] = TxMerkleNode::from_slice(&hash).unwrap();
-        }
-    }
-
-    /// Returns a real block (0000000000013b8ab2cd513b0261a14096412195a72a0c4827d229dcc7e0f7af)
-    /// with 9 txs.
-    fn get_block_13b8a() -> Block {
-        let block_hex =
-            "0100000090f0a9f110702f808219ebea1173056042a714bad51b916cb6800000000000005275289558f51c\
-            9966699404ae2294730c3c9f9bda53523ce50e9b95e558da2fdb261b4d4c86041b1ab1bf930901000000010\
-            000000000000000000000000000000000000000000000000000000000000000ffffffff07044c86041b0146\
-            ffffffff0100f2052a01000000434104e18f7afbe4721580e81e8414fc8c24d7cfacf254bb5c7b949450c3e\
-            997c2dc1242487a8169507b631eb3771f2b425483fb13102c4eb5d858eef260fe70fbfae0ac000000000100\
-            00000196608ccbafa16abada902780da4dc35dafd7af05fa0da08cf833575f8cf9e836000000004a4930460\
-            22100dab24889213caf43ae6adc41cf1c9396c08240c199f5225acf45416330fd7dbd022100fe37900e0644\
-            bf574493a07fc5edba06dbc07c311b947520c2d514bc5725dcb401ffffffff0100f2052a010000001976a91\
-            4f15d1921f52e4007b146dfa60f369ed2fc393ce288ac000000000100000001fb766c1288458c2bafcfec81\
-            e48b24d98ec706de6b8af7c4e3c29419bfacb56d000000008c493046022100f268ba165ce0ad2e6d93f089c\
-            fcd3785de5c963bb5ea6b8c1b23f1ce3e517b9f022100da7c0f21adc6c401887f2bfd1922f11d76159cbc59\
-            7fbd756a23dcbb00f4d7290141042b4e8625a96127826915a5b109852636ad0da753c9e1d5606a50480cd0c\
-            40f1f8b8d898235e571fe9357d9ec842bc4bba1827daaf4de06d71844d0057707966affffffff0280969800\
-            000000001976a9146963907531db72d0ed1a0cfb471ccb63923446f388ac80d6e34c000000001976a914f06\
-            88ba1c0d1ce182c7af6741e02658c7d4dfcd388ac000000000100000002c40297f730dd7b5a99567eb8d27b\
-            78758f607507c52292d02d4031895b52f2ff010000008b483045022100f7edfd4b0aac404e5bab4fd3889e0\
-            c6c41aa8d0e6fa122316f68eddd0a65013902205b09cc8b2d56e1cd1f7f2fafd60a129ed94504c4ac7bdc67\
-            b56fe67512658b3e014104732012cb962afa90d31b25d8fb0e32c94e513ab7a17805c14ca4c3423e18b4fb5\
-            d0e676841733cb83abaf975845c9f6f2a8097b7d04f4908b18368d6fc2d68ecffffffffca5065ff9617cbcb\
-            a45eb23726df6498a9b9cafed4f54cbab9d227b0035ddefb000000008a473044022068010362a13c7f9919f\
-            a832b2dee4e788f61f6f5d344a7c2a0da6ae740605658022006d1af525b9a14a35c003b78b72bd59738cd67\
-            6f845d1ff3fc25049e01003614014104732012cb962afa90d31b25d8fb0e32c94e513ab7a17805c14ca4c34\
-            23e18b4fb5d0e676841733cb83abaf975845c9f6f2a8097b7d04f4908b18368d6fc2d68ecffffffff01001e\
-            c4110200000043410469ab4181eceb28985b9b4e895c13fa5e68d85761b7eee311db5addef76fa862186513\
-            4a221bd01f28ec9999ee3e021e60766e9d1f3458c115fb28650605f11c9ac000000000100000001cdaf2f75\
-            8e91c514655e2dc50633d1e4c84989f8aa90a0dbc883f0d23ed5c2fa010000008b48304502207ab51be6f12\
-            a1962ba0aaaf24a20e0b69b27a94fac5adf45aa7d2d18ffd9236102210086ae728b370e5329eead9accd880\
-            d0cb070aea0c96255fae6c4f1ddcce1fd56e014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf3\
-            3d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffff\
-            ffff02404b4c00000000001976a9142b6ba7c9d796b75eef7942fc9288edd37c32f5c388ac002d310100000\
-            0001976a9141befba0cdc1ad56529371864d9f6cb042faa06b588ac000000000100000001b4a47603e71b61\
-            bc3326efd90111bf02d2f549b067f4c4a8fa183b57a0f800cb010000008a4730440220177c37f9a505c3f1a\
-            1f0ce2da777c339bd8339ffa02c7cb41f0a5804f473c9230220585b25a2ee80eb59292e52b987dad92acb0c\
-            64eced92ed9ee105ad153cdb12d001410443bd44f683467e549dae7d20d1d79cbdb6df985c6e9c029c8d0c6\
-            cb46cc1a4d3cf7923c5021b27f7a0b562ada113bc85d5fda5a1b41e87fe6e8802817cf69996ffffffff0280\
-            651406000000001976a9145505614859643ab7b547cd7f1f5e7e2a12322d3788ac00aa0271000000001976a\
-            914ea4720a7a52fc166c55ff2298e07baf70ae67e1b88ac00000000010000000586c62cd602d219bb60edb1\
-            4a3e204de0705176f9022fe49a538054fb14abb49e010000008c493046022100f2bc2aba2534becbdf062eb\
-            993853a42bbbc282083d0daf9b4b585bd401aa8c9022100b1d7fd7ee0b95600db8535bbf331b19eed8d961f\
-            7a8e54159c53675d5f69df8c014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf33d789904f07d\
-            0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff03ad0e58\
-            ccdac3df9dc28a218bcf6f1997b0a93306faaa4b3a28ae83447b2179010000008b483045022100be12b2937\
-            179da88599e27bb31c3525097a07cdb52422d165b3ca2f2020ffcf702200971b51f853a53d644ebae9ec8f3\
-            512e442b1bcb6c315a5b491d119d10624c83014104462e76fd4067b3a0aa42070082dcb0bf2f388b6495cf3\
-            3d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8ebbb12dcd4ffff\
-            ffff2acfcab629bbc8685792603762c921580030ba144af553d271716a95089e107b010000008b483045022\
-            100fa579a840ac258871365dd48cd7552f96c8eea69bd00d84f05b283a0dab311e102207e3c0ee9234814cf\
-            bb1b659b83671618f45abc1326b9edcc77d552a4f2a805c0014104462e76fd4067b3a0aa42070082dcb0bf2\
-            f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15312ef1c0e8eb\
-            bb12dcd4ffffffffdcdc6023bbc9944a658ddc588e61eacb737ddf0a3cd24f113b5a8634c517fcd20000000\
-            08b4830450221008d6df731df5d32267954bd7d2dda2302b74c6c2a6aa5c0ca64ecbabc1af03c75022010e5\
-            5c571d65da7701ae2da1956c442df81bbf076cdbac25133f99d98a9ed34c014104462e76fd4067b3a0aa420\
-            70082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812b1d5fbcade15\
-            312ef1c0e8ebbb12dcd4ffffffffe15557cd5ce258f479dfd6dc6514edf6d7ed5b21fcfa4a038fd69f06b83\
-            ac76e010000008b483045022023b3e0ab071eb11de2eb1cc3a67261b866f86bf6867d4558165f7c8c8aca2d\
-            86022100dc6e1f53a91de3efe8f63512850811f26284b62f850c70ca73ed5de8771fb451014104462e76fd4\
-            067b3a0aa42070082dcb0bf2f388b6495cf33d789904f07d0f55c40fbd4b82963c69b3dc31895d0c772c812\
-            b1d5fbcade15312ef1c0e8ebbb12dcd4ffffffff01404b4c00000000001976a9142b6ba7c9d796b75eef794\
-            2fc9288edd37c32f5c388ac00000000010000000166d7577163c932b4f9690ca6a80b6e4eb001f0a2fa9023\
-            df5595602aae96ed8d000000008a4730440220262b42546302dfb654a229cefc86432b89628ff259dc87edd\
-            1154535b16a67e102207b4634c020a97c3e7bbd0d4d19da6aa2269ad9dded4026e896b213d73ca4b63f0141\
-            04979b82d02226b3a4597523845754d44f13639e3bf2df5e82c6aab2bdc79687368b01b1ab8b19875ae3c90\
-            d661a3d0a33161dab29934edeb36aa01976be3baf8affffffff02404b4c00000000001976a9144854e695a0\
-            2af0aeacb823ccbc272134561e0a1688ac40420f00000000001976a914abee93376d6b37b5c2940655a6fca\
-            f1c8e74237988ac0000000001000000014e3f8ef2e91349a9059cb4f01e54ab2597c1387161d3da89919f7e\
-            a6acdbb371010000008c49304602210081f3183471a5ca22307c0800226f3ef9c353069e0773ac76bb58065\
-            4d56aa523022100d4c56465bdc069060846f4fbf2f6b20520b2a80b08b168b31e66ddb9c694e24001410497\
-            6c79848e18251612f8940875b2b08d06e6dc73b9840e8860c066b7e87432c477e9a59a453e71e6d76d5fe34\
-            058b800a098fc1740ce3012e8fc8a00c96af966ffffffff02c0e1e400000000001976a9144134e75a6fcb60\
-            42034aab5e18570cf1f844f54788ac404b4c00000000001976a9142b6ba7c9d796b75eef7942fc9288edd37\
-            c32f5c388ac00000000";
-        deserialize(&hex::decode(block_hex).unwrap()).unwrap()
-    }
-}
diff --git a/src/util/misc.rs b/src/util/misc.rs
deleted file mode 100644
index f5c2a545..00000000
--- a/src/util/misc.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Miscellaneous functions
-//!
-//! Various utility functions
-
-use hashes::{sha256d, Hash};
-use blockdata::opcodes;
-use consensus::encode;
-
-static MSG_SIGN_PREFIX: &'static [u8] = b"\x18Bitcoin Signed Message:\n";
-
-/// Search for `needle` in the vector `haystack` and remove every
-/// instance of it, returning the number of instances removed.
-/// Loops through the vector opcode by opcode, skipping pushed data.
-pub fn script_find_and_remove(haystack: &mut Vec<u8>, needle: &[u8]) -> usize {
-    if needle.len() > haystack.len() { return 0; }
-    if needle.len() == 0 { return 0; }
-
-    let mut top = haystack.len() - needle.len();
-    let mut n_deleted = 0;
-
-    let mut i = 0;
-    while i <= top {
-        if &haystack[i..(i + needle.len())] == needle {
-            for j in i..top {
-                haystack.swap(j + needle.len(), j);
-            }
-            n_deleted += 1;
-            // This is ugly but prevents infinite loop in case of overflow
-            let overflow = top < needle.len();
-            top = top.wrapping_sub(needle.len());
-            if overflow { break; }
-        } else {
-            i += match opcodes::All::from((*haystack)[i]).classify() {
-                opcodes::Class::PushBytes(n) => n as usize + 1,
-                opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA1) => 2,
-                opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA2) => 3,
-                opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA4) => 5,
-                _ => 1
-            };
-        }
-    }
-    haystack.truncate(top.wrapping_add(needle.len()));
-    n_deleted
-}
-
-/// Hash message for signature using Bitcoin's message signing format
-pub fn signed_msg_hash(msg: &str) -> sha256d::Hash {
-    sha256d::Hash::hash(
-        &[
-            MSG_SIGN_PREFIX,
-            &encode::serialize(&encode::VarInt(msg.len() as u64)),
-            msg.as_bytes(),
-        ]
-        .concat(),
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use hashes::hex::ToHex;
-    use super::script_find_and_remove;
-    use super::signed_msg_hash;
-
-    #[test]
-    fn test_script_find_and_remove() {
-        let mut v = vec![101u8, 102, 103, 104, 102, 103, 104, 102, 103, 104, 105, 106, 107, 108, 109];
-
-        assert_eq!(script_find_and_remove(&mut v, &[]), 0);
-        assert_eq!(script_find_and_remove(&mut v, &[105, 105, 105]), 0);
-        assert_eq!(v, vec![101, 102, 103, 104, 102, 103, 104, 102, 103, 104, 105, 106, 107, 108, 109]);
-
-        assert_eq!(script_find_and_remove(&mut v, &[105, 106, 107]), 1);
-        assert_eq!(v, vec![101, 102, 103, 104, 102, 103, 104, 102, 103, 104, 108, 109]);
-
-        assert_eq!(script_find_and_remove(&mut v, &[104, 108, 109]), 1);
-        assert_eq!(v, vec![101, 102, 103, 104, 102, 103, 104, 102, 103]);
-
-        assert_eq!(script_find_and_remove(&mut v, &[101]), 1);
-        assert_eq!(v, vec![102, 103, 104, 102, 103, 104, 102, 103]);
-
-        assert_eq!(script_find_and_remove(&mut v, &[102]), 3);
-        assert_eq!(v, vec![103, 104, 103, 104, 103]);
-
-        assert_eq!(script_find_and_remove(&mut v, &[103, 104]), 2);
-        assert_eq!(v, vec![103]);
-
-        assert_eq!(script_find_and_remove(&mut v, &[105, 105, 5]), 0);
-        assert_eq!(script_find_and_remove(&mut v, &[105]), 0);
-        assert_eq!(script_find_and_remove(&mut v, &[103]), 1);
-        assert_eq!(v, Vec::<u8>::new());
-
-        assert_eq!(script_find_and_remove(&mut v, &[105, 105, 5]), 0);
-        assert_eq!(script_find_and_remove(&mut v, &[105]), 0);
-    }
-
-    #[test]
-    fn test_script_codesep_remove() {
-        let mut s = vec![33u8, 3, 132, 121, 160, 250, 153, 140, 211, 82, 89, 162, 239, 10, 122, 92, 104, 102, 44, 20, 116, 248, 140, 203, 109, 8, 167, 103, 123, 190, 199, 242, 32, 65, 173, 171, 33, 3, 132, 121, 160, 250, 153, 140, 211, 82, 89, 162, 239, 10, 122, 92, 104, 102, 44, 20, 116, 248, 140, 203, 109, 8, 167, 103, 123, 190, 199, 242, 32, 65, 173, 171, 81];
-        assert_eq!(script_find_and_remove(&mut s, &[171]), 2);
-        assert_eq!(s, vec![33, 3, 132, 121, 160, 250, 153, 140, 211, 82, 89, 162, 239, 10, 122, 92, 104, 102, 44, 20, 116, 248, 140, 203, 109, 8, 167, 103, 123, 190, 199, 242, 32, 65, 173, 33, 3, 132, 121, 160, 250, 153, 140, 211, 82, 89, 162, 239, 10, 122, 92, 104, 102, 44, 20, 116, 248, 140, 203, 109, 8, 167, 103, 123, 190, 199, 242, 32, 65, 173, 81]);
-    }
-
-    #[test]
-    fn test_signed_msg_hash() {
-        let hash = signed_msg_hash("test");
-        assert_eq!(hash.to_hex(), "a6f87fe6d58a032c320ff8d1541656f0282c2c7bfcc69d61af4c8e8ed528e49c");
-    }
-}
-
diff --git a/src/util/mod.rs b/src/util/mod.rs
deleted file mode 100644
index 36ebc5ee..00000000
--- a/src/util/mod.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Utility functions
-//!
-//! Functions needed by all parts of the Bitcoin library
-
-pub mod key;
-pub mod address;
-pub mod amount;
-pub mod base58;
-pub mod bip32;
-pub mod bip143;
-pub mod contracthash;
-pub mod hash;
-pub mod merkleblock;
-pub mod misc;
-pub mod psbt;
-pub mod uint;
-pub mod bip158;
-
-pub(crate) mod endian;
-
-use std::{error, fmt};
-
-use network;
-use consensus::encode;
-
-/// A trait which allows numbers to act as fixed-size bit arrays
-pub trait BitArray {
-    /// Is bit set?
-    fn bit(&self, idx: usize) -> bool;
-
-    /// Returns an array which is just the bits from start to end
-    fn bit_slice(&self, start: usize, end: usize) -> Self;
-
-    /// Bitwise and with `n` ones
-    fn mask(&self, n: usize) -> Self;
-
-    /// Trailing zeros
-    fn trailing_zeros(&self) -> usize;
-
-    /// Create all-zeros value
-    fn zero() -> Self;
-
-    /// Create value representing one
-    fn one() -> Self;
-}
-
-/// A general error code, other errors should implement conversions to/from this
-/// if appropriate.
-#[derive(Debug)]
-pub enum Error {
-    /// Encoding error
-    Encode(encode::Error),
-    /// Network error
-    Network(network::Error),
-    /// The header hash is not below the target
-    BlockBadProofOfWork,
-    /// The `target` field of a block header did not match the expected difficulty
-    BlockBadTarget,
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::Encode(ref e) => fmt::Display::fmt(e, f),
-            Error::Network(ref e) => fmt::Display::fmt(e, f),
-            Error::BlockBadProofOfWork | Error::BlockBadTarget => f.write_str(error::Error::description(self)),
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::Encode(ref e) => Some(e),
-            Error::Network(ref e) => Some(e),
-            Error::BlockBadProofOfWork | Error::BlockBadTarget => None
-        }
-    }
-
-    fn description(&self) -> &str {
-        match *self {
-            Error::Encode(ref e) => e.description(),
-            Error::Network(ref e) => e.description(),
-            Error::BlockBadProofOfWork => "block target correct but not attained",
-            Error::BlockBadTarget => "block target incorrect",
-        }
-    }
-}
-
-#[doc(hidden)]
-impl From<encode::Error> for Error {
-    fn from(e: encode::Error) -> Error {
-        Error::Encode(e)
-    }
-}
-
-#[doc(hidden)]
-impl From<network::Error> for Error {
-    fn from(e: network::Error) -> Error {
-        Error::Network(e)
-    }
-}
diff --git a/src/util/psbt/error.rs b/src/util/psbt/error.rs
deleted file mode 100644
index 1f3cb928..00000000
--- a/src/util/psbt/error.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-use std::error;
-use std::fmt;
-
-use blockdata::transaction::Transaction;
-use util::psbt::raw;
-
-/// Ways that a Partially Signed Transaction might fail.
-#[derive(Debug)]
-pub enum Error {
-    /// Magic bytes for a PSBT must be the ASCII for "psbt" serialized in most
-    /// significant byte order.
-    InvalidMagic,
-    /// The separator for a PSBT must be `0xff`.
-    InvalidSeparator,
-    /// Known keys must be according to spec.
-    InvalidKey(raw::Key),
-    /// Keys within key-value map should never be duplicated.
-    DuplicateKey(raw::Key),
-    /// The scriptSigs for the unsigned transaction must be empty.
-    UnsignedTxHasScriptSigs,
-    /// The scriptWitnesses for the unsigned transaction must be empty.
-    UnsignedTxHasScriptWitnesses,
-    /// A PSBT 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 PSBT describing a different unsigned
-    /// transaction.
-    UnexpectedUnsignedTx {
-        /// Expected
-        expected: Transaction,
-        /// Actual
-        actual: Transaction,
-    },
-    /// Unable to parse as a standard SigHash type.
-    NonStandardSigHashType(u32),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::InvalidKey(ref rkey) => write!(f, "{}: {}", error::Error::description(self), rkey),
-            Error::DuplicateKey(ref rkey) => write!(f, "{}: {}", error::Error::description(self), rkey),
-            Error::UnexpectedUnsignedTx { expected: ref e, actual: ref a } => write!(f, "{}: expected {}, actual {}", error::Error::description(self), e.txid(), a.txid()),
-            Error::NonStandardSigHashType(ref sht) => write!(f, "{}: {}", error::Error::description(self), sht),
-            Error::InvalidMagic
-            | Error::InvalidSeparator
-            | Error::UnsignedTxHasScriptSigs
-            | Error::UnsignedTxHasScriptWitnesses
-            | Error::MustHaveUnsignedTx
-            | Error::NoMorePairs => f.write_str(error::Error::description(self))
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::InvalidMagic => "invalid magic",
-            Error::InvalidSeparator => "invalid separator",
-            Error::InvalidKey(..) => "invalid key",
-            Error::DuplicateKey(..) => "duplicate key",
-            Error::UnsignedTxHasScriptSigs => "the unsigned transaction has script sigs",
-            Error::UnsignedTxHasScriptWitnesses => "the unsigned transaction has script witnesses",
-            Error::MustHaveUnsignedTx => {
-                "partially signed transactions must have an unsigned transaction"
-            }
-            Error::NoMorePairs => "no more key-value pairs for this psbt map",
-            Error::UnexpectedUnsignedTx { .. } => "different unsigned transaction",
-            Error::NonStandardSigHashType(..) =>  "non-standard sighash type",
-        }
-    }
-}
diff --git a/src/util/psbt/macros.rs b/src/util/psbt/macros.rs
deleted file mode 100644
index 020f1ff6..00000000
--- a/src/util/psbt/macros.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-#[allow(unused_macros)]
-macro_rules! hex_psbt {
-    ($s:expr) => { ::consensus::deserialize(&::hex::decode($s).unwrap()) };
-}
-
-macro_rules! merge {
-    ($thing:ident, $slf:ident, $other:ident) => {
-        if let (&None, Some($thing)) = (&$slf.$thing, $other.$thing) {
-            $slf.$thing = Some($thing);
-        }
-    };
-}
-
-macro_rules! impl_psbt_de_serialize {
-    ($thing:ty) => {
-        impl_psbt_serialize!($thing);
-        impl_psbt_deserialize!($thing);
-    };
-}
-
-macro_rules! impl_psbt_deserialize {
-    ($thing:ty) => {
-        impl ::util::psbt::serialize::Deserialize for $thing {
-            fn deserialize(bytes: &[u8]) -> Result<Self, ::consensus::encode::Error> {
-                ::consensus::deserialize(&bytes[..])
-            }
-        }
-    };
-}
-
-macro_rules! impl_psbt_serialize {
-    ($thing:ty) => {
-        impl ::util::psbt::serialize::Serialize for $thing {
-            fn serialize(&self) -> Vec<u8> {
-                ::consensus::serialize(self)
-            }
-        }
-    };
-}
-
-macro_rules! impl_psbtmap_consensus_encoding {
-    ($thing:ty) => {
-        impl ::consensus::Encodable for $thing {
-            fn consensus_encode<S: ::std::io::Write>(
-                &self,
-                mut s: S,
-            ) -> Result<usize, ::consensus::encode::Error> {
-                let mut len = 0;
-                for pair in ::util::psbt::Map::get_pairs(self)? {
-                    len += ::consensus::Encodable::consensus_encode(
-                        &pair,
-                        &mut s,
-                    )?;
-                }
-
-                Ok(len + ::consensus::Encodable::consensus_encode(&0x00_u8, s)?)
-            }
-        }
-    };
-}
-
-macro_rules! impl_psbtmap_consensus_decoding {
-    ($thing:ty) => {
-        impl ::consensus::Decodable for $thing {
-            fn consensus_decode<D: ::std::io::Read>(
-                mut d: D,
-            ) -> Result<Self, ::consensus::encode::Error> {
-                let mut rv: Self = ::std::default::Default::default();
-
-                loop {
-                    match ::consensus::Decodable::consensus_decode(&mut d) {
-                        Ok(pair) => ::util::psbt::Map::insert_pair(&mut rv, pair)?,
-                        Err(::consensus::encode::Error::Psbt(::util::psbt::Error::NoMorePairs)) => return Ok(rv),
-                        Err(e) => return Err(e),
-                    }
-                }
-            }
-        }
-    };
-}
-
-macro_rules! impl_psbtmap_consensus_enc_dec_oding {
-    ($thing:ty) => {
-        impl_psbtmap_consensus_decoding!($thing);
-        impl_psbtmap_consensus_encoding!($thing);
-    };
-}
-
-#[cfg_attr(rustfmt, rustfmt_skip)]
-macro_rules! impl_psbt_insert_pair {
-    ($slf:ident.$unkeyed_name:ident <= <$raw_key:ident: _>|<$raw_value:ident: $unkeyed_value_type:ty>) => {
-        if $raw_key.key.is_empty() {
-            if let None = $slf.$unkeyed_name {
-                let val: $unkeyed_value_type = ::util::psbt::serialize::Deserialize::deserialize(&$raw_value)?;
-
-                $slf.$unkeyed_name = Some(val)
-            } else {
-                return Err(::util::psbt::Error::DuplicateKey($raw_key).into());
-            }
-        } else {
-            return Err(::util::psbt::Error::InvalidKey($raw_key).into());
-        }
-    };
-    ($slf:ident.$keyed_name:ident <= <$raw_key:ident: $keyed_key_type:ty>|<$raw_value:ident: $keyed_value_type:ty>) => {
-        if !$raw_key.key.is_empty() {
-            let key_val: $keyed_key_type = ::util::psbt::serialize::Deserialize::deserialize(&$raw_key.key)?;
-
-            if $slf.$keyed_name.contains_key(&key_val) {
-                return Err(::util::psbt::Error::DuplicateKey($raw_key).into());
-            } else {
-                let val: $keyed_value_type = ::util::psbt::serialize::Deserialize::deserialize(&$raw_value)?;
-
-                $slf.$keyed_name.insert(key_val, val);
-            }
-        } else {
-            return Err(::util::psbt::Error::InvalidKey($raw_key).into());
-        }
-    };
-}
-
-#[cfg_attr(rustfmt, rustfmt_skip)]
-macro_rules! impl_psbt_get_pair {
-    ($rv:ident.push($slf:ident.$unkeyed_name:ident as <$unkeyed_typeval:expr, _>|<$unkeyed_value_type:ty>)) => {
-        if let Some(ref $unkeyed_name) = $slf.$unkeyed_name {
-            $rv.push(::util::psbt::raw::Pair {
-                key: ::util::psbt::raw::Key {
-                    type_value: $unkeyed_typeval,
-                    key: vec![],
-                },
-                value: ::util::psbt::serialize::Serialize::serialize($unkeyed_name),
-            });
-        }
-    };
-    ($rv:ident.push($slf:ident.$keyed_name:ident as <$keyed_typeval:expr, $keyed_key_type:ty>|<$keyed_value_type:ty>)) => {
-        for (key, val) in &$slf.$keyed_name {
-            $rv.push(::util::psbt::raw::Pair {
-                key: ::util::psbt::raw::Key {
-                    type_value: $keyed_typeval,
-                    key: ::util::psbt::serialize::Serialize::serialize(key),
-                },
-                value: ::util::psbt::serialize::Serialize::serialize(val),
-            });
-        }
-    };
-}
diff --git a/src/util/psbt/map/global.rs b/src/util/psbt/map/global.rs
deleted file mode 100644
index b34b4114..00000000
--- a/src/util/psbt/map/global.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-use std::collections::BTreeMap;
-use std::io::{self, Cursor};
-
-use blockdata::transaction::Transaction;
-use consensus::{encode, Encodable, Decodable};
-use util::psbt::map::Map;
-use util::psbt::raw;
-use util::psbt;
-use util::psbt::Error;
-
-/// A key-value map for global data.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Global {
-    /// The unsigned transaction, scriptSigs and witnesses for each input must be
-    /// empty.
-    pub unsigned_tx: Transaction,
-    /// Unknown global key-value pairs.
-    pub unknown: BTreeMap<raw::Key, Vec<u8>>,
-}
-
-impl Global {
-    /// Create a Global from an unsigned transaction, error if not unsigned
-    pub fn from_unsigned_tx(tx: Transaction) -> Result<Self, psbt::Error> {
-        for txin in &tx.input {
-            if !txin.script_sig.is_empty() {
-                return Err(Error::UnsignedTxHasScriptSigs);
-            }
-
-            if !txin.witness.is_empty() {
-                return Err(Error::UnsignedTxHasScriptWitnesses);
-            }
-        }
-
-        Ok(Global {
-            unsigned_tx: tx,
-            unknown: Default::default(),
-        })
-    }
-}
-
-impl Map for Global {
-    fn insert_pair(&mut self, pair: raw::Pair) -> Result<(), encode::Error> {
-        let raw::Pair {
-            key: raw_key,
-            value: raw_value,
-        } = pair;
-
-        match raw_key.type_value {
-            0u8 => {
-                return Err(Error::DuplicateKey(raw_key).into());
-            }
-            _ => {
-                if self.unknown.contains_key(&raw_key) {
-                    return Err(Error::DuplicateKey(raw_key).into());
-                } else {
-                    self.unknown.insert(raw_key, raw_value);
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    fn get_pairs(&self) -> Result<Vec<raw::Pair>, encode::Error> {
-        let mut rv: Vec<raw::Pair> = Default::default();
-
-        rv.push(raw::Pair {
-            key: raw::Key {
-                type_value: 0u8,
-                key: vec![],
-            },
-            value: {
-                // Manually serialized to ensure 0-input txs are serialized
-                // without witnesses.
-                let mut ret = Vec::new();
-                self.unsigned_tx.version.consensus_encode(&mut ret)?;
-                self.unsigned_tx.input.consensus_encode(&mut ret)?;
-                self.unsigned_tx.output.consensus_encode(&mut ret)?;
-                self.unsigned_tx.lock_time.consensus_encode(&mut ret)?;
-                ret
-            },
-        });
-
-        for (key, value) in self.unknown.iter() {
-            rv.push(raw::Pair {
-                key: key.clone(),
-                value: value.clone(),
-            });
-        }
-
-        Ok(rv)
-    }
-
-    fn merge(&mut self, other: Self) -> Result<(), psbt::Error> {
-        if self.unsigned_tx != other.unsigned_tx {
-            return Err(psbt::Error::UnexpectedUnsignedTx {
-                expected: self.unsigned_tx.clone(),
-                actual: other.unsigned_tx,
-            });
-        }
-
-        self.unknown.extend(other.unknown);
-        Ok(())
-    }
-}
-
-impl_psbtmap_consensus_encoding!(Global);
-
-impl Decodable for Global {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-
-        let mut tx: Option<Transaction> = None;
-        let mut unknowns: BTreeMap<raw::Key, Vec<u8>> = Default::default();
-
-        loop {
-            match raw::Pair::consensus_decode(&mut d) {
-                Ok(pair) => {
-                    match pair.key.type_value {
-                        0u8 => {
-                            // key has to be empty
-                            if pair.key.key.is_empty() {
-                                // there can only be one unsigned transaction
-                                if tx.is_none() {
-                                    let vlen: usize = pair.value.len();
-                                    let mut decoder = Cursor::new(pair.value);
-
-                                    // Manually deserialized to ensure 0-input
-                                    // txs without witnesses are deserialized
-                                    // properly.
-                                    tx = Some(Transaction {
-                                        version: Decodable::consensus_decode(&mut decoder)?,
-                                        input: Decodable::consensus_decode(&mut decoder)?,
-                                        output: Decodable::consensus_decode(&mut decoder)?,
-                                        lock_time: Decodable::consensus_decode(&mut decoder)?,
-                                    });
-
-                                    if decoder.position() != vlen as u64 {
-                                        return Err(encode::Error::ParseFailed("data not consumed entirely when explicitly deserializing"))
-                                    }
-                                } else {
-                                    return Err(Error::DuplicateKey(pair.key).into())
-                                }
-                            } else {
-                                return Err(Error::InvalidKey(pair.key).into())
-                            }
-                        }
-                        _ => {
-                            if unknowns.contains_key(&pair.key) {
-                                return Err(Error::DuplicateKey(pair.key).into());
-                            } else {
-                                unknowns.insert(pair.key, pair.value);
-                            }
-                        }
-                    }
-                }
-                Err(::consensus::encode::Error::Psbt(::util::psbt::Error::NoMorePairs)) => break,
-                Err(e) => return Err(e),
-            }
-        }
-
-        if let Some(tx) = tx {
-            let mut rv: Global = Global::from_unsigned_tx(tx)?;
-            rv.unknown = unknowns;
-            Ok(rv)
-        } else {
-            Err(Error::MustHaveUnsignedTx.into())
-        }
-    }
-}
diff --git a/src/util/psbt/map/input.rs b/src/util/psbt/map/input.rs
deleted file mode 100644
index 32f19bc5..00000000
--- a/src/util/psbt/map/input.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-use std::collections::BTreeMap;
-
-use blockdata::script::Script;
-use blockdata::transaction::{SigHashType, Transaction, TxOut};
-use consensus::encode;
-use util::bip32::{DerivationPath, Fingerprint};
-use util::key::PublicKey;
-use util::psbt;
-use util::psbt::map::Map;
-use util::psbt::raw;
-use util::psbt::Error;
-
-/// A key-value map for an input of the corresponding index in the unsigned
-/// transaction.
-#[derive(Clone, Default, Debug, PartialEq)]
-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
-    /// 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,
-    /// 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.
-    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.
-    pub sighash_type: Option<SigHashType>,
-    /// The redeem script for this input.
-    pub redeem_script: Option<Script>,
-    /// The witness script for this 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.
-    pub hd_keypaths: BTreeMap<PublicKey, (Fingerprint, DerivationPath)>,
-    /// 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>>>,
-    /// Unknown key-value pairs for this input.
-    pub unknown: BTreeMap<raw::Key, Vec<u8>>,
-}
-
-impl Map for Input {
-    fn insert_pair(&mut self, pair: raw::Pair) -> Result<(), encode::Error> {
-        let raw::Pair {
-            key: raw_key,
-            value: raw_value,
-        } = pair;
-
-        match raw_key.type_value {
-            0u8 => {
-                impl_psbt_insert_pair! {
-                    self.non_witness_utxo <= <raw_key: _>|<raw_value: Transaction>
-                }
-            }
-            1u8 => {
-                impl_psbt_insert_pair! {
-                    self.witness_utxo <= <raw_key: _>|<raw_value: TxOut>
-                }
-            }
-            3u8 => {
-                impl_psbt_insert_pair! {
-                    self.sighash_type <= <raw_key: _>|<raw_value: SigHashType>
-                }
-            }
-            4u8 => {
-                impl_psbt_insert_pair! {
-                    self.redeem_script <= <raw_key: _>|<raw_value: Script>
-                }
-            }
-            5u8 => {
-                impl_psbt_insert_pair! {
-                    self.witness_script <= <raw_key: _>|<raw_value: Script>
-                }
-            }
-            7u8 => {
-                impl_psbt_insert_pair! {
-                    self.final_script_sig <= <raw_key: _>|<raw_value: Script>
-                }
-            }
-            8u8 => {
-                impl_psbt_insert_pair! {
-                    self.final_script_witness <= <raw_key: _>|<raw_value: Vec<Vec<u8>>>
-                }
-            }
-            2u8 => {
-                impl_psbt_insert_pair! {
-                    self.partial_sigs <= <raw_key: PublicKey>|<raw_value: Vec<u8>>
-                }
-            }
-            6u8 => {
-                impl_psbt_insert_pair! {
-                    self.hd_keypaths <= <raw_key: PublicKey>|<raw_value: (Fingerprint, DerivationPath)>
-                }
-            }
-            _ => {
-                if self.unknown.contains_key(&raw_key) {
-                    return Err(Error::DuplicateKey(raw_key).into());
-                } else {
-                    self.unknown.insert(raw_key, raw_value);
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    fn get_pairs(&self) -> Result<Vec<raw::Pair>, encode::Error> {
-        let mut rv: Vec<raw::Pair> = Default::default();
-
-        impl_psbt_get_pair! {
-            rv.push(self.non_witness_utxo as <0u8, _>|<Transaction>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.witness_utxo as <1u8, _>|<TxOut>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.partial_sigs as <2u8, PublicKey>|<Vec<u8>>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.sighash_type as <3u8, _>|<SigHashType>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.redeem_script as <4u8, _>|<Script>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.witness_script as <5u8, _>|<Script>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.hd_keypaths as <6u8, PublicKey>|<(Fingerprint, DerivationPath)>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.final_script_sig as <7u8, _>|<Script>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.final_script_witness as <8u8, _>|<Script>)
-        }
-
-        for (key, value) in self.unknown.iter() {
-            rv.push(raw::Pair {
-                key: key.clone(),
-                value: value.clone(),
-            });
-        }
-
-        Ok(rv)
-    }
-
-    fn merge(&mut self, other: Self) -> Result<(), psbt::Error> {
-        merge!(non_witness_utxo, self, other);
-
-        if let (&None, Some(witness_utxo)) = (&self.witness_utxo, other.witness_utxo) {
-            self.witness_utxo = Some(witness_utxo);
-            self.non_witness_utxo = None; // Clear out any non-witness UTXO when we set a witness one
-        }
-
-        self.partial_sigs.extend(other.partial_sigs);
-        self.hd_keypaths.extend(other.hd_keypaths);
-        self.unknown.extend(other.unknown);
-
-        merge!(redeem_script, self, other);
-        merge!(witness_script, self, other);
-        merge!(final_script_sig, self, other);
-        merge!(final_script_witness, self, other);
-
-        Ok(())
-    }
-}
-
-impl_psbtmap_consensus_enc_dec_oding!(Input);
diff --git a/src/util/psbt/map/mod.rs b/src/util/psbt/map/mod.rs
deleted file mode 100644
index a84cf8a3..00000000
--- a/src/util/psbt/map/mod.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-use consensus::encode;
-use util::psbt;
-use util::psbt::raw;
-
-/// A trait that describes a PSBT key-value map.
-pub trait Map {
-    /// Attempt to insert a key-value pair.
-    fn insert_pair(&mut self, pair: raw::Pair) -> Result<(), encode::Error>;
-
-    /// Attempt to get all key-value pairs.
-    fn get_pairs(&self) -> Result<Vec<raw::Pair>, encode::Error>;
-
-    /// Attempt to merge with another key-value map of the same type.
-    fn merge(&mut self, other: Self) -> Result<(), psbt::Error>;
-}
-
-// place at end to pick up macros
-mod global;
-mod input;
-mod output;
-
-pub use self::global::Global;
-pub use self::input::Input;
-pub use self::output::Output;
diff --git a/src/util/psbt/map/output.rs b/src/util/psbt/map/output.rs
deleted file mode 100644
index 8219e812..00000000
--- a/src/util/psbt/map/output.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-use std::collections::BTreeMap;
-
-use blockdata::script::Script;
-use consensus::encode;
-use util::bip32::{DerivationPath, Fingerprint};
-use util::key::PublicKey;
-use util::psbt;
-use util::psbt::map::Map;
-use util::psbt::raw;
-use util::psbt::Error;
-
-/// A key-value map for an output of the corresponding index in the unsigned
-/// transaction.
-#[derive(Clone, Default, Debug, PartialEq)]
-pub struct Output {
-    /// The redeem script for this output.
-    pub redeem_script: Option<Script>,
-    /// The witness script for this 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.
-    pub hd_keypaths: BTreeMap<PublicKey, (Fingerprint, DerivationPath)>,
-    /// Unknown key-value pairs for this output.
-    pub unknown: BTreeMap<raw::Key, Vec<u8>>,
-}
-
-impl Map for Output {
-    fn insert_pair(&mut self, pair: raw::Pair) -> Result<(), encode::Error> {
-        let raw::Pair {
-            key: raw_key,
-            value: raw_value,
-        } = pair;
-
-        match raw_key.type_value {
-            0u8 => {
-                impl_psbt_insert_pair! {
-                    self.redeem_script <= <raw_key: _>|<raw_value: Script>
-                }
-            }
-            1u8 => {
-                impl_psbt_insert_pair! {
-                    self.witness_script <= <raw_key: _>|<raw_value: Script>
-                }
-            }
-            2u8 => {
-                impl_psbt_insert_pair! {
-                    self.hd_keypaths <= <raw_key: PublicKey>|<raw_value: (Fingerprint, DerivationPath)>
-                }
-            }
-            _ => {
-                if self.unknown.contains_key(&raw_key) {
-                    return Err(Error::DuplicateKey(raw_key).into());
-                } else {
-                    self.unknown.insert(raw_key, raw_value);
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    fn get_pairs(&self) -> Result<Vec<raw::Pair>, encode::Error> {
-        let mut rv: Vec<raw::Pair> = Default::default();
-
-        impl_psbt_get_pair! {
-            rv.push(self.redeem_script as <0u8, _>|<Script>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.witness_script as <1u8, _>|<Script>)
-        }
-
-        impl_psbt_get_pair! {
-            rv.push(self.hd_keypaths as <2u8, PublicKey>|<(Fingerprint, DerivationPath)>)
-        }
-
-        for (key, value) in self.unknown.iter() {
-            rv.push(raw::Pair {
-                key: key.clone(),
-                value: value.clone(),
-            });
-        }
-
-        Ok(rv)
-    }
-
-    fn merge(&mut self, other: Self) -> Result<(), psbt::Error> {
-        self.hd_keypaths.extend(other.hd_keypaths);
-        self.unknown.extend(other.unknown);
-
-        merge!(redeem_script, self, other);
-        merge!(witness_script, self, other);
-
-        Ok(())
-    }
-}
-
-impl_psbtmap_consensus_enc_dec_oding!(Output);
diff --git a/src/util/psbt/mod.rs b/src/util/psbt/mod.rs
deleted file mode 100644
index 48a8e240..00000000
--- a/src/util/psbt/mod.rs
+++ /dev/null
@@ -1,568 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-//! # Partially Signed Transactions
-//!
-//! Implementation of BIP174 Partially Signed Bitcoin Transaction Format as
-//! defined at https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
-//! except we define PSBTs containing non-standard SigHash types as invalid.
-
-use blockdata::script::Script;
-use blockdata::transaction::Transaction;
-use consensus::{encode, Encodable, Decodable};
-
-use std::io;
-
-mod error;
-pub use self::error::Error;
-
-pub mod raw;
-
-#[macro_use]
-mod macros;
-
-pub mod serialize;
-
-mod map;
-pub use self::map::{Map, Global, Input, Output};
-
-/// A Partially Signed Transaction.
-#[derive(Debug, Clone, PartialEq)]
-pub struct PartiallySignedTransaction {
-    /// The key-value pairs for all global data.
-    pub global: Global,
-    /// The corresponding key-value map for each input in the unsigned
-    /// transaction.
-    pub inputs: Vec<Input>,
-    /// The corresponding key-value map for each output in the unsigned
-    /// transaction.
-    pub outputs: Vec<Output>,
-}
-
-impl PartiallySignedTransaction {
-    /// Create a PartiallySignedTransaction from an unsigned transaction, error
-    /// if not unsigned
-    pub fn from_unsigned_tx(tx: Transaction) -> Result<Self, self::Error> {
-        Ok(PartiallySignedTransaction {
-            inputs: vec![Default::default(); tx.input.len()],
-            outputs: vec![Default::default(); tx.output.len()],
-            global: Global::from_unsigned_tx(tx)?,
-        })
-    }
-
-    /// Extract the Transaction from a PartiallySignedTransaction by filling in
-    /// the available signature information in place.
-    pub fn extract_tx(self) -> Transaction {
-        let mut tx: Transaction = self.global.unsigned_tx;
-
-        for (vin, psbtin) in tx.input.iter_mut().zip(self.inputs.into_iter()) {
-            vin.script_sig = psbtin.final_script_sig.unwrap_or_else(|| Script::new());
-            vin.witness = psbtin.final_script_witness.unwrap_or_else(|| Vec::new());
-        }
-
-        tx
-    }
-
-    /// Attempt to merge with another `PartiallySignedTransaction`.
-    pub fn merge(&mut self, other: Self) -> Result<(), self::Error> {
-        self.global.merge(other.global)?;
-
-        for (self_input, other_input) in self.inputs.iter_mut().zip(other.inputs.into_iter()) {
-            self_input.merge(other_input)?;
-        }
-
-        for (self_output, other_output) in self.outputs.iter_mut().zip(other.outputs.into_iter()) {
-            self_output.merge(other_output)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl Encodable for PartiallySignedTransaction {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let mut len = 0;
-        len += b"psbt".consensus_encode(&mut s)?;
-
-        len += 0xff_u8.consensus_encode(&mut s)?;
-
-        len += self.global.consensus_encode(&mut s)?;
-
-        for i in &self.inputs {
-            len += i.consensus_encode(&mut s)?;
-        }
-
-        for i in &self.outputs {
-            len += i.consensus_encode(&mut s)?;
-        }
-
-        Ok(len)
-    }
-}
-
-impl Decodable for PartiallySignedTransaction {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let magic: [u8; 4] = Decodable::consensus_decode(&mut d)?;
-
-        if *b"psbt" != magic {
-            return Err(Error::InvalidMagic.into());
-        }
-
-        if 0xff_u8 != u8::consensus_decode(&mut d)? {
-            return Err(Error::InvalidSeparator.into());
-        }
-
-        let global: Global = Decodable::consensus_decode(&mut d)?;
-
-        let inputs: Vec<Input> = {
-            let inputs_len: usize = (&global.unsigned_tx.input).len();
-
-            let mut inputs: Vec<Input> = Vec::with_capacity(inputs_len);
-
-            for _ in 0..inputs_len {
-                inputs.push(Decodable::consensus_decode(&mut d)?);
-            }
-
-            inputs
-        };
-
-        let outputs: Vec<Output> = {
-            let outputs_len: usize = (&global.unsigned_tx.output).len();
-
-            let mut outputs: Vec<Output> = Vec::with_capacity(outputs_len);
-
-            for _ in 0..outputs_len {
-                outputs.push(Decodable::consensus_decode(&mut d)?);
-            }
-
-            outputs
-        };
-
-        Ok(PartiallySignedTransaction {
-            global: global,
-            inputs: inputs,
-            outputs: outputs,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use hashes::hex::FromHex;
-    use hash_types::Txid;
-
-    use std::collections::BTreeMap;
-
-    use hex::decode as hex_decode;
-
-    use secp256k1::Secp256k1;
-
-    use blockdata::script::Script;
-    use blockdata::transaction::{Transaction, TxIn, TxOut, OutPoint};
-    use network::constants::Network::Bitcoin;
-    use consensus::encode::{deserialize, serialize, serialize_hex};
-    use util::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey, Fingerprint};
-    use util::key::PublicKey;
-    use util::psbt::map::{Global, Output};
-    use util::psbt::raw;
-
-    use super::PartiallySignedTransaction;
-
-    #[test]
-    fn trivial_psbt() {
-        let psbt = PartiallySignedTransaction {
-            global: Global {
-                unsigned_tx: Transaction {
-                    version: 2,
-                    lock_time: 0,
-                    input: vec![],
-                    output: vec![],
-                },
-                unknown: BTreeMap::new(),
-            },
-            inputs: vec![],
-            outputs: vec![],
-        };
-        assert_eq!(
-            serialize_hex(&psbt),
-            "70736274ff01000a0200000000000000000000"
-        );
-    }
-
-    #[test]
-    fn serialize_then_deserialize_output() {
-        let secp = &Secp256k1::new();
-        let seed = hex_decode("000102030405060708090a0b0c0d0e0f").unwrap();
-
-        let mut hd_keypaths: BTreeMap<PublicKey, (Fingerprint, DerivationPath)> = Default::default();
-
-        let mut sk: ExtendedPrivKey = ExtendedPrivKey::new_master(Bitcoin, &seed).unwrap();
-
-        let fprint: Fingerprint = sk.fingerprint(&secp);
-
-        let dpath: Vec<ChildNumber> = vec![
-            ChildNumber::from_normal_idx(0).unwrap(),
-            ChildNumber::from_normal_idx(1).unwrap(),
-            ChildNumber::from_normal_idx(2).unwrap(),
-            ChildNumber::from_normal_idx(4).unwrap(),
-            ChildNumber::from_normal_idx(42).unwrap(),
-            ChildNumber::from_hardened_idx(69).unwrap(),
-            ChildNumber::from_normal_idx(420).unwrap(),
-            ChildNumber::from_normal_idx(31337).unwrap(),
-        ];
-
-        sk = sk.derive_priv(secp, &dpath).unwrap();
-
-        let pk: ExtendedPubKey = ExtendedPubKey::from_private(&secp, &sk);
-
-        hd_keypaths.insert(pk.public_key, (fprint, dpath.into()));
-
-        let expected: Output = Output {
-            redeem_script: Some(hex_script!(
-                "76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac"
-            )),
-            witness_script: Some(hex_script!(
-                "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787"
-            )),
-            hd_keypaths: hd_keypaths,
-            ..Default::default()
-        };
-
-        let actual: Output = deserialize(&serialize(&expected)).unwrap();
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn serialize_then_deserialize_global() {
-        let expected = Global {
-            unsigned_tx: Transaction {
-                version: 2,
-                lock_time: 1257139,
-                input: vec![TxIn {
-                    previous_output: OutPoint {
-                        txid: Txid::from_hex(
-                            "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126",
-                        ).unwrap(),
-                        vout: 0,
-                    },
-                    script_sig: Script::new(),
-                    sequence: 4294967294,
-                    witness: vec![],
-                }],
-                output: vec![
-                    TxOut {
-                        value: 99999699,
-                        script_pubkey: hex_script!(
-                            "76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac"
-                        ),
-                    },
-                    TxOut {
-                        value: 100000000,
-                        script_pubkey: hex_script!(
-                            "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787"
-                        ),
-                    },
-                ],
-            },
-            unknown: Default::default(),
-        };
-
-        let actual: Global = deserialize(&serialize(&expected)).unwrap();
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn serialize_then_deserialize_psbtkvpair() {
-        let expected = raw::Pair {
-            key: raw::Key {
-                type_value: 0u8,
-                key: vec![42u8, 69u8],
-            },
-            value: vec![69u8, 42u8, 4u8],
-        };
-
-        let actual: raw::Pair = deserialize(&serialize(&expected)).unwrap();
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn deserialize_and_serialize_psbt_with_two_partial_sigs() {
-        let hex = "70736274ff0100890200000001207ae985d787dfe6143d5c58fad79cc7105e0e799fcf033b7f2ba17e62d7b3200000000000ffffffff02563d03000000000022002019899534b9a011043c0dd57c3ff9a381c3522c5f27c6a42319085b56ca543a1d6adc020000000000220020618b47a07ebecca4e156edb1b9ea7c24bdee0139fc049237965ffdaf56d5ee73000000000001012b801a0600000000002200201148e93e9315e37dbed2121be5239257af35adc03ffdfc5d914b083afa44dab82202025fe7371376d53cf8a2783917c28bf30bd690b0a4d4a207690093ca2b920ee076473044022007e06b362e89912abd4661f47945430739b006a85d1b2a16c01dc1a4bd07acab022061576d7aa834988b7ab94ef21d8eebd996ea59ea20529a19b15f0c9cebe3d8ac01220202b3fe93530020a8294f0e527e33fbdff184f047eb6b5a1558a352f62c29972f8a473044022002787f926d6817504431ee281183b8119b6845bfaa6befae45e13b6d430c9d2f02202859f149a6cd26ae2f03a107e7f33c7d91730dade305fe077bae677b5d44952a01010547522102b3fe93530020a8294f0e527e33fbdff184f047eb6b5a1558a352f62c29972f8a21025fe7371376d53cf8a2783917c28bf30bd690b0a4d4a207690093ca2b920ee07652ae0001014752210283ef76537f2d58ae3aa3a4bd8ae41c3f230ccadffb1a0bd3ca504d871cff05e7210353d79cc0cb1396f4ce278d005f16d948e02a6aec9ed1109f13747ecb1507b37b52ae00010147522102b3937241777b6665e0d694e52f9c1b188433641df852da6fc42187b5d8a368a321034cdd474f01cc5aa7ff834ad8bcc882a87e854affc775486bc2a9f62e8f49bd7852ae00";
-        let psbt: PartiallySignedTransaction = hex_psbt!(hex).unwrap();
-        assert_eq!(hex, serialize_hex(&psbt));
-    }
-
-    mod bip_vectors {
-        use std::collections::BTreeMap;
-
-        use hex::decode as hex_decode;
-
-        use hashes::hex::FromHex;
-        use hash_types::Txid;
-
-        use blockdata::script::Script;
-        use blockdata::transaction::{SigHashType, Transaction, TxIn, TxOut, OutPoint};
-        use consensus::encode::serialize_hex;
-        use util::psbt::map::{Map, Global, Input, Output};
-        use util::psbt::raw;
-        use util::psbt::PartiallySignedTransaction;
-
-        #[test]
-        fn invalid_vector_1() {
-            let psbt: Result<PartiallySignedTransaction, _> = hex_psbt!("0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300");
-            assert!(psbt.is_err());
-        }
-
-        #[test]
-        fn invalid_vector_2() {
-            let psbt: Result<PartiallySignedTransaction, _> = hex_psbt!("70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000000");
-            assert!(psbt.is_err());
-        }
-
-        #[test]
-        fn invalid_vector_3() {
-            let psbt: Result<PartiallySignedTransaction, _> = hex_psbt!("70736274ff0100fd0a010200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be4000000006a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa88292feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000");
-            assert!(psbt.is_err());
-        }
-
-        #[test]
-        fn invalid_vector_4() {
-            let psbt: Result<PartiallySignedTransaction, _> = hex_psbt!("70736274ff000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000000");
-            assert!(psbt.is_err());
-        }
-
-        #[test]
-        fn invalid_vector_5() {
-            let psbt: Result<PartiallySignedTransaction, _> = hex_psbt!("70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000001003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a010000000000000000");
-            assert!(psbt.is_err());
-        }
-
-        #[test]
-        fn valid_vector_1() {
-            let unserialized = PartiallySignedTransaction {
-                global: Global {
-                    unsigned_tx: Transaction {
-                        version: 2,
-                        lock_time: 1257139,
-                        input: vec![TxIn {
-                            previous_output: OutPoint {
-                                txid: Txid::from_hex(
-                                    "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126",
-                                ).unwrap(),
-                                vout: 0,
-                            },
-                            script_sig: Script::new(),
-                            sequence: 4294967294,
-                            witness: vec![],
-                        }],
-                        output: vec![
-                            TxOut {
-                                value: 99999699,
-                                script_pubkey: hex_script!("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac"),
-                            },
-                            TxOut {
-                                value: 100000000,
-                                script_pubkey: hex_script!("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787"),
-                            },
-                        ],
-                    },
-                    unknown: BTreeMap::new(),
-                },
-                inputs: vec![Input {
-                    non_witness_utxo: Some(Transaction {
-                        version: 1,
-                        lock_time: 0,
-                        input: vec![TxIn {
-                            previous_output: OutPoint {
-                                txid: Txid::from_hex(
-                                    "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389",
-                                ).unwrap(),
-                                vout: 1,
-                            },
-                            script_sig: hex_script!("160014be18d152a9b012039daf3da7de4f53349eecb985"),
-                            sequence: 4294967295,
-                            witness: vec![
-                                hex_decode("304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c01").unwrap(),
-                                hex_decode("03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105").unwrap(),
-                            ],
-                        },
-                        TxIn {
-                            previous_output: OutPoint {
-                                txid: Txid::from_hex(
-                                    "b490486aec3ae671012dddb2bb08466bef37720a533a894814ff1da743aaf886",
-                                ).unwrap(),
-                                vout: 1,
-                            },
-                            script_sig: hex_script!("160014fe3e9ef1a745e974d902c4355943abcb34bd5353"),
-                            sequence: 4294967295,
-                            witness: vec![
-                                hex_decode("3045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01").unwrap(),
-                                hex_decode("0223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab3").unwrap(),
-                            ],
-                        }],
-                        output: vec![
-                            TxOut {
-                                value: 200000000,
-                                script_pubkey: hex_script!("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac"),
-                            },
-                            TxOut {
-                                value: 190303501938,
-                                script_pubkey: hex_script!("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587"),
-                            },
-                        ],
-                    }),
-                    ..Default::default()
-                },],
-                outputs: vec![
-                    Output {
-                        ..Default::default()
-                    },
-                    Output {
-                        ..Default::default()
-                    },
-                ],
-            };
-
-            let serialized = "70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab300000000000000";
-
-            assert_eq!(serialize_hex(&unserialized), serialized);
-            assert_eq!(unserialized, hex_psbt!(serialized).unwrap());
-        }
-
-        #[test]
-        fn valid_vector_2() {
-            let psbt: PartiallySignedTransaction = hex_psbt!("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac000000000001076a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa882920001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000").unwrap();
-
-            assert_eq!(psbt.inputs.len(), 2);
-            assert_eq!(psbt.outputs.len(), 2);
-
-            assert!(&psbt.inputs[0].final_script_sig.is_some());
-
-            let redeem_script: &Script = &psbt.inputs[1].redeem_script.as_ref().unwrap();
-            let expected_out = hex_script!("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787");
-
-            assert!(redeem_script.is_v0_p2wpkh());
-            assert_eq!(
-                redeem_script.to_p2sh(),
-                psbt.inputs[1].witness_utxo.as_ref().unwrap().script_pubkey
-            );
-            assert_eq!(redeem_script.to_p2sh(), expected_out);
-
-            for output in psbt.outputs {
-                assert_eq!(output.get_pairs().unwrap().len(), 0)
-            }
-        }
-
-        #[test]
-        fn valid_vector_3() {
-            let psbt: PartiallySignedTransaction = hex_psbt!("70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000001030401000000000000").unwrap();
-
-            assert_eq!(psbt.inputs.len(), 1);
-            assert_eq!(psbt.outputs.len(), 2);
-
-            let tx_input = &psbt.global.unsigned_tx.input[0];
-            let psbt_non_witness_utxo = (&psbt.inputs[0].non_witness_utxo).as_ref().unwrap();
-
-            assert_eq!(tx_input.previous_output.txid, psbt_non_witness_utxo.txid());
-            assert!(
-                psbt_non_witness_utxo.output[tx_input.previous_output.vout as usize]
-                    .script_pubkey
-                    .is_p2pkh()
-            );
-            assert_eq!(
-                (&psbt.inputs[0].sighash_type).as_ref().unwrap(),
-                &SigHashType::All
-            );
-        }
-
-        #[test]
-        fn valid_vector_4() {
-            let psbt: PartiallySignedTransaction = hex_psbt!("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000100df0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e13000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb8230800220202ead596687ca806043edc3de116cdf29d5e9257c196cd055cf698c8d02bf24e9910b4a6ba670000008000000080020000800022020394f62be9df19952c5587768aeb7698061ad2c4a25c894f47d8c162b4d7213d0510b4a6ba6700000080010000800200008000").unwrap();
-
-            assert_eq!(psbt.inputs.len(), 2);
-            assert_eq!(psbt.outputs.len(), 2);
-
-            assert!(&psbt.inputs[0].final_script_sig.is_none());
-            assert!(&psbt.inputs[1].final_script_sig.is_none());
-
-            let redeem_script: &Script = &psbt.inputs[1].redeem_script.as_ref().unwrap();
-            let expected_out = hex_script!("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787");
-
-            assert!(redeem_script.is_v0_p2wpkh());
-            assert_eq!(
-                redeem_script.to_p2sh(),
-                psbt.inputs[1].witness_utxo.as_ref().unwrap().script_pubkey
-            );
-            assert_eq!(redeem_script.to_p2sh(), expected_out);
-
-            for output in psbt.outputs {
-                assert!(output.get_pairs().unwrap().len() > 0)
-            }
-        }
-
-        #[test]
-        fn valid_vector_5() {
-            let psbt: PartiallySignedTransaction = hex_psbt!("70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000").unwrap();
-
-            assert_eq!(psbt.inputs.len(), 1);
-            assert_eq!(psbt.outputs.len(), 1);
-
-            assert!(&psbt.inputs[0].final_script_sig.is_none());
-
-            let redeem_script: &Script = &psbt.inputs[0].redeem_script.as_ref().unwrap();
-            let expected_out = hex_script!("a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87");
-
-            assert!(redeem_script.is_v0_p2wsh());
-            assert_eq!(
-                redeem_script.to_p2sh(),
-                psbt.inputs[0].witness_utxo.as_ref().unwrap().script_pubkey
-            );
-
-            assert_eq!(redeem_script.to_p2sh(), expected_out);
-        }
-
-        #[test]
-        fn valid_vector_6() {
-            let psbt: PartiallySignedTransaction = hex_psbt!("70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a010000000000000a0f0102030405060708090f0102030405060708090a0b0c0d0e0f0000").unwrap();
-
-            assert_eq!(psbt.inputs.len(), 1);
-            assert_eq!(psbt.outputs.len(), 1);
-
-            let tx = &psbt.global.unsigned_tx;
-            assert_eq!(
-                tx.txid(),
-                Txid::from_hex(
-                    "75c5c9665a570569ad77dd1279e6fd4628a093c4dcbf8d41532614044c14c115"
-                ).unwrap()
-            );
-
-            let mut unknown: BTreeMap<raw::Key, Vec<u8>> = BTreeMap::new();
-            let key: raw::Key = raw::Key {
-                type_value: 0x0fu8,
-                key: hex_decode("010203040506070809").unwrap(),
-            };
-            let value: Vec<u8> = hex_decode("0102030405060708090a0b0c0d0e0f").unwrap();
-
-            unknown.insert(key, value);
-
-            assert_eq!(psbt.inputs[0].unknown, unknown)
-        }
-    }
-}
diff --git a/src/util/psbt/raw.rs b/src/util/psbt/raw.rs
deleted file mode 100644
index 9bf73ff9..00000000
--- a/src/util/psbt/raw.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-//! # Raw PSBT Key-Value Pairs
-//!
-//! Raw PSBT key-value pairs as defined at
-//! https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki.
-
-use std::{fmt, io};
-
-use consensus::encode::{self, Decodable, Encodable, VarInt, MAX_VEC_SIZE};
-use hashes::hex::ToHex;
-use util::psbt::Error;
-
-/// A PSBT key in its raw byte form.
-#[derive(Debug, PartialEq, Hash, Eq, Clone, Ord, PartialOrd)]
-pub struct Key {
-    /// The type of this PSBT key.
-    pub type_value: u8,
-    /// The key itself in raw byte form.
-    pub key: Vec<u8>,
-}
-
-/// A PSBT key-value pair in its raw byte form.
-#[derive(Debug, PartialEq)]
-pub struct Pair {
-    /// The key of this key-value pair.
-    pub key: Key,
-    /// The value of this key-value pair in raw byte form.
-    pub value: Vec<u8>,
-}
-
-impl fmt::Display for Key {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "type: {:#x}, key: {}",
-            self.type_value,
-            self.key[..].to_hex()
-        )
-    }
-}
-
-impl Decodable for Key {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        let VarInt(byte_size): VarInt = Decodable::consensus_decode(&mut d)?;
-
-        if byte_size == 0 {
-            return Err(Error::NoMorePairs.into());
-        }
-
-        let key_byte_size: u64 = byte_size - 1;
-
-        if key_byte_size > MAX_VEC_SIZE as u64 {
-            return Err(encode::Error::OversizedVectorAllocation {
-                requested: key_byte_size as usize,
-                max: MAX_VEC_SIZE,
-            })
-        }
-
-        let type_value: u8 = Decodable::consensus_decode(&mut d)?;
-
-        let mut key = Vec::with_capacity(key_byte_size as usize);
-        for _ in 0..key_byte_size {
-            key.push(Decodable::consensus_decode(&mut d)?);
-        }
-
-        Ok(Key {
-            type_value: type_value,
-            key: key,
-        })
-    }
-}
-
-impl Encodable for Key {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let mut len = 0;
-        len += VarInt((self.key.len() + 1) as u64).consensus_encode(&mut s)?;
-
-        len += self.type_value.consensus_encode(&mut s)?;
-
-        for key in &self.key {
-            len += key.consensus_encode(&mut s)?
-        }
-
-        Ok(len)
-    }
-}
-
-impl Encodable for Pair {
-    fn consensus_encode<S: io::Write>(
-        &self,
-        mut s: S,
-    ) -> Result<usize, encode::Error> {
-        let len = self.key.consensus_encode(&mut s)?;
-        Ok(len + self.value.consensus_encode(s)?)
-    }
-}
-
-impl Decodable for Pair {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        Ok(Pair {
-            key: Decodable::consensus_decode(&mut d)?,
-            value: Decodable::consensus_decode(d)?,
-        })
-    }
-}
diff --git a/src/util/psbt/serialize.rs b/src/util/psbt/serialize.rs
deleted file mode 100644
index 8ecd2f34..00000000
--- a/src/util/psbt/serialize.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-// Rust Bitcoin Library
-// Written by
-//   The Rust Bitcoin 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/>.
-//
-
-//! # PSBT Serialization
-//!
-//! Defines traits used for (de)serializing PSBT values into/from raw
-//! bytes in PSBT key-value pairs.
-
-use std::io;
-
-use blockdata::script::Script;
-use blockdata::transaction::{SigHashType, Transaction, TxOut};
-use consensus::encode::{self, serialize, Decodable};
-use util::bip32::{ChildNumber, DerivationPath, Fingerprint};
-use util::key::PublicKey;
-use util::psbt;
-
-/// A trait for serializing a value as raw data for insertion into PSBT
-/// key-value pairs.
-pub trait Serialize {
-    /// Serialize a value as raw data.
-    fn serialize(&self) -> Vec<u8>;
-}
-
-/// A trait for deserializing a value from raw data in PSBT key-value pairs.
-pub trait Deserialize: Sized {
-    /// Deserialize a value from raw data.
-    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error>;
-}
-
-impl_psbt_de_serialize!(Transaction);
-impl_psbt_de_serialize!(TxOut);
-impl_psbt_de_serialize!(Vec<Vec<u8>>); // scriptWitness
-
-impl Serialize for Script {
-    fn serialize(&self) -> Vec<u8> {
-        self.to_bytes()
-    }
-}
-
-impl Deserialize for Script {
-    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        Ok(Self::from(bytes.to_vec()))
-    }
-}
-
-impl Serialize for PublicKey {
-    fn serialize(&self) -> Vec<u8> {
-        let mut buf = Vec::new();
-        self.write_into(&mut buf);
-        buf
-    }
-}
-
-impl Deserialize for PublicKey {
-    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        PublicKey::from_slice(bytes)
-            .map_err(|_| encode::Error::ParseFailed("invalid public key"))
-    }
-}
-
-impl Serialize for (Fingerprint, DerivationPath) {
-    fn serialize(&self) -> Vec<u8> {
-        let mut rv: Vec<u8> = Vec::with_capacity(4 + 4 * (self.1).as_ref().len());
-
-        rv.append(&mut self.0.to_bytes().to_vec());
-
-        for cnum in self.1.into_iter() {
-            rv.append(&mut serialize(&u32::from(*cnum)))
-        }
-
-        rv
-    }
-}
-
-impl Deserialize for (Fingerprint, DerivationPath) {
-    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        if bytes.len() < 4 {
-            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 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),
-            }
-        }
-
-        Ok((fprint, dpath.into()))
-    }
-}
-
-// partial sigs
-impl Serialize for Vec<u8> {
-    fn serialize(&self) -> Vec<u8> {
-        self.clone()
-    }
-}
-
-impl Deserialize for Vec<u8> {
-    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        Ok(bytes.to_vec())
-    }
-}
-
-impl Serialize for SigHashType {
-    fn serialize(&self) -> Vec<u8> {
-        serialize(&self.as_u32())
-    }
-}
-
-impl Deserialize for SigHashType {
-    fn deserialize(bytes: &[u8]) -> Result<Self, encode::Error> {
-        let raw: u32 = encode::deserialize(bytes)?;
-        let rv: SigHashType = SigHashType::from_u32(raw);
-
-        if rv.as_u32() == raw {
-            Ok(rv)
-        } else {
-            Err(psbt::Error::NonStandardSigHashType(raw).into())
-        }
-    }
-}
diff --git a/src/util/uint.rs b/src/util/uint.rs
deleted file mode 100644
index 2e26f979..00000000
--- a/src/util/uint.rs
+++ /dev/null
@@ -1,558 +0,0 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Big unsigned integer types
-//!
-//! Implementation of a various large-but-fixed sized unsigned integer types.
-//! The functions here are designed to be fast.
-//!
-
-use std::fmt;
-
-use consensus::encode;
-use util::BitArray;
-
-macro_rules! construct_uint {
-    ($name:ident, $n_words:expr) => (
-        /// Little-endian large integer type
-        #[repr(C)]
-        pub struct $name(pub [u64; $n_words]);
-        impl_array_newtype!($name, u64, $n_words);
-
-        impl $name {
-            /// Conversion to u32
-            #[inline]
-            pub fn low_u32(&self) -> u32 {
-                let &$name(ref arr) = self;
-                arr[0] as u32
-            }
-
-            /// Conversion to u64
-            #[inline]
-            pub fn low_u64(&self) -> u64 {
-                let &$name(ref arr) = self;
-                arr[0] as u64
-            }
-
-
-            /// Return the least number of bits needed to represent the number
-            #[inline]
-            pub fn bits(&self) -> usize {
-                let &$name(ref arr) = self;
-                for i in 1..$n_words {
-                    if arr[$n_words - i] > 0 { return (0x40 * ($n_words - i + 1)) - arr[$n_words - i].leading_zeros() as usize; }
-                }
-                0x40 - arr[0].leading_zeros() as usize
-            }
-
-            /// Multiplication by u32
-            pub fn mul_u32(self, other: u32) -> $name {
-                let $name(ref arr) = self;
-                let mut carry = [0u64; $n_words];
-                let mut ret = [0u64; $n_words];
-                for i in 0..$n_words {
-                    let not_last_word = i < $n_words - 1;
-                    let upper = other as u64 * (arr[i] >> 32);
-                    let lower = other as u64 * (arr[i] & 0xFFFFFFFF);
-                    if not_last_word {
-                        carry[i + 1] += upper >> 32;
-                    }
-                    let (sum, overflow) = lower.overflowing_add(upper << 32);
-                    ret[i] = sum;
-                    if overflow && not_last_word {
-                        carry[i + 1] += 1;
-                    }
-                }
-                $name(ret) + $name(carry)
-            }
-
-            /// Create an object from a given unsigned 64-bit integer
-            pub fn from_u64(init: u64) -> Option<$name> {
-                let mut ret = [0; $n_words];
-                ret[0] = init;
-                Some($name(ret))
-            }
-
-            /// Create an object from a given signed 64-bit integer
-            pub fn from_i64(init: i64) -> Option<$name> {
-                assert!(init >= 0);
-                $name::from_u64(init as u64)
-            }
-        }
-
-        impl ::std::ops::Add<$name> for $name {
-            type Output = $name;
-
-            fn add(self, other: $name) -> $name {
-                let $name(ref me) = self;
-                let $name(ref you) = other;
-                let mut ret = [0u64; $n_words];
-                let mut carry = [0u64; $n_words];
-                let mut b_carry = false;
-                for i in 0..$n_words {
-                    ret[i] = me[i].wrapping_add(you[i]);
-                    if i < $n_words - 1 && ret[i] < me[i] {
-                        carry[i + 1] = 1;
-                        b_carry = true;
-                    }
-                }
-                if b_carry { $name(ret) + $name(carry) } else { $name(ret) }
-            }
-        }
-
-        impl ::std::ops::Sub<$name> for $name {
-            type Output = $name;
-
-            #[inline]
-            fn sub(self, other: $name) -> $name {
-                self + !other + BitArray::one()
-            }
-        }
-
-        impl ::std::ops::Mul<$name> for $name {
-            type Output = $name;
-
-            fn mul(self, other: $name) -> $name {
-                let mut me = $name::zero();
-                // TODO: be more efficient about this
-                for i in 0..(2 * $n_words) {
-                    let to_mul = (other >> (32 * i)).low_u32();
-                    me = me + (self.mul_u32(to_mul) << (32 * i));
-                }
-                me
-            }
-        }
-
-        impl ::std::ops::Div<$name> for $name {
-            type Output = $name;
-
-            fn div(self, other: $name) -> $name {
-                let mut sub_copy = self;
-                let mut shift_copy = other;
-                let mut ret = [0u64; $n_words];
-        
-                let my_bits = self.bits();
-                let your_bits = other.bits();
-
-                // Check for division by 0
-                assert!(your_bits != 0);
-
-                // Early return in case we are dividing by a larger number than us
-                if my_bits < your_bits {
-                    return $name(ret);
-                }
-
-                // Bitwise long division
-                let mut shift = my_bits - your_bits;
-                shift_copy = shift_copy << shift;
-                loop {
-                    if sub_copy >= shift_copy {
-                        ret[shift / 64] |= 1 << (shift % 64);
-                        sub_copy = sub_copy - shift_copy;
-                    }
-                    shift_copy = shift_copy >> 1;
-                    if shift == 0 { break; }
-                    shift -= 1;
-                }
-
-                $name(ret)
-            }
-        }
-
-        impl BitArray for $name {
-            #[inline]
-            fn bit(&self, index: usize) -> bool {
-                let &$name(ref arr) = self;
-                arr[index / 64] & (1 << (index % 64)) != 0
-            }
-
-            #[inline]
-            fn bit_slice(&self, start: usize, end: usize) -> $name {
-                (*self >> start).mask(end - start)
-            }
-
-            #[inline]
-            fn mask(&self, n: usize) -> $name {
-                let &$name(ref arr) = self;
-                let mut ret = [0; $n_words];
-                for i in 0..$n_words {
-                    if n >= 0x40 * (i + 1) {
-                        ret[i] = arr[i];
-                    } else {
-                        ret[i] = arr[i] & ((1 << (n - 0x40 * i)) - 1);
-                        break;
-                    }
-                }
-                $name(ret)
-            }
-
-            #[inline]
-            fn trailing_zeros(&self) -> usize {
-                let &$name(ref arr) = self;
-                for i in 0..($n_words - 1) {
-                    if arr[i] > 0 { return (0x40 * i) + arr[i].trailing_zeros() as usize; }
-                }
-                (0x40 * ($n_words - 1)) + arr[$n_words - 1].trailing_zeros() as usize
-            }
-
-            fn zero() -> $name { $name([0; $n_words]) }
-            fn one() -> $name {
-                $name({ let mut ret = [0; $n_words]; ret[0] = 1; ret })
-            }
-        }
-
-        impl ::std::default::Default for $name {
-            fn default() -> $name {
-                BitArray::zero()
-            }
-        }
-
-        impl ::std::ops::BitAnd<$name> for $name {
-            type Output = $name;
-
-            #[inline]
-            fn bitand(self, other: $name) -> $name {
-                let $name(ref arr1) = self;
-                let $name(ref arr2) = other;
-                let mut ret = [0u64; $n_words];
-                for i in 0..$n_words {
-                    ret[i] = arr1[i] & arr2[i];
-                }
-                $name(ret)
-            }
-        }
-
-        impl ::std::ops::BitXor<$name> for $name {
-            type Output = $name;
-
-            #[inline]
-            fn bitxor(self, other: $name) -> $name {
-                let $name(ref arr1) = self;
-                let $name(ref arr2) = other;
-                let mut ret = [0u64; $n_words];
-                for i in 0..$n_words {
-                    ret[i] = arr1[i] ^ arr2[i];
-                }
-                $name(ret)
-            }
-        }
-
-        impl ::std::ops::BitOr<$name> for $name {
-            type Output = $name;
-
-            #[inline]
-            fn bitor(self, other: $name) -> $name {
-                let $name(ref arr1) = self;
-                let $name(ref arr2) = other;
-                let mut ret = [0u64; $n_words];
-                for i in 0..$n_words {
-                    ret[i] = arr1[i] | arr2[i];
-                }
-                $name(ret)
-            }
-        }
-
-        impl ::std::ops::Not for $name {
-            type Output = $name;
-
-            #[inline]
-            fn not(self) -> $name {
-                let $name(ref arr) = self;
-                let mut ret = [0u64; $n_words];
-                for i in 0..$n_words {
-                    ret[i] = !arr[i];
-                }
-                $name(ret)
-            }
-        }
-
-        impl ::std::ops::Shl<usize> for $name {
-            type Output = $name;
-
-            fn shl(self, shift: usize) -> $name {
-                let $name(ref original) = self;
-                let mut ret = [0u64; $n_words];
-                let word_shift = shift / 64;
-                let bit_shift = shift % 64;
-                for i in 0..$n_words {
-                    // Shift
-                    if bit_shift < 64 && i + word_shift < $n_words {
-                        ret[i + word_shift] += original[i] << bit_shift;
-                    }
-                    // Carry
-                    if bit_shift > 0 && i + word_shift + 1 < $n_words {
-                        ret[i + word_shift + 1] += original[i] >> (64 - bit_shift);
-                    }
-                }
-                $name(ret)
-            }
-        }
-
-        impl ::std::ops::Shr<usize> for $name {
-            type Output = $name;
-
-            fn shr(self, shift: usize) -> $name {
-                let $name(ref original) = self;
-                let mut ret = [0u64; $n_words];
-                let word_shift = shift / 64;
-                let bit_shift = shift % 64;
-                for i in word_shift..$n_words {
-                    // Shift
-                    ret[i - word_shift] += original[i] >> bit_shift;
-                    // Carry
-                    if bit_shift > 0 && i < $n_words - 1 {
-                        ret[i - word_shift] += original[i + 1] << (64 - bit_shift);
-                    }
-                }
-                $name(ret)
-            }
-        }
-
-        impl fmt::Debug for $name {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                let &$name(ref data) = self;
-                write!(f, "0x")?;
-                for ch in data.iter().rev() {
-                    write!(f, "{:016x}", ch)?;
-                }
-                Ok(())
-            }
-        }
-
-        impl fmt::Display for $name {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                <fmt::Debug>::fmt(self, f)
-            }
-        }
-
-        impl ::consensus::Encodable for $name {
-            #[inline]
-            fn consensus_encode<S: ::std::io::Write>(
-                &self,
-                mut s: S,
-            ) -> Result<usize, encode::Error> {
-                let &$name(ref data) = self;
-                let mut len = 0;
-                for word in data.iter() {
-                    len += word.consensus_encode(&mut s)?;
-                }
-                Ok(len)
-            }
-        }
-
-        impl ::consensus::Decodable for $name {
-            fn consensus_decode<D: ::std::io::Read>(
-                mut d: D,
-            ) -> Result<$name, encode::Error> {
-                use consensus::Decodable;
-                let mut ret: [u64; $n_words] = [0; $n_words];
-                for i in 0..$n_words {
-                    ret[i] = Decodable::consensus_decode(&mut d)?;
-                }
-                Ok($name(ret))
-            }
-        }
-    );
-}
-
-construct_uint!(Uint256, 4);
-construct_uint!(Uint128, 2);
-
-impl Uint256 {
-    /// Increment by 1
-    #[inline]
-    pub fn increment(&mut self) {
-        let &mut Uint256(ref mut arr) = self;
-        arr[0] += 1;
-        if arr[0] == 0 {
-            arr[1] += 1;
-            if arr[1] == 0 {
-                arr[2] += 1;
-                if arr[2] == 0 {
-                    arr[3] += 1;
-                }
-            }
-        }
-    }
-
-    /// Decay to a uint128
-    #[inline]
-    pub fn low_128(&self) -> Uint128 {
-        let &Uint256(data) = self;
-        Uint128([data[0], data[1]])
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use consensus::{deserialize, serialize};
-    use util::uint::Uint256;
-    use util::BitArray;
-
-    #[test]
-    pub fn uint256_bits_test() {
-        assert_eq!(Uint256::from_u64(255).unwrap().bits(), 8);
-        assert_eq!(Uint256::from_u64(256).unwrap().bits(), 9);
-        assert_eq!(Uint256::from_u64(300).unwrap().bits(), 9);
-        assert_eq!(Uint256::from_u64(60000).unwrap().bits(), 16);
-        assert_eq!(Uint256::from_u64(70000).unwrap().bits(), 17);
-
-        // Try to read the following lines out loud quickly
-        let mut shl = Uint256::from_u64(70000).unwrap();
-        shl = shl << 100;
-        assert_eq!(shl.bits(), 117);
-        shl = shl << 100;
-        assert_eq!(shl.bits(), 217);
-        shl = shl << 100;
-        assert_eq!(shl.bits(), 0);
-
-        // Bit set check
-        assert!(!Uint256::from_u64(10).unwrap().bit(0));
-        assert!(Uint256::from_u64(10).unwrap().bit(1));
-        assert!(!Uint256::from_u64(10).unwrap().bit(2));
-        assert!(Uint256::from_u64(10).unwrap().bit(3));
-        assert!(!Uint256::from_u64(10).unwrap().bit(4));
-    }
-
-    #[test]
-    pub fn uint256_display_test() {
-        assert_eq!(format!("{}", Uint256::from_u64(0xDEADBEEF).unwrap()),
-                   "0x00000000000000000000000000000000000000000000000000000000deadbeef");
-        assert_eq!(format!("{}", Uint256::from_u64(u64::max_value()).unwrap()),
-                   "0x000000000000000000000000000000000000000000000000ffffffffffffffff");
-
-        let max_val = Uint256([0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
-                               0xFFFFFFFFFFFFFFFF]);
-        assert_eq!(format!("{}", max_val),
-                   "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-    }
-
-    #[test]
-    pub fn uint256_comp_test() {
-        let small = Uint256([10u64, 0, 0, 0]);
-        let big = Uint256([0x8C8C3EE70C644118u64, 0x0209E7378231E632, 0, 0]);
-        let bigger = Uint256([0x9C8C3EE70C644118u64, 0x0209E7378231E632, 0, 0]);
-        let biggest = Uint256([0x5C8C3EE70C644118u64, 0x0209E7378231E632, 0, 1]);
-
-        assert!(small < big);
-        assert!(big < bigger);
-        assert!(bigger < biggest);
-        assert!(bigger <= biggest);
-        assert!(biggest <= biggest);
-        assert!(bigger >= big);
-        assert!(bigger >= small);
-        assert!(small <= small);
-    }
-
-    #[test]
-    pub fn uint256_arithmetic_test() {
-        let init = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
-        let copy = init;
-
-        let add = init + copy;
-        assert_eq!(add, Uint256([0xBD5B7DDFBD5B7DDEu64, 1, 0, 0]));
-        // Bitshifts
-        let shl = add << 88;
-        assert_eq!(shl, Uint256([0u64, 0xDFBD5B7DDE000000, 0x1BD5B7D, 0]));
-        let shr = shl >> 40;
-        assert_eq!(shr, Uint256([0x7DDE000000000000u64, 0x0001BD5B7DDFBD5B, 0, 0]));
-        // Increment
-        let mut incr = shr;
-        incr.increment();
-        assert_eq!(incr, Uint256([0x7DDE000000000001u64, 0x0001BD5B7DDFBD5B, 0, 0]));
-        // Subtraction
-        let sub = incr - init;
-        assert_eq!(sub, Uint256([0x9F30411021524112u64, 0x0001BD5B7DDFBD5A, 0, 0]));
-        // Multiplication
-        let mult = sub.mul_u32(300);
-        assert_eq!(mult, Uint256([0x8C8C3EE70C644118u64, 0x0209E7378231E632, 0, 0]));
-        // Division
-        assert_eq!(Uint256::from_u64(105).unwrap() /
-                   Uint256::from_u64(5).unwrap(),
-                   Uint256::from_u64(21).unwrap());
-        let div = mult / Uint256::from_u64(300).unwrap();
-        assert_eq!(div, Uint256([0x9F30411021524112u64, 0x0001BD5B7DDFBD5A, 0, 0]));
-        // TODO: bit inversion
-    }
-
-    #[test]
-    pub fn mul_u32_test() {
-        let u64_val = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
-
-        let u96_res = u64_val.mul_u32(0xFFFFFFFF);
-        let u128_res = u96_res.mul_u32(0xFFFFFFFF);
-        let u160_res = u128_res.mul_u32(0xFFFFFFFF);
-        let u192_res = u160_res.mul_u32(0xFFFFFFFF);
-        let u224_res = u192_res.mul_u32(0xFFFFFFFF);
-        let u256_res = u224_res.mul_u32(0xFFFFFFFF);
-
-        assert_eq!(u96_res, Uint256([0xffffffff21524111u64, 0xDEADBEEE, 0, 0]));
-        assert_eq!(u128_res, Uint256([0x21524111DEADBEEFu64, 0xDEADBEEE21524110, 0, 0]));
-        assert_eq!(u160_res, Uint256([0xBD5B7DDD21524111u64, 0x42A4822200000001, 0xDEADBEED, 0]));
-        assert_eq!(u192_res, Uint256([0x63F6C333DEADBEEFu64, 0xBD5B7DDFBD5B7DDB, 0xDEADBEEC63F6C334, 0]));
-        assert_eq!(u224_res, Uint256([0x7AB6FBBB21524111u64, 0xFFFFFFFBA69B4558, 0x854904485964BAAA, 0xDEADBEEB]));
-        assert_eq!(u256_res, Uint256([0xA69B4555DEADBEEFu64, 0xA69B455CD41BB662, 0xD41BB662A69B4550, 0xDEADBEEAA69B455C]));
-    }
-
-    #[test]
-    pub fn multiplication_test() {
-        let u64_val = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
-
-        let u128_res = u64_val * u64_val;
-
-        assert_eq!(u128_res, Uint256([0x048D1354216DA321u64, 0xC1B1CD13A4D13D46, 0, 0]));
-
-        let u256_res = u128_res * u128_res;
-
-        assert_eq!(u256_res, Uint256([0xF4E166AAD40D0A41u64, 0xF5CF7F3618C2C886u64,
-                                      0x4AFCFF6F0375C608u64, 0x928D92B4D7F5DF33u64]));
-    }
-
-    #[test]
-    pub fn uint256_bitslice_test() {
-        let init = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
-        let add = init + (init << 64);
-        assert_eq!(add.bit_slice(64, 128), init);
-        assert_eq!(add.mask(64), init);
-    }
-
-    #[test]
-    pub fn uint256_extreme_bitshift_test() {
-        // Shifting a u64 by 64 bits gives an undefined value, so make sure that
-        // we're doing the Right Thing here
-        let init = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
-
-        assert_eq!(init << 64, Uint256([0, 0xDEADBEEFDEADBEEF, 0, 0]));
-        let add = (init << 64) + init;
-        assert_eq!(add, Uint256([0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF, 0, 0]));
-        assert_eq!(add >> 0, Uint256([0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF, 0, 0]));
-        assert_eq!(add << 0, Uint256([0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF, 0, 0]));
-        assert_eq!(add >> 64, Uint256([0xDEADBEEFDEADBEEF, 0, 0, 0]));
-        assert_eq!(add << 64, Uint256([0, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF, 0]));
-    }
-
-    #[test]
-    pub fn uint256_serialize_test() {
-        let start1 = Uint256([0x8C8C3EE70C644118u64, 0x0209E7378231E632, 0, 0]);
-        let start2 = Uint256([0x8C8C3EE70C644118u64, 0x0209E7378231E632, 0xABCD, 0xFFFF]);
-        let serial1 = serialize(&start1);
-        let serial2 = serialize(&start2);
-        let end1: Result<Uint256, _> = deserialize(&serial1);
-        let end2: Result<Uint256, _> = deserialize(&serial2);
-
-        assert_eq!(end1.ok(), Some(start1));
-        assert_eq!(end2.ok(), Some(start2));
-    }
-}
-
diff --git a/tapyrus/CHANGELOG.md b/tapyrus/CHANGELOG.md
new file mode 100644
index 00000000..3e86cfcd
--- /dev/null
+++ b/tapyrus/CHANGELOG.md
@@ -0,0 +1,560 @@
+# 0.31.2 - 2024-04-01
+
+- Fix parsing bug in `merkle_block::deserialize` [#2614](https://github.com/rust-bitcoin/rust-bitcoin/pull/2614)
+
+# 0.31.1 - 2024-01-09
+
+- Fix bug in `FeeRate::checked_mul_by_weight` [#2128](https://github.com/rust-bitcoin/rust-bitcoin/pull/2182)
+- Add BIP-32 types remove in 0.31 back in and mark as deprecated [#2258](https://github.com/rust-bitcoin/rust-bitcoin/pull/2258)
+
+# 0.31.0 - 2023-10-18
+
+- Bump MSRV to Rust 1.48.0 [#1729](https://github.com/rust-bitcoin/rust-bitcoin/pull/1729)
+- Add new example code for signature verification [#1776](https://github.com/rust-bitcoin/rust-bitcoin/pull/1776)
+- Manually implement `Debug` on `Witness` [#1913](https://github.com/rust-bitcoin/rust-bitcoin/pull/1913)
+- Use new bech32 API [#1951](https://github.com/rust-bitcoin/rust-bitcoin/pull/1951) and [#2117](https://github.com/rust-bitcoin/rust-bitcoin/pull/2117)
+- Upgrade to `secp256k1 v0.28.0` [#2098](https://github.com/rust-bitcoin/rust-bitcoin/pull/2098)
+- Upgrade to `base64 v0.21.3` [#2032](https://github.com/rust-bitcoin/rust-bitcoin/pull/2032)
+
+- API Improvements:
+  - Add kilo weight unit conversion [#1735](https://github.com/rust-bitcoin/rust-bitcoin/pull/1735)
+  - Add `ChainHash::from_genesis_block_hash`[#1753](https://github.com/rust-bitcoin/rust-bitcoin/pull/1753)
+  - Add implementation of `PartialEq` trait for `Address<NetworkUnchecked>` [#1757](https://github.com/rust-bitcoin/rust-bitcoin/pull/1757)
+  - Add unsafe address type conversions [#1765](https://github.com/rust-bitcoin/rust-bitcoin/pull/1765)
+  - Add `Inventory::network_hash()` method [#515](https://github.com/rust-bitcoin/rust-bitcoin/pull/515)
+  - Implement `serde::Serialize` for `Address` [#1785](https://github.com/rust-bitcoin/rust-bitcoin/pull/1785)
+  - Expose valid (min, max) difficulty transition thresholds [#1820](https://github.com/rust-bitcoin/rust-bitcoin/pull/1820)
+  - Add functionality to generate `PrivateKey` [#1837](https://github.com/rust-bitcoin/rust-bitcoin/pull/1837)
+  - Allow parsing sub-sat denominations with decimal points [#1768](https://github.com/rust-bitcoin/rust-bitcoin/pull/1768)
+  - Fix associated constants of `InputWeightPrediction` [#1835](https://github.com/rust-bitcoin/rust-bitcoin/pull/1835)
+  - Add `FeeRate::checked_mul_by_weight` [#1864](https://github.com/rust-bitcoin/rust-bitcoin/pull/1864)
+  - Use `Amount` type for the `TxOut` value field [#1811](https://github.com/rust-bitcoin/rust-bitcoin/pull/1811)
+  - Add support for alloc-free parse errors [#1297](https://github.com/rust-bitcoin/rust-bitcoin/pull/1297)
+  - Add `Amount::from_int_btc` [#1870](https://github.com/rust-bitcoin/rust-bitcoin/pull/1870)
+  - Make `ckd_priv` function private and impl `AsRef` for `ChildNumber` [#1882](https://github.com/rust-bitcoin/rust-bitcoin/pull/1882)
+  - Use `hex_lit::hex` in benches (also backported to v0.30.1) [#1941](https://github.com/rust-bitcoin/rust-bitcoin/pull/1941)
+  - Add a verify function to `PublicKey` [#1911](https://github.com/rust-bitcoin/rust-bitcoin/pull/1911)
+  - Add method `Script::count_sigops` [#1890](https://github.com/rust-bitcoin/rust-bitcoin/pull/1890)
+  - Implement `From<PublicKey> for XOnlyPublicKey` [#1901](https://github.com/rust-bitcoin/rust-bitcoin/pull/1901)
+  - Implement `From<secp256k1::PublicKey> for tapyrus::PublicKey` [#1949](https://github.com/rust-bitcoin/rust-bitcoin/pull/1949)
+  - Add `DerivationPath::to_u32_vec` [#1946](https://github.com/rust-bitcoin/rust-bitcoin/pull/1946)
+  - Use `Target` as type for `pow_limit` [#2107](https://github.com/rust-bitcoin/rust-bitcoin/pull/2107)
+  - Add `Witness::p2wpkh` constructor [#2084](https://github.com/rust-bitcoin/rust-bitcoin/pull/2084)
+  - Make `Instruction` be able to read the script number [#2081](https://github.com/rust-bitcoin/rust-bitcoin/pull/2081)
+  - Add `Script::is_mulitsig` [#2078](https://github.com/rust-bitcoin/rust-bitcoin/pull/2078)
+  - Count sigops for `Transaction` [#2073](https://github.com/rust-bitcoin/rust-bitcoin/pull/2073)
+  - Add `Psbt` fee checks [#2064](https://github.com/rust-bitcoin/rust-bitcoin/pull/2064)
+  - Add version bytes consts [#2020](https://github.com/rust-bitcoin/rust-bitcoin/pull/2020)
+  - Add `transaction::Version` data type [#2006](https://github.com/rust-bitcoin/rust-bitcoin/pull/2006)
+
+- Moves, Removes, and renames:
+  - Move witness types to the script module [#1846](https://github.com/rust-bitcoin/rust-bitcoin/pull/1846)
+  - Remove reexport of `psbt::Prevouts` [#1872](https://github.com/rust-bitcoin/rust-bitcoin/pull/1872)
+  - Rename `Transaction::is_coin_base` to `is_coinbase` [#1796](https://github.com/rust-bitcoin/rust-bitcoin/pull/1796)
+  - Rename `TaprootSpendInfo::as_script_map` to `script_map` [#1897](https://github.com/rust-bitcoin/rust-bitcoin/pull/1897)
+  - Rename `Script::empty` to `Script::new` [#1925](https://github.com/rust-bitcoin/rust-bitcoin/pull/1925)
+  - Rename `PartiallySignedTransaction` to `Psbt` [#1938](https://github.com/rust-bitcoin/rust-bitcoin/pull/1938)
+  - Rename `XpubIdenifier` to `XKeyIdentifier` [#2021](https://github.com/rust-bitcoin/rust-bitcoin/pull/2021)
+  - Rename `ExtendedPubKey` to `Xpub` [#2019](https://github.com/rust-bitcoin/rust-bitcoin/pull/2019)
+  - Rename `ExtendedPrivKey` to `Xpriv` [#2019](https://github.com/rust-bitcoin/rust-bitcoin/pull/2019)
+  - Remove `_v0` from various function names (eg, `new_v0_p2wpkh`) [#1994](https://github.com/rust-bitcoin/rust-bitcoin/pull/1994)
+  - Remove `SighashCache::segwit_signature_hash` (add `p2wpkh_signiture_hash` and `p2wsh_signature_hash`) [#1995](https://github.com/rust-bitcoin/rust-bitcoin/pull/1995)
+  - Reexport all the hash types from the crate root [#1998](https://github.com/rust-bitcoin/rust-bitcoin/pull/1998)
+  - Rename `opcodes::All` to `Opcode` [#1995](https://github.com/rust-bitcoin/rust-bitcoin/pull/1995)
+  - Removed `TxOut::default()`, the same logic now exists as `TxOut::NULL` [#1811](https://github.com/rust-bitcoin/rust-bitcoin/pull/1811) and [#1838](https://github.com/rust-bitcoin/rust-bitcoin/pull/1838)
+
+- Error handling improvements:
+  - Improve `hashes::Error` [#1873](https://github.com/rust-bitcoin/rust-bitcoin/pull/1873)
+  - Add `ValidationError` [#1874](https://github.com/rust-bitcoin/rust-bitcoin/pull/1874)
+  - Improve `crypto::taproot` error type [#1895](https://github.com/rust-bitcoin/rust-bitcoin/pull/1895)
+  - Audit error types code base wide [#2101](https://github.com/rust-bitcoin/rust-bitcoin/pull/2101)
+
+# 0.30.1 - 2023-07-16
+
+- Fix compilation when [`RUSTFLAGS=--cfg=bench` is set](https://github.com/rust-bitcoin/rust-bitcoin/pull/1943)
+
+# 0.30 - 2023-03-21 "The First Crate-Smashing Release"
+
+We now have a website for crates that live under the `rust-bitcoin` GitHub organization: https://rust-bitcoin.org/
+
+This release is big, to help users upgrade we wrote a blog post, please see https://rust-bitcoin.org/blog/release-0.30.0/
+
+- [Import `bitcoin_hashes`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1284) into this repository.
+
+- Update dependencies we control
+  - Depend on the new private crate `bitcoin-private`
+  - Depend on the new `bitcoin_hashes` v0.12
+  - Depend on the new `secp256k1` v0.27
+
+- We moved a lot of modules around, specifically we move basically everything out of `util`.
+
+- API improvements:
+  - [Use marker type to enforce validation of `Address`'s network](https://github.com/rust-bitcoin/rust-bitcoin/pull/1489)
+  - [New `Witness` features](https://github.com/rust-bitcoin/rust-bitcoin/pull/1323)
+  - [`Witness` API improvements](https://github.com/rust-bitcoin/rust-bitcoin/pull/1380)
+  - Renamed `Script` to `ScriptBuf` and [added a new unsized type](https://github.com/rust-bitcoin/rust-bitcoin/pull/1155) `Script`
+  - [Add `tapscript_leaf_hash()` to `Script`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1485)
+  - [Unify `TapLeafHash` and `TapBranchHash` into `TapNodeHash` while tree construction](https://github.com/rust-bitcoin/rust-bitcoin/pull/1479)
+  - [Add `Script::builder` convenience function](https://github.com/rust-bitcoin/rust-bitcoin/pull/1312)
+  - [Implement `PartiallySignedTransaction::fee`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1338)
+  - [Implement `Script::p2pk_public_key(&self) -> Option<PublicKey>`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1412)
+  - [Add `log2` to `Work`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1437)
+  - [Add weight utilities to `TxIn` and `TxOut`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1467)
+  - [Add conversions for `TweakedKeyPair` -> `TweakedPublicKey`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1583)
+  - [Add `From<Address>` for `ScriptBuf`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1592)
+  - [Rename `from_slice` methods to `decode`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1621)
+  - [Add methods for pushing locktimes to scripts](https://github.com/rust-bitcoin/rust-bitcoin/pull/1629)
+  - [Create Address::matches_script_pubkey method](https://github.com/rust-bitcoin/rust-bitcoin/pull/1663)
+  - [Add API method `absolute::LockTime::is_satisfied_by_lock`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1258)
+  - [Add `FromHexStr`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1400) for parsing strings with and without `0x` prefix
+  - [Add CentiBitcoin to denominations](https://github.com/rust-bitcoin/rust-bitcoin/pull/1715)
+  - [Add `difficulty_float` method for `block::Header`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1720)
+
+- Various sighash code moves, and type improvements:
+  - [Improve `SighashCache` API](https://github.com/rust-bitcoin/rust-bitcoin/pull/1625)
+  - [Do not export unusual hash types at crate root](https://github.com/rust-bitcoin/rust-bitcoin/pull/1617)
+  - [Move sighash types around](https://github.com/rust-bitcoin/rust-bitcoin/pull/1597)
+  - [Try to fix up sighash export mess](https://github.com/rust-bitcoin/rust-bitcoin/pull/1277)
+
+- New types:
+  - `ScriptBuf` ([Implement unsized `Script`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1155).
+  - [Network `Magic`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1288)
+  - [Add `Weight` and `FeeRate` newtypes](https://github.com/rust-bitcoin/rust-bitcoin/pull/1627)
+  - [Add `Target` and `Work` types](https://github.com/rust-bitcoin/rust-bitcoin/pull/1197)
+  - [Add `relative::LockTime` type](https://github.com/rust-bitcoin/rust-bitcoin/pull/1196)
+
+- Removed types/traits:
+  - [Remove `ToHex`](https://github.com/rust-bitcoin/rust-bitcoin/pull/1531)
+  - [Remove code deprecated in v0.28](https://github.com/rust-bitcoin/rust-bitcoin/pull/1276)
+  - Remove `PackedLockTime`, [replace with richer `LockTime` everywhere](https://github.com/rust-bitcoin/rust-bitcoin/pull/1330)
+     Be aware that `LockTime` does not have an `Ord` implementation, so users who need a
+     total ordering on locktimes will be forced to wrap this type. In `Transaction`, which
+     contains a `LockTime` but is `Ord`, we have manually sorted the locktimes based on
+     their consensus encoding. This ordering is somewhat arbitrary -- there is no total
+     ordering on locktimes since they may be measured in either blocks or seconds.
+  - [Removed `FromHex` implementation](https://github.com/rust-bitcoin/rust-bitcoin/pull/1565) from
+    all types except `Vec` and arrays, replace where appropriate with `FromStr`.
+
+- Performance improvements:
+  - [Remove needless allocation from BIP-158 encoding](https://github.com/rust-bitcoin/rust-bitcoin/pull/1146)
+  - [Implement fast hex encoding](https://github.com/rust-bitcoin/rust-bitcoin/pull/1268) (usage added in a [later PR](https://github.com/rust-bitcoin/rust-bitcoin/pull/1476))
+
+- Testing improvements:
+  - Started using [kani](https://github.com/model-checking/kani)
+  - Started using [mutagen](https://github.com/llogiq/mutagen)
+
+# 0.29 - 2022-07-20 "Edition 2018 Release"
+
+As promised, this is our quick release to bring on edition 2018 by increasing our MSRV to Rust
+1.41.1 [#983](https://github.com/rust-bitcoin/rust-bitcoin/pull/983)
+
+This work saw a bunch of new language features become available to us. At the
+same time we were able to start using `rustfmt`. We also started linting as part
+of CI.
+
+## Breaking changes
+
+There are numerous breaking changes in this release related to the new language features but also
+other improvements such as more newtypes added. Note that not all changes cause compilation failure!
+For example, [`Witness` serialization was changed](https://github.com/rust-bitcoin/rust-bitcoin/pull/1068)
+to support human-readable formats.
+
+[Detailed list of breaking changes](https://github.com/rust-bitcoin/rust-bitcoin/pulls?q=is%3Apr+label%3A%22API+break%22+is%3Aclosed+milestone%3A0.29.0+)
+
+## Highlights
+
+- Added support for BIP 152 [#1088](https://github.com/rust-bitcoin/rust-bitcoin/pull/1088)
+- Edition 2018 improvements
+  - Implement `TryFrom` [#1007](https://github.com/rust-bitcoin/rust-bitcoin/pull/1007)
+  - Add `non_exhaustive` to all error enums [#1026](https://github.com/rust-bitcoin/rust-bitcoin/pull/1026)
+  - Various other improvements, see [tracking issue](https://github.com/rust-bitcoin/rust-bitcoin/issues/510) for more information.
+- Enable `clippy` on CI [#1061](https://github.com/rust-bitcoin/rust-bitcoin/pull/1061)
+- Taproot improvements
+  [#950](https://github.com/rust-bitcoin/rust-bitcoin/pull/950) [#936](https://github.com/rust-bitcoin/rust-bitcoin/pull/936)
+- serde improvements/changes
+  [#1006](https://github.com/rust-bitcoin/rust-bitcoin/pull/1006) [#905](https://github.com/rust-bitcoin/rust-bitcoin/pull/905)
+  [#1071](https://github.com/rust-bitcoin/rust-bitcoin/pull/1071) []
+- Performance improvements
+  [#1033](https://github.com/rust-bitcoin/rust-bitcoin/pull/1033) [#996](https://github.com/rust-bitcoin/rust-bitcoin/pull/996)
+  [#1053](https://github.com/rust-bitcoin/rust-bitcoin/pull/1053) [#1023](https://github.com/rust-bitcoin/rust-bitcoin/pull/1023)
+- PSBT improvements
+  [#853](https://github.com/rust-bitcoin/rust-bitcoin/pull/853) [#951] (https://github.com/rust-bitcoin/rust-bitcoin/pull/951)
+  [#940](https://github.com/rust-bitcoin/rust-bitcoin/pull/940)
+- Script improvements
+  [#1021](https://github.com/rust-bitcoin/rust-bitcoin/pull/1021) [#954](https://github.com/rust-bitcoin/rust-bitcoin/pull/954)
+- New types that may be of interest
+  - `Sequence`, transaction sequence number [#1093](https://github.com/rust-bitcoin/rust-bitcoin/pull/1093)
+  - `ChainHash`, as used in Lightning [#878](https://github.com/rust-bitcoin/rust-bitcoin/pull/878)
+  - `LockTime`, transaction nLockTime [#994](https://github.com/rust-bitcoin/rust-bitcoin/pull/994)
+- Improve pubkey sorting: [#1084](https://github.com/rust-bitcoin/rust-bitcoin/pull/1084)
+- Introduce `rustfmt` [#1040](https://github.com/rust-bitcoin/rust-bitcoin/pull/1040)
+- Dependencies
+  - Upgrade to use `bitcoinconsensus` v0.20.2-0.5.0 [#1165](https://github.com/rust-bitcoin/rust-bitcoin/pull/1165)
+  - Upgrade to use `secp256k1` v0.24.0 [#1110](https://github.com/rust-bitcoin/rust-bitcoin/pull/1110)
+  - Upgrade to use `bech32` v0.9.0 [#1131](https://github.com/rust-bitcoin/rust-bitcoin/pull/1131)
+  - Remove `base64-compat` in favour of `base64` [#993](https://github.com/rust-bitcoin/rust-bitcoin/pull/993)
+  - Do not pin transitive `ryu` dependency [#1013](https://github.com/rust-bitcoin/rust-bitcoin/pull/1013)
+- Take `Writer`/`Reader` by `&mut` in consensus en/decoding [#1035](https://github.com/rust-bitcoin/rust-bitcoin/pull/1035)
+- Consume `self` in conversion methods named `to_*` instead of borrowing [#1161](https://github.com/rust-bitcoin/rust-bitcoin/pull/1161)
+
+# 0.28.2 - 2022-11-01
+
+Backported a set of changes from 0.29 which may cause some specific
+transactions and/or blocks to fail to deserialize. No known such transactions
+exist on any public blockchain.
+
+# 0.28 - 2022-04-20 "The Taproot Release"
+
+At nearly nine months, this is our longest release cycle ever, and thanks
+to a huge increase in the number of active contributors this year and last,
+it is also **by far** our largest release ever, at 148 PRs merged from 23
+different contributors. Our primary goal in this release was to introduce
+support for Taproot and its associated data structures: addresses, taptrees,
+sighashes, PSBT fields, and more. As it turned out, these changes required
+(or at least, incentivized) changing a lot of our APIs, causing a significant
+increase in scope.
+
+We have more big changes coming down the pike. 2022 is going to be a big
+year for `rust-bitcoin`, which we know is exciting for us but disruptive to
+downstream users who ultimately want the library to just work. Our hope is
+that by 2023 we will have eliminated large amounts of technical debt,
+modernized our APIs to meet current Rust conventions, and clarified the scope
+of the individual crates in this ecosystem while still providing the essential
+functionality needed by our downstream users, especially wallet projects.
+
+We will also develop a plan to make our releases more predictable and manageable,
+likely by having scheduled releases with limited scope. We would like to reach
+a point where we no longer have frequent breaking releases, but right now we
+are nowhere close.
+
+Upcoming changes will include
+- A quick new release which updates our MRSV from 1.29 to 1.41 and does little else
+- Updating our codebase to take advantage of the new MSRV, especially regarding
+nostd and wasm support
+- A comprehensive rethinking and flattening of our public-facing APIs
+- Richer support for PSBT, Script, and BIP-0340/Schnorr signatures
+
+With so many changes since 0.27, we cannot list every PR. Here are the highlights:
+
+- Remove dangerous `fuzztarget` cargo feature [#634](https://github.com/rust-bitcoin/rust-bitcoin/pull/634)
+- Improve serde serialization for `Script` [#596](https://github.com/rust-bitcoin/rust-bitcoin/pull/596)
+- Documentation improvements [#623](https://github.com/rust-bitcoin/rust-bitcoin/pull/623) [#633](https://github.com/rust-bitcoin/rust-bitcoin/pull/633) [#663](https://github.com/rust-bitcoin/rust-bitcoin/pull/663) [#689](https://github.com/rust-bitcoin/rust-bitcoin/pull/689) [#704](https://github.com/rust-bitcoin/rust-bitcoin/pull/704) [#744](https://github.com/rust-bitcoin/rust-bitcoin/pull/744) [#852](https://github.com/rust-bitcoin/rust-bitcoin/pull/852) [#869](https://github.com/rust-bitcoin/rust-bitcoin/pull/869) [#865](https://github.com/rust-bitcoin/rust-bitcoin/pull/865) [#864](https://github.com/rust-bitcoin/rust-bitcoin/pull/864) [#858](https://github.com/rust-bitcoin/rust-bitcoin/pull/858) [#806](https://github.com/rust-bitcoin/rust-bitcoin/pull/806) [#877](https://github.com/rust-bitcoin/rust-bitcoin/pull/877) [#912](https://github.com/rust-bitcoin/rust-bitcoin/pull/912) [#923](https://github.com/rust-bitcoin/rust-bitcoin/pull/923)
+- Introduce `WitnessVersion` type [#617](https://github.com/rust-bitcoin/rust-bitcoin/pull/617)
+- Improve error types and API [#625](https://github.com/rust-bitcoin/rust-bitcoin/pull/625)
+- Implement `Block.get_strippedsize()` and `Transaction.get_vsize()` [#626](https://github.com/rust-bitcoin/rust-bitcoin/pull/626)
+- Add Bloom filter network messages [#580](https://github.com/rust-bitcoin/rust-bitcoin/pull/580)
+- **Taproot:** add signature hash support [#628](https://github.com/rust-bitcoin/rust-bitcoin/pull/628) [#702](https://github.com/rust-bitcoin/rust-bitcoin/pull/702) [#722](https://github.com/rust-bitcoin/rust-bitcoin/pull/722) [#835](https://github.com/rust-bitcoin/rust-bitcoin/pull/835) [#903](https://github.com/rust-bitcoin/rust-bitcoin/pull/903) [#796](https://github.com/rust-bitcoin/rust-bitcoin/pull/796)
+- **Taproot:** add new Script opcodes [#644](https://github.com/rust-bitcoin/rust-bitcoin/pull/644) [#721](https://github.com/rust-bitcoin/rust-bitcoin/pull/721) [#868](https://github.com/rust-bitcoin/rust-bitcoin/pull/868) [#920](https://github.com/rust-bitcoin/rust-bitcoin/pull/920)
+- **Taproot:** add bech32m support, addresses and new key types [#563](https://github.com/rust-bitcoin/rust-bitcoin/pull/563) [#691](https://github.com/rust-bitcoin/rust-bitcoin/pull/691) [#697](https://github.com/rust-bitcoin/rust-bitcoin/pull/697) [#728](https://github.com/rust-bitcoin/rust-bitcoin/pull/728) [#696](https://github.com/rust-bitcoin/rust-bitcoin/pull/696) [#757](https://github.com/rust-bitcoin/rust-bitcoin/pull/757)
+- **Taproot:** add taptree data structures [#677](https://github.com/rust-bitcoin/rust-bitcoin/pull/677) [#703](https://github.com/rust-bitcoin/rust-bitcoin/pull/703) [#701](https://github.com/rust-bitcoin/rust-bitcoin/pull/701) [#718](https://github.com/rust-bitcoin/rust-bitcoin/pull/718) [#845](https://github.com/rust-bitcoin/rust-bitcoin/pull/845) [#901](https://github.com/rust-bitcoin/rust-bitcoin/pull/901) [#910](https://github.com/rust-bitcoin/rust-bitcoin/pull/910) [#909](https://github.com/rust-bitcoin/rust-bitcoin/pull/909) [#914](https://github.com/rust-bitcoin/rust-bitcoin/pull/914)
+- no-std improvements [#637](https://github.com/rust-bitcoin/rust-bitcoin/pull/637)
+- PSBT improvements, including Taproot [#654](https://github.com/rust-bitcoin/rust-bitcoin/pull/654) [#681](https://github.com/rust-bitcoin/rust-bitcoin/pull/681) [#669](https://github.com/rust-bitcoin/rust-bitcoin/pull/669) [#774](https://github.com/rust-bitcoin/rust-bitcoin/pull/774) [#779](https://github.com/rust-bitcoin/rust-bitcoin/pull/779) [#752](https://github.com/rust-bitcoin/rust-bitcoin/pull/752) [#776](https://github.com/rust-bitcoin/rust-bitcoin/pull/776) [#790](https://github.com/rust-bitcoin/rust-bitcoin/pull/790) [#836](https://github.com/rust-bitcoin/rust-bitcoin/pull/836) [#847](https://github.com/rust-bitcoin/rust-bitcoin/pull/847) [#842](https://github.com/rust-bitcoin/rust-bitcoin/pull/842)
+- serde improvements [#672](https://github.com/rust-bitcoin/rust-bitcoin/pull/672)
+- Update rust-secp256k1 dependency [#694](https://github.com/rust-bitcoin/rust-bitcoin/pull/694) [#755](https://github.com/rust-bitcoin/rust-bitcoin/pull/755) [#875](https://github.com/rust-bitcoin/rust-bitcoin/pull/875)
+- Change BIP32 to use rust-secp256k1 keys rather than rust-bitcoin ones (no compressedness flag) [#590](https://github.com/rust-bitcoin/rust-bitcoin/pull/590) [#591](https://github.com/rust-bitcoin/rust-bitcoin/pull/591)
+- Rename inner key field in `PrivateKey` and `PublicKey` [#762](https://github.com/rust-bitcoin/rust-bitcoin/pull/762)
+- Address and denomination related changes [#768](https://github.com/rust-bitcoin/rust-bitcoin/pull/768) [#784](https://github.com/rust-bitcoin/rust-bitcoin/pull/784)
+- Don't allow hybrid EC keys [#829](https://github.com/rust-bitcoin/rust-bitcoin/pull/829)
+- Change erroneous behavior for `SIGHASH_SINGLE` bug [#860](https://github.com/rust-bitcoin/rust-bitcoin/pull/860) [#897](https://github.com/rust-bitcoin/rust-bitcoin/pull/897)
+- Delete the deprecated `contracthash` module [#871](https://github.com/rust-bitcoin/rust-bitcoin/pull/871); this functionality will migrate to ElementsProject/rust-elements
+- Remove compilation-breaking feature-gating of enum variants" [#881](https://github.com/rust-bitcoin/rust-bitcoin/pull/881)
+
+Additionally we made several minor API changes (renaming methods, etc.) to improve
+compliance with modern Rust conventions. Where possible we left the existing methods
+in place, marked as deprecated.
+
+# 0.27 - 2021-07-21
+
+- [Bigendian fixes and CI test](https://github.com/rust-bitcoin/rust-bitcoin/pull/627)
+- [no_std support, keeping MSRV](https://github.com/rust-bitcoin/rust-bitcoin/pull/603)
+- [Bech32m adoption](https://github.com/rust-bitcoin/rust-bitcoin/pull/601)
+- [Use Amount type for dust value calculation](https://github.com/rust-bitcoin/rust-bitcoin/pull/616)
+- [Errors enum improvements](https://github.com/rust-bitcoin/rust-bitcoin/pull/521)
+- [std -> core](https://github.com/rust-bitcoin/rust-bitcoin/pull/614)
+
+# 0.26.2 - 2021-06-08
+
+- [Fix `Display` impl of `ChildNumber`](https://github.com/rust-bitcoin/rust-bitcoin/pull/611)
+
+The previous release changed the behavior of `Display` for `ChildNumber`, assuming that any correct usage would not be
+affected. [Issue 608](https://github.com/rust-bitcoin/rust-bitcoin/issues/608) goes into the details of why this isn't
+the case and how we broke both `rust-miniscript` and BDK.
+
+# 0.26.1 - 2021-06-06 (yanked, see explanation above)
+
+- [Change Amount Debug impl to BTC with 8 decimals](https://github.com/rust-bitcoin/rust-bitcoin/pull/414)
+- [Make uint types (un)serializable](https://github.com/rust-bitcoin/rust-bitcoin/pull/511)
+- Add [more derives for key::Error](https://github.com/rust-bitcoin/rust-bitcoin/pull/551)
+- [Fix optional amount serialization](https://github.com/rust-bitcoin/rust-bitcoin/pull/552)
+- Add [PSBT base64 (de)serialization with Display & FromStr](https://github.com/rust-bitcoin/rust-bitcoin/pull/557)
+- Add [non-API breaking derives for error & transaction types](https://github.com/rust-bitcoin/rust-bitcoin/pull/558)
+- [Fix error derives](https://github.com/rust-bitcoin/rust-bitcoin/pull/559)
+- [Add function to check RBF-ness of transactions](https://github.com/rust-bitcoin/rust-bitcoin/pull/565)
+- [Add Script:dust_value() to get minimum output value for a spk](https://github.com/rust-bitcoin/rust-bitcoin/pull/566)
+- [Improving bip32 ChildNumber display implementation](https://github.com/rust-bitcoin/rust-bitcoin/pull/567)
+- [Make Script::fmt_asm a static method and add Script::str_asm ](https://github.com/rust-bitcoin/rust-bitcoin/pull/569)
+- [Return BlockHash from BlockHeader::validate_pow](https://github.com/rust-bitcoin/rust-bitcoin/pull/572)
+- [Add a method to error on non-standard hashtypes](https://github.com/rust-bitcoin/rust-bitcoin/pull/573)
+- [Include proprietary key in deserialized PSBT](https://github.com/rust-bitcoin/rust-bitcoin/pull/577)
+- [Fix Script::dust_value()'s calculation for non-P2*PKH script_pubkeys](https://github.com/rust-bitcoin/rust-bitcoin/pull/579)
+- Add [Address to optimized QR string](https://github.com/rust-bitcoin/rust-bitcoin/pull/581) conversion
+- [Correct Transaction struct encode_signing_data_to doc comment](https://github.com/rust-bitcoin/rust-bitcoin/pull/582)
+- Fixing [CI if base image's apt db is outdated](https://github.com/rust-bitcoin/rust-bitcoin/pull/583)
+- [Introduce some policy constants from Bitcoin Core](https://github.com/rust-bitcoin/rust-bitcoin/pull/584)
+- [Fix warnings for sighashtype](https://github.com/rust-bitcoin/rust-bitcoin/pull/586)
+- [Introduction of Schnorr keys](https://github.com/rust-bitcoin/rust-bitcoin/pull/589)
+- Adding [constructors for compressed and uncompressed ECDSA keys](https://github.com/rust-bitcoin/rust-bitcoin/pull/592)
+- [Count bytes read in encoding](https://github.com/rust-bitcoin/rust-bitcoin/pull/594)
+- [Add verify_with_flags to Script and Transaction](https://github.com/rust-bitcoin/rust-bitcoin/pull/598)
+- [Fixes documentation intra-links and enforce it](https://github.com/rust-bitcoin/rust-bitcoin/pull/600)
+- [Fixing hashes core dependency and fuzz feature](https://github.com/rust-bitcoin/rust-bitcoin/pull/602)
+
+# 0.26.0 - 2020-12-21
+
+- Add [signet support](https://github.com/rust-bitcoin/rust-bitcoin/pull/291)
+- Add [wtxidrelay message and `WTx` inv type](https://github.com/rust-bitcoin/rust-bitcoin/pull/446) for BIP 339
+- Add [addrv2 support](https://github.com/rust-bitcoin/rust-bitcoin/pull/449)
+- Distinguish [`FilterHeader` and `FilterHash`](https://github.com/rust-bitcoin/rust-bitcoin/pull/454)
+- Add [hash preimage fields](https://github.com/rust-bitcoin/rust-bitcoin/pull/478) to PSBT
+- Detect [write errors for `PublicKey::write_into`](https://github.com/rust-bitcoin/rust-bitcoin/pull/507)
+- impl `Ord` and `PartialOrd` [for `Inventory`](https://github.com/rust-bitcoin/rust-bitcoin/pull/517)
+- Add [binary encoding for BIP32 xkeys](https://github.com/rust-bitcoin/rust-bitcoin/pull/470)
+- Add [Taproot Tagged Hashes](https://github.com/rust-bitcoin/rust-bitcoin/pull/259)
+- Add [`message::MAX_INV_SIZE` constant](https://github.com/rust-bitcoin/rust-bitcoin/pull/516)
+- impl [`ToSocketAddrs` for network addresses](https://github.com/rust-bitcoin/rust-bitcoin/pull/514)
+- Add [new global fields to PSBT](https://github.com/rust-bitcoin/rust-bitcoin/pull/499)
+- [Serde serialization of PSBT data](https://github.com/rust-bitcoin/rust-bitcoin/pull/497)
+- [Make `Inventory` and `NetworkMessage` enums exhaustive](https://github.com/rust-bitcoin/rust-bitcoin/pull/496)
+- [Add PSBT proprietary keys](https://github.com/rust-bitcoin/rust-bitcoin/pull/471)
+- [Add `PublicKey::read_from` method symmetric with `write_to`](https://github.com/rust-bitcoin/rust-bitcoin/pull/542)
+- [Bump rust-secp to 0.20, turn off `recovery` feature by default](https://github.com/rust-bitcoin/rust-bitcoin/pull/545)
+- [Change return value of `consensus_encode` to `io::Error`](https://github.com/rust-bitcoin/rust-bitcoin/pull/494)
+
+# 0.25.1 - 2020-10-26
+
+- Remove an incorrect `debug_assert` that can cause a panic when running using
+  the dev profile.
+
+# 0.25.1 - 2020-10-07
+
+- [Expose methods on `Script`](https://github.com/rust-bitcoin/rust-bitcoin/pull/387) to generate various scriptpubkeys
+- [Expose all cargo features of secp256k1](https://github.com/rust-bitcoin/rust-bitcoin/pull/486)
+- Allow directly creating [various hash newtypes](https://github.com/rust-bitcoin/rust-bitcoin/pull/388)
+- Add methods to `Block` [to get the coinbase tx and BIP34 height commitment](https://github.com/rust-bitcoin/rust-bitcoin/pull/444)
+- [Add `extend` method](https://github.com/rust-bitcoin/rust-bitcoin/pull/459) to bip32::DerivationPath
+- [Alias `(Fingerprint, DerivationPath)` as `KeySource`](https://github.com/rust-bitcoin/rust-bitcoin/pull/480)
+- [Add serde implementation for PSBT data structs](https://github.com/rust-bitcoin/rust-bitcoin/pull/497)
+- [Add FromStr/Display implementation for SigHashType](https://github.com/rust-bitcoin/rust-bitcoin/pull/497/commits/a4a7035a947998c8d0d69dab206e97253fd8e048)
+- Expose [the raw sighash message](https://github.com/rust-bitcoin/rust-bitcoin/pull/485) from sighash computations
+- Add [support for signmessage/verifymessage style message signatures](https://github.com/rust-bitcoin/rust-bitcoin/pull/413)
+
+# 0.25.0 - 2020-09-10
+
+- **Bump MSRV to 1.29.0**
+
+# 0.24.0 - 2020-09-10
+
+- [Remove](https://github.com/rust-bitcoin/rust-bitcoin/pull/385) the `BitcoinHash` trait
+- [Introduce `SigHashCache` structure](https://github.com/rust-bitcoin/rust-bitcoin/pull/390) to replace `SighashComponents` and support all sighash modes
+- [Add](https://github.com/rust-bitcoin/rust-bitcoin/pull/416) `Transaction::get_size` method
+- [Export](https://github.com/rust-bitcoin/rust-bitcoin/pull/412) `util::amount::Denomination`
+- [Add](https://github.com/rust-bitcoin/rust-bitcoin/pull/417) `Block::get_size` and `Block::get_weight` methods
+- [Add](https://github.com/rust-bitcoin/rust-bitcoin/pull/415) `MerkleBlock::from_header_txids`
+- [Add](https://github.com/rust-bitcoin/rust-bitcoin/pull/429) `BlockHeader::u256_from_compact_target`
+- [Add](https://github.com/rust-bitcoin/rust-bitcoin/pull/448) `feefilter` network message
+- [Cleanup/replace](https://github.com/rust-bitcoin/rust-bitcoin/pull/397) `Script::Instructions` iterator API
+- [Disallow uncompressed pubkeys in witness address generation](https://github.com/rust-bitcoin/rust-bitcoin/pull/428)
+- [Deprecate](https://github.com/rust-bitcoin/rust-bitcoin/pull/451) `util::contracthash` module
+- [Add](https://github.com/rust-bitcoin/rust-bitcoin/pull/435) modulo division operation for `Uint128` and `Uint256`
+- [Add](https://github.com/rust-bitcoin/rust-bitcoin/pull/436) `slice_to_u64_be` endian conversion method
+
+# 0.23.0 - 2020-01-07
+
+- Update `secp256k1` dependency to `0.17.1`.
+- Update `bitcoinconsensus` dependency to `0.19.0-1`.
+- Update `bech32` dependency to `0.7.2`.
+
+# 0.22.0 - 2020-01-07
+
+- Add `ServiceFlags` type.
+- Add `NetworkMessage::command`.
+- Add `key::Error`.
+- Add newtypes for specific hashes:
+    - `Txid`
+    - `Wtxid`
+    - `BlockHash`
+    - `SigHash`
+    - `PubkeyHash`
+    - `ScriptHash`
+    - `WPubkeyHash`
+    - `WScriptHash`
+    - `TxMerkleNode`
+    - `WitnessMerkleNode`
+    - `WitnessCommitment`
+    - `XpubIdentifier`
+    - `FilterHash`
+- Refactor `CommandString`.
+- Refactor `Reject` message.
+- Rename `RejectReason` enum variants.
+- Refactor `encode::Error`.
+- Implement `Default` for `TxIn`.
+- Implement `std::hash::Hash` for `Inventory`.
+- Implement `Copy` for `InvType` enum.
+- Use `psbt::Error` in `PartiallySignedTransaction::from_unsigned_tx`.
+- Drop message decode max length to 4_000_000.
+- Drop `hex` and `byteorder` dependencies.
+
+# 0.21.0 - 2019-10-02
+
+* Add [serde to `BlockHeader` and `Block`](https://github.com/rust-bitcoin/rust-bitcoin/pull/321)
+* [Clean up `StreamReader` API](https://github.com/rust-bitcoin/rust-bitcoin/pull/318) (breaking change)
+* Add [reject message](https://github.com/rust-bitcoin/rust-bitcoin/pull/323) to p2p messages
+
+# 0.20.0 - 2019-08-23
+
+* Update `secp256k1` 0.15 and `bitcoinconsensus` 0.17
+
+# 0.19.0 - 2019-08-16
+
+* Add `Amount` and `SignedAmount` types.
+* Add BIP-158 support with `BlockFilter` and related types.
+* Add `util::misc::signed_msg_hash()` for signing messages.
+* Add `MerkleBlock` and `PartialMerkleTree` types.
+* bip32: Support serde serializaton for types and add some utility methods:
+    * `ChildNumber::increment`
+    * `DerivationPath::children_from`
+    * `DerivationPath::normal_children`
+    * `DerivationPath::hardened_children`
+* Add `blockdata::script::Builder::push_verify` to verify-ify an opcode.
+* Add `sendheaders` network message.
+* Add `OutPoint::new()` method and JSON-serialize as `<txid>:<vout>`.
+* Refactor `Address` type:
+    * Now supports segwit addresses with version >0.
+    * Add `Address::from_script` constructor.
+    * Add `Address::address_type` inspector.
+    * Parsing now returns an `address::Error` instead of `encode::Error`.
+    * Removed `bitcoin_bech32` dependency for bech32 payloads.
+* bip143: Rename `witness_script` to `script_code`
+* Rename `BlockHeader::spv_validate` to `validate_pow`
+* Rename `OP_NOP2` and `OP_NOP3` to `OP_CLTV` and `OP_CSV`
+* psbt: Use `BTreeMap` instead of `HashMap` to ensure serialization roundtrips.
+* Drop `Decimal` type.
+* Drop `LoneHeaders` type.
+* Replace `strason` dependency with (optional) `serde_json`.
+* Export the `bitcoin_hashes` and `secp256k1` dependent crates.
+* Updated `bitcoin_hashes` dependency to v0.7.
+* Removed `rand` and `serde_test` dependencies.
+* Internal improvements to consensus encoding logic.
+
+# 0.18.0 - 2019-03-21
+
+* Update `bitcoin-bech32` version to 0.9
+* add `to_bytes` method for `util::key` types
+* add serde impls for `util::key` types
+* contracthash: minor cleanups, use `util::key` types instead of `secp256k1` types
+
+# 0.17.1 - 2019-03-04
+
+* Add some trait impls to `PublicKey` for miniscript interoperability
+
+# 0.17.0 - 2019-02-28 - ``The PSBT Release''
+
+* **Update minimum rustc version to 1.22**.
+* [Replace `rust-crypto` with `bitcoin_hashes`; refactor hash types](https://github.com/rust-bitcoin/rust-bitcoin/pull/215)
+* [Remove `Address::p2pk`](https://github.com/rust-bitcoin/rust-bitcoin/pull/222/)
+* Remove misleading blanket `MerkleRoot` implementation; [it is now only defined for `Block`](https://github.com/rust-bitcoin/rust-bitcoin/pull/218)
+* [Add BIP157](https://github.com/rust-bitcoin/rust-bitcoin/pull/215) (client-side block filtering messages)
+* Allow network messages [to be deserialized even across multiple packets](https://github.com/rust-bitcoin/rust-bitcoin/pull/231)
+* [Replace all key types](https://github.com/rust-bitcoin/rust-bitcoin/pull/183) to better match abstractions needed for PSBT
+* [Clean up BIP32](https://github.com/rust-bitcoin/rust-bitcoin/pull/233) in preparation for PSBT; [use new native key types rather than `secp256k1` ones](https://github.com/rust-bitcoin/rust-bitcoin/pull/238/)
+* Remove [apparently-used `Option` serialization](https://github.com/rust-bitcoin/rust-bitcoin/pull/236#event-2158116421) code
+* Finally merge [PSBT](https://github.com/rust-bitcoin/rust-bitcoin/pull/103) after nearly nine months
+
+# 0.16.0 - 2019-01-15
+
+* Reorganize opcode types to eliminate unsafe code
+* Un-expose some macros that were unintentionally exported
+* Update rust-secp256k1 dependency to 0.12
+* Remove `util::iter::Pair` type which does not belong in this library
+* Minor bugfixes and optimizations
+
+# 0.15.1 - 2018-11-08
+
+* [Detect p2pk addresses with compressed keys](https://github.com/rust-bitcoin/rust-bitcoin/pull/189)
+
+# 0.15.0 - 2018-11-03
+
+* [Significant API overhaul](https://github.com/rust-bitcoin/rust-bitcoin/pull/156):
+    * Remove `nu_select` macro and low-level networking support
+    * Move `network::consensus_params` to `consensus::params`
+    * Move many other things into `consensus::params`
+    * Move `BitcoinHash` from `network::serialize` to `util::hash`; remove impl for `Vec<u8>`
+    * Rename/restructure error types
+    * Rename `Consensus{De,En}coder` to `consensus::{De,En}coder`
+    * Replace `Raw{De,En}coder` with blanket impls of `consensus::{De,En}coder` on `io::Read` and `io::Write`
+    * make `serialize` and `serialize_hex` infallible
+* Make 0-input transaction de/serialization [always use segwit](https://github.com/rust-bitcoin/rust-bitcoin/pull/153)
+* Implement `FromStr` and `Display` for many more types
+
+# 0.14.2 - 2018-09-11
+
+* Add serde support for `Address`
+
+# 0.14.1 - 2018-08-28
+
+* Reject non-compact `VarInt`s on various types
+* Expose many types at the top level of the crate
+* Add `Ord`, `PartialOrd` impls for `Script`
+
+# 0.14.0 - 2018-08-22
+
+* Add [regtest network](https://github.com/rust-bitcoin/rust-bitcoin/pull/84) to `Network` enum
+* Add [`Script::is_op_return()`](https://github.com/rust-bitcoin/rust-bitcoin/pull/101/) which is more specific than
+  `Script::is_provably_unspendable()`
+* Update to bech32 0.8.0; [add Regtest bech32 address support](https://github.com/rust-bitcoin/rust-bitcoin/pull/110)
+* [Replace rustc-serialize dependency with hex](https://github.com/rust-bitcoin/rust-bitcoin/pull/107) as a stopgap
+  toward eliminating any extra dependencies for this; clean up the many independent hex encoders and decoders
+  throughout the codebase.
+* [Add conversions between `ChildNumber` and `u32`](https://github.com/rust-bitcoin/rust-bitcoin/pull/126); make
+  representation non-public; fix documentation
+* [Add several derivation convenience](https://github.com/rust-bitcoin/rust-bitcoin/pull/129) to `bip32` extended keys
+* Make `deserialize::deserialize()` [enforce no trailing bytes](https://github.com/rust-bitcoin/rust-bitcoin/pull/129)
+* Replace `TxOutRef` with `OutPoint`; use it in `TxIn` struct.
+* Use modern `as_` `to_` `into_` conventions for array-wrapping types; impl `Display` rather than `ToString` for most types
+* Change `script::Instructions` iterator [to allow rejecting non-minimal pushes](https://github.com/rust-bitcoin/rust-bitcoin/pull/136);
+  fix bug where errors would iterate forever.
+* Overhaul `util::Error`; introduce `serialize::Error` [and use it for `SimpleDecoder` and `SimpleDecoder` rather
+  than parameterizing these over their error type](https://github.com/rust-bitcoin/rust-bitcoin/pull/137).
+* Overhaul `UDecimal` and `Decimal` serialization and parsing [and fix many lingering parsing bugs](https://github.com/rust-bitcoin/rust-bitcoin/pull/142)
+* [Update to serde 1.0 and strason 0.4](https://github.com/rust-bitcoin/rust-bitcoin/pull/125)
+* Update to secp256k1 0.11.0
+* Many, many documentation and test improvements.
+
+# 0.13.1
+
+* Add `Display` trait to uints, `FromStr` trait to `Network` enum
+* Add witness inv types to inv enum, constants for Bitcoin regtest network, `is_coin_base` accessor for tx inputs
+* Expose `merkleroot(Vec<Sha256dHash>)`
+
+# 0.13
+
+* Move witnesses inside the `TxIn` structure
+* Add `Transaction::get_weight()`
+* Update bip143 `sighash_all` API to be more ergonomic
+
+# 0.12
+
+* The in-memory blockchain was moved into a dedicated project rust-bitcoin-chain.
+* Removed old script interpreter
+* A new optional feature "bitcoinconsensus" lets this library use Bitcoin Core's native
+script verifier, wrappend into Rust by the rust-bitcoinconsenus project.
+See `Transaction::verify` and `Script::verify` methods.
+* Replaced Base58 traits with `encode_slice`, `check_encode_slice`, from and `from_check` functions in the base58 module.
+* Un-reversed the Debug output for Sha256dHash
+* Add bech32 support
+* Support segwit address types
+
+### 0.11
+
+* Remove `num` dependency at Matt's request; agree this is obnoxious to require all
+downstream users to also have a `num` dependency just so they can use `Uint256::from_u64`.
diff --git a/tapyrus/Cargo.toml b/tapyrus/Cargo.toml
new file mode 100644
index 00000000..f31c7c26
--- /dev/null
+++ b/tapyrus/Cargo.toml
@@ -0,0 +1,73 @@
+[package]
+name = "tapyrus"
+version = "0.5.0"
+authors = ["Kohei Taniguchi <kohei@chaintope.com>", "Hajime Yamaguchi <h_yamaguchi@chaintope.com>"]
+license = "MIT"
+homepage = "https://github.com/chaintope/rust-tapyrus/"
+repository = "https://github.com/chaintope/rust-tapyrus/"
+description = "General purpose library for using and interoperating with Tapyrus."
+keywords = [ "crypto", "tapyrus" ]
+readme = "../README.md"
+edition = "2018"
+exclude = ["tests", "contrib"]
+
+[features]
+default = [ "std", "secp-recovery" ]
+rand-std = ["secp256k1/rand-std", "std"]
+rand = ["secp256k1/rand"]
+serde = ["actual-serde", "hashes/serde", "secp256k1/serde", "internals/serde"]
+secp-lowmemory = ["secp256k1/lowmemory"]
+secp-recovery = ["secp256k1/recovery"]
+bitcoinconsensus-std = ["bitcoinconsensus/std", "std"]
+
+# At least one of std, no-std must be enabled.
+#
+# The no-std feature doesn't disable std - you need to turn off the std feature for that by disabling default.
+# Instead no-std enables additional features required for this crate to be usable without std.
+# As a result, both can be enabled without conflict.
+std = ["secp256k1/std", "hashes/std", "bech32/std", "internals/std", "hex/std"]
+no-std = ["core2", "hashes/alloc", "hashes/core2", "bech32/alloc", "secp256k1/alloc", "hex/alloc", "hex/core2"]
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[dependencies]
+internals = { package = "tapyrus-internals", path = "../internals" }
+hex = { package = "hex-conservative", version = "0.1.1", default-features = false }
+bech32 = { version = "0.10.0-beta", default-features = false }
+hashes = { package = "tapyrus_hashes", path = "../hashes", default-features = false }
+secp256k1 = { version = "0.28.0", default-features = false, features = ["hashes"] }
+hex_lit = "0.1.1"
+
+base64 = { version = "0.21.3", optional = true }
+# Only use this feature for no-std builds, otherwise use bitcoinconsensus-std.
+bitcoinconsensus = { version = "0.20.2-0.5.0", default-features = false, optional = true }
+
+# There is no reason to use this dependency directly, it is activated by the "no-std" feature.
+core2 = { version = "0.3.2", default-features = false, features = ["alloc"], optional = true }
+# Do NOT use this as a feature! Use the `serde` feature instead.
+actual-serde = { package = "serde", version = "1.0.103", default-features = false, features = [ "derive", "alloc" ], optional = true }
+
+num-bigint = { version = "=0.4.4", default-features = false, features = ["rand"] }
+num-integer ={ version = "0.1", default-features = false }
+num-traits = { version = "0.2", default-features = false }
+
+[dev-dependencies]
+serde_json = "1.0.0"
+serde_test = "1.0.19"
+serde_derive = "1.0.103"
+bincode = "1.3.1"
+
+[target.'cfg(mutate)'.dev-dependencies]
+mutagen = { git = "https://github.com/llogiq/mutagen" }
+
+[[example]]
+name = "bip32"
+
+[[example]]
+name = "handshake"
+required-features = ["std", "rand-std"]
+
+[lints.rust]
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(fuzzing)', 'cfg(kani)', 'cfg(mutate)', 'cfg(rust_v_1_60)'] }
diff --git a/tapyrus/build.rs b/tapyrus/build.rs
new file mode 100644
index 00000000..4621b7f1
--- /dev/null
+++ b/tapyrus/build.rs
@@ -0,0 +1,31 @@
+fn main() {
+    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
+    let output = std::process::Command::new(rustc)
+        .arg("--version")
+        .output()
+        .expect("Failed to run rustc --version");
+    assert!(output.status.success(), "Failed to get rust version");
+    let stdout = String::from_utf8(output.stdout).expect("rustc produced non-UTF-8 output");
+    let version_prefix = "rustc ";
+    if !stdout.starts_with(version_prefix) {
+        panic!("unexpected rustc output: {}", stdout);
+    }
+
+    let version = &stdout[version_prefix.len()..];
+    let end = version.find(&[' ', '-'] as &[_]).unwrap_or(version.len());
+    let version = &version[..end];
+    let mut version_components = version.split('.');
+    let major = version_components.next().unwrap();
+    assert_eq!(major, "1", "Unexpected Rust version");
+    let minor = version_components
+        .next()
+        .unwrap_or("0")
+        .parse::<u64>()
+        .expect("invalid Rust minor version");
+
+    for activate_version in &[53, 60] {
+        if minor >= *activate_version {
+            println!("cargo:rustc-cfg=rust_v_1_{}", activate_version);
+        }
+    }
+}
diff --git a/tapyrus/contrib/act/event.json b/tapyrus/contrib/act/event.json
new file mode 100644
index 00000000..43c2f0eb
--- /dev/null
+++ b/tapyrus/contrib/act/event.json
@@ -0,0 +1,3 @@
+{
+    "act": true
+}
diff --git a/tapyrus/contrib/test.sh b/tapyrus/contrib/test.sh
new file mode 100755
index 00000000..9e217577
--- /dev/null
+++ b/tapyrus/contrib/test.sh
@@ -0,0 +1,137 @@
+#!/bin/sh
+
+set -ex
+
+FEATURES="base64 bitcoinconsensus serde rand secp-recovery"
+
+if [ "$DO_COV" = true ]
+then
+    export RUSTFLAGS="-C link-dead-code"
+fi
+
+cargo --version
+rustc --version
+
+# Some tests require certain toolchain types.
+NIGHTLY=false
+STABLE=true
+if cargo --version | grep nightly; then
+    STABLE=false
+    NIGHTLY=true
+fi
+if cargo --version | grep beta; then
+    STABLE=false
+fi
+
+if [ "$DO_LINT" = true ]
+then
+    cargo clippy --locked --all-features --all-targets -- -D warnings
+    cargo clippy --locked --example bip32 -- -D warnings
+    cargo clippy --locked --example handshake --features=rand-std -- -D warnings
+
+    # We should not have any duplicate dependencies. This catches mistakes made upgrading dependencies
+    # in one crate and not in another (e.g. upgrade tapyrus_hashes in tapyrus but not in secp).
+    duplicate_dependencies=$(
+        # Only show the actual duplicated deps, not their reverse tree, then
+        # whitelist the 'syn' crate which is duplicated but it's not our fault.
+        #
+        # Whitelist `tapyrus_hashes` while we release it and until secp v0.28.0 comes out.
+        cargo tree  --target=all --all-features --duplicates \
+            | grep '^[0-9A-Za-z]' \
+            | grep -v 'syn' \
+            | grep -v 'tapyrus_hashes' \
+            | wc -l
+                          )
+    if [ "$duplicate_dependencies" -ne 0 ]; then
+        echo "Dependency tree is broken, contains duplicates"
+        cargo tree  --target=all --all-features --duplicates
+        exit 1
+    fi
+fi
+
+echo "********* Testing std *************"
+# Test without any features other than std first
+cargo test --locked --verbose --no-default-features --features="std"
+
+echo "********* Testing default *************"
+# Then test with the default features
+cargo test --verbose
+
+if [ "$DO_NO_STD" = true ]
+then
+    echo "********* Testing no-std build *************"
+    # Build no_std, to make sure that cfg(test) doesn't hide any issues
+    cargo build --locked --verbose --features="no-std" --no-default-features
+
+    # Build std + no_std, to make sure they are not incompatible
+    cargo build --locked --verbose --features="no-std"
+
+    # Test no_std
+    cargo test --locked --verbose --features="no-std" --no-default-features
+
+    # Build all features
+    cargo build --locked --verbose --features="no-std $FEATURES" --no-default-features
+
+    # Build specific features
+    for feature in ${FEATURES}
+    do
+        cargo build --locked --verbose --features="no-std $feature" --no-default-features
+    done
+
+    cargo run --locked --example bip32 7934c09359b234e076b9fa5a1abfd38e3dc2a9939745b7cc3c22a48d831d14bd
+    cargo run --locked --no-default-features --features no-std --example bip32 7934c09359b234e076b9fa5a1abfd38e3dc2a9939745b7cc3c22a48d831d14bd
+fi
+
+# Test each feature
+for feature in ${FEATURES}
+do
+    echo "********* Testing $feature *************"
+    cargo test --locked --verbose --features="$feature"
+done
+
+# Build the docs if told to (this only works with the nightly toolchain)
+if [ "$DO_DOCSRS" = true ]; then
+    RUSTDOCFLAGS="--cfg docsrs -D warnings -D rustdoc::broken-intra-doc-links" cargo +nightly doc --all-features
+fi
+
+# Build the docs with a stable toolchain, in unison with the DO_DOCSRS command
+# above this checks that we feature guarded docs imports correctly.
+if [ "$DO_DOCS" = true ]; then
+    RUSTDOCFLAGS="-D warnings" cargo +stable doc --all-features
+fi
+
+# Run formatter if told to.
+if [ "$DO_FMT" = true ]; then
+    if [ "$NIGHTLY" = false ]; then
+        echo "DO_FMT requires a nightly toolchain (consider using RUSTUP_TOOLCHAIN)"
+        exit 1
+    fi
+    rustup component add rustfmt
+    cargo fmt --check
+fi
+
+# Bench if told to, only works with non-stable toolchain (nightly, beta).
+if [ "$DO_BENCH" = true ]
+then
+    if [ "$STABLE" = true ]; then
+        if [ -n "$RUSTUP_TOOLCHAIN" ]; then
+            echo "RUSTUP_TOOLCHAIN is set to a stable toolchain but DO_BENCH requires a non-stable (beta, nightly) toolchain"
+        else
+            echo "DO_BENCH requires a non-stable (beta, nightly) toolchain"
+        fi
+        exit 1
+    fi
+    RUSTFLAGS='--cfg=bench' cargo bench
+fi
+
+# Use as dependency if told to
+if [ "$AS_DEPENDENCY" = true ]
+then
+    cargo new dep_test 2> /dev/null # Mute warning about workspace, fixed below.
+    cd dep_test
+    echo 'tapyrus = { path = "..", features = ["serde"] }\n\n' >> Cargo.toml
+    # Adding an empty workspace section excludes this crate from the rust-tapyrus workspace.
+    echo '[workspace]\n\n' >> Cargo.toml
+
+    cargo test --verbose
+fi
diff --git a/tapyrus/embedded/Cargo.toml b/tapyrus/embedded/Cargo.toml
new file mode 100644
index 00000000..6abcb9ce
--- /dev/null
+++ b/tapyrus/embedded/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+authors = ["Riccardo Casatta <riccardo@casatta.it>", "Dev Random <c1.devrandom@niftybox.net>"]
+edition = "2018"
+readme = "README.md"
+name = "embedded"
+version = "0.1.0"
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[dependencies]
+cortex-m = "0.6.0"
+cortex-m-rt = "0.6.10"
+cortex-m-semihosting = "0.3.3"
+panic-halt = "0.2.0"
+alloc-cortex-m = "0.4.1"
+tapyrus = { path="../", default-features = false, features = ["no-std", "secp-lowmemory"] }
+
+
+[[bin]]
+name = "embedded"
+test = false
+bench = false
+
+[profile.release]
+codegen-units = 1 # better optimizations
+debug = true # symbols are nice and they don't increase the size on Flash
+lto = true # better optimizations
+
+[patch.crates-io.tapyrus_hashes]
+path = "../../hashes"
+
+[patch.crates-io.tapyrus-internals]
+path = "../../internals"
diff --git a/tapyrus/embedded/README.md b/tapyrus/embedded/README.md
new file mode 100644
index 00000000..a2497190
--- /dev/null
+++ b/tapyrus/embedded/README.md
@@ -0,0 +1,34 @@
+# Running
+
+To run the embedded test, first prepare your environment:
+
+```shell
+sudo ./scripts/install-deps
+rustup +nightly target add thumbv7m-none-eabi
+```
+
+Then:
+
+```shell
+source ./scripts/env.sh && cargo +nightly run --target thumbv7m-none-eabi
+```
+
+Output should be something like:
+
+```text
+heap size 524288
+secp buf size 66240
+Seed WIF: L1HKVVLHXiUhecWnwFYF6L3shkf1E12HUmuZTESvBXUdx3yqVP1D
+Address: bc1qpx9t9pzzl4qsydmhyt6ctrxxjd4ep549np9993
+```
+
+Note that this heap size is required because of the amount of stack used by libsecp256k1 when initializing a context.
+
+## Cleanup
+
+After sourcing `scripts/env.sh` and _before_ building again using another target
+you'll want to unset `RUSTFLAGS` otherwise you'll get linker errors.
+
+```shell
+unset RUSTFLAGS
+```
diff --git a/tapyrus/embedded/memory.x b/tapyrus/embedded/memory.x
new file mode 100644
index 00000000..a07f29cf
--- /dev/null
+++ b/tapyrus/embedded/memory.x
@@ -0,0 +1,5 @@
+MEMORY
+{
+  FLASH : ORIGIN = 0x00000000, LENGTH = 512K
+  RAM : ORIGIN = 0x20000000, LENGTH = 512K
+}
diff --git a/tapyrus/embedded/scripts/env.sh b/tapyrus/embedded/scripts/env.sh
new file mode 100644
index 00000000..125162b6
--- /dev/null
+++ b/tapyrus/embedded/scripts/env.sh
@@ -0,0 +1,2 @@
+export RUSTFLAGS="-C link-arg=-Tlink.x"
+export CARGO_TARGET_THUMBV7M_NONE_EABI_RUNNER="qemu-system-arm -cpu cortex-m3 -machine mps2-an385 -nographic -semihosting-config enable=on,target=native -kernel"
diff --git a/tapyrus/embedded/scripts/install-deps b/tapyrus/embedded/scripts/install-deps
new file mode 100755
index 00000000..d22806dd
--- /dev/null
+++ b/tapyrus/embedded/scripts/install-deps
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+apt install gcc-arm-none-eabi qemu-system-arm gdb-multiarch
diff --git a/tapyrus/embedded/src/main.rs b/tapyrus/embedded/src/main.rs
new file mode 100644
index 00000000..00a5eac9
--- /dev/null
+++ b/tapyrus/embedded/src/main.rs
@@ -0,0 +1,64 @@
+#![feature(alloc_error_handler)]
+#![feature(panic_info_message)]
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+extern crate tapyrus;
+
+use alloc::string::ToString;
+use alloc::vec;
+use core::panic::PanicInfo;
+
+use alloc_cortex_m::CortexMHeap;
+// use panic_halt as _;
+use tapyrus::{Address, Network, PrivateKey};
+use tapyrus::secp256k1::ffi::types::AlignedType;
+use tapyrus::secp256k1::Secp256k1;
+
+use cortex_m_rt::entry;
+use cortex_m_semihosting::{debug, hprintln};
+
+// this is the allocator the application will use
+#[global_allocator]
+static ALLOCATOR: CortexMHeap = CortexMHeap::empty();
+
+const HEAP_SIZE: usize = 1024 * 256; // 256 KB
+
+#[entry]
+fn main() -> ! {
+    hprintln!("heap size {}", HEAP_SIZE).unwrap();
+
+    unsafe { ALLOCATOR.init(cortex_m_rt::heap_start() as usize, HEAP_SIZE) }
+
+    let size = Secp256k1::preallocate_size();
+    hprintln!("secp buf size {}", size*16).unwrap();
+
+    // Load a private key
+    let raw = "L1HKVVLHXiUhecWnwFYF6L3shkf1E12HUmuZTESvBXUdx3yqVP1D";
+    let pk = PrivateKey::from_wif(raw).unwrap();
+    hprintln!("Seed WIF: {}", pk).unwrap();
+
+    let mut buf_ful = vec![AlignedType::zeroed(); size];
+    let secp = Secp256k1::preallocated_new(&mut buf_ful).unwrap();
+
+    // Derive address
+    let pubkey = pk.public_key(&secp);
+    let address = Address::p2pkh(&pubkey, Network::Prod);
+    hprintln!("Address: {}", address).unwrap();
+
+    assert_eq!(address.to_string(), "1sTEaz9UHVQFcWDintqpvysAgiEVgaEAf".to_string());
+    // exit QEMU
+    // NOTE do not run this on hardware; it can corrupt OpenOCD state
+    debug::exit(debug::EXIT_SUCCESS);
+
+    loop {}
+}
+
+#[inline(never)]
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    hprintln!("panic {:?}", info.message()).unwrap();
+    debug::exit(debug::EXIT_FAILURE);
+    loop {}
+}
diff --git a/tapyrus/examples/bip32.rs b/tapyrus/examples/bip32.rs
new file mode 100644
index 00000000..39382cd4
--- /dev/null
+++ b/tapyrus/examples/bip32.rs
@@ -0,0 +1,56 @@
+extern crate tapyrus;
+
+use std::str::FromStr;
+use std::{env, process};
+
+use tapyrus::bip32::{DerivationPath, Xpriv, Xpub};
+use tapyrus::hex::FromHex;
+use tapyrus::secp256k1::ffi::types::AlignedType;
+use tapyrus::secp256k1::Secp256k1;
+
+fn main() {
+    // This example derives root xprv from a 32-byte seed,
+    // derives the child xprv with path m/84h/0h/0h,
+    // prints out corresponding xpub,
+    // calculates and prints out the first receiving segwit address.
+    // Run this example with cargo and seed(hex-encoded) argument:
+    // cargo run --example bip32 7934c09359b234e076b9fa5a1abfd38e3dc2a9939745b7cc3c22a48d831d14bd
+
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        eprintln!("not enough arguments. usage: {} <hex-encoded 32-byte seed>", &args[0]);
+        process::exit(1);
+    }
+
+    let seed_hex = &args[1];
+    println!("Seed: {}", seed_hex);
+
+    // default network as mainnet
+    let network = tapyrus::Network::Prod;
+    println!("Network: {:?}", network);
+
+    let seed = Vec::from_hex(seed_hex).unwrap();
+
+    // we need secp256k1 context for key derivation
+    let mut buf: Vec<AlignedType> = Vec::new();
+    buf.resize(Secp256k1::preallocate_size(), AlignedType::zeroed());
+    let secp = Secp256k1::preallocated_new(buf.as_mut_slice()).unwrap();
+
+    // calculate root key from seed
+    let root = Xpriv::new_master(network, &seed).unwrap();
+    println!("Root key: {}", root);
+
+    // derive child xpub
+    let path = DerivationPath::from_str("m/84h/0h/0h").unwrap();
+    let child = root.derive_priv(&secp, &path).unwrap();
+    println!("Child at {}: {}", path, child);
+    let xpub = Xpub::from_priv(&secp, &child);
+    println!("Public key at {}: {}", path, xpub);
+
+    // generate first receiving address at m/0/0
+    // manually creating indexes this time
+    // let zero = ChildNumber::from_normal_idx(0).unwrap();
+    // let public_key = xpub.derive_pub(&secp, &[zero, zero]).unwrap().public_key;
+    // let address = Address::p2wpkh(&PublicKey::new(public_key), network).unwrap();
+    // println!("First receiving address: {}", address);
+}
diff --git a/tapyrus/examples/handshake.rs b/tapyrus/examples/handshake.rs
new file mode 100644
index 00000000..7fb234ca
--- /dev/null
+++ b/tapyrus/examples/handshake.rs
@@ -0,0 +1,107 @@
+extern crate tapyrus;
+
+use std::io::{BufReader, Write};
+use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, TcpStream};
+use std::time::{SystemTime, UNIX_EPOCH};
+use std::{env, process};
+
+use tapyrus::consensus::{encode, Decodable};
+use tapyrus::network::NetworkId;
+use tapyrus::p2p::{self, address, message, message_network, Magic};
+use tapyrus::secp256k1;
+use tapyrus::secp256k1::rand::Rng;
+
+fn main() {
+    // This example establishes a connection to a Bitcoin node, sends the intial
+    // "version" message, waits for the reply, and finally closes the connection.
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        eprintln!("not enough arguments");
+        process::exit(1);
+    }
+
+    let str_address = &args[1];
+
+    let address: SocketAddr = str_address.parse().unwrap_or_else(|error| {
+        eprintln!("Error parsing address: {:?}", error);
+        process::exit(1);
+    });
+
+    let version_message = build_version_message(address);
+
+    let magic = Magic::from_bytes(NetworkId::from(1).magic().to_be_bytes());
+    let first_message = message::RawNetworkMessage::new(magic, version_message);
+
+    if let Ok(mut stream) = TcpStream::connect(address) {
+        // Send the message
+        let _ = stream.write_all(encode::serialize(&first_message).as_slice());
+        println!("Sent version message");
+
+        // Setup StreamReader
+        let read_stream = stream.try_clone().unwrap();
+        let mut stream_reader = BufReader::new(read_stream);
+        loop {
+            // Loop an retrieve new messages
+            let reply = message::RawNetworkMessage::consensus_decode(&mut stream_reader).unwrap();
+            match reply.payload() {
+                message::NetworkMessage::Version(_) => {
+                    println!("Received version message: {:?}", reply.payload());
+
+                    let second_message =
+                        message::RawNetworkMessage::new(magic, message::NetworkMessage::Verack);
+
+                    let _ = stream.write_all(encode::serialize(&second_message).as_slice());
+                    println!("Sent verack message");
+                }
+                message::NetworkMessage::Verack => {
+                    println!("Received verack message: {:?}", reply.payload());
+                    break;
+                }
+                _ => {
+                    println!("Received unknown message: {:?}", reply.payload());
+                    break;
+                }
+            }
+        }
+        let _ = stream.shutdown(Shutdown::Both);
+    } else {
+        eprintln!("Failed to open connection");
+    }
+}
+
+fn build_version_message(address: SocketAddr) -> message::NetworkMessage {
+    // Building version message, see https://en.bitcoin.it/wiki/Protocol_documentation#version
+    let my_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
+
+    // "bitfield of features to be enabled for this connection"
+    let services = p2p::ServiceFlags::NONE;
+
+    // "standard UNIX timestamp in seconds"
+    let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time error").as_secs();
+
+    // "The network address of the node receiving this message"
+    let addr_recv = address::Address::new(&address, p2p::ServiceFlags::NONE);
+
+    // "The network address of the node emitting this message"
+    let addr_from = address::Address::new(&my_address, p2p::ServiceFlags::NONE);
+
+    // "Node random nonce, randomly generated every time a version packet is sent. This nonce is used to detect connections to self."
+    let nonce: u64 = secp256k1::rand::thread_rng().gen();
+
+    // "User Agent (0x00 if string is 0 bytes long)"
+    let user_agent = String::from("rust-example");
+
+    // "The last block received by the emitting node"
+    let start_height: i32 = 0;
+
+    // Construct the message
+    message::NetworkMessage::Version(message_network::VersionMessage::new(
+        services,
+        timestamp as i64,
+        addr_recv,
+        addr_from,
+        nonce,
+        user_agent,
+        start_height,
+    ))
+}
diff --git a/tapyrus/examples/sighash.rs b/tapyrus/examples/sighash.rs
new file mode 100644
index 00000000..315e6ae0
--- /dev/null
+++ b/tapyrus/examples/sighash.rs
@@ -0,0 +1,199 @@
+use hex_lit::hex;
+use tapyrus::hashes::Hash;
+use tapyrus::{consensus, ecdsa, sighash, Amount, PublicKey, Script, ScriptBuf, Transaction};
+
+//These are real blockchain transactions examples of computing sighash for:
+// - P2WPKH
+// - P2MS 2of3
+// - P2SH 2of2 multisig
+// - P2WSH 2of2 multisig
+
+//run with: cargo run --example sighash
+
+//TODO add P2TR examples, ideally for both key-path and script-path spending
+
+/// Computes segwit sighash for a transaction input that spends a p2wpkh output with "witness_v0_keyhash" scriptPubKey.type
+///
+/// # Arguments
+///
+/// * `raw_tx` - spending tx hex
+/// * `inp_idx` - spending tx input index
+/// * `value` - ref tx output value in taps
+fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, value: u64) {
+    let tx: Transaction = consensus::deserialize(raw_tx).unwrap();
+    let inp = &tx.input[inp_idx];
+    let witness = &inp.witness;
+    println!("Witness: {:?}", witness);
+
+    // BIP-141: The witness must consist of exactly 2 items (≤ 520 bytes each). The first one a
+    // signature, and the second one a public key.
+    assert_eq!(witness.len(), 2);
+    let sig_bytes = witness.nth(0).unwrap();
+    let pk_bytes = witness.nth(1).unwrap();
+
+    let sig = ecdsa::Signature::from_slice(sig_bytes).expect("failed to parse sig");
+
+    //BIP-143: "The item 5 : For P2WPKH witness program, the scriptCode is 0x1976a914{20-byte-pubkey-hash}88ac"
+    //this is nothing but a standard P2PKH script OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG:
+    let pk = PublicKey::from_slice(pk_bytes).expect("failed to parse pubkey");
+    let wpkh = pk.wpubkey_hash().expect("compressed key");
+    println!("Script pubkey hash: {:x}", wpkh);
+    let spk = ScriptBuf::new_p2wpkh(&wpkh);
+
+    let mut cache = sighash::SighashCache::new(&tx);
+    let sighash = cache
+        .p2wpkh_signature_hash(inp_idx, &spk, Amount::from_tap(value), sig.hash_ty)
+        .expect("failed to compute sighash");
+    println!("Segwit p2wpkh sighash: {:x}", sighash);
+    let msg = secp256k1::Message::from_digest(sighash.to_byte_array());
+    println!("Message is {:x}", msg);
+    let secp = secp256k1::Secp256k1::verification_only();
+    secp.verify_ecdsa(&msg, &sig.sig, &pk.inner).unwrap();
+}
+
+/// Computes sighash for a legacy multisig transaction input that spends either a p2sh or a p2ms output.
+///
+/// # Arguments
+///
+/// * `raw_tx` - spending tx hex
+/// * `inp_idx` - spending tx input inde
+/// * `script_pubkey_bytes_opt` - Option with scriptPubKey bytes. If None, it's p2sh case, i.e., reftx output's scriptPubKey.type is "scripthash". In this case scriptPubkey is extracted from the spending transaction's scriptSig. If Some(), it's p2ms case, i.e., reftx output's scriptPubKey.type is "multisig", and the scriptPubkey is supplied from the referenced output.
+fn compute_sighash_legacy(raw_tx: &[u8], inp_idx: usize, script_pubkey_bytes_opt: Option<&[u8]>) {
+    let tx: Transaction = consensus::deserialize(raw_tx).unwrap();
+    let inp = &tx.input[inp_idx];
+    let script_sig = &inp.script_sig;
+    println!("scriptSig is: {}", script_sig);
+    let cache = sighash::SighashCache::new(&tx);
+    //In the P2SH case we get scriptPubKey from scriptSig of the spending input.
+    //The scriptSig that corresponds to an M of N multisig should be: PUSHBYTES_0 PUSHBYTES_K0 <sig0><sighashflag0> ... PUSHBYTES_Km <sigM><sighashflagM> PUSHBYTES_X <scriptPubKey>
+    //Here we assume that we have an M of N multisig scriptPubKey.
+    let mut instructions: Vec<_> = script_sig.instructions().collect();
+    let script_pubkey_p2sh;
+    let script_pubkey_bytes = match script_pubkey_bytes_opt {
+        //In the P2MS case, the scriptPubKey is in the referenced output, passed into this function
+        Some(bytes) => bytes,
+        //In the P2SH case, the scriptPubKey is the last scriptSig PushBytes instruction
+        None => {
+            script_pubkey_p2sh = instructions.pop().unwrap().unwrap();
+            script_pubkey_p2sh.push_bytes().unwrap().as_bytes()
+        }
+    };
+    let script_code = Script::from_bytes(script_pubkey_bytes);
+    let pushbytes_0 = instructions.remove(0).unwrap();
+    assert!(
+        pushbytes_0.push_bytes().unwrap().as_bytes().is_empty(),
+        "first in ScriptSig must be PUSHBYTES_0 got {:?}",
+        pushbytes_0
+    );
+
+    //All other scriptSig instructions  must be signatures
+    for instr in instructions {
+        let sig = ecdsa::Signature::from_slice(instr.unwrap().push_bytes().unwrap().as_bytes())
+            .expect("failed to parse sig");
+        let sighash = cache
+            .legacy_signature_hash(inp_idx, script_code, sig.hash_ty.to_u32())
+            .expect("failed to compute sighash");
+        println!("Legacy sighash: {:x} (sighash flag {})", sighash, sig.hash_ty);
+    }
+}
+
+/// Computes sighash for a segwit multisig transaction input that spends a p2wsh output with "witness_v0_scripthash" scriptPubKey.type
+///
+/// # Arguments
+///
+/// * `raw_tx` - spending tx hex
+/// * `inp_idx` - spending tx input index
+/// * `value` - ref tx output value in taps
+fn compute_sighash_p2wsh(raw_tx: &[u8], inp_idx: usize, value: u64) {
+    let tx: Transaction = consensus::deserialize(raw_tx).unwrap();
+    let inp = &tx.input[inp_idx];
+    let witness = &inp.witness;
+    println!("witness {:?}", witness);
+
+    //last element is called witnessScript according to BIP141. It supersedes scriptPubKey.
+    let witness_script_bytes: &[u8] = witness.last().expect("Out of Bounds");
+    let witness_script = Script::from_bytes(witness_script_bytes);
+    let mut cache = sighash::SighashCache::new(&tx);
+
+    //in an M of N multisig, the witness elements from 1 (0-based) to M-2 are signatures (with sighash flags as the last byte)
+    for n in 1..=witness.len() - 2 {
+        let sig_bytes = witness.nth(n).expect("Out of Bounds");
+        let sig = ecdsa::Signature::from_slice(sig_bytes).expect("failed to parse sig");
+        let sig_len = sig_bytes.len() - 1; //last byte is EcdsaSighashType sighash flag
+                                           //ECDSA signature in DER format lengths are between 70 and 72 bytes
+        assert!((70..=72).contains(&sig_len), "signature length {} out of bounds", sig_len);
+        //here we assume that all sighash_flags are the same. Can they be different?
+        let sighash = cache
+            .p2wsh_signature_hash(inp_idx, witness_script, Amount::from_tap(value), sig.hash_ty)
+            .expect("failed to compute sighash");
+        println!("Segwit p2wsh sighash: {:x} ({})", sighash, sig.hash_ty);
+    }
+}
+
+fn main() {
+    sighash_p2wpkh();
+    sighash_p2ms_multisig_2x3();
+    sighash_p2sh_multisig_2x2();
+    sighash_p2wsh_multisig_2x2();
+}
+
+/// Example showing how to verify the signature for spending a p2wpkh transaction.
+fn sighash_p2wpkh() {
+    //Spending transaction:
+    //tapyrus-cli getrawtransaction 663becacc6368150a46725e404ccdfa34d1fffbececa784c31f0a7849b4dad08  3
+    let raw_tx = hex!("020000000001015ce1d4ffc716022f83cc0d557e6dad0500eeff9e9623bde014bdc09c5b672d750000000000fdffffff025fb7460b000000001600142cf4c1dc0352e0658971ca62a7457a1cd8c3389c4ce3a2000000000016001433f57fe374c6ceab61c8639128c038ac2a8c8db60247304402203cb50efb5c4a9aa7fd369ab6f4b226db99f44f9c610b5b50bc42f343a6aa401302201af791542eee6c1b11705e8895cc5adc36458910dc91aadcafb76a6478a29b9f01210242e811e66fd17e9a6e4ef772766c668d6e0595ca1d7f0583148bc460b575fbfdf0df0b00");
+
+    //vin:0
+    let inp_idx = 0;
+    //output value from the referenced vout:0 from the referenced tx:
+    //tapyrus-cli getrawtransaction 752d675b9cc0bd14e0bd23969effee0005ad6d7e550dcc832f0216c7ffd4e15c  3
+    let ref_out_value = 200000000;
+
+    println!("\nsighash_p2wpkh:");
+    compute_sighash_p2wpkh(&raw_tx, inp_idx, ref_out_value);
+}
+
+fn sighash_p2sh_multisig_2x2() {
+    //Spending transactoin:
+    //tapyrus-cli getrawtransaction 214646c4b563cd8c788754ec94468ab71602f5ed07d5e976a2b0e41a413bcc0e  3
+    //after decoding ScriptSig from the input:0, its last ASM element is the scriptpubkey:
+    //tapyrus-cli decodescript 5221032d7306898e980c66aefdfb6b377eaf71597c449bf9ce741a3380c5646354f6de2103e8c742e1f283ef810c1cd0c8875e5c2998a05fc5b23c30160d3d33add7af565752ae
+    //its ASM is 2 of 2 multisig: 2 032d7306898e980c66aefdfb6b377eaf71597c449bf9ce741a3380c5646354f6de 03e8c742e1f283ef810c1cd0c8875e5c2998a05fc5b23c30160d3d33add7af5657 2 OP_CHECKMULTISIG
+    let raw_tx = hex!("0100000001d611ad58b2f5bc0db7d15dfde4f497d6482d1b4a1e8c462ef077d4d32b3dae7901000000da0047304402203b17b4f64fa7299e8a85a688bda3cb1394b80262598bbdffd71dab1d7f266098022019cc20dc20eae417374609cb9ca22b28261511150ed69d39664b9d3b1bcb3d1201483045022100cfff9c400abb4ce5f247bd1c582cf54ec841719b0d39550b714c3c793fb4347b02201427a961a7f32aba4eeb1b71b080ea8712705e77323b747c03c8f5dbdda1025a01475221032d7306898e980c66aefdfb6b377eaf71597c449bf9ce741a3380c5646354f6de2103e8c742e1f283ef810c1cd0c8875e5c2998a05fc5b23c30160d3d33add7af565752aeffffffff020ed000000000000016001477800cff52bd58133b895622fd1220d9e2b47a79cd0902000000000017a914da55145ca5c56ba01f1b0b98d896425aa4b0f4468700000000");
+    let inp_idx = 0;
+
+    println!("\nsighash_p2sh_multisig_2x2:");
+    compute_sighash_legacy(&raw_tx, inp_idx, None);
+}
+
+fn sighash_p2wsh_multisig_2x2() {
+    //The spending transaction is
+    //tapyrus-cli getrawtransaction 2bb157363e7a62d70b92082a9b2c9bb6f329154f816b8d239bd58c35c789a96a  3
+    //input 0 (the only input)
+    //ScriptPubkey from its Witness data is:
+    //tapyrus-cli decodescript 52210289da5da9d3700156db2d01e6362491733f6c886971791deda74b4e9d707190b2210323c437f30384498be79df2990ce5a8de00844e768c0ccce914335b6c26adea7352ae
+    //its ASM is 2 0289da5da9d3700156db2d01e6362491733f6c886971791deda74b4e9d707190b2 0323c437f30384498be79df2990ce5a8de00844e768c0ccce914335b6c26adea73 2 OP_CHECKMULTISIG
+    let raw_tx = hex!("010000000001011b9eb4122976fad8f809ee4cea8ac8d1c5b6b8e0d0f9f93327a5d78c9a3945280000000000ffffffff02ba3e0d00000000002200201c3b09401aaa7c9709d118a75d301bdb2180fb68b2e9b3ade8ad4ff7281780cfa586010000000000220020a41d0d894799879ca1bd88c1c3f1c2fd4b1592821cc3c5bfd5be5238b904b09f040047304402201c7563e876d67b5702aea5726cd202bf92d0b1dc52c4acd03435d6073e630bac022032b64b70d7fba0cb8be30b882ea06c5f8ec7288d113459dd5d3e294214e2c96201483045022100f532f7e3b8fd01a0edc86de4870db4e04858964d0a609df81deb99d9581e6c2e02206d9e9b6ab661176be8194faded62f518cdc6ee74dba919e0f35d77cff81f38e5014752210289da5da9d3700156db2d01e6362491733f6c886971791deda74b4e9d707190b2210323c437f30384498be79df2990ce5a8de00844e768c0ccce914335b6c26adea7352ae00000000");
+    //For the witness transaction sighash computation, we need its referenced output's value from the original transaction:
+    //tapyrus-cli getrawtransaction 2845399a8cd7a52733f9f9d0e0b8b6c5d1c88aea4cee09f8d8fa762912b49e1b  3
+    //we need vout 0 value in taps:
+    let ref_out_value = 968240;
+
+    println!("\nsighash_p2wsh_multisig_2x2:");
+    compute_sighash_p2wsh(&raw_tx, 0, ref_out_value);
+}
+
+fn sighash_p2ms_multisig_2x3() {
+    //Spending tx:
+    //tapyrus-cli getrawtransaction 949591ad468cef5c41656c0a502d9500671ee421fadb590fbc6373000039b693  3
+    //Inp 0 scriptSig has 2 sigs
+    let raw_tx = hex!("010000000110a5fee9786a9d2d72c25525e52dd70cbd9035d5152fac83b62d3aa7e2301d58000000009300483045022100af204ef91b8dba5884df50f87219ccef22014c21dd05aa44470d4ed800b7f6e40220428fe058684db1bb2bfb6061bff67048592c574effc217f0d150daedcf36787601483045022100e8547aa2c2a2761a5a28806d3ae0d1bbf0aeff782f9081dfea67b86cacb321340220771a166929469c34959daf726a2ac0c253f9aff391e58a3c7cb46d8b7e0fdc4801ffffffff0180a21900000000001976a914971802edf585cdbc4e57017d6e5142515c1e502888ac00000000");
+    //Original transaction:
+    //tapyrus-cli getrawtransaction 581d30e2a73a2db683ac2f15d53590bd0cd72de52555c2722d9d6a78e9fea510  3
+    //Out 0 scriptPubKey.type “multisig” has 3 uncompressed pubkeys
+    let reftx_script_pubkey_bytes = hex!("524104d81fd577272bbe73308c93009eec5dc9fc319fc1ee2e7066e17220a5d47a18314578be2faea34b9f1f8ca078f8621acd4bc22897b03daa422b9bf56646b342a24104ec3afff0b2b66e8152e9018fe3be3fc92b30bf886b3487a525997d00fd9da2d012dce5d5275854adc3106572a5d1e12d4211b228429f5a7b2f7ba92eb0475bb14104b49b496684b02855bc32f5daefa2e2e406db4418f3b86bca5195600951c7d918cdbe5e6d3736ec2abf2dd7610995c3086976b2c0c7b4e459d10b34a316d5a5e753ae");
+    let inp_idx = 0;
+
+    println!("\nsighash_p2ms_multisig_2x3:");
+    compute_sighash_legacy(&raw_tx, inp_idx, Some(&reftx_script_pubkey_bytes));
+}
diff --git a/tapyrus/src/address/error.rs b/tapyrus/src/address/error.rs
new file mode 100644
index 00000000..d12bd9c4
--- /dev/null
+++ b/tapyrus/src/address/error.rs
@@ -0,0 +1,113 @@
+use core::fmt;
+
+use internals::write_err;
+
+use crate::address::{Address, NetworkUnchecked};
+use crate::prelude::String;
+use crate::{base58, Network};
+
+/// Address error.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// An uncompressed pubkey was used where it is not allowed.
+    UncompressedPubkey,
+    /// Address size more than 520 bytes is not allowed.
+    ExcessiveScriptSize,
+    /// Script is not a p2pkh, p2sh or witness program.
+    UnrecognizedScript,
+    /// Address's network differs from required one.
+    NetworkValidation {
+        /// Network that was required.
+        required: Network,
+        /// Network on which the address was found to be valid.
+        found: Network,
+        /// The address itself
+        address: Address<NetworkUnchecked>,
+    },
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            UncompressedPubkey =>
+                write!(f, "an uncompressed pubkey was used where it is not allowed"),
+            ExcessiveScriptSize => write!(f, "script size exceed 520 bytes"),
+            UnrecognizedScript => write!(f, "script is not a p2pkh, p2sh or witness program"),
+            NetworkValidation { required, found, ref address } => {
+                write!(f, "address ")?;
+                address.fmt_internal(f)?; // Using fmt_internal in order to remove the "Address<NetworkUnchecked>(..)" wrapper
+                write!(
+                    f,
+                    " belongs to network {} which is different from required {}",
+                    found, required
+                )
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match self {
+            UncompressedPubkey
+            | ExcessiveScriptSize
+            | UnrecognizedScript
+            | NetworkValidation { .. } => None,
+        }
+    }
+}
+
+/// Address type is either invalid or not supported in rust-tapyrus.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct UnknownAddressTypeError(pub String);
+
+impl fmt::Display for UnknownAddressTypeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "failed to parse {} as address type", self.0; self)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnknownAddressTypeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// Address parsing error.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ParseError {
+    /// Base58 error.
+    Base58(base58::Error),
+}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use ParseError::*;
+
+        match *self {
+            Base58(ref e) => write_err!(f, "base58 error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use ParseError::*;
+
+        match *self {
+            Base58(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<base58::Error> for ParseError {
+    fn from(e: base58::Error) -> Self { Self::Base58(e) }
+}
diff --git a/tapyrus/src/address/mod.rs b/tapyrus/src/address/mod.rs
new file mode 100644
index 00000000..b5cdcaf8
--- /dev/null
+++ b/tapyrus/src/address/mod.rs
@@ -0,0 +1,1110 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin addresses.
+//!
+//! Support for ordinary base58 Bitcoin addresses and private keys.
+//!
+//! # Example: creating a new address from a randomly-generated key pair
+//!
+//! ```rust
+//! # #[cfg(feature = "rand-std")] {
+//! use tapyrus::{Address, PublicKey, Network};
+//! use tapyrus::secp256k1::{rand, Secp256k1};
+//!
+//! // Generate random key pair.
+//! let s = Secp256k1::new();
+//! let public_key = PublicKey::new(s.generate_keypair(&mut rand::thread_rng()).1);
+//!
+//! // Generate pay-to-pubkey-hash address.
+//! let address = Address::p2pkh(&public_key, Network::Prod);
+//! # }
+//! ```
+//!
+//! # Note: creating a new address requires the rand-std feature flag
+//!
+//! ```toml
+//! tapyrus = { version = "...", features = ["rand-std"] }
+//! ```
+
+use core::convert::TryInto;
+use core::fmt;
+use core::marker::PhantomData;
+use core::str::FromStr;
+
+use bech32::primitives::hrp::{self, Hrp};
+use hashes::Hash;
+use secp256k1::XOnlyPublicKey;
+
+use crate::base58;
+use crate::blockdata::constants::{
+    MAX_SCRIPT_ELEMENT_SIZE, PUBKEY_ADDRESS_PREFIX_MAIN, PUBKEY_ADDRESS_PREFIX_TEST,
+    SCRIPT_ADDRESS_PREFIX_MAIN, SCRIPT_ADDRESS_PREFIX_TEST, COLORED_PUBKEY_ADDRESS_PREFIX_MAIN,
+    COLORED_SCRIPT_ADDRESS_PREFIX_MAIN, COLORED_PUBKEY_ADDRESS_PREFIX_TEST,
+    COLORED_SCRIPT_ADDRESS_PREFIX_TEST,
+};
+use crate::blockdata::script::{self, Script, ScriptBuf, ScriptHash};
+use crate::consensus::{deserialize, serialize};
+use crate::crypto::key::{PubkeyHash, PublicKey};
+use crate::network::Network;
+use crate::prelude::*;
+use crate::script::color_identifier::ColorIdentifier;
+
+/// Error code for the address module.
+pub mod error;
+pub use self::error::{Error, ParseError, UnknownAddressTypeError};
+
+/// The different types of addresses.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
+pub enum AddressType {
+    /// Pay to pubkey hash.
+    P2pkh,
+    /// Pay to script hash.
+    P2sh,
+    /// colored-pay-to-pubkey-hash
+    Cp2pkh,
+    /// colored-pay-to-script-hash
+    Cp2sh,
+}
+
+impl fmt::Display for AddressType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match *self {
+            AddressType::P2pkh => "p2pkh",
+            AddressType::P2sh => "p2sh",
+            AddressType::Cp2pkh => "cp2pkh",
+            AddressType::Cp2sh => "cp2sh",
+        })
+    }
+}
+
+impl FromStr for AddressType {
+    type Err = UnknownAddressTypeError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "p2pkh" => Ok(AddressType::P2pkh),
+            "p2sh" => Ok(AddressType::P2sh),
+            "cp2pkh" => Ok(AddressType::Cp2pkh),
+            "cp2sh" => Ok(AddressType::Cp2sh),
+            _ => Err(UnknownAddressTypeError(s.to_owned())),
+        }
+    }
+}
+
+/// The method used to produce an address.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
+pub enum Payload {
+    /// P2PKH address.
+    PubkeyHash(PubkeyHash),
+    /// P2SH address.
+    ScriptHash(ScriptHash),
+    /// CP2PKH address.
+    ColoredPubkeyHash(ColorIdentifier, PubkeyHash),
+    /// CP2SH address.
+    ColoredScriptHash(ColorIdentifier, ScriptHash),
+}
+
+impl Payload {
+    /// Constructs a [Payload] from an output script (`scriptPubkey`).
+    pub fn from_script(script: &Script) -> Result<Payload, Error> {
+        Ok(if script.is_p2pkh() {
+            let bytes = script.as_bytes()[3..23].try_into().expect("statically 20B long");
+            Payload::PubkeyHash(PubkeyHash::from_byte_array(bytes))
+        } else if script.is_p2sh() {
+            let bytes = script.as_bytes()[2..22].try_into().expect("statically 20B long");
+            Payload::ScriptHash(ScriptHash::from_byte_array(bytes))
+        } else if script.is_cp2pkh() {
+            let color_id: ColorIdentifier = deserialize(&script.as_bytes()[1..34]).expect("statically 33B long");
+            let pubkey_hash_bytes = script.as_bytes()[38..58].try_into().expect("statically 20B long");
+            Payload::ColoredPubkeyHash(color_id, PubkeyHash::from_byte_array(pubkey_hash_bytes))
+        } else if script.is_cp2sh() {
+            let color_id: ColorIdentifier = deserialize(&script.as_bytes()[1..34]).expect("statically 33B long");
+            let script_hash_bytes = script.as_bytes()[37..57].try_into().expect("statically 20B long");
+            Payload::ColoredScriptHash(color_id, ScriptHash::from_byte_array(script_hash_bytes))
+        } else {
+            return Err(Error::UnrecognizedScript);
+        })
+    }
+
+    /// Generates a script pubkey spending to this [Payload].
+    pub fn script_pubkey(&self) -> ScriptBuf {
+        match *self {
+            Payload::PubkeyHash(ref hash) => ScriptBuf::new_p2pkh(hash),
+            Payload::ScriptHash(ref hash) => ScriptBuf::new_p2sh(hash),
+            Payload::ColoredPubkeyHash(ref color_id, ref hash) => ScriptBuf::new_cp2pkh(color_id, hash),
+            Payload::ColoredScriptHash(ref color_id, ref hash) => ScriptBuf::new_cp2sh(color_id, hash),
+        }
+    }
+
+    /// Returns true if the address creates a particular script
+    /// This function doesn't make any allocations.
+    pub fn matches_script_pubkey(&self, script: &Script) -> bool {
+        match *self {
+            Payload::PubkeyHash(ref hash) if script.is_p2pkh() =>
+                &script.as_bytes()[3..23] == <PubkeyHash as AsRef<[u8; 20]>>::as_ref(hash),
+            Payload::ScriptHash(ref hash) if script.is_p2sh() =>
+                &script.as_bytes()[2..22] == <ScriptHash as AsRef<[u8; 20]>>::as_ref(hash),
+            Payload::ColoredPubkeyHash(ref color_id, ref hash) if script.is_cp2pkh() =>
+                script.as_bytes()[1..34] == serialize(color_id) &&
+                &script.as_bytes()[38..58] == <PubkeyHash as AsRef<[u8; 20]>>::as_ref(hash),
+            Payload::ColoredScriptHash(ref color_id, ref hash) if script.is_cp2sh() =>
+                script.as_bytes()[1..34] == serialize(color_id) &&
+                &script.as_bytes()[37..57] == <ScriptHash as AsRef<[u8; 20]>>::as_ref(hash),
+            _ => false,
+        }
+    }
+
+    /// Creates a pay to (compressed) public key hash payload from a public key
+    #[inline]
+    pub fn p2pkh(pk: &PublicKey) -> Payload { Payload::PubkeyHash(pk.pubkey_hash()) }
+
+    /// Creates a pay to script hash P2SH payload from a script
+    #[inline]
+    pub fn p2sh(script: &Script) -> Result<Payload, Error> {
+        if script.len() > MAX_SCRIPT_ELEMENT_SIZE {
+            return Err(Error::ExcessiveScriptSize);
+        }
+        Ok(Payload::ScriptHash(script.script_hash()))
+    }
+
+    /// Creates a pay to (compressed) public key hash payload from a public key
+    #[inline]
+    pub fn cp2pkh(color_id: &ColorIdentifier, pk: &PublicKey) -> Payload {
+        Payload::ColoredPubkeyHash(*color_id, pk.pubkey_hash())
+    }
+
+    /// Creates a pay to script hash P2SH address from a script
+    /// This address type was introduced with BIP16 and is the popular type to implement multi-sig these days.
+    #[inline]
+    pub fn cp2sh(color_id: &ColorIdentifier, script: &Script) -> Result<Payload, Error> {
+        if script.len() > MAX_SCRIPT_ELEMENT_SIZE {
+            return Err(Error::ExcessiveScriptSize);
+        }
+        Ok(Payload::ColoredScriptHash(*color_id, script.script_hash()))
+    }
+
+    /// Returns a byte slice of the inner program of the payload. If the payload
+    /// is a script hash or pubkey hash, a reference to the hash is returned.
+    fn inner_prog_as_bytes(&self) -> &[u8] {
+        match self {
+            Payload::ScriptHash(hash) => hash.as_ref(),
+            Payload::PubkeyHash(hash) => hash.as_ref(),
+            Payload::ColoredPubkeyHash(_, hash) => hash.as_ref(),
+            Payload::ColoredScriptHash(_, hash) => hash.as_ref(),
+        }
+    }
+}
+
+/// A utility struct to encode an address payload with the given parameters.
+/// This is a low-level utility struct. Consider using `Address` instead.
+pub struct AddressEncoding<'a> {
+    /// The address payload to encode.
+    pub payload: &'a Payload,
+    /// base58 version byte for p2pkh payloads (e.g. 0x00 for "1..." addresses).
+    pub p2pkh_prefix: u8,
+    /// base58 version byte for p2sh payloads (e.g. 0x05 for "3..." addresses).
+    pub p2sh_prefix: u8,
+    /// base58 versin byte for cp2pkh paylaods (e.g. 0x01 for "c..." addresses).
+    pub cp2pkh_prefix: u8,
+    /// base58 version byte for cp2sh payloads (e.g. 0x06 for "C..." addresses).
+    pub cp2sh_prefix: u8,
+    /// The bech32 human-readable part.
+    pub hrp: Hrp,
+}
+
+/// Formats bech32 as upper case if alternate formatting is chosen (`{:#}`).
+impl<'a> fmt::Display for AddressEncoding<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self.payload {
+            Payload::PubkeyHash(hash) => {
+                let mut prefixed = [0; 21];
+                prefixed[0] = self.p2pkh_prefix;
+                prefixed[1..].copy_from_slice(&hash[..]);
+                base58::encode_check_to_fmt(fmt, &prefixed[..])
+            }
+            Payload::ScriptHash(hash) => {
+                let mut prefixed = [0; 21];
+                prefixed[0] = self.p2sh_prefix;
+                prefixed[1..].copy_from_slice(&hash[..]);
+                base58::encode_check_to_fmt(fmt, &prefixed[..])
+            }
+            Payload::ColoredPubkeyHash(color_id, hash) => {
+                let mut prefixed = [0; 54];
+                prefixed[0] = self.cp2pkh_prefix;
+                prefixed[1..34].copy_from_slice(&serialize(color_id)[..]);
+                prefixed[34..].copy_from_slice(&hash[..]);
+                base58::encode_check_to_fmt(fmt, &prefixed[..])
+            }
+            Payload::ColoredScriptHash(color_id, hash) => {
+                let mut prefixed = [0; 54];
+                prefixed[0] = self.cp2sh_prefix;
+                prefixed[1..34].copy_from_slice(&serialize(color_id)[..]);
+                prefixed[34..].copy_from_slice(&hash[..]);
+                base58::encode_check_to_fmt(fmt, &prefixed[..])
+            }
+        }
+    }
+}
+
+mod sealed {
+    pub trait NetworkValidation {}
+    impl NetworkValidation for super::NetworkChecked {}
+    impl NetworkValidation for super::NetworkUnchecked {}
+}
+
+/// Marker of status of address's network validation. See section [*Parsing addresses*](Address#parsing-addresses)
+/// on [`Address`] for details.
+pub trait NetworkValidation: sealed::NetworkValidation + Sync + Send + Sized + Unpin {
+    /// Indicates whether this `NetworkValidation` is `NetworkChecked` or not.
+    const IS_CHECKED: bool;
+}
+
+/// Marker that address's network has been successfully validated. See section [*Parsing addresses*](Address#parsing-addresses)
+/// on [`Address`] for details.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum NetworkChecked {}
+
+/// Marker that address's network has not yet been validated. See section [*Parsing addresses*](Address#parsing-addresses)
+/// on [`Address`] for details.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum NetworkUnchecked {}
+
+impl NetworkValidation for NetworkChecked {
+    const IS_CHECKED: bool = true;
+}
+impl NetworkValidation for NetworkUnchecked {
+    const IS_CHECKED: bool = false;
+}
+
+/// The inner representation of an address, without the network validation tag.
+///
+/// An `Address` is composed of a payload and a network. This struct represents the inner
+/// representation of an address without the network validation tag, which is used to ensure that
+/// addresses are used only on the appropriate network.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct AddressInner {
+    payload: Payload,
+    network: Network,
+}
+
+/// A Bitcoin address.
+///
+/// ### Parsing addresses
+///
+/// When parsing string as an address, one has to pay attention to the network, on which the parsed
+/// address is supposed to be valid. For the purpose of this validation, `Address` has
+/// [`is_valid_for_network`](Address<NetworkUnchecked>::is_valid_for_network) method. In order to provide more safety,
+/// enforced by compiler, `Address` also contains a special marker type, which indicates whether network of the parsed
+/// address has been checked. This marker type will prevent from calling certain functions unless the network
+/// verification has been successfully completed.
+///
+/// The result of parsing an address is `Address<NetworkUnchecked>` suggesting that network of the parsed address
+/// has not yet been verified. To perform this verification, method [`require_network`](Address<NetworkUnchecked>::require_network)
+/// can be called, providing network on which the address is supposed to be valid. If the verification succeeds,
+/// `Address<NetworkChecked>` is returned.
+///
+/// The types `Address` and `Address<NetworkChecked>` are synonymous, i. e. they can be used interchangeably.
+///
+/// ```rust
+/// use std::str::FromStr;
+/// use tapyrus::{Address, Network};
+/// use tapyrus::address::{NetworkUnchecked, NetworkChecked};
+///
+/// // variant 1
+/// let address: Address<NetworkUnchecked> = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf".parse().unwrap();
+/// let address: Address<NetworkChecked> = address.require_network(Network::Prod).unwrap();
+///
+/// // variant 2
+/// let address: Address = Address::from_str("32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf").unwrap()
+///                .require_network(Network::Prod).unwrap();
+///
+/// // variant 3
+/// let address: Address<NetworkChecked> = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf".parse::<Address<_>>()
+///                .unwrap().require_network(Network::Prod).unwrap();
+/// ```
+///
+/// ### Formatting addresses
+///
+/// To format address into its textual representation, both `Debug` (for usage in programmer-facing,
+/// debugging context) and `Display` (for user-facing output) can be used, with the following caveats:
+///
+/// 1. `Display` is implemented only for `Address<NetworkChecked>`:
+///
+/// ```
+/// # use std::str::FromStr;
+/// # use tapyrus::address::{Address, NetworkChecked};
+/// let address: Address<NetworkChecked> = Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM")
+///                .unwrap().assume_checked();
+/// assert_eq!(address.to_string(), "132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM");
+/// ```
+///
+/// ```ignore
+/// # use std::str::FromStr;
+/// # use tapyrus::address::{Address, NetworkChecked};
+/// let address: Address<NetworkUnchecked> = Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM")
+///                .unwrap();
+/// let s = address.to_string(); // does not compile
+/// ```
+///
+/// 2. `Debug` on `Address<NetworkUnchecked>` does not produce clean address but address wrapped by
+///    an indicator that its network has not been checked. This is to encourage programmer to
+///    properly check the network and use `Display` in user-facing context.
+///
+/// ```
+/// # use std::str::FromStr;
+/// # use tapyrus::address::{Address, NetworkUnchecked};
+/// let address: Address<NetworkUnchecked> = Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM")
+///                .unwrap();
+/// assert_eq!(format!("{:?}", address), "Address<NetworkUnchecked>(132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM)");
+/// ```
+///
+/// ```
+/// # use std::str::FromStr;
+/// # use tapyrus::address::{Address, NetworkChecked};
+/// let address: Address<NetworkChecked> = Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM")
+///                .unwrap().assume_checked();
+/// assert_eq!(format!("{:?}", address), "132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM");
+/// ```
+///
+/// ### Relevant BIPs
+///
+/// * [BIP13 - Address Format for pay-to-script-hash](https://github.com/bitcoin/bips/blob/master/bip-0013.mediawiki)
+/// * [BIP16 - Pay to Script Hash](https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki)
+/// * [BIP141 - Segregated Witness (Consensus layer)](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+/// * [BIP142 - Address Format for Segregated Witness](https://github.com/bitcoin/bips/blob/master/bip-0142.mediawiki)
+/// * [BIP341 - Taproot: SegWit version 1 spending rules](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki)
+/// * [BIP350 - Bech32m format for v1+ witness addresses](https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki)
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+///
+/// The `#[repr(transparent)]` attribute is used to guarantee that the layout of the
+/// `Address` struct is the same as the layout of the `AddressInner` struct. This attribute is
+/// an implementation detail and users should not rely on it in their code.
+///
+#[repr(transparent)]
+pub struct Address<V = NetworkChecked>(AddressInner, PhantomData<V>)
+where
+    V: NetworkValidation;
+
+#[cfg(feature = "serde")]
+struct DisplayUnchecked<'a, N: NetworkValidation>(&'a Address<N>);
+
+#[cfg(feature = "serde")]
+impl<N: NetworkValidation> fmt::Display for DisplayUnchecked<'_, N> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { self.0.fmt_internal(fmt) }
+}
+
+#[cfg(feature = "serde")]
+crate::serde_utils::serde_string_deserialize_impl!(Address<NetworkUnchecked>, "a Bitcoin address");
+
+#[cfg(feature = "serde")]
+impl<N: NetworkValidation> serde::Serialize for Address<N> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.collect_str(&DisplayUnchecked(self))
+    }
+}
+
+/// Methods on [`Address`] that can be called on both `Address<NetworkChecked>` and
+/// `Address<NetworkUnchecked>`.
+impl<V: NetworkValidation> Address<V> {
+    /// Returns a reference to the payload of this address.
+    pub fn payload(&self) -> &Payload { &self.0.payload }
+
+    /// Returns a reference to the network of this address.
+    pub fn network(&self) -> &Network { &self.0.network }
+
+    /// Returns a reference to the unchecked address, which is dangerous to use if the address
+    /// is invalid in the context of `NetworkUnchecked`.
+    pub fn as_unchecked(&self) -> &Address<NetworkUnchecked> {
+        unsafe { &*(self as *const Address<V> as *const Address<NetworkUnchecked>) }
+    }
+
+    /// Extracts and returns the network and payload components of the `Address`.
+    pub fn into_parts(self) -> (Network, Payload) {
+        let AddressInner { payload, network } = self.0;
+        (network, payload)
+    }
+
+    /// Gets the address type of the address.
+    ///
+    /// This method is publicly available as [`address_type`](Address<NetworkChecked>::address_type)
+    /// on `Address<NetworkChecked>` but internally can be called on `Address<NetworkUnchecked>` as
+    /// `address_type_internal`.
+    ///
+    /// # Returns
+    /// None if unknown, non-standard or related to the future witness version.
+    fn address_type_internal(&self) -> Option<AddressType> {
+        match self.payload() {
+            Payload::PubkeyHash(_) => Some(AddressType::P2pkh),
+            Payload::ScriptHash(_) => Some(AddressType::P2sh),
+            Payload::ColoredPubkeyHash(_, _) => Some(AddressType::Cp2pkh),
+            Payload::ColoredScriptHash(_, _) => Some(AddressType::Cp2sh),
+        }
+    }
+
+    /// Format the address for the usage by `Debug` and `Display` implementations.
+    fn fmt_internal(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let p2pkh_prefix = match self.network() {
+            Network::Prod => PUBKEY_ADDRESS_PREFIX_MAIN,
+            Network::Dev => PUBKEY_ADDRESS_PREFIX_TEST,
+        };
+        let p2sh_prefix = match self.network() {
+            Network::Prod => SCRIPT_ADDRESS_PREFIX_MAIN,
+            Network::Dev => SCRIPT_ADDRESS_PREFIX_TEST,
+        };
+        let cp2pkh_prefix = match self.network() {
+            Network::Prod => COLORED_PUBKEY_ADDRESS_PREFIX_MAIN,
+            Network::Dev => COLORED_PUBKEY_ADDRESS_PREFIX_TEST,
+        };
+        let cp2sh_prefix = match self.network() {
+            Network::Prod => COLORED_SCRIPT_ADDRESS_PREFIX_MAIN,
+            Network::Dev => COLORED_SCRIPT_ADDRESS_PREFIX_TEST,
+        };
+        let hrp = match self.network() {
+            Network::Prod => hrp::BC,
+            Network::Dev => hrp::TB,
+        };
+        let encoding = AddressEncoding { payload: self.payload(), p2pkh_prefix, p2sh_prefix,
+            cp2pkh_prefix, cp2sh_prefix, hrp };
+
+        use fmt::Display;
+
+        encoding.fmt(fmt)
+    }
+
+    /// Create new address from given components, infering the network validation
+    /// marker type of the address.
+    #[inline]
+    pub fn new(network: Network, payload: Payload) -> Self {
+        Self(AddressInner { network, payload }, PhantomData)
+    }
+}
+
+/// Methods and functions that can be called only on `Address<NetworkChecked>`.
+impl Address {
+    /// Creates a pay to (compressed) public key hash address from a public key.
+    ///
+    /// This is the preferred non-witness type address.
+    #[inline]
+    pub fn p2pkh(pk: &PublicKey, network: Network) -> Address {
+        Address::new(network, Payload::p2pkh(pk))
+    }
+
+    /// Creates a pay to script hash P2SH address from a script.
+    ///
+    /// This address type was introduced with BIP16 and is the popular type to implement multi-sig
+    /// these days.
+    #[inline]
+    pub fn p2sh(script: &Script, network: Network) -> Result<Address, Error> {
+        Ok(Address::new(network, Payload::p2sh(script)?))
+    }
+
+    /// Gets the address type of the address.
+    ///
+    /// # Returns
+    /// None if unknown, non-standard or related to the future witness version.
+    #[inline]
+    pub fn address_type(&self) -> Option<AddressType> { self.address_type_internal() }
+
+    /// Checks whether or not the address is following Bitcoin standardness rules when
+    /// *spending* from this address. *NOT* to be called by senders.
+    ///
+    /// <details>
+    /// <summary>Spending Standardness</summary>
+    ///
+    /// For forward compatibility, the senders must send to any [`Address`]. Receivers
+    /// can use this method to check whether or not they can spend from this address.
+    ///
+    /// SegWit addresses with unassigned witness versions or non-standard program sizes are
+    /// considered non-standard.
+    /// </details>
+    ///
+    pub fn is_spend_standard(&self) -> bool { self.address_type().is_some() }
+
+    /// Constructs an [`Address`] from an output script (`scriptPubkey`).
+    pub fn from_script(script: &Script, network: Network) -> Result<Address, Error> {
+        Ok(Address::new(network, Payload::from_script(script)?))
+    }
+
+    /// Generates a script pubkey spending to this address.
+    pub fn script_pubkey(&self) -> ScriptBuf { self.payload().script_pubkey() }
+
+    /// Creates a URI string *tapyrus:address* optimized to be encoded in QR codes.
+    ///
+    /// If the address is bech32, the address becomes uppercase.
+    /// If the address is base58, the address is left mixed case.
+    ///
+    /// Quoting BIP 173 "inside QR codes uppercase SHOULD be used, as those permit the use of
+    /// alphanumeric mode, which is 45% more compact than the normal byte mode."
+    ///
+    /// Note however that despite BIP21 explicitly stating that the `tapyrus:` prefix should be
+    /// parsed as case-insensitive many wallets got this wrong and don't parse correctly.
+    /// [See compatibility table.](https://github.com/btcpayserver/btcpayserver/issues/2110)
+    ///
+    /// If you want to avoid allocation you can use alternate display instead:
+    /// ```
+    /// # use core::fmt::Write;
+    /// # const ADDRESS: &str = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf";
+    /// # let address = ADDRESS.parse::<tapyrus::Address<_>>().unwrap().assume_checked();
+    /// # let mut writer = String::new();
+    /// # // magic trick to make error handling look better
+    /// # (|| -> Result<(), core::fmt::Error> {
+    ///
+    /// write!(writer, "{:#}", address)?;
+    ///
+    /// # Ok(())
+    /// # })().unwrap();
+    /// # assert_eq!(writer, ADDRESS);
+    /// ```
+    pub fn to_qr_uri(&self) -> String { format!("tapyrus:{:#}", self) }
+
+    /// Returns true if the given pubkey is directly related to the address payload.
+    ///
+    /// This is determined by directly comparing the address payload with either the
+    /// hash of the given public key or the segwit redeem hash generated from the
+    /// given key. For taproot addresses, the supplied key is assumed to be tweaked
+    pub fn is_related_to_pubkey(&self, pubkey: &PublicKey) -> bool {
+        let pubkey_hash = pubkey.pubkey_hash();
+        let payload = self.payload().inner_prog_as_bytes();
+        let xonly_pubkey = XOnlyPublicKey::from(pubkey.inner);
+
+        (*pubkey_hash.as_byte_array() == *payload) || (xonly_pubkey.serialize() == *payload)
+    }
+
+    /// Returns true if the supplied xonly public key can be used to derive the address.
+    ///
+    /// This will only work for Taproot addresses. The Public Key is
+    /// assumed to have already been tweaked.
+    pub fn is_related_to_xonly_pubkey(&self, xonly_pubkey: &XOnlyPublicKey) -> bool {
+        let payload = self.payload().inner_prog_as_bytes();
+        payload == xonly_pubkey.serialize()
+    }
+
+    /// Returns true if the address creates a particular script
+    /// This function doesn't make any allocations.
+    pub fn matches_script_pubkey(&self, script_pubkey: &Script) -> bool {
+        self.payload().matches_script_pubkey(script_pubkey)
+    }
+}
+
+/// Methods that can be called only on `Address<NetworkUnchecked>`.
+impl Address<NetworkUnchecked> {
+    /// Returns a reference to the checked address.
+    /// This function is dangerous in case the address is not a valid checked address.
+    pub fn assume_checked_ref(&self) -> &Address {
+        unsafe { &*(self as *const Address<NetworkUnchecked> as *const Address) }
+    }
+    /// Parsed addresses do not always have *one* network. The problem is that legacy testnet,
+    /// regtest and signet addresse use the same prefix instead of multiple different ones. When
+    /// parsing, such addresses are always assumed to be testnet addresses (the same is true for
+    /// bech32 signet addresses). So if one wants to check if an address belongs to a certain
+    /// network a simple comparison is not enough anymore. Instead this function can be used.
+    ///
+    /// ```rust
+    /// use tapyrus::{Address, Network};
+    /// use tapyrus::address::NetworkUnchecked;
+    ///
+    /// let address: Address<NetworkUnchecked> = "2N83imGV3gPwBzKJQvWJ7cRUY2SpUyU6A5e".parse().unwrap();
+    /// assert!(address.is_valid_for_network(Network::Dev));
+    ///
+    /// assert_eq!(address.is_valid_for_network(Network::Prod), false);
+    ///
+    /// let address: Address<NetworkUnchecked> = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf".parse().unwrap();
+    /// assert!(address.is_valid_for_network(Network::Prod));
+    /// assert_eq!(address.is_valid_for_network(Network::Dev), false);
+    /// ```
+    pub fn is_valid_for_network(&self, network: Network) -> bool {
+        match (self.network(), network) {
+            (a, b) if *a == b => true,
+            (_, _) => false,
+        }
+    }
+
+    /// Checks whether network of this address is as required.
+    ///
+    /// For details about this mechanism, see section [*Parsing addresses*](Address#parsing-addresses)
+    /// on [`Address`].
+    #[inline]
+    pub fn require_network(self, required: Network) -> Result<Address, Error> {
+        if self.is_valid_for_network(required) {
+            Ok(self.assume_checked())
+        } else {
+            Err(Error::NetworkValidation { found: *self.network(), required, address: self })
+        }
+    }
+
+    /// Marks, without any additional checks, network of this address as checked.
+    ///
+    /// Improper use of this method may lead to loss of funds. Reader will most likely prefer
+    /// [`require_network`](Address<NetworkUnchecked>::require_network) as a safe variant.
+    /// For details about this mechanism, see section [*Parsing addresses*](Address#parsing-addresses)
+    /// on [`Address`].
+    #[inline]
+    pub fn assume_checked(self) -> Address {
+        let (network, payload) = self.into_parts();
+        Address::new(network, payload)
+    }
+}
+
+// For NetworkUnchecked , it compare Addresses and if network and payload matches then return true.
+impl PartialEq<Address<NetworkUnchecked>> for Address {
+    fn eq(&self, other: &Address<NetworkUnchecked>) -> bool {
+        self.network() == other.network() && self.payload() == other.payload()
+    }
+}
+
+impl PartialEq<Address> for Address<NetworkUnchecked> {
+    fn eq(&self, other: &Address) -> bool { other == self }
+}
+
+impl From<Address> for script::ScriptBuf {
+    fn from(a: Address) -> Self { a.script_pubkey() }
+}
+
+// Alternate formatting `{:#}` is used to return uppercase version of bech32 addresses which should
+// be used in QR codes, see [`Address::to_qr_uri`].
+impl fmt::Display for Address {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { self.fmt_internal(fmt) }
+}
+
+impl<V: NetworkValidation> fmt::Debug for Address<V> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if V::IS_CHECKED {
+            self.fmt_internal(f)
+        } else {
+            write!(f, "Address<NetworkUnchecked>(")?;
+            self.fmt_internal(f)?;
+            write!(f, ")")
+        }
+    }
+}
+
+/// Address can be parsed only with `NetworkUnchecked`.
+impl FromStr for Address<NetworkUnchecked> {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Base58
+        if s.len() > 80 {
+            return Err(ParseError::Base58(base58::Error::InvalidLength(s.len() * 11 / 15)));
+        }
+        let data = base58::decode_check(s)?;
+        if data.len() != 21 && data.len() != 54 {
+            return Err(ParseError::Base58(base58::Error::InvalidLength(data.len())));
+        }
+        let (network, payload) = match data.len() {
+            21 => {
+                match data[0] {
+                    PUBKEY_ADDRESS_PREFIX_MAIN =>
+                        (Network::Prod, Payload::PubkeyHash(PubkeyHash::from_slice(&data[1..]).unwrap())),
+                    SCRIPT_ADDRESS_PREFIX_MAIN =>
+                        (Network::Prod, Payload::ScriptHash(ScriptHash::from_slice(&data[1..]).unwrap())),
+                    PUBKEY_ADDRESS_PREFIX_TEST =>
+                        (Network::Dev, Payload::PubkeyHash(PubkeyHash::from_slice(&data[1..]).unwrap())),
+                    SCRIPT_ADDRESS_PREFIX_TEST =>
+                        (Network::Dev, Payload::ScriptHash(ScriptHash::from_slice(&data[1..]).unwrap())),
+                    x => return Err(ParseError::Base58(base58::Error::InvalidAddressVersion(x))),
+                }
+            }
+            54 => {
+                match data[0] {
+                    COLORED_PUBKEY_ADDRESS_PREFIX_MAIN =>
+                        (Network::Prod, Payload::ColoredPubkeyHash(deserialize(&data[1..34]).unwrap(), PubkeyHash::from_slice(&data[34..]).unwrap())),
+                    COLORED_SCRIPT_ADDRESS_PREFIX_MAIN =>
+                        (Network::Prod, Payload::ColoredScriptHash(deserialize(&data[1..34]).unwrap(), ScriptHash::from_slice(&data[34..]).unwrap())),
+                    COLORED_PUBKEY_ADDRESS_PREFIX_TEST =>
+                        (Network::Dev, Payload::ColoredPubkeyHash(deserialize(&data[1..34]).unwrap(), PubkeyHash::from_slice(&data[34..]).unwrap())),
+                    COLORED_SCRIPT_ADDRESS_PREFIX_TEST =>
+                        (Network::Dev, Payload::ColoredScriptHash(deserialize(&data[1..34]).unwrap(), ScriptHash::from_slice(&data[34..]).unwrap())),
+                    x => return Err(ParseError::Base58(base58::Error::InvalidAddressVersion(x))),
+                }
+            }
+            _ => return Err(ParseError::Base58(base58::Error::InvalidLength(data.len()))),
+        };
+
+        Ok(Address::new(network, payload))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+    use hex_lit::hex;
+
+    use super::*;
+    use crate::crypto::key::PublicKey;
+    use crate::network::Network::{Dev, Prod};
+
+    fn roundtrips(addr: &Address) {
+        assert_eq!(
+            Address::from_str(&addr.to_string()).unwrap().assume_checked(),
+            *addr,
+            "string round-trip failed for {}",
+            addr,
+        );
+        assert_eq!(
+            Address::from_script(&addr.script_pubkey(), *addr.network()).as_ref(),
+            Ok(addr),
+            "script round-trip failed for {}",
+            addr,
+        );
+
+        #[cfg(feature = "serde")]
+        {
+            let ser = serde_json::to_string(addr).expect("failed to serialize address");
+            let back: Address<NetworkUnchecked> =
+                serde_json::from_str(&ser).expect("failed to deserialize address");
+            assert_eq!(back.assume_checked(), *addr, "serde round-trip failed for {}", addr)
+        }
+    }
+
+    #[test]
+    fn test_p2pkh_address_58() {
+        let addr = Address::new(
+            Prod,
+            Payload::PubkeyHash("162c5ea71c0b23f5b9022ef047c4a86470a5b070".parse().unwrap()),
+        );
+
+        assert_eq!(
+            addr.script_pubkey(),
+            ScriptBuf::from_hex("76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac").unwrap()
+        );
+        assert_eq!(&addr.to_string(), "132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM");
+        assert_eq!(addr.address_type(), Some(AddressType::P2pkh));
+        roundtrips(&addr);
+    }
+
+    #[test]
+    fn test_p2pkh_from_key() {
+        let key = "048d5141948c1702e8c95f438815794b87f706a8d4cd2bffad1dc1570971032c9b6042a0431ded2478b5c9cf2d81c124a5e57347a3c63ef0e7716cf54d613ba183".parse::<PublicKey>().unwrap();
+        let addr = Address::p2pkh(&key, Prod);
+        assert_eq!(&addr.to_string(), "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY");
+
+        let key = "03df154ebfcf29d29cc10d5c2565018bce2d9edbab267c31d2caf44a63056cf99f"
+            .parse::<PublicKey>()
+            .unwrap();
+        let addr = Address::p2pkh(&key, Dev);
+        assert_eq!(&addr.to_string(), "mqkhEMH6NCeYjFybv7pvFC22MFeaNT9AQC");
+        assert_eq!(addr.address_type(), Some(AddressType::P2pkh));
+        roundtrips(&addr);
+    }
+
+    #[test]
+    fn test_p2sh_address_58() {
+        let addr = Address::new(
+            Prod,
+            Payload::ScriptHash("162c5ea71c0b23f5b9022ef047c4a86470a5b070".parse().unwrap()),
+        );
+
+        assert_eq!(
+            addr.script_pubkey(),
+            ScriptBuf::from_hex("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087").unwrap(),
+        );
+        assert_eq!(&addr.to_string(), "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k");
+        assert_eq!(addr.address_type(), Some(AddressType::P2sh));
+        roundtrips(&addr);
+    }
+
+    #[test]
+    fn test_p2sh_parse() {
+        let script = ScriptBuf::from_hex("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae").unwrap();
+        let addr = Address::p2sh(&script, Dev).unwrap();
+        assert_eq!(&addr.to_string(), "2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr");
+        assert_eq!(addr.address_type(), Some(AddressType::P2sh));
+        roundtrips(&addr);
+    }
+
+    #[test]
+    fn test_p2sh_parse_for_large_script() {
+        let script = ScriptBuf::from_hex("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123").unwrap();
+        assert_eq!(Address::p2sh(&script, Dev), Err(Error::ExcessiveScriptSize));
+    }
+
+    #[test]
+    fn test_cp2pkh_address() {
+        let color_id = "c36db65fd59fd356f6729140571b5bcd6bb3b83492a16e1bf0a3884442fc3c8a0e".parse().unwrap();
+        let addr = Address::new(
+            Prod,
+            Payload::ColoredPubkeyHash(color_id, "162c5ea71c0b23f5b9022ef047c4a86470a5b070".parse().unwrap()),
+        );
+        assert_eq!(
+            addr.script_pubkey().as_bytes(),
+            hex!("21c36db65fd59fd356f6729140571b5bcd6bb3b83492a16e1bf0a3884442fc3c8a0ebc76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac")
+        );
+        assert_eq!(&addr.to_string(), "vxgHyieT46FQMYAvmNM6BsmwNNXMTPk2C6StiVD3Cmy45ge5gftf5f417CehuVWVo5KfBbgtGyLn9j");
+        assert_eq!(addr.address_type(), Some(AddressType::Cp2pkh));
+        roundtrips(&addr);
+    }
+
+    #[test]
+    fn test_cp2pkh_from_key() {
+        let key = "048d5141948c1702e8c95f438815794b87f706a8d4cd2bffad1dc1570971032c9b6042a0431ded2478b5c9cf2d81c124a5e57347a3c63ef0e7716cf54d613ba183".parse().unwrap();
+        let color_id = "c36db65fd59fd356f6729140571b5bcd6bb3b83492a16e1bf0a3884442fc3c8a0e".parse().unwrap();
+        let addr = Address::new(Prod, Payload::cp2pkh(&color_id, &key));
+        assert_eq!(&addr.to_string(), "vxgHyieT46FQMYAvmNM6BsmwNNXMTPk2C6StiVD3Cmy463vKtag2nkNBtGeqUNzBuXWtgUctod91ag");
+        assert_eq!(addr.address_type(), Some(AddressType::Cp2pkh));
+        roundtrips(&addr);
+
+        let key = "03df154ebfcf29d29cc10d5c2565018bce2d9edbab267c31d2caf44a63056cf99f".parse().unwrap();
+        let addr = Address::new(Dev, Payload::cp2pkh(&color_id, &key));
+        assert_eq!(&addr.to_string(), "22VZyRTDaMem4DcgBgRZgbo7PZm45gXSMWzHrYiYE9j1qVUiHVfNFhik8yY4YzpArPc3Hufwe5oeWgmg");
+        assert_eq!(addr.address_type(), Some(AddressType::Cp2pkh));
+        roundtrips(&addr);
+    }
+
+    #[test]
+    fn test_cp2sh_address() {
+        let color_id = "c36db65fd59fd356f6729140571b5bcd6bb3b83492a16e1bf0a3884442fc3c8a0e".parse().unwrap();
+
+        let addr = Address::new(
+            Prod,
+            Payload::ColoredScriptHash(color_id, "162c5ea71c0b23f5b9022ef047c4a86470a5b070".parse().unwrap()),
+        );
+
+        assert_eq!(
+            addr.script_pubkey().as_bytes(),
+            hex!("21c36db65fd59fd356f6729140571b5bcd6bb3b83492a16e1bf0a3884442fc3c8a0ebca914162c5ea71c0b23f5b9022ef047c4a86470a5b07087")
+        );
+        assert_eq!(&addr.to_string(), "4Zxhb33iSoydtcKzWc7hpoRjtJh2W9otwDeqP5PbZHGoq7m3fwysg7ec2TJ2RRuheF8PgQqrGKDjdij");
+        assert_eq!(addr.address_type(), Some(AddressType::Cp2sh));
+        roundtrips(&addr);
+    }
+
+    #[test]
+    fn test_address_debug() {
+        // This is not really testing output of Debug but the ability and proper functioning
+        // of Debug derivation on structs generic in NetworkValidation.
+        #[derive(Debug)]
+        #[allow(unused)]
+        struct Test<V: NetworkValidation> {
+            address: Address<V>,
+        }
+
+        let addr_str = "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k";
+        let unchecked = Address::from_str(addr_str).unwrap();
+
+        assert_eq!(
+            format!("{:?}", Test { address: unchecked.clone() }),
+            format!("Test {{ address: Address<NetworkUnchecked>({}) }}", addr_str)
+        );
+
+        assert_eq!(
+            format!("{:?}", Test { address: unchecked.assume_checked() }),
+            format!("Test {{ address: {} }}", addr_str)
+        );
+    }
+
+    #[test]
+    fn test_address_type() {
+        let addresses = [
+            ("1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY", Some(AddressType::P2pkh)),
+            ("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k", Some(AddressType::P2sh)),
+            ("vorwiRCJRHzkPNpYj8a4MkPvDcYi7X7SH6oghAqFcBdXYDkePfkgZKTu8mRUVP1XkY7LmerMSuSEgT", Some(AddressType::Cp2pkh)),
+            ("4ZotEmkGJBBPEeAe8ZsvnyJMs9w3rowGMJfCB45DmggUJaG54GfwKBV4mxJ7oPmJKuKhAykUzrunSe1", Some(AddressType::Cp2sh)),
+        ];
+        for (address, expected_type) in &addresses {
+            let addr = Address::from_str(address)
+                .unwrap()
+                .require_network(Network::Prod)
+                .expect("mainnet");
+            assert_eq!(&addr.address_type(), expected_type);
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_json_serialize() {
+        use serde_json;
+
+        // P2PKH
+        let addr =
+            Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM").unwrap().assume_checked();
+        let json = serde_json::to_value(&addr).unwrap();
+        assert_eq!(
+            json,
+            serde_json::Value::String("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM".to_owned())
+        );
+        let into: Address = serde_json::from_value::<Address<_>>(json).unwrap().assume_checked();
+        assert_eq!(addr.to_string(), into.to_string());
+        assert_eq!(
+            into.script_pubkey(),
+            ScriptBuf::from_hex("76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac").unwrap()
+        );
+
+        // P2SH
+        let addr =
+            Address::from_str("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k").unwrap().assume_checked();
+        let json = serde_json::to_value(&addr).unwrap();
+        assert_eq!(
+            json,
+            serde_json::Value::String("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k".to_owned())
+        );
+        let into: Address = serde_json::from_value::<Address<_>>(json).unwrap().assume_checked();
+        assert_eq!(addr.to_string(), into.to_string());
+        assert_eq!(
+            into.script_pubkey(),
+            ScriptBuf::from_hex("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087").unwrap()
+        );
+
+        // CP2PKH
+        let addr = Address::from_str("vxgHyieT46FQMYAvmNM6BsmwNNXMTPk2C6StiVD3Cmy45ge5gftf5f417CehuVWVo5KfBbgtGyLn9j").unwrap().assume_checked();
+        let json = serde_json::to_value(&addr).unwrap();
+        assert_eq!(
+            json,
+            serde_json::Value::String("vxgHyieT46FQMYAvmNM6BsmwNNXMTPk2C6StiVD3Cmy45ge5gftf5f417CehuVWVo5KfBbgtGyLn9j".to_owned())
+        );
+        let into: Address = serde_json::from_value::<Address<_>>(json).unwrap().assume_checked();
+        assert_eq!(addr.to_string(), into.to_string());
+        assert_eq!(
+            into.script_pubkey(),
+            ScriptBuf::from_hex("21c36db65fd59fd356f6729140571b5bcd6bb3b83492a16e1bf0a3884442fc3c8a0ebc76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac").unwrap()
+        );
+
+        // CP2SH
+        let addr = Address::from_str("4Zxhb33iSoydtcKzWc7hpoRjtJh2W9otwDeqP5PbZHGoq7m3fwysg7ec2TJ2RRuheF8PgQqrGKDjdij").unwrap().assume_checked();
+        let json = serde_json::to_value(&addr).unwrap();
+        assert_eq!(
+            json,
+            serde_json::Value::String("4Zxhb33iSoydtcKzWc7hpoRjtJh2W9otwDeqP5PbZHGoq7m3fwysg7ec2TJ2RRuheF8PgQqrGKDjdij".to_owned())
+        );
+        let into: Address = serde_json::from_value::<Address<_>>(json).unwrap().assume_checked();
+        assert_eq!(addr.to_string(), into.to_string());
+        assert_eq!(
+            into.script_pubkey(),
+            ScriptBuf::from_hex("21c36db65fd59fd356f6729140571b5bcd6bb3b83492a16e1bf0a3884442fc3c8a0ebca914162c5ea71c0b23f5b9022ef047c4a86470a5b07087").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_qr_string() {
+        for el in
+            ["132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM", "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k"].iter()
+        {
+            let addr =
+                Address::from_str(el).unwrap().require_network(Network::Prod).expect("mainnet");
+            assert_eq!(addr.to_qr_uri(), format!("tapyrus:{}", el));
+        }
+    }
+
+    #[test]
+    fn test_valid_networks() {
+        let legacy_payload = &[
+            Payload::PubkeyHash(PubkeyHash::all_zeros()),
+            Payload::ScriptHash(ScriptHash::all_zeros()),
+        ];
+
+        const LEGACY_EQUIVALENCE_CLASSES: &[&[Network]] = &[&[Network::Prod], &[Network::Dev]];
+
+        fn test_addr_type(payloads: &[Payload], equivalence_classes: &[&[Network]]) {
+            for pl in payloads {
+                for addr_net in equivalence_classes.iter().flat_map(|ec| ec.iter()) {
+                    for valid_net in equivalence_classes
+                        .iter()
+                        .filter(|ec| ec.contains(addr_net))
+                        .flat_map(|ec| ec.iter())
+                    {
+                        let addr = Address::new(*addr_net, pl.clone());
+                        assert!(addr.is_valid_for_network(*valid_net));
+                    }
+
+                    for invalid_net in equivalence_classes
+                        .iter()
+                        .filter(|ec| !ec.contains(addr_net))
+                        .flat_map(|ec| ec.iter())
+                    {
+                        let addr = Address::new(*addr_net, pl.clone());
+                        assert!(!addr.is_valid_for_network(*invalid_net));
+                    }
+                }
+            }
+        }
+
+        test_addr_type(legacy_payload, LEGACY_EQUIVALENCE_CLASSES);
+    }
+
+    #[test]
+    fn test_is_related_to_pubkey_p2pkh() {
+        let address_string = "1J4LVanjHMu3JkXbVrahNuQCTGCRRgfWWx";
+        let address = Address::from_str(address_string)
+            .expect("address")
+            .require_network(Network::Prod)
+            .expect("mainnet");
+
+        let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
+        let pubkey = PublicKey::from_str(pubkey_string).expect("pubkey");
+
+        let result = address.is_related_to_pubkey(&pubkey);
+        assert!(result);
+
+        let unused_pubkey = PublicKey::from_str(
+            "02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c",
+        )
+        .expect("pubkey");
+        assert!(!address.is_related_to_pubkey(&unused_pubkey))
+    }
+
+    #[test]
+    fn test_is_related_to_pubkey_p2pkh_uncompressed_key() {
+        let address_string = "msvS7KzhReCDpQEJaV2hmGNvuQqVUDuC6p";
+        let address = Address::from_str(address_string)
+            .expect("address")
+            .require_network(Network::Dev)
+            .expect("testnet");
+
+        let pubkey_string = "04e96e22004e3db93530de27ccddfdf1463975d2138ac018fc3e7ba1a2e5e0aad8e424d0b55e2436eb1d0dcd5cb2b8bcc6d53412c22f358de57803a6a655fbbd04";
+        let pubkey = PublicKey::from_str(pubkey_string).expect("pubkey");
+
+        let result = address.is_related_to_pubkey(&pubkey);
+        assert!(result);
+
+        let unused_pubkey = PublicKey::from_str(
+            "02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c",
+        )
+        .expect("pubkey");
+        assert!(!address.is_related_to_pubkey(&unused_pubkey))
+    }
+
+    #[test]
+    fn test_fail_address_from_script() {
+        let bad_p2wpkh = ScriptBuf::from_hex("0014dbc5b0a8f9d4353b4b54c3db48846bb15abfec").unwrap();
+        let bad_p2wsh = ScriptBuf::from_hex(
+            "00202d4fa2eb233d008cc83206fa2f4f2e60199000f5b857a835e3172323385623",
+        )
+        .unwrap();
+        let invalid_segwitv0_script =
+            ScriptBuf::from_hex("001161458e330389cd0437ee9fe3641d70cc18").unwrap();
+        let expected = Err(Error::UnrecognizedScript);
+
+        assert_eq!(Address::from_script(&bad_p2wpkh, Network::Prod), expected);
+        assert_eq!(Address::from_script(&bad_p2wsh, Network::Prod), expected);
+        assert_eq!(Address::from_script(&invalid_segwitv0_script, Network::Prod), expected);
+    }
+
+    #[test]
+    fn invalid_address_parses_error() {
+        let got = AddressType::from_str("invalid");
+        let want = Err(UnknownAddressTypeError("invalid".to_string()));
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn test_matches_script_pubkey() {
+        let addresses = [
+            "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY",
+            "1J4LVanjHMu3JkXbVrahNuQCTGCRRgfWWx",
+            "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k",
+            "3QBRmWNqqBGme9er7fMkGqtZtp4gjMFxhE",
+        ];
+        for addr in &addresses {
+            let addr = Address::from_str(addr).unwrap().require_network(Network::Prod).unwrap();
+            for another in &addresses {
+                let another =
+                    Address::from_str(another).unwrap().require_network(Network::Prod).unwrap();
+                assert_eq!(addr.matches_script_pubkey(&another.script_pubkey()), addr == another);
+            }
+        }
+    }
+}
diff --git a/tapyrus/src/amount.rs b/tapyrus/src/amount.rs
new file mode 100644
index 00000000..d3b07778
--- /dev/null
+++ b/tapyrus/src/amount.rs
@@ -0,0 +1,2352 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin amounts.
+//!
+//! This module mainly introduces the [Amount] and [SignedAmount] types.
+//! We refer to the documentation on the types for more information.
+//!
+
+use core::cmp::Ordering;
+use core::fmt::{self, Write};
+use core::str::FromStr;
+use core::{default, ops};
+
+use crate::consensus::encode::{self, Decodable, Encodable};
+use crate::io;
+use crate::prelude::*;
+
+/// A set of denominations in which amounts can be expressed.
+///
+/// # Examples
+/// ```
+/// # use core::str::FromStr;
+/// # use tapyrus::Amount;
+///
+/// assert_eq!(Amount::from_str("1 TPC").unwrap(), Amount::from_tap(100_000_000));
+/// assert_eq!(Amount::from_str("1 cTPC").unwrap(), Amount::from_tap(1_000_000));
+/// assert_eq!(Amount::from_str("1 mTPC").unwrap(), Amount::from_tap(100_000));
+/// assert_eq!(Amount::from_str("1 uTPC").unwrap(), Amount::from_tap(100));
+/// assert_eq!(Amount::from_str("10 nTPC").unwrap(), Amount::from_tap(1));
+/// assert_eq!(Amount::from_str("10000 pTPC").unwrap(), Amount::from_tap(1));
+/// assert_eq!(Amount::from_str("1 tap").unwrap(), Amount::from_tap(1));
+/// assert_eq!(Amount::from_str("1000 mtaps").unwrap(), Amount::from_tap(1));
+/// ```
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+#[non_exhaustive]
+pub enum Denomination {
+    /// TPC
+    TPC,
+    /// cTPC
+    CentiTPC,
+    /// mTPC
+    MilliTPC,
+    /// uTPC
+    MicroTPC,
+    /// nTPC
+    NanoTPC,
+    /// pTPC
+    PicoTPC,
+    /// tapyrus
+    Tapyrus,
+    /// mtap
+    MilliTapyrus,
+}
+
+impl Denomination {
+    /// The number of decimal places more than a tapyrus.
+    fn precision(self) -> i8 {
+        match self {
+            Denomination::TPC => -8,
+            Denomination::CentiTPC => -6,
+            Denomination::MilliTPC => -5,
+            Denomination::MicroTPC => -2,
+            Denomination::NanoTPC => 1,
+            Denomination::PicoTPC => 4,
+            Denomination::Tapyrus => 0,
+            Denomination::MilliTapyrus => 3,
+        }
+    }
+
+    /// Returns stringly representation of this
+    fn as_str(self) -> &'static str {
+        match self {
+            Denomination::TPC => "TPC",
+            Denomination::CentiTPC => "cTPC",
+            Denomination::MilliTPC => "mTPC",
+            Denomination::MicroTPC => "uTPC",
+            Denomination::NanoTPC => "nTPC",
+            Denomination::PicoTPC => "pTPC",
+            Denomination::Tapyrus => "tapyrus",
+            Denomination::MilliTapyrus => "mtap",
+        }
+    }
+
+    /// The different str forms of denominations that are recognized.
+    fn forms(s: &str) -> Option<Self> {
+        match s {
+            "TPC" | "tpc" => Some(Denomination::TPC),
+            "cTPC" | "ctpc" => Some(Denomination::CentiTPC),
+            "mTPC" | "mtpc" => Some(Denomination::MilliTPC),
+            "uTPC" | "utpc" => Some(Denomination::MicroTPC),
+            "nTPC" | "ntpc" => Some(Denomination::NanoTPC),
+            "pTPC" | "ptpc" => Some(Denomination::PicoTPC),
+            "TAPYRUS" | "tapyrus" | "TAPYRUSES" | "tapyruses" | "TAP" | "tap" | "TAPS" | "taps" => Some(Denomination::Tapyrus),
+            "mTAP" | "mtap" | "mTAPs" | "mtaps" => Some(Denomination::MilliTapyrus),
+            _ => None,
+        }
+    }
+}
+
+/// These form are ambigous and could have many meanings.  For example, M could denote Mega or Milli.
+/// If any of these forms are used, an error type PossiblyConfusingDenomination is returned.
+const CONFUSING_FORMS: [&str; 9] =
+    ["Mtap", "Mtaps", "MTAP", "MTAPS", "MTap", "MTaps", "MTPC", "Mtpc", "PTPC"];
+
+impl fmt::Display for Denomination {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(self.as_str()) }
+}
+
+impl FromStr for Denomination {
+    type Err = ParseAmountError;
+
+    /// Convert from a str to Denomination.
+    ///
+    /// Any combination of upper and/or lower case, excluding uppercase of SI(m, u, n, p) is considered valid.
+    /// - Singular: TPC, mTPC, uTPC, nTPC, pTPC
+    /// - Plural or singular: tap, tapyrus, mtap
+    ///
+    /// Due to ambiguity between mega and milli, pico and peta we prohibit usage of leading capital 'M', 'P'.
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use self::ParseAmountError::*;
+
+        if CONFUSING_FORMS.contains(&s) {
+            return Err(PossiblyConfusingDenomination(s.to_owned()));
+        };
+
+        let form = self::Denomination::forms(s);
+
+        form.ok_or_else(|| UnknownDenomination(s.to_owned()))
+    }
+}
+
+/// An error during amount parsing.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ParseAmountError {
+    /// Amount is negative.
+    Negative,
+    /// Amount is too big to fit inside the type.
+    TooBig,
+    /// Amount has higher precision than supported by the type.
+    TooPrecise,
+    /// Invalid number format.
+    InvalidFormat,
+    /// Input string was too large.
+    InputTooLarge,
+    /// Invalid character in input.
+    InvalidCharacter(char),
+    /// The denomination was unknown.
+    UnknownDenomination(String),
+    /// The denomination has multiple possible interpretations.
+    PossiblyConfusingDenomination(String),
+}
+
+impl fmt::Display for ParseAmountError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use ParseAmountError::*;
+
+        match *self {
+            Negative => f.write_str("amount is negative"),
+            TooBig => f.write_str("amount is too big"),
+            TooPrecise => f.write_str("amount has a too high precision"),
+            InvalidFormat => f.write_str("invalid number format"),
+            InputTooLarge => f.write_str("input string was too large"),
+            InvalidCharacter(c) => write!(f, "invalid character in input: {}", c),
+            UnknownDenomination(ref d) => write!(f, "unknown denomination: {}", d),
+            PossiblyConfusingDenomination(ref d) => {
+                let (letter, upper, lower) = match d.chars().next() {
+                    Some('M') => ('M', "Mega", "milli"),
+                    Some('P') => ('P', "Peta", "pico"),
+                    // This panic could be avoided by adding enum ConfusingDenomination { Mega, Peta } but is it worth it?
+                    _ => panic!("invalid error information"),
+                };
+                write!(f, "the '{}' at the beginning of {} should technically mean '{}' but that denomination is uncommon and maybe '{}' was intended", letter, d, upper, lower)
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseAmountError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use ParseAmountError::*;
+
+        match *self {
+            Negative
+            | TooBig
+            | TooPrecise
+            | InvalidFormat
+            | InputTooLarge
+            | InvalidCharacter(_)
+            | UnknownDenomination(_)
+            | PossiblyConfusingDenomination(_) => None,
+        }
+    }
+}
+
+fn is_too_precise(s: &str, precision: usize) -> bool {
+    match s.find('.') {
+        Some(pos) =>
+            s[(pos + 1)..].chars().any(|d| d != '0')
+                || precision >= pos
+                || s[..pos].chars().rev().take(precision).any(|d| d != '0'),
+        None => precision >= s.len() || s.chars().rev().take(precision).any(|d| d != '0'),
+    }
+}
+
+/// Parse decimal string in the given denomination into a tapyrus value and a
+/// bool indicator for a negative amount.
+fn parse_signed_to_tapyrus(
+    mut s: &str,
+    denom: Denomination,
+) -> Result<(bool, u64), ParseAmountError> {
+    if s.is_empty() {
+        return Err(ParseAmountError::InvalidFormat);
+    }
+    if s.len() > 50 {
+        return Err(ParseAmountError::InputTooLarge);
+    }
+
+    let is_negative = s.starts_with('-');
+    if is_negative {
+        if s.len() == 1 {
+            return Err(ParseAmountError::InvalidFormat);
+        }
+        s = &s[1..];
+    }
+
+    let max_decimals = {
+        // The difference in precision between native (tapyrus)
+        // and desired denomination.
+        let precision_diff = -denom.precision();
+        if precision_diff <= 0 {
+            // If precision diff is negative, this means we are parsing
+            // into a less precise amount. That is not allowed unless
+            // there are no decimals and the last digits are zeroes as
+            // many as the difference in precision.
+            let last_n = unsigned_abs(precision_diff).into();
+            if is_too_precise(s, last_n) {
+                match s.parse::<i64>() {
+                    Ok(0) => return Ok((is_negative, 0)),
+                    _ => return Err(ParseAmountError::TooPrecise),
+                }
+            }
+            s = &s[0..s.find('.').unwrap_or(s.len()) - last_n];
+            0
+        } else {
+            precision_diff
+        }
+    };
+
+    let mut decimals = None;
+    let mut value: u64 = 0; // as tapyruses
+    for c in s.chars() {
+        match c {
+            '0'..='9' => {
+                // Do `value = 10 * value + digit`, catching overflows.
+                match 10_u64.checked_mul(value) {
+                    None => return Err(ParseAmountError::TooBig),
+                    Some(val) => match val.checked_add((c as u8 - b'0') as u64) {
+                        None => return Err(ParseAmountError::TooBig),
+                        Some(val) => value = val,
+                    },
+                }
+                // Increment the decimal digit counter if past decimal.
+                decimals = match decimals {
+                    None => None,
+                    Some(d) if d < max_decimals => Some(d + 1),
+                    _ => return Err(ParseAmountError::TooPrecise),
+                };
+            }
+            '.' => match decimals {
+                None if max_decimals <= 0 => break,
+                None => decimals = Some(0),
+                // Double decimal dot.
+                _ => return Err(ParseAmountError::InvalidFormat),
+            },
+            c => return Err(ParseAmountError::InvalidCharacter(c)),
+        }
+    }
+
+    // Decimally shift left by `max_decimals - decimals`.
+    let scale_factor = max_decimals - decimals.unwrap_or(0);
+    for _ in 0..scale_factor {
+        value = match 10_u64.checked_mul(value) {
+            Some(v) => v,
+            None => return Err(ParseAmountError::TooBig),
+        };
+    }
+
+    Ok((is_negative, value))
+}
+
+fn split_amount_and_denomination(s: &str) -> Result<(&str, Denomination), ParseAmountError> {
+    let (i, j) = if let Some(i) = s.find(' ') {
+        (i, i + 1)
+    } else {
+        let i = s.find(|c: char| c.is_alphabetic()).ok_or(ParseAmountError::InvalidFormat)?;
+        (i, i)
+    };
+    Ok((&s[..i], s[j..].parse()?))
+}
+
+/// Options given by `fmt::Formatter`
+struct FormatOptions {
+    fill: char,
+    align: Option<fmt::Alignment>,
+    width: Option<usize>,
+    precision: Option<usize>,
+    sign_plus: bool,
+    sign_aware_zero_pad: bool,
+}
+
+impl FormatOptions {
+    fn from_formatter(f: &fmt::Formatter) -> Self {
+        FormatOptions {
+            fill: f.fill(),
+            align: f.align(),
+            width: f.width(),
+            precision: f.precision(),
+            sign_plus: f.sign_plus(),
+            sign_aware_zero_pad: f.sign_aware_zero_pad(),
+        }
+    }
+}
+
+impl Default for FormatOptions {
+    fn default() -> Self {
+        FormatOptions {
+            fill: ' ',
+            align: None,
+            width: None,
+            precision: None,
+            sign_plus: false,
+            sign_aware_zero_pad: false,
+        }
+    }
+}
+
+fn dec_width(mut num: u64) -> usize {
+    let mut width = 1;
+    loop {
+        num /= 10;
+        if num == 0 {
+            break;
+        }
+        width += 1;
+    }
+    width
+}
+
+// NIH due to MSRV, impl copied from `core::i8::unsigned_abs` (introduced in Rust 1.51.1).
+fn unsigned_abs(x: i8) -> u8 { x.wrapping_abs() as u8 }
+
+fn repeat_char(f: &mut dyn fmt::Write, c: char, count: usize) -> fmt::Result {
+    for _ in 0..count {
+        f.write_char(c)?;
+    }
+    Ok(())
+}
+
+/// Format the given tapyrus amount in the given denomination.
+fn fmt_tapyrus_in(
+    tapyrus: u64,
+    negative: bool,
+    f: &mut dyn fmt::Write,
+    denom: Denomination,
+    show_denom: bool,
+    options: FormatOptions,
+) -> fmt::Result {
+    let precision = denom.precision();
+    // First we normalize the number:
+    // {num_before_decimal_point}{:0exp}{"." if nb_decimals > 0}{:0nb_decimals}{num_after_decimal_point}{:0trailing_decimal_zeros}
+    let mut num_after_decimal_point = 0;
+    let mut norm_nb_decimals = 0;
+    let mut num_before_decimal_point = tapyrus;
+    let trailing_decimal_zeros;
+    let mut exp = 0;
+    match precision.cmp(&0) {
+        // We add the number of zeroes to the end
+        Ordering::Greater => {
+            if tapyrus > 0 {
+                exp = precision as usize;
+            }
+            trailing_decimal_zeros = options.precision.unwrap_or(0);
+        }
+        Ordering::Less => {
+            let precision = unsigned_abs(precision);
+            let divisor = 10u64.pow(precision.into());
+            num_before_decimal_point = tapyrus / divisor;
+            num_after_decimal_point = tapyrus % divisor;
+            // normalize by stripping trailing zeros
+            if num_after_decimal_point == 0 {
+                norm_nb_decimals = 0;
+            } else {
+                norm_nb_decimals = usize::from(precision);
+                while num_after_decimal_point % 10 == 0 {
+                    norm_nb_decimals -= 1;
+                    num_after_decimal_point /= 10
+                }
+            }
+            // compute requested precision
+            let opt_precision = options.precision.unwrap_or(0);
+            trailing_decimal_zeros = opt_precision.saturating_sub(norm_nb_decimals);
+        }
+        Ordering::Equal => trailing_decimal_zeros = options.precision.unwrap_or(0),
+    }
+    let total_decimals = norm_nb_decimals + trailing_decimal_zeros;
+    // Compute expected width of the number
+    let mut num_width = if total_decimals > 0 {
+        // 1 for decimal point
+        1 + total_decimals
+    } else {
+        0
+    };
+    num_width += dec_width(num_before_decimal_point) + exp;
+    if options.sign_plus || negative {
+        num_width += 1;
+    }
+
+    if show_denom {
+        // + 1 for space
+        num_width += denom.as_str().len() + 1;
+    }
+
+    let width = options.width.unwrap_or(0);
+    let align = options.align.unwrap_or(fmt::Alignment::Right);
+    let (left_pad, pad_right) = match (num_width < width, options.sign_aware_zero_pad, align) {
+        (false, _, _) => (0, 0),
+        // Alignment is always right (ignored) when zero-padding
+        (true, true, _) | (true, false, fmt::Alignment::Right) => (width - num_width, 0),
+        (true, false, fmt::Alignment::Left) => (0, width - num_width),
+        // If the required padding is odd it needs to be skewed to the left
+        (true, false, fmt::Alignment::Center) =>
+            ((width - num_width) / 2, (width - num_width + 1) / 2),
+    };
+
+    if !options.sign_aware_zero_pad {
+        repeat_char(f, options.fill, left_pad)?;
+    }
+
+    if negative {
+        write!(f, "-")?;
+    } else if options.sign_plus {
+        write!(f, "+")?;
+    }
+
+    if options.sign_aware_zero_pad {
+        repeat_char(f, '0', left_pad)?;
+    }
+
+    write!(f, "{}", num_before_decimal_point)?;
+
+    repeat_char(f, '0', exp)?;
+
+    if total_decimals > 0 {
+        write!(f, ".")?;
+    }
+    if norm_nb_decimals > 0 {
+        write!(f, "{:0width$}", num_after_decimal_point, width = norm_nb_decimals)?;
+    }
+    repeat_char(f, '0', trailing_decimal_zeros)?;
+
+    if show_denom {
+        write!(f, " {}", denom.as_str())?;
+    }
+
+    repeat_char(f, options.fill, pad_right)?;
+    Ok(())
+}
+
+/// Amount
+///
+/// The [Amount] type can be used to express TPC amounts that support
+/// arithmetic and conversion to various denominations.
+///
+///
+/// Warning!
+///
+/// This type implements several arithmetic operations from [core::ops].
+/// To prevent errors due to overflow or underflow when using these operations,
+/// it is advised to instead use the checked arithmetic methods whose names
+/// start with `checked_`.  The operations from [core::ops] that [Amount]
+/// implements will panic when overflow or underflow occurs.  Also note that
+/// since the internal representation of amounts is unsigned, subtracting below
+/// zero is considered an underflow and will cause a panic if you're not using
+/// the checked arithmetic methods.
+///
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Amount(u64);
+
+impl Amount {
+    /// The zero amount.
+    pub const ZERO: Amount = Amount(0);
+    /// Exactly one tapyrus.
+    pub const ONE_TAP: Amount = Amount(1);
+    /// Exactly one TPC.
+    pub const ONE_TPC: Amount = Self::from_int_tpc(1);
+    /// The maximum value allowed as an amount. Useful for sanity checking.
+    pub const MAX_MONEY: Amount = Self::from_int_tpc(21_000_000);
+    /// The minimum value of an amount.
+    pub const MIN: Amount = Amount::ZERO;
+    /// The maximum value of an amount.
+    pub const MAX: Amount = Amount(u64::MAX);
+    /// The number of bytes that an amount contributes to the size of a transaction.
+    pub const SIZE: usize = 8; // Serialized length of a u64.
+
+    /// Create an [Amount] with tapyrus precision and the given number of tapyruses.
+    pub const fn from_tap(tapyrus: u64) -> Amount { Amount(tapyrus) }
+
+    /// Gets the number of tapyruses in this [`Amount`].
+    pub fn to_tap(self) -> u64 { self.0 }
+
+    /// The maximum value of an [Amount].
+    #[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
+    pub const fn max_value() -> Amount { Amount(u64::MAX) }
+
+    /// The minimum value of an [Amount].
+    #[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
+    pub const fn min_value() -> Amount { Amount(u64::MIN) }
+
+    /// Convert from a value expressing TPCs to an [Amount].
+    pub fn from_tpc(tpc: f64) -> Result<Amount, ParseAmountError> {
+        Amount::from_float_in(tpc, Denomination::TPC)
+    }
+
+    /// Convert from a value expressing integer values of bitcoins to an [Amount]
+    /// in const context.
+    ///
+    /// ## Panics
+    ///
+    /// The function panics if the argument multiplied by the number of taps
+    /// per tapyrus overflows a u64 type.
+    pub const fn from_int_tpc(tpc: u64) -> Amount {
+        // TODO replace whith unwrap() when available in const context.
+        match tpc.checked_mul(100_000_000) {
+            Some(amount) => Amount::from_tap(amount),
+            None => {
+                // TODO replace with panic!() when MSRV = 1.57+
+                #[allow(unconditional_panic)]
+                // disabling this lint until panic!() can be used.
+                #[allow(clippy::let_unit_value)]
+                #[allow(clippy::out_of_bounds_indexing)]
+                let _int_overflow_converting_tpc_to_taps = [(); 0][1];
+                Amount(0)
+            }
+        }
+    }
+
+    /// Parse a decimal string as a value in the given denomination.
+    ///
+    /// Note: This only parses the value string.  If you want to parse a value
+    /// with denomination, use [FromStr].
+    pub fn from_str_in(s: &str, denom: Denomination) -> Result<Amount, ParseAmountError> {
+        let (negative, tapyrus) = parse_signed_to_tapyrus(s, denom)?;
+        if negative {
+            return Err(ParseAmountError::Negative);
+        }
+        if tapyrus > i64::MAX as u64 {
+            return Err(ParseAmountError::TooBig);
+        }
+        Ok(Amount::from_tap(tapyrus))
+    }
+
+    /// Parses amounts with denomination suffix like they are produced with
+    /// [Self::to_string_with_denomination] or with [fmt::Display].
+    /// If you want to parse only the amount without the denomination,
+    /// use [Self::from_str_in].
+    pub fn from_str_with_denomination(s: &str) -> Result<Amount, ParseAmountError> {
+        let (amt, denom) = split_amount_and_denomination(s)?;
+        Amount::from_str_in(amt, denom)
+    }
+
+    /// Express this [Amount] as a floating-point value in the given denomination.
+    ///
+    /// Please be aware of the risk of using floating-point numbers.
+    pub fn to_float_in(self, denom: Denomination) -> f64 {
+        f64::from_str(&self.to_string_in(denom)).unwrap()
+    }
+
+    /// Express this [`Amount`] as a floating-point value in TPC.
+    ///
+    /// Please be aware of the risk of using floating-point numbers.
+    ///
+    /// # Examples
+    /// ```
+    /// # use tapyrus::{Amount, Denomination};
+    /// let amount = Amount::from_tap(100_000);
+    /// assert_eq!(amount.to_tpc(), amount.to_float_in(Denomination::TPC))
+    /// ```
+    pub fn to_tpc(self) -> f64 { self.to_float_in(Denomination::TPC) }
+
+    /// Convert this [Amount] in floating-point notation with a given
+    /// denomination.
+    /// Can return error if the amount is too big, too precise or negative.
+    ///
+    /// Please be aware of the risk of using floating-point numbers.
+    pub fn from_float_in(value: f64, denom: Denomination) -> Result<Amount, ParseAmountError> {
+        if value < 0.0 {
+            return Err(ParseAmountError::Negative);
+        }
+        // This is inefficient, but the safest way to deal with this. The parsing logic is safe.
+        // Any performance-critical application should not be dealing with floats.
+        Amount::from_str_in(&value.to_string(), denom)
+    }
+
+    /// Create an object that implements [`fmt::Display`] using specified denomination.
+    pub fn display_in(self, denomination: Denomination) -> Display {
+        Display {
+            taps_abs: self.to_tap(),
+            is_negative: false,
+            style: DisplayStyle::FixedDenomination { denomination, show_denomination: false },
+        }
+    }
+
+    /// Create an object that implements [`fmt::Display`] dynamically selecting denomination.
+    ///
+    /// This will use TPC for values greater than or equal to 1 TPC and tapyruses otherwise. To
+    /// avoid confusion the denomination is always shown.
+    pub fn display_dynamic(self) -> Display {
+        Display {
+            taps_abs: self.to_tap(),
+            is_negative: false,
+            style: DisplayStyle::DynamicDenomination,
+        }
+    }
+
+    /// Format the value of this [Amount] in the given denomination.
+    ///
+    /// Does not include the denomination.
+    #[rustfmt::skip]
+    pub fn fmt_value_in(self, f: &mut dyn fmt::Write, denom: Denomination) -> fmt::Result {
+        fmt_tapyrus_in(self.to_tap(), false, f, denom, false, FormatOptions::default())
+    }
+
+    /// Get a string number of this [Amount] in the given denomination.
+    ///
+    /// Does not include the denomination.
+    pub fn to_string_in(self, denom: Denomination) -> String {
+        let mut buf = String::new();
+        self.fmt_value_in(&mut buf, denom).unwrap();
+        buf
+    }
+
+    /// Get a formatted string of this [Amount] in the given denomination,
+    /// suffixed with the abbreviation for the denomination.
+    pub fn to_string_with_denomination(self, denom: Denomination) -> String {
+        let mut buf = String::new();
+        self.fmt_value_in(&mut buf, denom).unwrap();
+        write!(buf, " {}", denom).unwrap();
+        buf
+    }
+
+    // Some arithmetic that doesn't fit in `core::ops` traits.
+
+    /// Checked addition.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_add(self, rhs: Amount) -> Option<Amount> {
+        self.0.checked_add(rhs.0).map(Amount)
+    }
+
+    /// Checked subtraction.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_sub(self, rhs: Amount) -> Option<Amount> {
+        self.0.checked_sub(rhs.0).map(Amount)
+    }
+
+    /// Checked multiplication.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_mul(self, rhs: u64) -> Option<Amount> { self.0.checked_mul(rhs).map(Amount) }
+
+    /// Checked integer division.
+    /// Be aware that integer division loses the remainder if no exact division
+    /// can be made.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_div(self, rhs: u64) -> Option<Amount> { self.0.checked_div(rhs).map(Amount) }
+
+    /// Checked remainder.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_rem(self, rhs: u64) -> Option<Amount> { self.0.checked_rem(rhs).map(Amount) }
+
+    /// Convert to a signed amount.
+    pub fn to_signed(self) -> Result<SignedAmount, ParseAmountError> {
+        if self.to_tap() > SignedAmount::MAX.to_tap() as u64 {
+            Err(ParseAmountError::TooBig)
+        } else {
+            Ok(SignedAmount::from_tap(self.to_tap() as i64))
+        }
+    }
+}
+
+impl Decodable for Amount {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Amount(Decodable::consensus_decode(r)?))
+    }
+}
+
+impl Encodable for Amount {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(w)
+    }
+}
+
+impl default::Default for Amount {
+    fn default() -> Self { Amount::ZERO }
+}
+
+impl fmt::Debug for Amount {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Amount({:.8} TPC)", self.to_tpc())
+    }
+}
+
+// No one should depend on a binding contract for Display for this type.
+// Just using Bitcoin denominated string.
+impl fmt::Display for Amount {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.fmt_value_in(f, Denomination::TPC)?;
+        write!(f, " {}", Denomination::TPC)
+    }
+}
+
+impl ops::Add for Amount {
+    type Output = Amount;
+
+    fn add(self, rhs: Amount) -> Self::Output {
+        self.checked_add(rhs).expect("Amount addition error")
+    }
+}
+
+impl ops::AddAssign for Amount {
+    fn add_assign(&mut self, other: Amount) { *self = *self + other }
+}
+
+impl ops::Sub for Amount {
+    type Output = Amount;
+
+    fn sub(self, rhs: Amount) -> Self::Output {
+        self.checked_sub(rhs).expect("Amount subtraction error")
+    }
+}
+
+impl ops::SubAssign for Amount {
+    fn sub_assign(&mut self, other: Amount) { *self = *self - other }
+}
+
+impl ops::Rem<u64> for Amount {
+    type Output = Amount;
+
+    fn rem(self, modulus: u64) -> Self {
+        self.checked_rem(modulus).expect("Amount remainder error")
+    }
+}
+
+impl ops::RemAssign<u64> for Amount {
+    fn rem_assign(&mut self, modulus: u64) { *self = *self % modulus }
+}
+
+impl ops::Mul<u64> for Amount {
+    type Output = Amount;
+
+    fn mul(self, rhs: u64) -> Self::Output {
+        self.checked_mul(rhs).expect("Amount multiplication error")
+    }
+}
+
+impl ops::MulAssign<u64> for Amount {
+    fn mul_assign(&mut self, rhs: u64) { *self = *self * rhs }
+}
+
+impl ops::Div<u64> for Amount {
+    type Output = Amount;
+
+    fn div(self, rhs: u64) -> Self::Output { self.checked_div(rhs).expect("Amount division error") }
+}
+
+impl ops::DivAssign<u64> for Amount {
+    fn div_assign(&mut self, rhs: u64) { *self = *self / rhs }
+}
+
+impl FromStr for Amount {
+    type Err = ParseAmountError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> { Amount::from_str_with_denomination(s) }
+}
+
+impl core::iter::Sum for Amount {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        let taps: u64 = iter.map(|amt| amt.0).sum();
+        Amount::from_tap(taps)
+    }
+}
+
+/// A helper/builder that displays amount with specified settings.
+///
+/// This provides richer interface than `fmt::Formatter`:
+///
+/// * Ability to select denomination
+/// * Show or hide denomination
+/// * Dynamically-selected denomination - show in taps if less than 1 TPC.
+///
+/// However this can still be combined with `fmt::Formatter` options to precisely control zeros,
+/// padding, alignment... The formatting works like floats from `core` but note that precision will
+/// **never** be lossy - that means no rounding.
+///
+/// See [`Amount::display_in`] and [`Amount::display_dynamic`] on how to construct this.
+#[derive(Debug, Clone)]
+pub struct Display {
+    /// Absolute value of tapyruses to display (sign is below)
+    taps_abs: u64,
+    /// The sign
+    is_negative: bool,
+    /// How to display the value
+    style: DisplayStyle,
+}
+
+impl Display {
+    /// Makes subsequent calls to `Display::fmt` display denomination.
+    pub fn show_denomination(mut self) -> Self {
+        match &mut self.style {
+            DisplayStyle::FixedDenomination { show_denomination, .. } => *show_denomination = true,
+            // No-op because dynamic denomination is always shown
+            DisplayStyle::DynamicDenomination => (),
+        }
+        self
+    }
+}
+
+impl fmt::Display for Display {
+    #[rustfmt::skip]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let format_options = FormatOptions::from_formatter(f);
+        match &self.style {
+            DisplayStyle::FixedDenomination { show_denomination, denomination } => {
+                fmt_tapyrus_in(self.taps_abs, self.is_negative, f, *denomination, *show_denomination, format_options)
+            },
+            DisplayStyle::DynamicDenomination if self.taps_abs >= Amount::ONE_TPC.to_tap() => {
+                fmt_tapyrus_in(self.taps_abs, self.is_negative, f, Denomination::TPC, true, format_options)
+            },
+            DisplayStyle::DynamicDenomination => {
+                fmt_tapyrus_in(self.taps_abs, self.is_negative, f, Denomination::Tapyrus, true, format_options)
+            },
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+enum DisplayStyle {
+    FixedDenomination { denomination: Denomination, show_denomination: bool },
+    DynamicDenomination,
+}
+
+/// SignedAmount
+///
+/// The [SignedAmount] type can be used to express Bitcoin amounts that support
+/// arithmetic and conversion to various denominations.
+///
+///
+/// Warning!
+///
+/// This type implements several arithmetic operations from [core::ops].
+/// To prevent errors due to overflow or underflow when using these operations,
+/// it is advised to instead use the checked arithmetic methods whose names
+/// start with `checked_`.  The operations from [core::ops] that [Amount]
+/// implements will panic when overflow or underflow occurs.
+///
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct SignedAmount(i64);
+
+impl SignedAmount {
+    /// The zero amount.
+    pub const ZERO: SignedAmount = SignedAmount(0);
+    /// Exactly one tapyrus.
+    pub const ONE_TAP: SignedAmount = SignedAmount(1);
+    /// Exactly one tapyrus.
+    pub const ONE_TPC: SignedAmount = SignedAmount(100_000_000);
+    /// The maximum value allowed as an amount. Useful for sanity checking.
+    pub const MAX_MONEY: SignedAmount = SignedAmount(21_000_000 * 100_000_000);
+    /// The minimum value of an amount.
+    pub const MIN: SignedAmount = SignedAmount(i64::MIN);
+    /// The maximum value of an amount.
+    pub const MAX: SignedAmount = SignedAmount(i64::MAX);
+
+    /// Create an [SignedAmount] with tapyrus precision and the given number of tapyruses.
+    pub const fn from_tap(tapyrus: i64) -> SignedAmount { SignedAmount(tapyrus) }
+
+    /// Gets the number of tapyruses in this [`SignedAmount`].
+    pub fn to_tap(self) -> i64 { self.0 }
+
+    /// The maximum value of an [SignedAmount].
+    #[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
+    pub const fn max_value() -> SignedAmount { SignedAmount(i64::MAX) }
+
+    /// The minimum value of an [SignedAmount].
+    #[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
+    pub const fn min_value() -> SignedAmount { SignedAmount(i64::MIN) }
+
+    /// Convert from a value expressing bitcoins to an [SignedAmount].
+    pub fn from_tpc(tpc: f64) -> Result<SignedAmount, ParseAmountError> {
+        SignedAmount::from_float_in(tpc, Denomination::TPC)
+    }
+
+    /// Parse a decimal string as a value in the given denomination.
+    ///
+    /// Note: This only parses the value string.  If you want to parse a value
+    /// with denomination, use [FromStr].
+    pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
+        let (negative, tapyrus) = parse_signed_to_tapyrus(s, denom)?;
+        if tapyrus > i64::MAX as u64 {
+            return Err(ParseAmountError::TooBig);
+        }
+        Ok(match negative {
+            true => SignedAmount(-(tapyrus as i64)),
+            false => SignedAmount(tapyrus as i64),
+        })
+    }
+
+    /// Parses amounts with denomination suffix like they are produced with
+    /// [Self::to_string_with_denomination] or with [fmt::Display].
+    /// If you want to parse only the amount without the denomination,
+    /// use [Self::from_str_in].
+    pub fn from_str_with_denomination(s: &str) -> Result<SignedAmount, ParseAmountError> {
+        let (amt, denom) = split_amount_and_denomination(s)?;
+        SignedAmount::from_str_in(amt, denom)
+    }
+
+    /// Express this [SignedAmount] as a floating-point value in the given denomination.
+    ///
+    /// Please be aware of the risk of using floating-point numbers.
+    pub fn to_float_in(self, denom: Denomination) -> f64 {
+        f64::from_str(&self.to_string_in(denom)).unwrap()
+    }
+
+    /// Express this [`SignedAmount`] as a floating-point value in TPC.
+    ///
+    /// Equivalent to `to_float_in(Denomination::TPC)`.
+    ///
+    /// Please be aware of the risk of using floating-point numbers.
+    pub fn to_tpc(self) -> f64 { self.to_float_in(Denomination::TPC) }
+
+    /// Convert this [SignedAmount] in floating-point notation with a given
+    /// denomination.
+    /// Can return error if the amount is too big, too precise or negative.
+    ///
+    /// Please be aware of the risk of using floating-point numbers.
+    pub fn from_float_in(
+        value: f64,
+        denom: Denomination,
+    ) -> Result<SignedAmount, ParseAmountError> {
+        // This is inefficient, but the safest way to deal with this. The parsing logic is safe.
+        // Any performance-critical application should not be dealing with floats.
+        SignedAmount::from_str_in(&value.to_string(), denom)
+    }
+
+    /// Returns the absolute value as tapyruses.
+    ///
+    /// This is the implementation of `unsigned_abs()` copied from `core` to support older MSRV.
+    fn to_tap_abs(self) -> u64 { self.to_tap().wrapping_abs() as u64 }
+
+    /// Create an object that implements [`fmt::Display`] using specified denomination.
+    pub fn display_in(self, denomination: Denomination) -> Display {
+        Display {
+            taps_abs: self.to_tap_abs(),
+            is_negative: self.is_negative(),
+            style: DisplayStyle::FixedDenomination { denomination, show_denomination: false },
+        }
+    }
+
+    /// Create an object that implements [`fmt::Display`] dynamically selecting denomination.
+    ///
+    /// This will use TPC for values greater than or equal to 1 TPC and tapyruses otherwise. To
+    /// avoid confusion the denomination is always shown.
+    pub fn display_dynamic(self) -> Display {
+        Display {
+            taps_abs: self.to_tap_abs(),
+            is_negative: self.is_negative(),
+            style: DisplayStyle::DynamicDenomination,
+        }
+    }
+
+    /// Format the value of this [SignedAmount] in the given denomination.
+    ///
+    /// Does not include the denomination.
+    #[rustfmt::skip]
+    pub fn fmt_value_in(self, f: &mut dyn fmt::Write, denom: Denomination) -> fmt::Result {
+        fmt_tapyrus_in(self.to_tap_abs(), self.is_negative(), f, denom, false, FormatOptions::default())
+    }
+
+    /// Get a string number of this [SignedAmount] in the given denomination.
+    ///
+    /// Does not include the denomination.
+    pub fn to_string_in(self, denom: Denomination) -> String {
+        let mut buf = String::new();
+        self.fmt_value_in(&mut buf, denom).unwrap();
+        buf
+    }
+
+    /// Get a formatted string of this [SignedAmount] in the given denomination,
+    /// suffixed with the abbreviation for the denomination.
+    pub fn to_string_with_denomination(self, denom: Denomination) -> String {
+        let mut buf = String::new();
+        self.fmt_value_in(&mut buf, denom).unwrap();
+        write!(buf, " {}", denom).unwrap();
+        buf
+    }
+
+    // Some arithmetic that doesn't fit in `core::ops` traits.
+
+    /// Get the absolute value of this [SignedAmount].
+    pub fn abs(self) -> SignedAmount { SignedAmount(self.0.abs()) }
+
+    /// Returns a number representing sign of this [SignedAmount].
+    ///
+    /// - `0` if the amount is zero
+    /// - `1` if the amount is positive
+    /// - `-1` if the amount is negative
+    pub fn signum(self) -> i64 { self.0.signum() }
+
+    /// Returns `true` if this [SignedAmount] is positive and `false` if
+    /// this [SignedAmount] is zero or negative.
+    pub fn is_positive(self) -> bool { self.0.is_positive() }
+
+    /// Returns `true` if this [SignedAmount] is negative and `false` if
+    /// this [SignedAmount] is zero or positive.
+    pub fn is_negative(self) -> bool { self.0.is_negative() }
+
+    /// Get the absolute value of this [SignedAmount].
+    /// Returns [None] if overflow occurred. (`self == MIN`)
+    pub fn checked_abs(self) -> Option<SignedAmount> { self.0.checked_abs().map(SignedAmount) }
+
+    /// Checked addition.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
+        self.0.checked_add(rhs.0).map(SignedAmount)
+    }
+
+    /// Checked subtraction.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
+        self.0.checked_sub(rhs.0).map(SignedAmount)
+    }
+
+    /// Checked multiplication.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
+        self.0.checked_mul(rhs).map(SignedAmount)
+    }
+
+    /// Checked integer division.
+    /// Be aware that integer division loses the remainder if no exact division
+    /// can be made.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_div(self, rhs: i64) -> Option<SignedAmount> {
+        self.0.checked_div(rhs).map(SignedAmount)
+    }
+
+    /// Checked remainder.
+    /// Returns [None] if overflow occurred.
+    pub fn checked_rem(self, rhs: i64) -> Option<SignedAmount> {
+        self.0.checked_rem(rhs).map(SignedAmount)
+    }
+
+    /// Subtraction that doesn't allow negative [SignedAmount]s.
+    /// Returns [None] if either [self], `rhs` or the result is strictly negative.
+    pub fn positive_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
+        if self.is_negative() || rhs.is_negative() || rhs > self {
+            None
+        } else {
+            self.checked_sub(rhs)
+        }
+    }
+
+    /// Convert to an unsigned amount.
+    pub fn to_unsigned(self) -> Result<Amount, ParseAmountError> {
+        if self.is_negative() {
+            Err(ParseAmountError::Negative)
+        } else {
+            Ok(Amount::from_tap(self.to_tap() as u64))
+        }
+    }
+}
+
+impl default::Default for SignedAmount {
+    fn default() -> Self { SignedAmount::ZERO }
+}
+
+impl fmt::Debug for SignedAmount {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "SignedAmount({:.8} TPC)", self.to_tpc())
+    }
+}
+
+// No one should depend on a binding contract for Display for this type.
+// Just using Bitcoin denominated string.
+impl fmt::Display for SignedAmount {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.fmt_value_in(f, Denomination::TPC)?;
+        write!(f, " {}", Denomination::TPC)
+    }
+}
+
+impl ops::Add for SignedAmount {
+    type Output = SignedAmount;
+
+    fn add(self, rhs: SignedAmount) -> Self::Output {
+        self.checked_add(rhs).expect("SignedAmount addition error")
+    }
+}
+
+impl ops::AddAssign for SignedAmount {
+    fn add_assign(&mut self, other: SignedAmount) { *self = *self + other }
+}
+
+impl ops::Sub for SignedAmount {
+    type Output = SignedAmount;
+
+    fn sub(self, rhs: SignedAmount) -> Self::Output {
+        self.checked_sub(rhs).expect("SignedAmount subtraction error")
+    }
+}
+
+impl ops::SubAssign for SignedAmount {
+    fn sub_assign(&mut self, other: SignedAmount) { *self = *self - other }
+}
+
+impl ops::Rem<i64> for SignedAmount {
+    type Output = SignedAmount;
+
+    fn rem(self, modulus: i64) -> Self {
+        self.checked_rem(modulus).expect("SignedAmount remainder error")
+    }
+}
+
+impl ops::RemAssign<i64> for SignedAmount {
+    fn rem_assign(&mut self, modulus: i64) { *self = *self % modulus }
+}
+
+impl ops::Mul<i64> for SignedAmount {
+    type Output = SignedAmount;
+
+    fn mul(self, rhs: i64) -> Self::Output {
+        self.checked_mul(rhs).expect("SignedAmount multiplication error")
+    }
+}
+
+impl ops::MulAssign<i64> for SignedAmount {
+    fn mul_assign(&mut self, rhs: i64) { *self = *self * rhs }
+}
+
+impl ops::Div<i64> for SignedAmount {
+    type Output = SignedAmount;
+
+    fn div(self, rhs: i64) -> Self::Output {
+        self.checked_div(rhs).expect("SignedAmount division error")
+    }
+}
+
+impl ops::DivAssign<i64> for SignedAmount {
+    fn div_assign(&mut self, rhs: i64) { *self = *self / rhs }
+}
+
+impl FromStr for SignedAmount {
+    type Err = ParseAmountError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> { SignedAmount::from_str_with_denomination(s) }
+}
+
+impl core::iter::Sum for SignedAmount {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        let taps: i64 = iter.map(|amt| amt.0).sum();
+        SignedAmount::from_tap(taps)
+    }
+}
+
+/// Calculate the sum over the iterator using checked arithmetic.
+pub trait CheckedSum<R>: private::SumSeal<R> {
+    /// Calculate the sum over the iterator using checked arithmetic. If an over or underflow would
+    /// happen it returns `None`.
+    fn checked_sum(self) -> Option<R>;
+}
+
+impl<T> CheckedSum<Amount> for T
+where
+    T: Iterator<Item = Amount>,
+{
+    fn checked_sum(mut self) -> Option<Amount> {
+        let first = Some(self.next().unwrap_or_default());
+
+        self.fold(first, |acc, item| acc.and_then(|acc| acc.checked_add(item)))
+    }
+}
+
+impl<T> CheckedSum<SignedAmount> for T
+where
+    T: Iterator<Item = SignedAmount>,
+{
+    fn checked_sum(mut self) -> Option<SignedAmount> {
+        let first = Some(self.next().unwrap_or_default());
+
+        self.fold(first, |acc, item| acc.and_then(|acc| acc.checked_add(item)))
+    }
+}
+
+mod private {
+    use crate::{Amount, SignedAmount};
+
+    /// Used to seal the `CheckedSum` trait
+    pub trait SumSeal<A> {}
+
+    impl<T> SumSeal<Amount> for T where T: Iterator<Item = Amount> {}
+    impl<T> SumSeal<SignedAmount> for T where T: Iterator<Item = SignedAmount> {}
+}
+
+#[cfg(feature = "serde")]
+pub mod serde {
+    // methods are implementation of a standardized serde-specific signature
+    #![allow(missing_docs)]
+
+    //! This module adds serde serialization and deserialization support for Amounts.
+    //! Since there is not a default way to serialize and deserialize Amounts, multiple
+    //! ways are supported and it's up to the user to decide which serialiation to use.
+    //! The provided modules can be used as follows:
+    //!
+    //! ```rust,ignore
+    //! use serde::{Serialize, Deserialize};
+    //! use tapyrus::Amount;
+    //!
+    //! #[derive(Serialize, Deserialize)]
+    //! # #[serde(crate = "actual_serde")]
+    //! pub struct HasAmount {
+    //!     #[serde(with = "tapyrus::amount::serde::as_tpc")]
+    //!     pub amount: Amount,
+    //! }
+    //! ```
+
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    use crate::amount::{Amount, Denomination, SignedAmount};
+
+    /// This trait is used only to avoid code duplication and naming collisions
+    /// of the different serde serialization crates.
+    pub trait SerdeAmount: Copy + Sized + private::Sealed {
+        fn ser_tap<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error>;
+        fn des_tap<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error>;
+        fn ser_tpc<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error>;
+        fn des_tpc<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error>;
+    }
+
+    mod private {
+        /// add this as a trait bound to traits which consumers of this library
+        /// should not be able to implement.
+        pub trait Sealed {}
+        impl Sealed for super::Amount {}
+        impl Sealed for super::SignedAmount {}
+    }
+
+    /// This trait is only for internal Amount type serialization/deserialization
+    pub trait SerdeAmountForOpt: Copy + Sized + SerdeAmount + private::Sealed {
+        fn type_prefix() -> &'static str;
+        fn ser_tap_opt<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error>;
+        fn ser_tpc_opt<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error>;
+    }
+
+    impl SerdeAmount for Amount {
+        fn ser_tap<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
+            u64::serialize(&self.to_tap(), s)
+        }
+        fn des_tap<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error> {
+            Ok(Amount::from_tap(u64::deserialize(d)?))
+        }
+        fn ser_tpc<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
+            f64::serialize(&self.to_float_in(Denomination::TPC), s)
+        }
+        fn des_tpc<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error> {
+            use serde::de::Error;
+            Amount::from_tpc(f64::deserialize(d)?).map_err(D::Error::custom)
+        }
+    }
+
+    impl SerdeAmountForOpt for Amount {
+        fn type_prefix() -> &'static str { "u" }
+        fn ser_tap_opt<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
+            s.serialize_some(&self.to_tap())
+        }
+        fn ser_tpc_opt<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
+            s.serialize_some(&self.to_tpc())
+        }
+    }
+
+    impl SerdeAmount for SignedAmount {
+        fn ser_tap<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
+            i64::serialize(&self.to_tap(), s)
+        }
+        fn des_tap<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error> {
+            Ok(SignedAmount::from_tap(i64::deserialize(d)?))
+        }
+        fn ser_tpc<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
+            f64::serialize(&self.to_float_in(Denomination::TPC), s)
+        }
+        fn des_tpc<'d, D: Deserializer<'d>>(d: D) -> Result<Self, D::Error> {
+            use serde::de::Error;
+            SignedAmount::from_tpc(f64::deserialize(d)?).map_err(D::Error::custom)
+        }
+    }
+
+    impl SerdeAmountForOpt for SignedAmount {
+        fn type_prefix() -> &'static str { "i" }
+        fn ser_tap_opt<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
+            s.serialize_some(&self.to_tap())
+        }
+        fn ser_tpc_opt<S: Serializer>(self, s: S) -> Result<S::Ok, S::Error> {
+            s.serialize_some(&self.to_tpc())
+        }
+    }
+
+    pub mod as_tap {
+        //! Serialize and deserialize [`Amount`](crate::Amount) as real numbers denominated in tapyrus.
+        //! Use with `#[serde(with = "amount::serde::as_tap")]`.
+
+        use serde::{Deserializer, Serializer};
+
+        use crate::amount::serde::SerdeAmount;
+
+        pub fn serialize<A: SerdeAmount, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error> {
+            a.ser_tap(s)
+        }
+
+        pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(d: D) -> Result<A, D::Error> {
+            A::des_tap(d)
+        }
+
+        pub mod opt {
+            //! Serialize and deserialize [`Option<Amount>`](crate::Amount) as real numbers denominated in tapyrus.
+            //! Use with `#[serde(default, with = "amount::serde::as_tap::opt")]`.
+
+            use core::fmt;
+            use core::marker::PhantomData;
+
+            use serde::{de, Deserializer, Serializer};
+
+            use crate::amount::serde::SerdeAmountForOpt;
+
+            pub fn serialize<A: SerdeAmountForOpt, S: Serializer>(
+                a: &Option<A>,
+                s: S,
+            ) -> Result<S::Ok, S::Error> {
+                match *a {
+                    Some(a) => a.ser_tap_opt(s),
+                    None => s.serialize_none(),
+                }
+            }
+
+            pub fn deserialize<'d, A: SerdeAmountForOpt, D: Deserializer<'d>>(
+                d: D,
+            ) -> Result<Option<A>, D::Error> {
+                struct VisitOptAmt<X>(PhantomData<X>);
+
+                impl<'de, X: SerdeAmountForOpt> de::Visitor<'de> for VisitOptAmt<X> {
+                    type Value = Option<X>;
+
+                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                        write!(formatter, "An Option<{}64>", X::type_prefix())
+                    }
+
+                    fn visit_none<E>(self) -> Result<Self::Value, E>
+                    where
+                        E: de::Error,
+                    {
+                        Ok(None)
+                    }
+                    fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
+                    where
+                        D: Deserializer<'de>,
+                    {
+                        Ok(Some(X::des_tap(d)?))
+                    }
+                }
+                d.deserialize_option(VisitOptAmt::<A>(PhantomData))
+            }
+        }
+    }
+
+    pub mod as_tpc {
+        //! Serialize and deserialize [`Amount`](crate::Amount) as JSON numbers denominated in TPC".
+        //! Use with `#[serde(with = "amount::serde::as_tpc")]`.
+
+        use serde::{Deserializer, Serializer};
+
+        use crate::amount::serde::SerdeAmount;
+
+        pub fn serialize<A: SerdeAmount, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error> {
+            a.ser_tpc(s)
+        }
+
+        pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(d: D) -> Result<A, D::Error> {
+            A::des_tpc(d)
+        }
+
+        pub mod opt {
+            //! Serialize and deserialize `Option<Amount>` as JSON numbers denominated in TPC".
+            //! Use with `#[serde(default, with = "amount::serde::as_tpc::opt")]`.
+
+            use core::fmt;
+            use core::marker::PhantomData;
+
+            use serde::{de, Deserializer, Serializer};
+
+            use crate::amount::serde::SerdeAmountForOpt;
+
+            pub fn serialize<A: SerdeAmountForOpt, S: Serializer>(
+                a: &Option<A>,
+                s: S,
+            ) -> Result<S::Ok, S::Error> {
+                match *a {
+                    Some(a) => a.ser_tpc_opt(s),
+                    None => s.serialize_none(),
+                }
+            }
+
+            pub fn deserialize<'d, A: SerdeAmountForOpt, D: Deserializer<'d>>(
+                d: D,
+            ) -> Result<Option<A>, D::Error> {
+                struct VisitOptAmt<X>(PhantomData<X>);
+
+                impl<'de, X: SerdeAmountForOpt> de::Visitor<'de> for VisitOptAmt<X> {
+                    type Value = Option<X>;
+
+                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                        write!(formatter, "An Option<f64>")
+                    }
+
+                    fn visit_none<E>(self) -> Result<Self::Value, E>
+                    where
+                        E: de::Error,
+                    {
+                        Ok(None)
+                    }
+                    fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
+                    where
+                        D: Deserializer<'de>,
+                    {
+                        Ok(Some(X::des_tpc(d)?))
+                    }
+                }
+                d.deserialize_option(VisitOptAmt::<A>(PhantomData))
+            }
+        }
+    }
+}
+
+#[cfg(kani)]
+mod verification {
+    use std::cmp;
+    use std::convert::TryInto;
+
+    use super::*;
+
+    // Note regarding the `unwind` parameter: this defines how many iterations
+    // of loops kani will unwind before handing off to the SMT solver. Basically
+    // it should be set as low as possible such that Kani still succeeds (doesn't
+    // return "undecidable").
+    //
+    // There is more info here: https://model-checking.github.io/kani/tutorial-loop-unwinding.html
+    //
+    // Unfortunately what it means to "loop" is pretty opaque ... in this case
+    // there appear to be loops in memcmp, which I guess comes from assert_eq!,
+    // though I didn't see any failures until I added the to_signed() test.
+    // Further confusing the issue, a value of 2 works fine on my system, but on
+    // CI it fails, so we need to set it higher.
+    #[kani::unwind(4)]
+    #[kani::proof]
+    fn u_amount_add_homomorphic() {
+        let n1 = kani::any::<u64>();
+        let n2 = kani::any::<u64>();
+        kani::assume(n1.checked_add(n2).is_some()); // assume we don't overflow in the actual test
+        assert_eq!(Amount::from_tap(n1) + Amount::from_tap(n2), Amount::from_tap(n1 + n2));
+
+        let mut amt = Amount::from_tap(n1);
+        amt += Amount::from_tap(n2);
+        assert_eq!(amt, Amount::from_tap(n1 + n2));
+
+        let max = cmp::max(n1, n2);
+        let min = cmp::min(n1, n2);
+        assert_eq!(Amount::from_tap(max) - Amount::from_tap(min), Amount::from_tap(max - min));
+
+        let mut amt = Amount::from_tap(max);
+        amt -= Amount::from_tap(min);
+        assert_eq!(amt, Amount::from_tap(max - min));
+
+        assert_eq!(
+            Amount::from_tap(n1).to_signed(),
+            if n1 <= i64::MAX as u64 {
+                Ok(SignedAmount::from_tap(n1.try_into().unwrap()))
+            } else {
+                Err(ParseAmountError::TooBig)
+            },
+        );
+    }
+
+    #[kani::unwind(4)]
+    #[kani::proof]
+    fn u_amount_add_homomorphic_checked() {
+        let n1 = kani::any::<u64>();
+        let n2 = kani::any::<u64>();
+        assert_eq!(
+            Amount::from_tap(n1).checked_add(Amount::from_tap(n2)),
+            n1.checked_add(n2).map(Amount::from_tap),
+        );
+        assert_eq!(
+            Amount::from_tap(n1).checked_sub(Amount::from_tap(n2)),
+            n1.checked_sub(n2).map(Amount::from_tap),
+        );
+    }
+
+    #[kani::unwind(4)]
+    #[kani::proof]
+    fn s_amount_add_homomorphic() {
+        let n1 = kani::any::<i64>();
+        let n2 = kani::any::<i64>();
+        kani::assume(n1.checked_add(n2).is_some()); // assume we don't overflow in the actual test
+        kani::assume(n1.checked_sub(n2).is_some()); // assume we don't overflow in the actual test
+        assert_eq!(
+            SignedAmount::from_tap(n1) + SignedAmount::from_tap(n2),
+            SignedAmount::from_tap(n1 + n2)
+        );
+        assert_eq!(
+            SignedAmount::from_tap(n1) - SignedAmount::from_tap(n2),
+            SignedAmount::from_tap(n1 - n2)
+        );
+
+        let mut amt = SignedAmount::from_tap(n1);
+        amt += SignedAmount::from_tap(n2);
+        assert_eq!(amt, SignedAmount::from_tap(n1 + n2));
+        let mut amt = SignedAmount::from_tap(n1);
+        amt -= SignedAmount::from_tap(n2);
+        assert_eq!(amt, SignedAmount::from_tap(n1 - n2));
+
+        assert_eq!(
+            SignedAmount::from_tap(n1).to_unsigned(),
+            if n1 >= 0 {
+                Ok(Amount::from_tap(n1.try_into().unwrap()))
+            } else {
+                Err(ParseAmountError::Negative)
+            },
+        );
+    }
+
+    #[kani::unwind(4)]
+    #[kani::proof]
+    fn s_amount_add_homomorphic_checked() {
+        let n1 = kani::any::<i64>();
+        let n2 = kani::any::<i64>();
+        assert_eq!(
+            SignedAmount::from_tap(n1).checked_add(SignedAmount::from_tap(n2)),
+            n1.checked_add(n2).map(SignedAmount::from_tap),
+        );
+        assert_eq!(
+            SignedAmount::from_tap(n1).checked_sub(SignedAmount::from_tap(n2)),
+            n1.checked_sub(n2).map(SignedAmount::from_tap),
+        );
+
+        assert_eq!(
+            SignedAmount::from_tap(n1).positive_sub(SignedAmount::from_tap(n2)),
+            if n1 >= 0 && n2 >= 0 && n1 >= n2 {
+                Some(SignedAmount::from_tap(n1 - n2))
+            } else {
+                None
+            },
+        );
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+    #[cfg(feature = "std")]
+    use std::panic;
+
+    #[cfg(feature = "serde")]
+    use serde_test;
+
+    use super::*;
+
+    #[test]
+    fn from_str_zero() {
+        let denoms = vec!["TPC", "mTPC", "uTPC", "nTPC", "pTPC", "taps", "mtaps"];
+        for denom in denoms {
+            for v in &["0", "000"] {
+                let s = format!("{} {}", v, denom);
+                match Amount::from_str(&s) {
+                    Err(e) => panic!("Failed to crate amount from {}: {:?}", s, e),
+                    Ok(amount) => assert_eq!(amount, Amount::from_tap(0)),
+                }
+            }
+
+            let s = format!("-0 {}", denom);
+            match Amount::from_str(&s) {
+                Err(e) => assert_eq!(e, ParseAmountError::Negative),
+                Ok(_) => panic!("Unsigned amount from {}", s),
+            }
+            match SignedAmount::from_str(&s) {
+                Err(e) => panic!("Failed to crate amount from {}: {:?}", s, e),
+                Ok(amount) => assert_eq!(amount, SignedAmount::from_tap(0)),
+            }
+        }
+    }
+
+    #[test]
+    fn from_int_tpc() {
+        let amt = Amount::from_int_tpc(2);
+        assert_eq!(Amount::from_tap(200_000_000), amt);
+    }
+
+    #[should_panic]
+    #[test]
+    fn from_int_tpc_panic() { Amount::from_int_tpc(u64::MAX); }
+
+    #[test]
+    fn mul_div() {
+        let tap = Amount::from_tap;
+        let stap = SignedAmount::from_tap;
+
+        assert_eq!(tap(14) * 3, tap(42));
+        assert_eq!(tap(14) / 2, tap(7));
+        assert_eq!(tap(14) % 3, tap(2));
+        assert_eq!(stap(-14) * 3, stap(-42));
+        assert_eq!(stap(-14) / 2, stap(-7));
+        assert_eq!(stap(-14) % 3, stap(-2));
+
+        let mut b = stap(30);
+        b /= 3;
+        assert_eq!(b, stap(10));
+        b %= 3;
+        assert_eq!(b, stap(1));
+    }
+
+    #[cfg(feature = "std")]
+    #[test]
+    fn test_overflows() {
+        // panic on overflow
+        let result = panic::catch_unwind(|| Amount::MAX + Amount::from_tap(1));
+        assert!(result.is_err());
+        let result = panic::catch_unwind(|| Amount::from_tap(8446744073709551615) * 3);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn checked_arithmetic() {
+        let tap = Amount::from_tap;
+        let stap = SignedAmount::from_tap;
+
+        assert_eq!(SignedAmount::MAX.checked_add(stap(1)), None);
+        assert_eq!(SignedAmount::MIN.checked_sub(stap(1)), None);
+        assert_eq!(Amount::MAX.checked_add(tap(1)), None);
+        assert_eq!(Amount::MIN.checked_sub(tap(1)), None);
+
+        assert_eq!(tap(5).checked_div(2), Some(tap(2))); // integer division
+        assert_eq!(stap(-6).checked_div(2), Some(stap(-3)));
+    }
+
+    #[test]
+    fn floating_point() {
+        use super::Denomination as D;
+        let f = Amount::from_float_in;
+        let sf = SignedAmount::from_float_in;
+        let tap = Amount::from_tap;
+        let stap = SignedAmount::from_tap;
+
+        assert_eq!(f(11.22, D::TPC), Ok(tap(1122000000)));
+        assert_eq!(sf(-11.22, D::MilliTPC), Ok(stap(-1122000)));
+        assert_eq!(sf(-1000.0, D::MilliTapyrus), Ok(stap(-1)));
+        assert_eq!(f(0.0001234, D::TPC), Ok(tap(12340)));
+        assert_eq!(sf(-0.00012345, D::TPC), Ok(stap(-12345)));
+
+        assert_eq!(f(-100.0, D::MilliTapyrus), Err(ParseAmountError::Negative));
+        assert_eq!(f(11.22, D::Tapyrus), Err(ParseAmountError::TooPrecise));
+        assert_eq!(sf(-100.0, D::MilliTapyrus), Err(ParseAmountError::TooPrecise));
+        assert_eq!(sf(-100.0, D::MilliTapyrus), Err(ParseAmountError::TooPrecise));
+        assert_eq!(f(42.123456781, D::TPC), Err(ParseAmountError::TooPrecise));
+        assert_eq!(sf(-184467440738.0, D::TPC), Err(ParseAmountError::TooBig));
+        assert_eq!(f(18446744073709551617.0, D::Tapyrus), Err(ParseAmountError::TooBig));
+        assert_eq!(
+            f(SignedAmount::MAX.to_float_in(D::Tapyrus) + 1.0, D::Tapyrus),
+            Err(ParseAmountError::TooBig)
+        );
+        assert_eq!(
+            f(Amount::MAX.to_float_in(D::Tapyrus) + 1.0, D::Tapyrus),
+            Err(ParseAmountError::TooBig)
+        );
+
+        let tpc = move |f| SignedAmount::from_tpc(f).unwrap();
+        assert_eq!(tpc(2.5).to_float_in(D::TPC), 2.5);
+        assert_eq!(tpc(-2.5).to_float_in(D::MilliTPC), -2500.0);
+        assert_eq!(tpc(2.5).to_float_in(D::Tapyrus), 250000000.0);
+        assert_eq!(tpc(-2.5).to_float_in(D::MilliTapyrus), -250000000000.0);
+
+        let tpc = move |f| Amount::from_tpc(f).unwrap();
+        assert_eq!(&tpc(0.0012).to_float_in(D::TPC).to_string(), "0.0012")
+    }
+
+    #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 taps per tapyrus.
+    fn parsing() {
+        use super::ParseAmountError as E;
+        let tpc = Denomination::TPC;
+        let tap = Denomination::Tapyrus;
+        let mtap = Denomination::MilliTapyrus;
+        let p = Amount::from_str_in;
+        let sp = SignedAmount::from_str_in;
+
+        assert_eq!(p("x", tpc), Err(E::InvalidCharacter('x')));
+        assert_eq!(p("-", tpc), Err(E::InvalidFormat));
+        assert_eq!(sp("-", tpc), Err(E::InvalidFormat));
+        assert_eq!(p("-1.0x", tpc), Err(E::InvalidCharacter('x')));
+        assert_eq!(p("0.0 ", tpc), Err(ParseAmountError::InvalidCharacter(' ')));
+        assert_eq!(p("0.000.000", tpc), Err(E::InvalidFormat));
+        let more_than_max = format!("1{}", Amount::MAX);
+        assert_eq!(p(&more_than_max, tpc), Err(E::TooBig));
+        assert_eq!(p("0.000000042", tpc), Err(E::TooPrecise));
+        assert_eq!(p("999.0000000", mtap), Err(E::TooPrecise));
+        assert_eq!(p("1.0000000", mtap), Err(E::TooPrecise));
+        assert_eq!(p("1.1", mtap), Err(E::TooPrecise));
+        assert_eq!(p("1000.1", mtap), Err(E::TooPrecise));
+        assert_eq!(p("1001.0000000", mtap), Err(E::TooPrecise));
+        assert_eq!(p("1000.0000001", mtap), Err(E::TooPrecise));
+        assert_eq!(p("1000.1000000", mtap), Err(E::TooPrecise));
+        assert_eq!(p("1100.0000000", mtap), Err(E::TooPrecise));
+        assert_eq!(p("10001.0000000", mtap), Err(E::TooPrecise));
+
+        assert_eq!(p("1", tpc), Ok(Amount::from_tap(1_000_000_00)));
+        assert_eq!(sp("-.5", tpc), Ok(SignedAmount::from_tap(-500_000_00)));
+        assert_eq!(p("1.1", tpc), Ok(Amount::from_tap(1_100_000_00)));
+        assert_eq!(p("100", tap), Ok(Amount::from_tap(100)));
+        assert_eq!(p("55", tap), Ok(Amount::from_tap(55)));
+        assert_eq!(p("5500000000000000000", tap), Ok(Amount::from_tap(55_000_000_000_000_000_00)));
+        // Should this even pass?
+        assert_eq!(p("5500000000000000000.", tap), Ok(Amount::from_tap(55_000_000_000_000_000_00)));
+        assert_eq!(
+            p("12345678901.12345678", tpc),
+            Ok(Amount::from_tap(12_345_678_901__123_456_78))
+        );
+        assert_eq!(p("1000.0", mtap), Ok(Amount::from_tap(1)));
+        assert_eq!(p("1000.000000000000000000000000000", mtap), Ok(Amount::from_tap(1)));
+
+        // make sure tapyrus > i64::MAX is checked.
+        let amount = Amount::from_tap(i64::MAX as u64);
+        assert_eq!(Amount::from_str_in(&amount.to_string_in(tap), tap), Ok(amount));
+        assert_eq!(
+            Amount::from_str_in(&(amount + Amount(1)).to_string_in(tap), tap),
+            Err(E::TooBig)
+        );
+
+        assert_eq!(p("12.000", Denomination::MilliTapyrus), Err(E::TooPrecise));
+        // exactly 50 chars.
+        assert_eq!(
+            p("100000000000000.0000000000000000000000000000000000", Denomination::TPC),
+            Err(E::TooBig)
+        );
+        // more than 50 chars.
+        assert_eq!(
+            p("100000000000000.00000000000000000000000000000000000", Denomination::TPC),
+            Err(E::InputTooLarge)
+        );
+    }
+
+    #[test]
+    fn to_string() {
+        use super::Denomination as D;
+
+        assert_eq!(Amount::ONE_TPC.to_string_in(D::TPC), "1");
+        assert_eq!(format!("{:.8}", Amount::ONE_TPC.display_in(D::TPC)), "1.00000000");
+        assert_eq!(Amount::ONE_TPC.to_string_in(D::Tapyrus), "100000000");
+        assert_eq!(Amount::ONE_TAP.to_string_in(D::TPC), "0.00000001");
+        assert_eq!(SignedAmount::from_tap(-42).to_string_in(D::TPC), "-0.00000042");
+
+        assert_eq!(Amount::ONE_TPC.to_string_with_denomination(D::TPC), "1 TPC");
+        assert_eq!(Amount::ONE_TAP.to_string_with_denomination(D::MilliTapyrus), "1000 mtap");
+        assert_eq!(
+            SignedAmount::ONE_TPC.to_string_with_denomination(D::Tapyrus),
+            "100000000 tapyrus"
+        );
+        assert_eq!(Amount::ONE_TAP.to_string_with_denomination(D::TPC), "0.00000001 TPC");
+        assert_eq!(
+            SignedAmount::from_tap(-42).to_string_with_denomination(D::TPC),
+            "-0.00000042 TPC"
+        );
+    }
+
+    // May help identify a problem sooner
+    #[test]
+    fn test_repeat_char() {
+        let mut buf = String::new();
+        repeat_char(&mut buf, '0', 0).unwrap();
+        assert_eq!(buf.len(), 0);
+        repeat_char(&mut buf, '0', 42).unwrap();
+        assert_eq!(buf.len(), 42);
+        assert!(buf.chars().all(|c| c == '0'));
+    }
+
+    // Creates individual test functions to make it easier to find which check failed.
+    macro_rules! check_format_non_negative {
+        ($denom:ident; $($test_name:ident, $val:literal, $format_string:literal, $expected:literal);* $(;)?) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    assert_eq!(format!($format_string, Amount::from_tap($val).display_in(Denomination::$denom)), $expected);
+                    assert_eq!(format!($format_string, SignedAmount::from_tap($val as i64).display_in(Denomination::$denom)), $expected);
+                }
+            )*
+        }
+    }
+
+    macro_rules! check_format_non_negative_show_denom {
+        ($denom:ident, $denom_suffix:literal; $($test_name:ident, $val:literal, $format_string:literal, $expected:literal);* $(;)?) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    assert_eq!(format!($format_string, Amount::from_tap($val).display_in(Denomination::$denom).show_denomination()), concat!($expected, $denom_suffix));
+                    assert_eq!(format!($format_string, SignedAmount::from_tap($val as i64).display_in(Denomination::$denom).show_denomination()), concat!($expected, $denom_suffix));
+                }
+            )*
+        }
+    }
+
+    check_format_non_negative! {
+        Tapyrus;
+        tap_check_fmt_non_negative_0, 0, "{}", "0";
+        tap_check_fmt_non_negative_1, 0, "{:2}", " 0";
+        tap_check_fmt_non_negative_2, 0, "{:02}", "00";
+        tap_check_fmt_non_negative_3, 0, "{:.1}", "0.0";
+        tap_check_fmt_non_negative_4, 0, "{:4.1}", " 0.0";
+        tap_check_fmt_non_negative_5, 0, "{:04.1}", "00.0";
+        tap_check_fmt_non_negative_6, 1, "{}", "1";
+        tap_check_fmt_non_negative_7, 1, "{:2}", " 1";
+        tap_check_fmt_non_negative_8, 1, "{:02}", "01";
+        tap_check_fmt_non_negative_9, 1, "{:.1}", "1.0";
+        tap_check_fmt_non_negative_10, 1, "{:4.1}", " 1.0";
+        tap_check_fmt_non_negative_11, 1, "{:04.1}", "01.0";
+        tap_check_fmt_non_negative_12, 10, "{}", "10";
+        tap_check_fmt_non_negative_13, 10, "{:2}", "10";
+        tap_check_fmt_non_negative_14, 10, "{:02}", "10";
+        tap_check_fmt_non_negative_15, 10, "{:3}", " 10";
+        tap_check_fmt_non_negative_16, 10, "{:03}", "010";
+        tap_check_fmt_non_negative_17, 10, "{:.1}", "10.0";
+        tap_check_fmt_non_negative_18, 10, "{:5.1}", " 10.0";
+        tap_check_fmt_non_negative_19, 10, "{:05.1}", "010.0";
+        tap_check_fmt_non_negative_20, 1, "{:<2}", "1 ";
+        tap_check_fmt_non_negative_21, 1, "{:<02}", "01";
+        tap_check_fmt_non_negative_22, 1, "{:<3.1}", "1.0";
+        tap_check_fmt_non_negative_23, 1, "{:<4.1}", "1.0 ";
+    }
+
+    check_format_non_negative_show_denom! {
+        Tapyrus, " tapyrus";
+        tap_check_fmt_non_negative_show_denom_0, 0, "{}", "0";
+        tap_check_fmt_non_negative_show_denom_1, 0, "{:2}", "0";
+        tap_check_fmt_non_negative_show_denom_2, 0, "{:02}", "0";
+        tap_check_fmt_non_negative_show_denom_3, 0, "{:9}", "0";
+        tap_check_fmt_non_negative_show_denom_4, 0, "{:09}", "0";
+        tap_check_fmt_non_negative_show_denom_5, 0, "{:10}", " 0";
+        tap_check_fmt_non_negative_show_denom_6, 0, "{:010}", "00";
+        tap_check_fmt_non_negative_show_denom_7, 0, "{:.1}", "0.0";
+        tap_check_fmt_non_negative_show_denom_8, 0, "{:11.1}", "0.0";
+        tap_check_fmt_non_negative_show_denom_9, 0, "{:011.1}", "0.0";
+        tap_check_fmt_non_negative_show_denom_10, 0, "{:12.1}", " 0.0";
+        tap_check_fmt_non_negative_show_denom_11, 0, "{:012.1}", "00.0";
+        tap_check_fmt_non_negative_show_denom_12, 1, "{}", "1";
+        tap_check_fmt_non_negative_show_denom_13, 1, "{:10}", " 1";
+        tap_check_fmt_non_negative_show_denom_14, 1, "{:010}", "01";
+        tap_check_fmt_non_negative_show_denom_15, 1, "{:.1}", "1.0";
+        tap_check_fmt_non_negative_show_denom_16, 1, "{:12.1}", " 1.0";
+        tap_check_fmt_non_negative_show_denom_17, 1, "{:012.1}", "01.0";
+        tap_check_fmt_non_negative_show_denom_18, 10, "{}", "10";
+        tap_check_fmt_non_negative_show_denom_19, 10, "{:10}", "10";
+        tap_check_fmt_non_negative_show_denom_20, 10, "{:010}", "10";
+        tap_check_fmt_non_negative_show_denom_21, 10, "{:11}", " 10";
+        tap_check_fmt_non_negative_show_denom_22, 10, "{:011}", "010";
+    }
+
+    check_format_non_negative! {
+        TPC;
+        tpc_check_fmt_non_negative_0, 0, "{}", "0";
+        tpc_check_fmt_non_negative_1, 0, "{:2}", " 0";
+        tpc_check_fmt_non_negative_2, 0, "{:02}", "00";
+        tpc_check_fmt_non_negative_3, 0, "{:.1}", "0.0";
+        tpc_check_fmt_non_negative_4, 0, "{:4.1}", " 0.0";
+        tpc_check_fmt_non_negative_5, 0, "{:04.1}", "00.0";
+        tpc_check_fmt_non_negative_6, 1, "{}", "0.00000001";
+        tpc_check_fmt_non_negative_7, 1, "{:2}", "0.00000001";
+        tpc_check_fmt_non_negative_8, 1, "{:02}", "0.00000001";
+        tpc_check_fmt_non_negative_9, 1, "{:.1}", "0.00000001";
+        tpc_check_fmt_non_negative_10, 1, "{:11}", " 0.00000001";
+        tpc_check_fmt_non_negative_11, 1, "{:11.1}", " 0.00000001";
+        tpc_check_fmt_non_negative_12, 1, "{:011.1}", "00.00000001";
+        tpc_check_fmt_non_negative_13, 1, "{:.9}", "0.000000010";
+        tpc_check_fmt_non_negative_14, 1, "{:11.9}", "0.000000010";
+        tpc_check_fmt_non_negative_15, 1, "{:011.9}", "0.000000010";
+        tpc_check_fmt_non_negative_16, 1, "{:12.9}", " 0.000000010";
+        tpc_check_fmt_non_negative_17, 1, "{:012.9}", "00.000000010";
+        tpc_check_fmt_non_negative_18, 100_000_000, "{}", "1";
+        tpc_check_fmt_non_negative_19, 100_000_000, "{:2}", " 1";
+        tpc_check_fmt_non_negative_20, 100_000_000, "{:02}", "01";
+        tpc_check_fmt_non_negative_21, 100_000_000, "{:.1}", "1.0";
+        tpc_check_fmt_non_negative_22, 100_000_000, "{:4.1}", " 1.0";
+        tpc_check_fmt_non_negative_23, 100_000_000, "{:04.1}", "01.0";
+        tpc_check_fmt_non_negative_24, 110_000_000, "{}", "1.1";
+        tpc_check_fmt_non_negative_25, 100_000_001, "{}", "1.00000001";
+        tpc_check_fmt_non_negative_26, 100_000_001, "{:1}", "1.00000001";
+        tpc_check_fmt_non_negative_27, 100_000_001, "{:.1}", "1.00000001";
+        tpc_check_fmt_non_negative_28, 100_000_001, "{:10}", "1.00000001";
+        tpc_check_fmt_non_negative_29, 100_000_001, "{:11}", " 1.00000001";
+        tpc_check_fmt_non_negative_30, 100_000_001, "{:011}", "01.00000001";
+        tpc_check_fmt_non_negative_31, 100_000_001, "{:.8}", "1.00000001";
+        tpc_check_fmt_non_negative_32, 100_000_001, "{:.9}", "1.000000010";
+        tpc_check_fmt_non_negative_33, 100_000_001, "{:11.9}", "1.000000010";
+        tpc_check_fmt_non_negative_34, 100_000_001, "{:12.9}", " 1.000000010";
+        tpc_check_fmt_non_negative_35, 100_000_001, "{:012.9}", "01.000000010";
+        tpc_check_fmt_non_negative_36, 100_000_001, "{:+011.8}", "+1.00000001";
+        tpc_check_fmt_non_negative_37, 100_000_001, "{:+12.8}", " +1.00000001";
+        tpc_check_fmt_non_negative_38, 100_000_001, "{:+012.8}", "+01.00000001";
+        tpc_check_fmt_non_negative_39, 100_000_001, "{:+12.9}", "+1.000000010";
+        tpc_check_fmt_non_negative_40, 100_000_001, "{:+012.9}", "+1.000000010";
+        tpc_check_fmt_non_negative_41, 100_000_001, "{:+13.9}", " +1.000000010";
+        tpc_check_fmt_non_negative_42, 100_000_001, "{:+013.9}", "+01.000000010";
+        tpc_check_fmt_non_negative_43, 100_000_001, "{:<10}", "1.00000001";
+        tpc_check_fmt_non_negative_44, 100_000_001, "{:<11}", "1.00000001 ";
+        tpc_check_fmt_non_negative_45, 100_000_001, "{:<011}", "01.00000001";
+        tpc_check_fmt_non_negative_46, 100_000_001, "{:<11.9}", "1.000000010";
+        tpc_check_fmt_non_negative_47, 100_000_001, "{:<12.9}", "1.000000010 ";
+        tpc_check_fmt_non_negative_48, 100_000_001, "{:<12}", "1.00000001  ";
+        tpc_check_fmt_non_negative_49, 100_000_001, "{:^11}", "1.00000001 ";
+        tpc_check_fmt_non_negative_50, 100_000_001, "{:^11.9}", "1.000000010";
+        tpc_check_fmt_non_negative_51, 100_000_001, "{:^12.9}", "1.000000010 ";
+        tpc_check_fmt_non_negative_52, 100_000_001, "{:^12}", " 1.00000001 ";
+        tpc_check_fmt_non_negative_53, 100_000_001, "{:^12.9}", "1.000000010 ";
+        tpc_check_fmt_non_negative_54, 100_000_001, "{:^13.9}", " 1.000000010 ";
+    }
+
+    check_format_non_negative_show_denom! {
+        TPC, " TPC";
+        tpc_check_fmt_non_negative_show_denom_0, 1, "{:14.1}", "0.00000001";
+        tpc_check_fmt_non_negative_show_denom_1, 1, "{:14.8}", "0.00000001";
+        tpc_check_fmt_non_negative_show_denom_2, 1, "{:15}", " 0.00000001";
+        tpc_check_fmt_non_negative_show_denom_3, 1, "{:015}", "00.00000001";
+        tpc_check_fmt_non_negative_show_denom_4, 1, "{:.9}", "0.000000010";
+        tpc_check_fmt_non_negative_show_denom_5, 1, "{:15.9}", "0.000000010";
+        tpc_check_fmt_non_negative_show_denom_6, 1, "{:16.9}", " 0.000000010";
+        tpc_check_fmt_non_negative_show_denom_7, 1, "{:016.9}", "00.000000010";
+    }
+
+    check_format_non_negative_show_denom! {
+        TPC, " TPC ";
+        tpc_check_fmt_non_negative_show_denom_align_0, 1, "{:<15}", "0.00000001";
+        tpc_check_fmt_non_negative_show_denom_align_1, 1, "{:^15}", "0.00000001";
+        tpc_check_fmt_non_negative_show_denom_align_2, 1, "{:^16}", " 0.00000001";
+    }
+
+    check_format_non_negative! {
+        MilliTapyrus;
+        mtap_check_fmt_non_negative_0, 0, "{}", "0";
+        mtap_check_fmt_non_negative_1, 1, "{}", "1000";
+        mtap_check_fmt_non_negative_2, 1, "{:5}", " 1000";
+        mtap_check_fmt_non_negative_3, 1, "{:05}", "01000";
+        mtap_check_fmt_non_negative_4, 1, "{:.1}", "1000.0";
+        mtap_check_fmt_non_negative_5, 1, "{:6.1}", "1000.0";
+        mtap_check_fmt_non_negative_6, 1, "{:06.1}", "1000.0";
+        mtap_check_fmt_non_negative_7, 1, "{:7.1}", " 1000.0";
+        mtap_check_fmt_non_negative_8, 1, "{:07.1}", "01000.0";
+    }
+
+    #[test]
+    fn test_unsigned_signed_conversion() {
+        use super::ParseAmountError as E;
+        let sa = SignedAmount::from_tap;
+        let ua = Amount::from_tap;
+
+        assert_eq!(Amount::MAX.to_signed(), Err(E::TooBig));
+        assert_eq!(ua(i64::MAX as u64).to_signed(), Ok(sa(i64::MAX)));
+        assert_eq!(ua(i64::MAX as u64 + 1).to_signed(), Err(E::TooBig));
+
+        assert_eq!(sa(i64::MAX).to_unsigned(), Ok(ua(i64::MAX as u64)));
+
+        assert_eq!(sa(i64::MAX).to_unsigned().unwrap().to_signed(), Ok(sa(i64::MAX)));
+    }
+
+    #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 taps per tapyrus.
+    fn from_str() {
+        use super::ParseAmountError as E;
+
+        assert_eq!(Amount::from_str("x TPC"), Err(E::InvalidCharacter('x')));
+        assert_eq!(Amount::from_str("xTPC"), Err(E::UnknownDenomination("xTPC".into())));
+        assert_eq!(Amount::from_str("5 TPC TPC"), Err(E::UnknownDenomination("TPC TPC".into())));
+        assert_eq!(Amount::from_str("5TPC TPC"), Err(E::InvalidCharacter('T')));
+        assert_eq!(Amount::from_str("5 5 TPC"), Err(E::UnknownDenomination("5 TPC".into())));
+
+        #[track_caller]
+        fn case(s: &str, expected: Result<Amount, ParseAmountError>) {
+            assert_eq!(Amount::from_str(s), expected);
+            assert_eq!(Amount::from_str(&s.replace(' ', "")), expected);
+        }
+
+        #[track_caller]
+        fn scase(s: &str, expected: Result<SignedAmount, ParseAmountError>) {
+            assert_eq!(SignedAmount::from_str(s), expected);
+            assert_eq!(SignedAmount::from_str(&s.replace(' ', "")), expected);
+        }
+
+        case("5 BCH", Err(E::UnknownDenomination("BCH".to_owned())));
+
+        case("-1 TPC", Err(E::Negative));
+        case("-0.0 TPC", Err(E::Negative));
+        case("0.123456789 TPC", Err(E::TooPrecise));
+        scase("-0.1 tapyrus", Err(E::TooPrecise));
+        case("0.123456 mTPC", Err(E::TooPrecise));
+        scase("-200000000000 TPC", Err(E::TooBig));
+        case("18446744073709551616 tap", Err(E::TooBig));
+
+        case("0.00253583 TPC", Ok(Amount::from_tap(253583)));
+        scase("-5 tapyrus", Ok(SignedAmount::from_tap(-5)));
+        case("0.10000000 TPC", Ok(Amount::from_tap(100_000_00)));
+    }
+
+    #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 taps per tapyrus.
+    fn to_from_string_in() {
+        use super::Denomination as D;
+        let ua_str = Amount::from_str_in;
+        let ua_tap = Amount::from_tap;
+        let sa_str = SignedAmount::from_str_in;
+        let sa_tap = SignedAmount::from_tap;
+
+        assert_eq!("0.00253583", Amount::from_tap(253583).to_string_in(D::TPC));
+        assert_eq!("-5", SignedAmount::from_tap(-5).to_string_in(D::Tapyrus));
+        assert_eq!("0.1", Amount::from_tap(100_000_00).to_string_in(D::TPC));
+        assert_eq!("2535830", Amount::from_tap(253583).to_string_in(D::NanoTPC));
+        assert_eq!("-100000", SignedAmount::from_tap(-10_000).to_string_in(D::NanoTPC));
+        assert_eq!("2535830000", Amount::from_tap(253583).to_string_in(D::PicoTPC));
+        assert_eq!("-100000000", SignedAmount::from_tap(-10_000).to_string_in(D::PicoTPC));
+
+        assert_eq!("0.10000000", format!("{:.8}", Amount::from_tap(100_000_00).display_in(D::TPC)));
+
+        assert_eq!(ua_str(&ua_tap(0).to_string_in(D::Tapyrus), D::Tapyrus), Ok(ua_tap(0)));
+        assert_eq!(ua_str(&ua_tap(500).to_string_in(D::TPC), D::TPC), Ok(ua_tap(500)));
+        assert_eq!(ua_str(&ua_tap(1).to_string_in(D::MicroTPC), D::MicroTPC), Ok(ua_tap(1)));
+        assert_eq!(
+            ua_str(&ua_tap(1_000_000_000_000).to_string_in(D::MilliTPC), D::MilliTPC),
+            Ok(ua_tap(1_000_000_000_000))
+        );
+        assert_eq!(
+            ua_str(&ua_tap(u64::MAX).to_string_in(D::MilliTPC), D::MilliTPC),
+            Err(ParseAmountError::TooBig)
+        );
+
+        assert_eq!(sa_str(&sa_tap(-1).to_string_in(D::MicroTPC), D::MicroTPC), Ok(sa_tap(-1)));
+
+        assert_eq!(
+            sa_str(&sa_tap(i64::MAX).to_string_in(D::Tapyrus), D::MicroTPC),
+            Err(ParseAmountError::TooBig)
+        );
+        // Test an overflow bug in `abs()`
+        assert_eq!(
+            sa_str(&sa_tap(i64::MIN).to_string_in(D::Tapyrus), D::MicroTPC),
+            Err(ParseAmountError::TooBig)
+        );
+
+        assert_eq!(sa_str(&sa_tap(-1).to_string_in(D::NanoTPC), D::NanoTPC), Ok(sa_tap(-1)));
+        assert_eq!(
+            sa_str(&sa_tap(i64::MAX).to_string_in(D::Tapyrus), D::NanoTPC),
+            Err(ParseAmountError::TooPrecise)
+        );
+        assert_eq!(
+            sa_str(&sa_tap(i64::MIN).to_string_in(D::Tapyrus), D::NanoTPC),
+            Err(ParseAmountError::TooPrecise)
+        );
+
+        assert_eq!(sa_str(&sa_tap(-1).to_string_in(D::PicoTPC), D::PicoTPC), Ok(sa_tap(-1)));
+        assert_eq!(
+            sa_str(&sa_tap(i64::MAX).to_string_in(D::Tapyrus), D::PicoTPC),
+            Err(ParseAmountError::TooPrecise)
+        );
+        assert_eq!(
+            sa_str(&sa_tap(i64::MIN).to_string_in(D::Tapyrus), D::PicoTPC),
+            Err(ParseAmountError::TooPrecise)
+        );
+    }
+
+    #[test]
+    fn to_string_with_denomination_from_str_roundtrip() {
+        use super::Denomination as D;
+        let amt = Amount::from_tap(42);
+        let denom = Amount::to_string_with_denomination;
+        assert_eq!(Amount::from_str(&denom(amt, D::TPC)), Ok(amt));
+        assert_eq!(Amount::from_str(&denom(amt, D::MilliTPC)), Ok(amt));
+        assert_eq!(Amount::from_str(&denom(amt, D::MicroTPC)), Ok(amt));
+        assert_eq!(Amount::from_str(&denom(amt, D::Tapyrus)), Ok(amt));
+        assert_eq!(Amount::from_str(&denom(amt, D::NanoTPC)), Ok(amt));
+        assert_eq!(Amount::from_str(&denom(amt, D::MilliTapyrus)), Ok(amt));
+        assert_eq!(Amount::from_str(&denom(amt, D::PicoTPC)), Ok(amt));
+
+        assert_eq!(
+            Amount::from_str("42 tapyrus TPC"),
+            Err(ParseAmountError::UnknownDenomination("tapyrus TPC".into())),
+        );
+        assert_eq!(
+            SignedAmount::from_str("-42 tapyrus TPC"),
+            Err(ParseAmountError::UnknownDenomination("tapyrus TPC".into())),
+        );
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn serde_as_tap() {
+        #[derive(Serialize, Deserialize, PartialEq, Debug)]
+        #[serde(crate = "actual_serde")]
+        struct T {
+            #[serde(with = "crate::amount::serde::as_tap")]
+            pub amt: Amount,
+            #[serde(with = "crate::amount::serde::as_tap")]
+            pub samt: SignedAmount,
+        }
+
+        serde_test::assert_tokens(
+            &T { amt: Amount::from_tap(123456789), samt: SignedAmount::from_tap(-123456789) },
+            &[
+                serde_test::Token::Struct { name: "T", len: 2 },
+                serde_test::Token::Str("amt"),
+                serde_test::Token::U64(123456789),
+                serde_test::Token::Str("samt"),
+                serde_test::Token::I64(-123456789),
+                serde_test::Token::StructEnd,
+            ],
+        );
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 taps per tapyrus.
+    fn serde_as_tpc() {
+        use serde_json;
+
+        #[derive(Serialize, Deserialize, PartialEq, Debug)]
+        #[serde(crate = "actual_serde")]
+        struct T {
+            #[serde(with = "crate::amount::serde::as_tpc")]
+            pub amt: Amount,
+            #[serde(with = "crate::amount::serde::as_tpc")]
+            pub samt: SignedAmount,
+        }
+
+        let orig = T {
+            amt: Amount::from_tap(21_000_000__000_000_01),
+            samt: SignedAmount::from_tap(-21_000_000__000_000_01),
+        };
+
+        let json = "{\"amt\": 21000000.00000001, \
+                    \"samt\": -21000000.00000001}";
+        let t: T = serde_json::from_str(json).unwrap();
+        assert_eq!(t, orig);
+
+        let value: serde_json::Value = serde_json::from_str(json).unwrap();
+        assert_eq!(t, serde_json::from_value(value).unwrap());
+
+        // errors
+        let t: Result<T, serde_json::Error> =
+            serde_json::from_str("{\"amt\": 1000000.000000001, \"samt\": 1}");
+        assert!(t.unwrap_err().to_string().contains(&ParseAmountError::TooPrecise.to_string()));
+        let t: Result<T, serde_json::Error> = serde_json::from_str("{\"amt\": -1, \"samt\": 1}");
+        assert!(t.unwrap_err().to_string().contains(&ParseAmountError::Negative.to_string()));
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 taps per tapyrus.
+    fn serde_as_tpc_opt() {
+        use serde_json;
+
+        #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
+        #[serde(crate = "actual_serde")]
+        struct T {
+            #[serde(default, with = "crate::amount::serde::as_tpc::opt")]
+            pub amt: Option<Amount>,
+            #[serde(default, with = "crate::amount::serde::as_tpc::opt")]
+            pub samt: Option<SignedAmount>,
+        }
+
+        let with = T {
+            amt: Some(Amount::from_tap(2_500_000_00)),
+            samt: Some(SignedAmount::from_tap(-2_500_000_00)),
+        };
+        let without = T { amt: None, samt: None };
+
+        // Test Roundtripping
+        for s in [&with, &without].iter() {
+            let v = serde_json::to_string(s).unwrap();
+            let w: T = serde_json::from_str(&v).unwrap();
+            assert_eq!(w, **s);
+        }
+
+        let t: T = serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
+        assert_eq!(t, with);
+
+        let t: T = serde_json::from_str("{}").unwrap();
+        assert_eq!(t, without);
+
+        let value_with: serde_json::Value =
+            serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
+        assert_eq!(with, serde_json::from_value(value_with).unwrap());
+
+        let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+        assert_eq!(without, serde_json::from_value(value_without).unwrap());
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 taps per tapyrus.
+    fn serde_as_tap_opt() {
+        use serde_json;
+
+        #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
+        #[serde(crate = "actual_serde")]
+        struct T {
+            #[serde(default, with = "crate::amount::serde::as_tap::opt")]
+            pub amt: Option<Amount>,
+            #[serde(default, with = "crate::amount::serde::as_tap::opt")]
+            pub samt: Option<SignedAmount>,
+        }
+
+        let with = T {
+            amt: Some(Amount::from_tap(2_500_000_00)),
+            samt: Some(SignedAmount::from_tap(-2_500_000_00)),
+        };
+        let without = T { amt: None, samt: None };
+
+        // Test Roundtripping
+        for s in [&with, &without].iter() {
+            let v = serde_json::to_string(s).unwrap();
+            let w: T = serde_json::from_str(&v).unwrap();
+            assert_eq!(w, **s);
+        }
+
+        let t: T = serde_json::from_str("{\"amt\": 250000000, \"samt\": -250000000}").unwrap();
+        assert_eq!(t, with);
+
+        let t: T = serde_json::from_str("{}").unwrap();
+        assert_eq!(t, without);
+
+        let value_with: serde_json::Value =
+            serde_json::from_str("{\"amt\": 250000000, \"samt\": -250000000}").unwrap();
+        assert_eq!(with, serde_json::from_value(value_with).unwrap());
+
+        let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+        assert_eq!(without, serde_json::from_value(value_without).unwrap());
+    }
+
+    #[test]
+    fn sum_amounts() {
+        assert_eq!(Amount::from_tap(0), vec![].into_iter().sum::<Amount>());
+        assert_eq!(SignedAmount::from_tap(0), vec![].into_iter().sum::<SignedAmount>());
+
+        let amounts = vec![Amount::from_tap(42), Amount::from_tap(1337), Amount::from_tap(21)];
+        let sum = amounts.into_iter().sum::<Amount>();
+        assert_eq!(Amount::from_tap(1400), sum);
+
+        let amounts = vec![
+            SignedAmount::from_tap(-42),
+            SignedAmount::from_tap(1337),
+            SignedAmount::from_tap(21),
+        ];
+        let sum = amounts.into_iter().sum::<SignedAmount>();
+        assert_eq!(SignedAmount::from_tap(1316), sum);
+    }
+
+    #[test]
+    fn checked_sum_amounts() {
+        assert_eq!(Some(Amount::from_tap(0)), vec![].into_iter().checked_sum());
+        assert_eq!(Some(SignedAmount::from_tap(0)), vec![].into_iter().checked_sum());
+
+        let amounts = vec![Amount::from_tap(42), Amount::from_tap(1337), Amount::from_tap(21)];
+        let sum = amounts.into_iter().checked_sum();
+        assert_eq!(Some(Amount::from_tap(1400)), sum);
+
+        let amounts =
+            vec![Amount::from_tap(u64::MAX), Amount::from_tap(1337), Amount::from_tap(21)];
+        let sum = amounts.into_iter().checked_sum();
+        assert_eq!(None, sum);
+
+        let amounts = vec![
+            SignedAmount::from_tap(i64::MIN),
+            SignedAmount::from_tap(-1),
+            SignedAmount::from_tap(21),
+        ];
+        let sum = amounts.into_iter().checked_sum();
+        assert_eq!(None, sum);
+
+        let amounts = vec![
+            SignedAmount::from_tap(i64::MAX),
+            SignedAmount::from_tap(1),
+            SignedAmount::from_tap(21),
+        ];
+        let sum = amounts.into_iter().checked_sum();
+        assert_eq!(None, sum);
+
+        let amounts = vec![
+            SignedAmount::from_tap(42),
+            SignedAmount::from_tap(3301),
+            SignedAmount::from_tap(21),
+        ];
+        let sum = amounts.into_iter().checked_sum();
+        assert_eq!(Some(SignedAmount::from_tap(3364)), sum);
+    }
+
+    #[test]
+    fn denomination_string_acceptable_forms() {
+        // Non-exhaustive list of valid forms.
+        let valid = vec![
+            "TPC", "tpc", "mTPC", "mtpc", "uTPC", "utpc", "TAPYRUS", "tapyrus", "TAPYRUSES", "tapyruses", "TAP", "tap",
+            "TAPS", "taps", "nTPC", "pTPC",
+        ];
+        for denom in valid.iter() {
+            assert!(Denomination::from_str(denom).is_ok());
+        }
+    }
+
+    #[test]
+    fn disallow_confusing_forms() {
+        let confusing = ["Mtap", "Mtaps", "MTAP", "MTAPS", "MTap", "MTaps", "MTPC", "Mtpc", "PTPC"];
+        for denom in confusing.iter() {
+            match Denomination::from_str(denom) {
+                Ok(_) => panic!("from_str should error for {}", denom),
+                Err(ParseAmountError::PossiblyConfusingDenomination(_)) => {}
+                Err(e) => panic!("unexpected error: {}", e),
+            }
+        }
+    }
+
+    #[test]
+    fn disallow_unknown_denomination() {
+        // Non-exhaustive list of unknown forms.
+        let unknown = ["NTPC", "UTPC", "ABC", "abc", "cTpC", "Tap", "Taps"];
+        for denom in unknown.iter() {
+            match Denomination::from_str(denom) {
+                Ok(_) => panic!("from_str should error for {}", denom),
+                Err(ParseAmountError::UnknownDenomination(_)) => {}
+                Err(e) => panic!("unexpected error: {}", e),
+            }
+        }
+    }
+}
diff --git a/tapyrus/src/base58.rs b/tapyrus/src/base58.rs
new file mode 100644
index 00000000..8f5b0330
--- /dev/null
+++ b/tapyrus/src/base58.rs
@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Base58 encoder and decoder.
+//!
+//! This module provides functions for encoding and decoding base58 slices and
+//! strings respectively.
+//!
+
+use core::convert::TryInto;
+use core::{fmt, iter, slice, str};
+
+use hashes::{sha256d, Hash};
+
+use crate::prelude::*;
+
+static BASE58_CHARS: &[u8] = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+#[rustfmt::skip]
+static BASE58_DIGITS: [Option<u8>; 128] = [
+    None,     None,     None,     None,     None,     None,     None,     None,     // 0-7
+    None,     None,     None,     None,     None,     None,     None,     None,     // 8-15
+    None,     None,     None,     None,     None,     None,     None,     None,     // 16-23
+    None,     None,     None,     None,     None,     None,     None,     None,     // 24-31
+    None,     None,     None,     None,     None,     None,     None,     None,     // 32-39
+    None,     None,     None,     None,     None,     None,     None,     None,     // 40-47
+    None,     Some(0),  Some(1),  Some(2),  Some(3),  Some(4),  Some(5),  Some(6),  // 48-55
+    Some(7),  Some(8),  None,     None,     None,     None,     None,     None,     // 56-63
+    None,     Some(9),  Some(10), Some(11), Some(12), Some(13), Some(14), Some(15), // 64-71
+    Some(16), None,     Some(17), Some(18), Some(19), Some(20), Some(21), None,     // 72-79
+    Some(22), Some(23), Some(24), Some(25), Some(26), Some(27), Some(28), Some(29), // 80-87
+    Some(30), Some(31), Some(32), None,     None,     None,     None,     None,     // 88-95
+    None,     Some(33), Some(34), Some(35), Some(36), Some(37), Some(38), Some(39), // 96-103
+    Some(40), Some(41), Some(42), Some(43), None,     Some(44), Some(45), Some(46), // 104-111
+    Some(47), Some(48), Some(49), Some(50), Some(51), Some(52), Some(53), Some(54), // 112-119
+    Some(55), Some(56), Some(57), None,     None,     None,     None,     None,     // 120-127
+];
+
+/// Decodes a base58-encoded string into a byte vector.
+pub fn decode(data: &str) -> Result<Vec<u8>, Error> {
+    // 11/15 is just over log_256(58)
+    let mut scratch = vec![0u8; 1 + data.len() * 11 / 15];
+    // Build in base 256
+    for d58 in data.bytes() {
+        // Compute "X = X * 58 + next_digit" in base 256
+        if d58 as usize >= BASE58_DIGITS.len() {
+            return Err(Error::BadByte(d58));
+        }
+        let mut carry = match BASE58_DIGITS[d58 as usize] {
+            Some(d58) => d58 as u32,
+            None => {
+                return Err(Error::BadByte(d58));
+            }
+        };
+        for d256 in scratch.iter_mut().rev() {
+            carry += *d256 as u32 * 58;
+            *d256 = carry as u8;
+            carry /= 256;
+        }
+        assert_eq!(carry, 0);
+    }
+
+    // Copy leading zeroes directly
+    let mut ret: Vec<u8> = data.bytes().take_while(|&x| x == BASE58_CHARS[0]).map(|_| 0).collect();
+    // Copy rest of string
+    ret.extend(scratch.into_iter().skip_while(|&x| x == 0));
+    Ok(ret)
+}
+
+/// Decodes a base58check-encoded string into a byte vector verifying the checksum.
+pub fn decode_check(data: &str) -> Result<Vec<u8>, Error> {
+    let mut ret: Vec<u8> = decode(data)?;
+    if ret.len() < 4 {
+        return Err(Error::TooShort(ret.len()));
+    }
+    let check_start = ret.len() - 4;
+
+    let hash_check =
+        sha256d::Hash::hash(&ret[..check_start])[..4].try_into().expect("4 byte slice");
+    let data_check = ret[check_start..].try_into().expect("4 byte slice");
+
+    let expected = u32::from_le_bytes(hash_check);
+    let actual = u32::from_le_bytes(data_check);
+
+    if expected != actual {
+        return Err(Error::BadChecksum(expected, actual));
+    }
+
+    ret.truncate(check_start);
+    Ok(ret)
+}
+
+/// Encodes `data` as a base58 string (see also `base58::encode_check()`).
+pub fn encode(data: &[u8]) -> String { encode_iter(data.iter().cloned()) }
+
+/// Encodes `data` as a base58 string including the checksum.
+///
+/// The checksum is the first four bytes of the sha256d of the data, concatenated onto the end.
+pub fn encode_check(data: &[u8]) -> String {
+    let checksum = sha256d::Hash::hash(data);
+    encode_iter(data.iter().cloned().chain(checksum[0..4].iter().cloned()))
+}
+
+/// Encodes a slice as base58, including the checksum, into a formatter.
+///
+/// The checksum is the first four bytes of the sha256d of the data, concatenated onto the end.
+pub fn encode_check_to_fmt(fmt: &mut fmt::Formatter, data: &[u8]) -> fmt::Result {
+    let checksum = sha256d::Hash::hash(data);
+    let iter = data.iter().cloned().chain(checksum[0..4].iter().cloned());
+    format_iter(fmt, iter)
+}
+
+fn encode_iter<I>(data: I) -> String
+where
+    I: Iterator<Item = u8> + Clone,
+{
+    let mut ret = String::new();
+    format_iter(&mut ret, data).expect("writing into string shouldn't fail");
+    ret
+}
+
+fn format_iter<I, W>(writer: &mut W, data: I) -> Result<(), fmt::Error>
+where
+    I: Iterator<Item = u8> + Clone,
+    W: fmt::Write,
+{
+    let mut ret = SmallVec::new();
+
+    let mut leading_zero_count = 0;
+    let mut leading_zeroes = true;
+    // Build string in little endian with 0-58 in place of characters...
+    for d256 in data {
+        let mut carry = d256 as usize;
+        if leading_zeroes && carry == 0 {
+            leading_zero_count += 1;
+        } else {
+            leading_zeroes = false;
+        }
+
+        for ch in ret.iter_mut() {
+            let new_ch = *ch as usize * 256 + carry;
+            *ch = (new_ch % 58) as u8;
+            carry = new_ch / 58;
+        }
+        while carry > 0 {
+            ret.push((carry % 58) as u8);
+            carry /= 58;
+        }
+    }
+
+    // ... then reverse it and convert to chars
+    for _ in 0..leading_zero_count {
+        ret.push(0);
+    }
+
+    for ch in ret.iter().rev() {
+        writer.write_char(BASE58_CHARS[*ch as usize] as char)?;
+    }
+
+    Ok(())
+}
+
+/// Vector-like object that holds the first 100 elements on the stack. If more space is needed it
+/// will be allocated on the heap.
+struct SmallVec<T> {
+    len: usize,
+    stack: [T; 100],
+    heap: Vec<T>,
+}
+
+impl<T: Default + Copy> SmallVec<T> {
+    fn new() -> SmallVec<T> { SmallVec { len: 0, stack: [T::default(); 100], heap: Vec::new() } }
+
+    fn push(&mut self, val: T) {
+        if self.len < 100 {
+            self.stack[self.len] = val;
+            self.len += 1;
+        } else {
+            self.heap.push(val);
+        }
+    }
+
+    fn iter(&self) -> iter::Chain<slice::Iter<T>, slice::Iter<T>> {
+        // If len<100 then we just append an empty vec
+        self.stack[0..self.len].iter().chain(self.heap.iter())
+    }
+
+    fn iter_mut(&mut self) -> iter::Chain<slice::IterMut<T>, slice::IterMut<T>> {
+        // If len<100 then we just append an empty vec
+        self.stack[0..self.len].iter_mut().chain(self.heap.iter_mut())
+    }
+}
+
+/// An error that might occur during base58 decoding.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// Invalid character encountered.
+    BadByte(u8),
+    /// Checksum was not correct (expected, actual).
+    BadChecksum(u32, u32),
+    /// The length (in bytes) of the object was not correct.
+    ///
+    /// Note that if the length is excessively long the provided length may be an estimate (and the
+    /// checksum step may be skipped).
+    InvalidLength(usize),
+    /// Extended Key version byte(s) were not recognized.
+    InvalidExtendedKeyVersion([u8; 4]),
+    /// Address version byte were not recognized.
+    InvalidAddressVersion(u8),
+    /// Checked data was less than 4 bytes.
+    TooShort(usize),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            BadByte(b) => write!(f, "invalid base58 character {:#x}", b),
+            BadChecksum(exp, actual) =>
+                write!(f, "base58ck checksum {:#x} does not match expected {:#x}", actual, exp),
+            InvalidLength(ell) => write!(f, "length {} invalid for this base58 type", ell),
+            InvalidExtendedKeyVersion(ref v) =>
+                write!(f, "extended key version {:#04x?} is invalid for this base58 type", v),
+            InvalidAddressVersion(ref v) =>
+                write!(f, "address version {} is invalid for this base58 type", v),
+            TooShort(_) => write!(f, "base58ck data not even long enough for a checksum"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match self {
+            BadByte(_)
+            | BadChecksum(_, _)
+            | InvalidLength(_)
+            | InvalidExtendedKeyVersion(_)
+            | InvalidAddressVersion(_)
+            | TooShort(_) => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use hex::test_hex_unwrap as hex;
+
+    use super::*;
+
+    #[test]
+    fn test_base58_encode() {
+        // Basics
+        assert_eq!(&encode(&[0][..]), "1");
+        assert_eq!(&encode(&[1][..]), "2");
+        assert_eq!(&encode(&[58][..]), "21");
+        assert_eq!(&encode(&[13, 36][..]), "211");
+
+        // Leading zeroes
+        assert_eq!(&encode(&[0, 13, 36][..]), "1211");
+        assert_eq!(&encode(&[0, 0, 0, 0, 13, 36][..]), "1111211");
+
+        // Long input (>100 bytes => has to use heap)
+        let res = encode(
+            "BitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBit\
+        coinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoinBitcoin"
+                .as_bytes(),
+        );
+        let exp =
+            "ZqC5ZdfpZRi7fjA8hbhX5pEE96MdH9hEaC1YouxscPtbJF16qVWksHWR4wwvx7MotFcs2ChbJqK8KJ9X\
+        wZznwWn1JFDhhTmGo9v6GjAVikzCsBWZehu7bm22xL8b5zBR5AsBygYRwbFJsNwNkjpyFuDKwmsUTKvkULCvucPJrN5\
+        QUdxpGakhqkZFL7RU4yT";
+        assert_eq!(&res, exp);
+
+        // Addresses
+        let addr = hex!("00f8917303bfa8ef24f292e8fa1419b20460ba064d");
+        assert_eq!(&encode_check(&addr[..]), "1PfJpZsjreyVrqeoAfabrRwwjQyoSQMmHH");
+    }
+
+    #[test]
+    fn test_base58_decode() {
+        // Basics
+        assert_eq!(decode("1").ok(), Some(vec![0u8]));
+        assert_eq!(decode("2").ok(), Some(vec![1u8]));
+        assert_eq!(decode("21").ok(), Some(vec![58u8]));
+        assert_eq!(decode("211").ok(), Some(vec![13u8, 36]));
+
+        // Leading zeroes
+        assert_eq!(decode("1211").ok(), Some(vec![0u8, 13, 36]));
+        assert_eq!(decode("111211").ok(), Some(vec![0u8, 0, 0, 13, 36]));
+
+        // Addresses
+        assert_eq!(
+            decode_check("1PfJpZsjreyVrqeoAfabrRwwjQyoSQMmHH").ok(),
+            Some(hex!("00f8917303bfa8ef24f292e8fa1419b20460ba064d"))
+        );
+        // Non Base58 char.
+        assert_eq!(decode("¢").unwrap_err(), Error::BadByte(194));
+    }
+
+    #[test]
+    fn test_base58_roundtrip() {
+        let s = "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs";
+        let v: Vec<u8> = decode_check(s).unwrap();
+        assert_eq!(encode_check(&v[..]), s);
+        assert_eq!(decode_check(&encode_check(&v[..])).ok(), Some(v));
+
+        // Check that empty slice passes roundtrip.
+        assert_eq!(decode_check(&encode_check(&[])), Ok(vec![]));
+        // Check that `len > 4` is enforced.
+        assert_eq!(decode_check(&encode(&[1, 2, 3])), Err(Error::TooShort(3)));
+    }
+}
diff --git a/tapyrus/src/bip152.rs b/tapyrus/src/bip152.rs
new file mode 100644
index 00000000..b6574aba
--- /dev/null
+++ b/tapyrus/src/bip152.rs
@@ -0,0 +1,499 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! BIP152 Compact Blocks
+//!
+//! Implementation of compact blocks data structure and algorithms.
+//!
+
+use core::convert::{TryFrom, TryInto};
+use core::{convert, fmt, mem};
+#[cfg(feature = "std")]
+use std::error;
+
+use hashes::{sha256, siphash24, Hash};
+use internals::impl_array_newtype;
+
+use crate::consensus::encode::{self, Decodable, Encodable, VarInt};
+use crate::internal_macros::{impl_bytes_newtype, impl_consensus_encoding};
+use crate::prelude::*;
+use crate::{block, io, Block, BlockHash, Transaction};
+
+/// A BIP-152 error
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// An unknown version number was used.
+    UnknownVersion,
+    /// The prefill slice provided was invalid.
+    InvalidPrefill,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Error::UnknownVersion => write!(f, "an unknown version number was used"),
+            Error::InvalidPrefill => write!(f, "the prefill slice provided was invalid"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use self::Error::*;
+
+        match *self {
+            UnknownVersion | InvalidPrefill => None,
+        }
+    }
+}
+
+/// A [PrefilledTransaction] structure is used in [HeaderAndShortIds] to
+/// provide a list of a few transactions explicitly.
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct PrefilledTransaction {
+    /// The index of the transaction in the block.
+    ///
+    /// This field is differentially encoded relative to the previous
+    /// prefilled transaction as described as follows:
+    ///
+    /// > Several uses of CompactSize below are "differentially encoded". For
+    /// > these, instead of using raw indexes, the number encoded is the
+    /// > difference between the current index and the previous index, minus one.
+    /// > For example, a first index of 0 implies a real index of 0, a second
+    /// > index of 0 thereafter refers to a real index of 1, etc.
+    pub idx: u16,
+    /// The actual transaction.
+    pub tx: Transaction,
+}
+
+impl convert::AsRef<Transaction> for PrefilledTransaction {
+    fn as_ref(&self) -> &Transaction { &self.tx }
+}
+
+impl Encodable for PrefilledTransaction {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        Ok(VarInt::from(self.idx).consensus_encode(w)? + self.tx.consensus_encode(w)?)
+    }
+}
+
+impl Decodable for PrefilledTransaction {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let idx = VarInt::consensus_decode(r)?.0;
+        let idx = u16::try_from(idx)
+            .map_err(|_| encode::Error::ParseFailed("BIP152 prefilled tx index out of bounds"))?;
+        let tx = Transaction::consensus_decode(r)?;
+        Ok(PrefilledTransaction { idx, tx })
+    }
+}
+
+/// Short transaction IDs are used to represent a transaction without sending a full 256-bit hash.
+#[derive(PartialEq, Eq, Clone, Copy, Hash, Default, PartialOrd, Ord)]
+pub struct ShortId([u8; 6]);
+impl_array_newtype!(ShortId, u8, 6);
+impl_bytes_newtype!(ShortId, 6);
+
+impl ShortId {
+    /// Calculate the SipHash24 keys used to calculate short IDs.
+    pub fn calculate_siphash_keys(header: &block::Header, nonce: u64) -> (u64, u64) {
+        // 1. single-SHA256 hashing the block header with the nonce appended (in little-endian)
+        let h = {
+            let mut engine = sha256::Hash::engine();
+            header.consensus_encode(&mut engine).expect("engines don't error");
+            nonce.consensus_encode(&mut engine).expect("engines don't error");
+            sha256::Hash::from_engine(engine)
+        };
+
+        // 2. Running SipHash-2-4 with the input being the transaction ID and the keys (k0/k1)
+        // set to the first two little-endian 64-bit integers from the above hash, respectively.
+        (
+            u64::from_le_bytes(h[0..8].try_into().expect("8 byte slice")),
+            u64::from_le_bytes(h[8..16].try_into().expect("8 byte slice")),
+        )
+    }
+
+    /// Calculate the short ID with the given (w)txid and using the provided SipHash keys.
+    pub fn with_siphash_keys<T: AsRef<[u8]>>(txid: &T, siphash_keys: (u64, u64)) -> ShortId {
+        // 2. Running SipHash-2-4 with the input being the transaction ID and the keys (k0/k1)
+        // set to the first two little-endian 64-bit integers from the above hash, respectively.
+        let hash = siphash24::Hash::hash_with_keys(siphash_keys.0, siphash_keys.1, txid.as_ref());
+
+        // 3. Dropping the 2 most significant bytes from the SipHash output to make it 6 bytes.
+        let mut id = ShortId([0; 6]);
+        id.0.copy_from_slice(&hash[0..6]);
+        id
+    }
+}
+
+impl Encodable for ShortId {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(w)
+    }
+}
+
+impl Decodable for ShortId {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<ShortId, encode::Error> {
+        Ok(ShortId(Decodable::consensus_decode(r)?))
+    }
+}
+
+/// A [HeaderAndShortIds] structure is used to relay a block header, the short
+/// transactions IDs used for matching already-available transactions, and a
+/// select few transactions which we expect a peer may be missing.
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct HeaderAndShortIds {
+    /// The header of the block being provided.
+    pub header: block::Header,
+    ///  A nonce for use in short transaction ID calculations.
+    pub nonce: u64,
+    ///  The short transaction IDs calculated from the transactions
+    ///  which were not provided explicitly in prefilled_txs.
+    pub short_ids: Vec<ShortId>,
+    ///  Used to provide the coinbase transaction and a select few
+    ///  which we expect a peer may be missing.
+    pub prefilled_txs: Vec<PrefilledTransaction>,
+}
+impl_consensus_encoding!(HeaderAndShortIds, header, nonce, short_ids, prefilled_txs);
+
+impl HeaderAndShortIds {
+    /// Create a new [HeaderAndShortIds] from a full block.
+    ///
+    /// The version number must be either 1 or 2.
+    ///
+    /// The `prefill` slice indicates which transactions should be prefilled in
+    /// the block. It should contain the indexes in the block of the txs to
+    /// prefill. It must be ordered. 0 should not be included as the
+    /// coinbase tx is always prefilled.
+    ///
+    /// > Nodes SHOULD NOT use the same nonce across multiple different blocks.
+    pub fn from_block(
+        block: &Block,
+        nonce: u64,
+        version: u32,
+        mut prefill: &[usize],
+    ) -> Result<HeaderAndShortIds, Error> {
+        if version != 1 && version != 2 {
+            return Err(Error::UnknownVersion);
+        }
+
+        let siphash_keys = ShortId::calculate_siphash_keys(&block.header, nonce);
+
+        let mut prefilled = Vec::with_capacity(prefill.len() + 1); // +1 for coinbase tx
+        let mut short_ids = Vec::with_capacity(block.txdata.len() - prefill.len());
+        let mut last_prefill = 0;
+        for (idx, tx) in block.txdata.iter().enumerate() {
+            // Check if we should prefill this tx.
+            let prefill_tx = if prefill.first() == Some(&idx) {
+                prefill = &prefill[1..];
+                true
+            } else {
+                idx == 0 // Always prefill coinbase.
+            };
+
+            if prefill_tx {
+                let diff_idx = idx - last_prefill;
+                last_prefill = idx + 1;
+                prefilled.push(PrefilledTransaction {
+                    idx: diff_idx as u16,
+                    tx: match version {
+                        // >  As encoded in "tx" messages sent in response to getdata MSG_TX
+                        1 => {
+                            // strip witness for version 1
+                            let mut no_witness = tx.clone();
+                            no_witness.input.iter_mut().for_each(|i| i.witness.clear());
+                            no_witness
+                        }
+                        // > Transactions inside cmpctblock messages (both those used as direct
+                        // > announcement and those in response to getdata) and in blocktxn should
+                        // > include witness data, using the same format as responses to getdata
+                        // > MSG_WITNESS_TX, specified in BIP144.
+                        2 => tx.clone(),
+                        _ => unreachable!(),
+                    },
+                });
+            } else {
+                short_ids.push(ShortId::with_siphash_keys(
+                    &match version {
+                        1 => tx.txid().to_raw_hash(),
+                        2 => tx.wtxid().to_raw_hash(),
+                        _ => unreachable!(),
+                    },
+                    siphash_keys,
+                ));
+            }
+        }
+
+        if !prefill.is_empty() {
+            return Err(Error::InvalidPrefill);
+        }
+
+        Ok(HeaderAndShortIds {
+            header: block.header.clone(),
+            nonce,
+            // Provide coinbase prefilled.
+            prefilled_txs: prefilled,
+            short_ids,
+        })
+    }
+}
+
+/// A [BlockTransactionsRequest] structure is used to list transaction indexes
+/// in a block being requested.
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct BlockTransactionsRequest {
+    ///  The blockhash of the block which the transactions being requested are in.
+    pub block_hash: BlockHash,
+    ///  The indexes of the transactions being requested in the block.
+    ///
+    ///  Warning: Encoding panics with [`u64::MAX`] values. See [`BlockTransactionsRequest::consensus_encode()`]
+    pub indexes: Vec<u64>,
+}
+
+impl Encodable for BlockTransactionsRequest {
+    /// # Panics
+    ///
+    /// Panics if the index overflows [`u64::MAX`]. This happens when [`BlockTransactionsRequest::indexes`]
+    /// contains an entry with the value [`u64::MAX`] as `u64` overflows during differential encoding.
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = self.block_hash.consensus_encode(w)?;
+        // Manually encode indexes because they are differentially encoded VarInts.
+        len += VarInt(self.indexes.len() as u64).consensus_encode(w)?;
+        let mut last_idx = 0;
+        for idx in &self.indexes {
+            len += VarInt(*idx - last_idx).consensus_encode(w)?;
+            last_idx = *idx + 1; // can panic here
+        }
+        Ok(len)
+    }
+}
+
+impl Decodable for BlockTransactionsRequest {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(BlockTransactionsRequest {
+            block_hash: BlockHash::consensus_decode(r)?,
+            indexes: {
+                // Manually decode indexes because they are differentially encoded VarInts.
+                let nb_indexes = VarInt::consensus_decode(r)?.0 as usize;
+
+                // Since the number of indices ultimately represent transactions,
+                // we can limit the number of indices to the maximum number of
+                // transactions that would be allowed in a vector.
+                let byte_size = (nb_indexes)
+                    .checked_mul(mem::size_of::<Transaction>())
+                    .ok_or(encode::Error::ParseFailed("Invalid length"))?;
+                if byte_size > encode::MAX_VEC_SIZE {
+                    return Err(encode::Error::OversizedVectorAllocation {
+                        requested: byte_size,
+                        max: encode::MAX_VEC_SIZE,
+                    });
+                }
+
+                let mut indexes = Vec::with_capacity(nb_indexes);
+                let mut last_index: u64 = 0;
+                for _ in 0..nb_indexes {
+                    let differential: VarInt = Decodable::consensus_decode(r)?;
+                    last_index = match last_index.checked_add(differential.0) {
+                        Some(i) => i,
+                        None => return Err(encode::Error::ParseFailed("block index overflow")),
+                    };
+                    indexes.push(last_index);
+                    last_index = match last_index.checked_add(1) {
+                        Some(i) => i,
+                        None => return Err(encode::Error::ParseFailed("block index overflow")),
+                    };
+                }
+                indexes
+            },
+        })
+    }
+}
+
+/// A transaction index is requested that is out of range from the
+/// corresponding block.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct TxIndexOutOfRangeError(u64);
+
+impl fmt::Display for TxIndexOutOfRangeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "a transaction index is requested that is \
+            out of range from the corresponding block: {}",
+            self.0,
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl error::Error for TxIndexOutOfRangeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// A [BlockTransactions] structure is used to provide some of the transactions
+/// in a block, as requested.
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct BlockTransactions {
+    ///  The blockhash of the block which the transactions being provided are in.
+    pub block_hash: BlockHash,
+    ///  The transactions provided.
+    pub transactions: Vec<Transaction>,
+}
+impl_consensus_encoding!(BlockTransactions, block_hash, transactions);
+
+impl BlockTransactions {
+    /// Construct a [BlockTransactions] from a [BlockTransactionsRequest] and
+    /// the corresponsing full [Block] by providing all requested transactions.
+    pub fn from_request(
+        request: &BlockTransactionsRequest,
+        block: &Block,
+    ) -> Result<BlockTransactions, TxIndexOutOfRangeError> {
+        Ok(BlockTransactions {
+            block_hash: request.block_hash,
+            transactions: {
+                let mut txs = Vec::with_capacity(request.indexes.len());
+                for idx in &request.indexes {
+                    if *idx >= block.txdata.len() as u64 {
+                        return Err(TxIndexOutOfRangeError(*idx));
+                    }
+                    txs.push(block.txdata[*idx as usize].clone());
+                }
+                txs
+            },
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use hex::FromHex;
+
+    use super::*;
+    use crate::blockdata::locktime::absolute;
+    use crate::blockdata::transaction;
+    use crate::consensus::encode::{deserialize, serialize};
+    use crate::crypto::key::PublicKey;
+    use crate::crypto::schnorr::Signature;
+    use crate::hash_types::TxMerkleNode;
+    use crate::{Amount, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut, MalFixTxid, Witness};
+
+    fn dummy_tx(nonce: &[u8]) -> Transaction {
+        Transaction {
+            version: transaction::Version::ONE,
+            lock_time: absolute::LockTime::from_consensus(2),
+            input: vec![TxIn {
+                previous_output: OutPoint::new(MalFixTxid::hash(nonce), 0),
+                script_sig: ScriptBuf::new(),
+                sequence: Sequence(1),
+                witness: Witness::new(),
+            }],
+            output: vec![TxOut { value: Amount::ONE_TAP, script_pubkey: ScriptBuf::new() }],
+        }
+    }
+
+    fn dummy_block() -> Block {
+        Block {
+            header: block::Header {
+                version: block::Version::ONE,
+                prev_blockhash: BlockHash::hash(&[0]),
+                merkle_root: TxMerkleNode::hash(&[1]),
+                im_merkle_root: TxMerkleNode::hash(&[1]),
+                time: 2,
+                xfield: block::XField::AggregatePublicKey(PublicKey::generator()),
+                proof: Some(Signature::default()),
+            },
+            txdata: vec![dummy_tx(&[2]), dummy_tx(&[3]), dummy_tx(&[4])],
+        }
+    }
+
+    #[test]
+    fn test_header_and_short_ids_from_block() {
+        let block = dummy_block();
+
+        let compact = HeaderAndShortIds::from_block(&block, 42, 2, &[]).unwrap();
+        assert_eq!(compact.nonce, 42);
+        assert_eq!(compact.short_ids.len(), 2);
+        assert_eq!(compact.prefilled_txs.len(), 1);
+        assert_eq!(compact.prefilled_txs[0].idx, 0);
+        assert_eq!(&compact.prefilled_txs[0].tx, &block.txdata[0]);
+
+        let compact = HeaderAndShortIds::from_block(&block, 42, 2, &[0, 1, 2]).unwrap();
+        let idxs = compact.prefilled_txs.iter().map(|t| t.idx).collect::<Vec<_>>();
+        assert_eq!(idxs, vec![0, 0, 0]);
+
+        let compact = HeaderAndShortIds::from_block(&block, 42, 2, &[2]).unwrap();
+        let idxs = compact.prefilled_txs.iter().map(|t| t.idx).collect::<Vec<_>>();
+        assert_eq!(idxs, vec![0, 1]);
+    }
+
+    #[test]
+    #[ignore]
+    fn test_compact_block_vector() {
+        // Tested with Elements implementation of compact blocks.
+        let raw_block = Vec::<u8>::from_hex("000000206c750a364035aefd5f81508a08769975116d9195312ee4520dceac39e1fdc62c4dc67473b8e354358c1e610afeaff7410858bd45df43e2940f8a62bd3d5e3ac943c2975cffff7f200000000002020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016b0101ffffffff020006062a0100000001510000000000000000266a24aa21a9ed4a3d9f3343dafcc0d6f6d4310f2ee5ce273ed34edca6c75db3a73e7f368734200120000000000000000000000000000000000000000000000000000000000000000000000000020000000001021fc20ba2bd745507b8e00679e3b362558f9457db374ca28ffa5243f4c23a4d5f00000000171600147c9dea14ffbcaec4b575e03f05ceb7a81cd3fcbffdffffff915d689be87b43337f42e26033df59807b768223368f189a023d0242d837768900000000171600147c9dea14ffbcaec4b575e03f05ceb7a81cd3fcbffdffffff0200cdf5050000000017a9146803c72d9154a6a20f404bed6d3dcee07986235a8700e1f5050000000017a9144e6a4c7cb5b5562904843bdf816342f4db9f5797870247304402205e9bf6e70eb0e4b495bf483fd8e6e02da64900f290ef8aaa64bb32600d973c450220670896f5d0e5f33473e5f399ab680cc1d25c2d2afd15abd722f04978f28be887012103e4e4d9312b2261af508b367d8ba9be4f01b61d6d6e78bec499845b4f410bcf2702473044022045ac80596a6ac9c8c572f94708709adaf106677221122e08daf8b9741a04f66a022003ccd52a3b78f8fd08058fc04fc0cffa5f4c196c84eae9e37e2a85babe731b57012103e4e4d9312b2261af508b367d8ba9be4f01b61d6d6e78bec499845b4f410bcf276a000000").unwrap();
+        let raw_compact = Vec::<u8>::from_hex("000000206c750a364035aefd5f81508a08769975116d9195312ee4520dceac39e1fdc62c4dc67473b8e354358c1e610afeaff7410858bd45df43e2940f8a62bd3d5e3ac943c2975cffff7f2000000000a4df3c3744da89fa010a6979e971450100020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04016b0101ffffffff020006062a0100000001510000000000000000266a24aa21a9ed4a3d9f3343dafcc0d6f6d4310f2ee5ce273ed34edca6c75db3a73e7f368734200120000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
+
+        let block: Block = deserialize(&raw_block).unwrap();
+        let nonce = 18053200567810711460;
+        let compact = HeaderAndShortIds::from_block(&block, nonce, 2, &[]).unwrap();
+        let compact_expected = deserialize(&raw_compact).unwrap();
+
+        assert_eq!(compact, compact_expected);
+    }
+
+    #[test]
+    fn test_getblocktx_differential_encoding_de_and_serialization() {
+        let testcases = vec![
+            // differentially encoded VarInts, indicies
+            (vec![4, 0, 5, 1, 10], vec![0, 6, 8, 19]),
+            (vec![1, 0], vec![0]),
+            (vec![5, 0, 0, 0, 0, 0], vec![0, 1, 2, 3, 4]),
+            (vec![3, 1, 1, 1], vec![1, 3, 5]),
+            (vec![3, 0, 0, 253, 0, 1], vec![0, 1, 258]), // .., 253, 0, 1] == VarInt(256)
+        ];
+        let deser_errorcases = vec![
+            vec![2, 255, 254, 255, 255, 255, 255, 255, 255, 255, 0], // .., 255, 254, .., 255] == VarInt(u64::MAX-1)
+            vec![1, 255, 255, 255, 255, 255, 255, 255, 255, 255], // .., 255, 255, .., 255] == VarInt(u64::MAX)
+        ];
+        for testcase in testcases {
+            {
+                // test deserialization
+                let mut raw: Vec<u8> = [0u8; 32].to_vec();
+                raw.extend(testcase.0.clone());
+                let btr: BlockTransactionsRequest = deserialize(&raw.to_vec()).unwrap();
+                assert_eq!(testcase.1, btr.indexes);
+            }
+            {
+                // test serialization
+                let raw: Vec<u8> = serialize(&BlockTransactionsRequest {
+                    block_hash: Hash::all_zeros(),
+                    indexes: testcase.1,
+                });
+                let mut expected_raw: Vec<u8> = [0u8; 32].to_vec();
+                expected_raw.extend(testcase.0);
+                assert_eq!(expected_raw, raw);
+            }
+        }
+        for errorcase in deser_errorcases {
+            {
+                // test that we return Err() if deserialization fails (and don't panic)
+                let mut raw: Vec<u8> = [0u8; 32].to_vec();
+                raw.extend(errorcase);
+                assert!(deserialize::<BlockTransactionsRequest>(&raw.to_vec()).is_err());
+            }
+        }
+    }
+
+    #[test]
+    #[should_panic] // 'attempt to add with overflow' in consensus_encode()
+    fn test_getblocktx_panic_when_encoding_u64_max() {
+        serialize(&BlockTransactionsRequest {
+            block_hash: Hash::all_zeros(),
+            indexes: vec![u64::MAX],
+        });
+    }
+}
diff --git a/tapyrus/src/bip158.rs b/tapyrus/src/bip158.rs
new file mode 100644
index 00000000..6835e82a
--- /dev/null
+++ b/tapyrus/src/bip158.rs
@@ -0,0 +1,736 @@
+// SPDX-License-Identifier: CC0-1.0
+
+// This module was largely copied from https://github.com/rust-bitcoin/murmel/blob/master/src/blockfilter.rs
+// on 11. June 2019 which is licensed under Apache, that file specifically
+// was written entirely by Tamas Blummer, who is re-licensing its contents here as CC0.
+
+//! BIP 158 Compact Block Filters for Light Clients.
+//!
+//! This module implements a structure for compact filters on block data, for
+//! use in the BIP 157 light client protocol. The filter construction proposed
+//! is an alternative to Bloom filters, as used in BIP 37, that minimizes filter
+//! size by using Golomb-Rice coding for compression.
+//!
+//! ### Relevant BIPS
+//!
+//! * [BIP 157 - Client Side Block Filtering](https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki)
+//! * [BIP 158 - Compact Block Filters for Light Clients](https://github.com/bitcoin/bips/blob/master/bip-0158.mediawiki)
+//!
+//! # Examples
+//!
+//! ```ignore
+//! fn get_script_for_coin(coin: &OutPoint) -> Result<ScriptBuf, BlockFilterError> {
+//!   // get utxo ...
+//! }
+//!
+//! // create a block filter for a block (server side)
+//! let filter = BlockFilter::new_script_filter(&block, get_script_for_coin)?;
+//!
+//! // or create a filter from known raw data
+//! let filter = BlockFilter::new(content);
+//!
+//! // read and evaluate a filter
+//!
+//! let query: Iterator<Item=ScriptBuf> = // .. some scripts you care about
+//! if filter.match_any(&block_hash, &mut query.map(|s| s.as_bytes())) {
+//!   // get this block
+//! }
+//!  ```
+//!
+
+use core::cmp::{self, Ordering};
+use core::convert::TryInto;
+use core::fmt::{self, Display, Formatter};
+
+use hashes::{siphash24, Hash};
+use internals::write_err;
+
+use crate::blockdata::block::Block;
+use crate::blockdata::script::Script;
+use crate::blockdata::transaction::OutPoint;
+use crate::consensus::encode::VarInt;
+use crate::consensus::{Decodable, Encodable};
+use crate::hash_types::{BlockHash, FilterHash, FilterHeader};
+use crate::io;
+use crate::prelude::*;
+
+/// Golomb encoding parameter as in BIP-158, see also https://gist.github.com/sipa/576d5f09c3b86c3b1b75598d799fc845
+const P: u8 = 19;
+const M: u64 = 784931;
+
+/// Errors for blockfilter.
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum Error {
+    /// Missing UTXO, cannot calculate script filter.
+    UtxoMissing(OutPoint),
+    /// IO error reading or writing binary serialization of the filter.
+    Io(io::Error),
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
+        use Error::*;
+
+        match *self {
+            UtxoMissing(ref coin) => write!(f, "unresolved UTXO {}", coin),
+            Io(ref e) => write_err!(f, "IO error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            UtxoMissing(_) => None,
+            Io(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(io: io::Error) -> Self { Error::Io(io) }
+}
+
+/// A block filter, as described by BIP 158.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockFilter {
+    /// Golomb encoded filter
+    pub content: Vec<u8>,
+}
+
+impl FilterHash {
+    /// Computes the filter header from a filter hash and previous filter header.
+    pub fn filter_header(&self, previous_filter_header: &FilterHeader) -> FilterHeader {
+        let mut header_data = [0u8; 64];
+        header_data[0..32].copy_from_slice(&self[..]);
+        header_data[32..64].copy_from_slice(&previous_filter_header[..]);
+        FilterHeader::hash(&header_data)
+    }
+}
+
+impl BlockFilter {
+    /// Creates a new filter from pre-computed data.
+    pub fn new(content: &[u8]) -> BlockFilter { BlockFilter { content: content.to_vec() } }
+
+    /// Computes a SCRIPT_FILTER that contains spent and output scripts.
+    pub fn new_script_filter<M, S>(block: &Block, script_for_coin: M) -> Result<BlockFilter, Error>
+    where
+        M: Fn(&OutPoint) -> Result<S, Error>,
+        S: Borrow<Script>,
+    {
+        let mut out = Vec::new();
+        let mut writer = BlockFilterWriter::new(&mut out, block);
+
+        writer.add_output_scripts();
+        writer.add_input_scripts(script_for_coin)?;
+        writer.finish()?;
+
+        Ok(BlockFilter { content: out })
+    }
+
+    /// Computes this filter's ID in a chain of filters (see [BIP 157]).
+    ///
+    /// [BIP 157]: <https://github.com/bitcoin/bips/blob/master/bip-0157.mediawiki#Filter_Headers>
+    pub fn filter_header(&self, previous_filter_header: &FilterHeader) -> FilterHeader {
+        let filter_hash = FilterHash::hash(self.content.as_slice());
+        filter_hash.filter_header(previous_filter_header)
+    }
+
+    /// Returns true if any query matches against this [`BlockFilter`].
+    pub fn match_any<I>(&self, block_hash: &BlockHash, query: I) -> Result<bool, Error>
+    where
+        I: Iterator,
+        I::Item: Borrow<[u8]>,
+    {
+        let filter_reader = BlockFilterReader::new(block_hash);
+        filter_reader.match_any(&mut self.content.as_slice(), query)
+    }
+
+    /// Returns true if all queries match against this [`BlockFilter`].
+    pub fn match_all<I>(&self, block_hash: &BlockHash, query: I) -> Result<bool, Error>
+    where
+        I: Iterator,
+        I::Item: Borrow<[u8]>,
+    {
+        let filter_reader = BlockFilterReader::new(block_hash);
+        filter_reader.match_all(&mut self.content.as_slice(), query)
+    }
+}
+
+/// Compiles and writes a block filter.
+pub struct BlockFilterWriter<'a, W> {
+    block: &'a Block,
+    writer: GcsFilterWriter<'a, W>,
+}
+
+impl<'a, W: io::Write> BlockFilterWriter<'a, W> {
+    /// Creates a new [`BlockFilterWriter`] from `block`.
+    pub fn new(writer: &'a mut W, block: &'a Block) -> BlockFilterWriter<'a, W> {
+        let block_hash_as_int = block.block_hash().to_byte_array();
+        let k0 = u64::from_le_bytes(block_hash_as_int[0..8].try_into().expect("8 byte slice"));
+        let k1 = u64::from_le_bytes(block_hash_as_int[8..16].try_into().expect("8 byte slice"));
+        let writer = GcsFilterWriter::new(writer, k0, k1, M, P);
+        BlockFilterWriter { block, writer }
+    }
+
+    /// Adds output scripts of the block to filter (excluding OP_RETURN scripts).
+    pub fn add_output_scripts(&mut self) {
+        for transaction in &self.block.txdata {
+            for output in &transaction.output {
+                if !output.script_pubkey.is_op_return() {
+                    self.add_element(output.script_pubkey.as_bytes());
+                }
+            }
+        }
+    }
+
+    /// Adds consumed output scripts of a block to filter.
+    pub fn add_input_scripts<M, S>(&mut self, script_for_coin: M) -> Result<(), Error>
+    where
+        M: Fn(&OutPoint) -> Result<S, Error>,
+        S: Borrow<Script>,
+    {
+        for script in self
+            .block
+            .txdata
+            .iter()
+            .skip(1) // skip coinbase
+            .flat_map(|t| t.input.iter().map(|i| &i.previous_output))
+            .map(script_for_coin)
+        {
+            match script {
+                Ok(script) => self.add_element(script.borrow().as_bytes()),
+                Err(e) => return Err(e),
+            }
+        }
+        Ok(())
+    }
+
+    /// Adds an arbitrary element to filter.
+    pub fn add_element(&mut self, data: &[u8]) { self.writer.add_element(data); }
+
+    /// Writes the block filter.
+    pub fn finish(&mut self) -> Result<usize, io::Error> { self.writer.finish() }
+}
+
+/// Reads and interprets a block filter.
+pub struct BlockFilterReader {
+    reader: GcsFilterReader,
+}
+
+impl BlockFilterReader {
+    /// Creates a new [`BlockFilterReader`] from `block_hash`.
+    pub fn new(block_hash: &BlockHash) -> BlockFilterReader {
+        let block_hash_as_int = block_hash.to_byte_array();
+        let k0 = u64::from_le_bytes(block_hash_as_int[0..8].try_into().expect("8 byte slice"));
+        let k1 = u64::from_le_bytes(block_hash_as_int[8..16].try_into().expect("8 byte slice"));
+        BlockFilterReader { reader: GcsFilterReader::new(k0, k1, M, P) }
+    }
+
+    /// Returns true if any query matches against this [`BlockFilterReader`].
+    pub fn match_any<I, R>(&self, reader: &mut R, query: I) -> Result<bool, Error>
+    where
+        I: Iterator,
+        I::Item: Borrow<[u8]>,
+        R: io::Read + ?Sized,
+    {
+        self.reader.match_any(reader, query)
+    }
+
+    /// Returns true if all queries match against this [`BlockFilterReader`].
+    pub fn match_all<I, R>(&self, reader: &mut R, query: I) -> Result<bool, Error>
+    where
+        I: Iterator,
+        I::Item: Borrow<[u8]>,
+        R: io::Read + ?Sized,
+    {
+        self.reader.match_all(reader, query)
+    }
+}
+
+/// Golomb-Rice encoded filter reader.
+pub struct GcsFilterReader {
+    filter: GcsFilter,
+    m: u64,
+}
+
+impl GcsFilterReader {
+    /// Creates a new [`GcsFilterReader`] with specific seed to siphash.
+    pub fn new(k0: u64, k1: u64, m: u64, p: u8) -> GcsFilterReader {
+        GcsFilterReader { filter: GcsFilter::new(k0, k1, p), m }
+    }
+
+    /// Returns true if any query matches against this [`GcsFilterReader`].
+    pub fn match_any<I, R>(&self, reader: &mut R, query: I) -> Result<bool, Error>
+    where
+        I: Iterator,
+        I::Item: Borrow<[u8]>,
+        R: io::Read + ?Sized,
+    {
+        let mut decoder = reader;
+        let n_elements: VarInt = Decodable::consensus_decode(&mut decoder).unwrap_or(VarInt(0));
+        let reader = &mut decoder;
+        // map hashes to [0, n_elements << grp]
+        let nm = n_elements.0 * self.m;
+        let mut mapped =
+            query.map(|e| map_to_range(self.filter.hash(e.borrow()), nm)).collect::<Vec<_>>();
+        // sort
+        mapped.sort_unstable();
+        if mapped.is_empty() {
+            return Ok(true);
+        }
+        if n_elements.0 == 0 {
+            return Ok(false);
+        }
+
+        // find first match in two sorted arrays in one read pass
+        let mut reader = BitStreamReader::new(reader);
+        let mut data = self.filter.golomb_rice_decode(&mut reader)?;
+        let mut remaining = n_elements.0 - 1;
+        for p in mapped {
+            loop {
+                match data.cmp(&p) {
+                    Ordering::Equal => return Ok(true),
+                    Ordering::Less =>
+                        if remaining > 0 {
+                            data += self.filter.golomb_rice_decode(&mut reader)?;
+                            remaining -= 1;
+                        } else {
+                            return Ok(false);
+                        },
+                    Ordering::Greater => break,
+                }
+            }
+        }
+        Ok(false)
+    }
+
+    /// Returns true if all queries match against this [`GcsFilterReader`].
+    pub fn match_all<I, R>(&self, reader: &mut R, query: I) -> Result<bool, Error>
+    where
+        I: Iterator,
+        I::Item: Borrow<[u8]>,
+        R: io::Read + ?Sized,
+    {
+        let mut decoder = reader;
+        let n_elements: VarInt = Decodable::consensus_decode(&mut decoder).unwrap_or(VarInt(0));
+        let reader = &mut decoder;
+        // map hashes to [0, n_elements << grp]
+        let nm = n_elements.0 * self.m;
+        let mut mapped =
+            query.map(|e| map_to_range(self.filter.hash(e.borrow()), nm)).collect::<Vec<_>>();
+        // sort
+        mapped.sort_unstable();
+        mapped.dedup();
+        if mapped.is_empty() {
+            return Ok(true);
+        }
+        if n_elements.0 == 0 {
+            return Ok(false);
+        }
+
+        // figure if all mapped are there in one read pass
+        let mut reader = BitStreamReader::new(reader);
+        let mut data = self.filter.golomb_rice_decode(&mut reader)?;
+        let mut remaining = n_elements.0 - 1;
+        for p in mapped {
+            loop {
+                match data.cmp(&p) {
+                    Ordering::Equal => break,
+                    Ordering::Less =>
+                        if remaining > 0 {
+                            data += self.filter.golomb_rice_decode(&mut reader)?;
+                            remaining -= 1;
+                        } else {
+                            return Ok(false);
+                        },
+                    Ordering::Greater => return Ok(false),
+                }
+            }
+        }
+        Ok(true)
+    }
+}
+
+/// Fast reduction of hash to [0, nm) range.
+fn map_to_range(hash: u64, nm: u64) -> u64 { ((hash as u128 * nm as u128) >> 64) as u64 }
+
+/// Golomb-Rice encoded filter writer.
+pub struct GcsFilterWriter<'a, W> {
+    filter: GcsFilter,
+    writer: &'a mut W,
+    elements: BTreeSet<Vec<u8>>,
+    m: u64,
+}
+
+impl<'a, W: io::Write> GcsFilterWriter<'a, W> {
+    /// Creates a new [`GcsFilterWriter`] wrapping a generic writer, with specific seed to siphash.
+    pub fn new(writer: &'a mut W, k0: u64, k1: u64, m: u64, p: u8) -> GcsFilterWriter<'a, W> {
+        GcsFilterWriter { filter: GcsFilter::new(k0, k1, p), writer, elements: BTreeSet::new(), m }
+    }
+
+    /// Adds data to the filter.
+    pub fn add_element(&mut self, element: &[u8]) {
+        if !element.is_empty() {
+            self.elements.insert(element.to_vec());
+        }
+    }
+
+    /// Writes the filter to the wrapped writer.
+    pub fn finish(&mut self) -> Result<usize, io::Error> {
+        let nm = self.elements.len() as u64 * self.m;
+
+        // map hashes to [0, n_elements * M)
+        let mut mapped: Vec<_> = self
+            .elements
+            .iter()
+            .map(|e| map_to_range(self.filter.hash(e.as_slice()), nm))
+            .collect();
+        mapped.sort_unstable();
+
+        // write number of elements as varint
+        let mut wrote = VarInt::from(mapped.len()).consensus_encode(&mut self.writer)?;
+
+        // write out deltas of sorted values into a Golonb-Rice coded bit stream
+        let mut writer = BitStreamWriter::new(self.writer);
+        let mut last = 0;
+        for data in mapped {
+            wrote += self.filter.golomb_rice_encode(&mut writer, data - last)?;
+            last = data;
+        }
+        wrote += writer.flush()?;
+        Ok(wrote)
+    }
+}
+
+/// Golomb Coded Set Filter.
+struct GcsFilter {
+    k0: u64, // sip hash key
+    k1: u64, // sip hash key
+    p: u8,
+}
+
+impl GcsFilter {
+    /// Creates a new [`GcsFilter`].
+    fn new(k0: u64, k1: u64, p: u8) -> GcsFilter { GcsFilter { k0, k1, p } }
+
+    /// Golomb-Rice encodes a number `n` to a bit stream (parameter 2^k).
+    fn golomb_rice_encode<W>(
+        &self,
+        writer: &mut BitStreamWriter<'_, W>,
+        n: u64,
+    ) -> Result<usize, io::Error>
+    where
+        W: io::Write,
+    {
+        let mut wrote = 0;
+        let mut q = n >> self.p;
+        while q > 0 {
+            let nbits = cmp::min(q, 64);
+            wrote += writer.write(!0u64, nbits as u8)?;
+            q -= nbits;
+        }
+        wrote += writer.write(0, 1)?;
+        wrote += writer.write(n, self.p)?;
+        Ok(wrote)
+    }
+
+    /// Golomb-Rice decodes a number from a bit stream (parameter 2^k).
+    fn golomb_rice_decode<R>(&self, reader: &mut BitStreamReader<R>) -> Result<u64, io::Error>
+    where
+        R: io::Read,
+    {
+        let mut q = 0u64;
+        while reader.read(1)? == 1 {
+            q += 1;
+        }
+        let r = reader.read(self.p)?;
+        Ok((q << self.p) + r)
+    }
+
+    /// Hashes an arbitrary slice with siphash using parameters of this filter.
+    fn hash(&self, element: &[u8]) -> u64 {
+        siphash24::Hash::hash_to_u64_with_keys(self.k0, self.k1, element)
+    }
+}
+
+/// Bitwise stream reader.
+pub struct BitStreamReader<'a, R> {
+    buffer: [u8; 1],
+    offset: u8,
+    reader: &'a mut R,
+}
+
+impl<'a, R: io::Read> BitStreamReader<'a, R> {
+    /// Creates a new [`BitStreamReader`] that reads bitwise from a given `reader`.
+    pub fn new(reader: &'a mut R) -> BitStreamReader<'a, R> {
+        BitStreamReader { buffer: [0u8], reader, offset: 8 }
+    }
+
+    /// Reads nbit bits, returning the bits in a `u64` starting with the rightmost bit.
+    ///
+    /// # Examples
+    /// ```
+    /// # use tapyrus::bip158::BitStreamReader;
+    /// # let data = vec![0xff];
+    /// # let mut input = data.as_slice();
+    /// let mut reader = BitStreamReader::new(&mut input); // input contains all 1's
+    /// let res = reader.read(1).expect("read failed");
+    /// assert_eq!(res, 1_u64);
+    /// ```
+    pub fn read(&mut self, mut nbits: u8) -> Result<u64, io::Error> {
+        if nbits > 64 {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "can not read more than 64 bits at once",
+            ));
+        }
+        let mut data = 0u64;
+        while nbits > 0 {
+            if self.offset == 8 {
+                self.reader.read_exact(&mut self.buffer)?;
+                self.offset = 0;
+            }
+            let bits = cmp::min(8 - self.offset, nbits);
+            data <<= bits;
+            data |= ((self.buffer[0] << self.offset) >> (8 - bits)) as u64;
+            self.offset += bits;
+            nbits -= bits;
+        }
+        Ok(data)
+    }
+}
+
+/// Bitwise stream writer.
+pub struct BitStreamWriter<'a, W> {
+    buffer: [u8; 1],
+    offset: u8,
+    writer: &'a mut W,
+}
+
+impl<'a, W: io::Write> BitStreamWriter<'a, W> {
+    /// Creates a new [`BitStreamWriter`] that writes bitwise to a given `writer`.
+    pub fn new(writer: &'a mut W) -> BitStreamWriter<'a, W> {
+        BitStreamWriter { buffer: [0u8], writer, offset: 0 }
+    }
+
+    /// Writes nbits bits from data.
+    pub fn write(&mut self, data: u64, mut nbits: u8) -> Result<usize, io::Error> {
+        if nbits > 64 {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "can not write more than 64 bits at once",
+            ));
+        }
+        let mut wrote = 0;
+        while nbits > 0 {
+            let bits = cmp::min(8 - self.offset, nbits);
+            self.buffer[0] |= ((data << (64 - nbits)) >> (64 - 8 + self.offset)) as u8;
+            self.offset += bits;
+            nbits -= bits;
+            if self.offset == 8 {
+                wrote += self.flush()?;
+            }
+        }
+        Ok(wrote)
+    }
+
+    /// flush bits not yet written.
+    pub fn flush(&mut self) -> Result<usize, io::Error> {
+        if self.offset > 0 {
+            self.writer.write_all(&self.buffer)?;
+            self.buffer[0] = 0u8;
+            self.offset = 0;
+            Ok(1)
+        } else {
+            Ok(0)
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::collections::HashMap;
+
+    use hex::test_hex_unwrap as hex;
+    use serde_json::Value;
+
+    use super::*;
+    use crate::consensus::encode::deserialize;
+    use crate::hash_types::BlockHash;
+    use crate::ScriptBuf;
+
+    #[test]
+    #[ignore]
+    fn test_blockfilters() {
+        // test vectors from: https://github.com/jimpo/bitcoin/blob/c7efb652f3543b001b4dd22186a354605b14f47e/src/test/data/blockfilters.json
+        let data = include_str!("../tests/data/blockfilters.json");
+
+        let testdata = serde_json::from_str::<Value>(data).unwrap().as_array().unwrap().clone();
+        for t in testdata.iter().skip(1) {
+            let block_hash = t.get(1).unwrap().as_str().unwrap().parse::<BlockHash>().unwrap();
+            let block: Block = deserialize(&hex!(t.get(2).unwrap().as_str().unwrap())).unwrap();
+            assert_eq!(block.block_hash(), block_hash);
+            let scripts = t.get(3).unwrap().as_array().unwrap();
+            let previous_filter_header =
+                t.get(4).unwrap().as_str().unwrap().parse::<FilterHeader>().unwrap();
+            let filter_content = hex!(t.get(5).unwrap().as_str().unwrap());
+            let filter_header =
+                t.get(6).unwrap().as_str().unwrap().parse::<FilterHeader>().unwrap();
+
+            let mut txmap = HashMap::new();
+            let mut si = scripts.iter();
+            for tx in block.txdata.iter().skip(1) {
+                for input in tx.input.iter() {
+                    txmap.insert(
+                        input.previous_output,
+                        ScriptBuf::from(hex!(si.next().unwrap().as_str().unwrap())),
+                    );
+                }
+            }
+
+            let filter = BlockFilter::new_script_filter(&block, |o| {
+                if let Some(s) = txmap.get(o) {
+                    Ok(s.clone())
+                } else {
+                    Err(Error::UtxoMissing(*o))
+                }
+            })
+            .unwrap();
+
+            let test_filter = BlockFilter::new(filter_content.as_slice());
+
+            assert_eq!(test_filter.content, filter.content);
+
+            let block_hash = &block.block_hash();
+            assert!(filter
+                .match_all(
+                    block_hash,
+                    &mut txmap.iter().filter_map(|(_, s)| if !s.is_empty() {
+                        Some(s.as_bytes())
+                    } else {
+                        None
+                    })
+                )
+                .unwrap());
+
+            for script in txmap.values() {
+                let query = [script];
+                if !script.is_empty() {
+                    assert!(filter
+                        .match_any(block_hash, &mut query.iter().map(|s| s.as_bytes()))
+                        .unwrap());
+                }
+            }
+
+            assert_eq!(filter_header, filter.filter_header(&previous_filter_header));
+        }
+    }
+
+    #[test]
+    fn test_filter() {
+        let mut patterns = BTreeSet::new();
+
+        patterns.insert(hex!("000000"));
+        patterns.insert(hex!("111111"));
+        patterns.insert(hex!("222222"));
+        patterns.insert(hex!("333333"));
+        patterns.insert(hex!("444444"));
+        patterns.insert(hex!("555555"));
+        patterns.insert(hex!("666666"));
+        patterns.insert(hex!("777777"));
+        patterns.insert(hex!("888888"));
+        patterns.insert(hex!("999999"));
+        patterns.insert(hex!("aaaaaa"));
+        patterns.insert(hex!("bbbbbb"));
+        patterns.insert(hex!("cccccc"));
+        patterns.insert(hex!("dddddd"));
+        patterns.insert(hex!("eeeeee"));
+        patterns.insert(hex!("ffffff"));
+
+        let mut out = Vec::new();
+        {
+            let mut writer = GcsFilterWriter::new(&mut out, 0, 0, M, P);
+            for p in &patterns {
+                writer.add_element(p.as_slice());
+            }
+            writer.finish().unwrap();
+        }
+
+        let bytes = out;
+
+        {
+            let query = [hex!("abcdef"), hex!("eeeeee")];
+            let reader = GcsFilterReader::new(0, 0, M, P);
+            assert!(reader
+                .match_any(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
+                .unwrap());
+        }
+        {
+            let query = [hex!("abcdef"), hex!("123456")];
+            let reader = GcsFilterReader::new(0, 0, M, P);
+            assert!(!reader
+                .match_any(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
+                .unwrap());
+        }
+        {
+            let reader = GcsFilterReader::new(0, 0, M, P);
+            let mut query = Vec::new();
+            for p in &patterns {
+                query.push(p.clone());
+            }
+            assert!(reader
+                .match_all(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
+                .unwrap());
+        }
+        {
+            let reader = GcsFilterReader::new(0, 0, M, P);
+            let mut query = Vec::new();
+            for p in &patterns {
+                query.push(p.clone());
+            }
+            query.push(hex!("abcdef"));
+            assert!(!reader
+                .match_all(&mut bytes.as_slice(), &mut query.iter().map(|v| v.as_slice()))
+                .unwrap());
+        }
+    }
+
+    #[test]
+    fn test_bit_stream() {
+        let mut out = Vec::new();
+        {
+            let mut writer = BitStreamWriter::new(&mut out);
+            writer.write(0, 1).unwrap(); // 0
+            writer.write(2, 2).unwrap(); // 10
+            writer.write(6, 3).unwrap(); // 110
+            writer.write(11, 4).unwrap(); // 1011
+            writer.write(1, 5).unwrap(); // 00001
+            writer.write(32, 6).unwrap(); // 100000
+            writer.write(7, 7).unwrap(); // 0000111
+            writer.flush().unwrap();
+        }
+        let bytes = out;
+        assert_eq!(
+            "01011010110000110000000001110000",
+            format!("{:08b}{:08b}{:08b}{:08b}", bytes[0], bytes[1], bytes[2], bytes[3])
+        );
+        {
+            let mut input = bytes.as_slice();
+            let mut reader = BitStreamReader::new(&mut input);
+            assert_eq!(reader.read(1).unwrap(), 0);
+            assert_eq!(reader.read(2).unwrap(), 2);
+            assert_eq!(reader.read(3).unwrap(), 6);
+            assert_eq!(reader.read(4).unwrap(), 11);
+            assert_eq!(reader.read(5).unwrap(), 1);
+            assert_eq!(reader.read(6).unwrap(), 32);
+            assert_eq!(reader.read(7).unwrap(), 7);
+            // 4 bits remained
+            assert!(reader.read(5).is_err());
+        }
+    }
+}
diff --git a/tapyrus/src/bip32.rs b/tapyrus/src/bip32.rs
new file mode 100644
index 00000000..69b0d5e0
--- /dev/null
+++ b/tapyrus/src/bip32.rs
@@ -0,0 +1,1233 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! BIP32 implementation.
+//!
+//! Implementation of BIP32 hierarchical deterministic wallets, as defined
+//! at <https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki>.
+//!
+
+#![allow(deprecated)] // Remove once we remove XpubIdentifier.
+
+use core::convert::TryInto;
+use core::default::Default;
+use core::ops::Index;
+use core::str::FromStr;
+use core::{fmt, slice};
+
+use hashes::{hash160, hash_newtype, sha512, Hash, HashEngine, Hmac, HmacEngine};
+use internals::{impl_array_newtype, write_err};
+use secp256k1::{self, Secp256k1, XOnlyPublicKey};
+#[cfg(feature = "serde")]
+use serde;
+
+use crate::base58;
+use crate::crypto::key::{self, Keypair, PrivateKey, PublicKey};
+use crate::internal_macros::impl_bytes_newtype;
+use crate::io::Write;
+use crate::network::Network;
+use crate::prelude::*;
+
+/// Version bytes for extended public keys on the Tapyrus network.
+const VERSION_BYTES_PROD_PUBLIC: [u8; 4] = [0x04, 0x88, 0xB2, 0x1E];
+/// Version bytes for extended private keys on the Tapyrus network.
+const VERSION_BYTES_PROD_PRIVATE: [u8; 4] = [0x04, 0x88, 0xAD, 0xE4];
+/// Version bytes for extended public keys on any of the dev networks.
+const VERSION_BYTES_DEV_PUBLIC: [u8; 4] = [0x04, 0x35, 0x87, 0xCF];
+/// Version bytes for extended private keys on any of the dev networks.
+const VERSION_BYTES_DEV_PRIVATE: [u8; 4] = [0x04, 0x35, 0x83, 0x94];
+
+/// The old name for xpub, extended public key.
+#[deprecated(since = "0.31.0", note = "use xpub instead")]
+pub type ExtendendPubKey = Xpub;
+
+/// The old name for xpriv, extended public key.
+#[deprecated(since = "0.31.0", note = "use xpriv instead")]
+pub type ExtendendPrivKey = Xpriv;
+
+/// A chain code
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ChainCode([u8; 32]);
+impl_array_newtype!(ChainCode, u8, 32);
+impl_bytes_newtype!(ChainCode, 32);
+
+impl ChainCode {
+    fn from_hmac(hmac: Hmac<sha512::Hash>) -> Self {
+        hmac[32..].try_into().expect("half of hmac is guaranteed to be 32 bytes")
+    }
+}
+
+/// A fingerprint
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub struct Fingerprint([u8; 4]);
+impl_array_newtype!(Fingerprint, u8, 4);
+impl_bytes_newtype!(Fingerprint, 4);
+
+hash_newtype! {
+    /// XpubIdentifier as defined in BIP-32.
+    #[deprecated(since = "0.0.0-NEXT-RELEASE", note = "use XKeyIdentifier instead")]
+    pub struct XpubIdentifier(hash160::Hash);
+
+    /// Extended key identifier as defined in BIP-32.
+    pub struct XKeyIdentifier(hash160::Hash);
+}
+
+/// Extended private key
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Debug))]
+pub struct Xpriv {
+    /// The network this key is to be used on
+    pub network: Network,
+    /// How many derivations this key is from the master (which is 0)
+    pub depth: u8,
+    /// Fingerprint of the parent key (0 for master)
+    pub parent_fingerprint: Fingerprint,
+    /// Child number of the key used to derive from parent (0 for master)
+    pub child_number: ChildNumber,
+    /// Private key
+    pub private_key: secp256k1::SecretKey,
+    /// Chain code
+    pub chain_code: ChainCode,
+}
+#[cfg(feature = "serde")]
+crate::serde_utils::serde_string_impl!(Xpriv, "a BIP-32 extended private key");
+
+#[cfg(not(feature = "std"))]
+impl fmt::Debug for Xpriv {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Xpriv")
+            .field("network", &self.network)
+            .field("depth", &self.depth)
+            .field("parent_fingerprint", &self.parent_fingerprint)
+            .field("child_number", &self.child_number)
+            .field("chain_code", &self.chain_code)
+            .field("private_key", &"[SecretKey]")
+            .finish()
+    }
+}
+
+/// Extended public key
+#[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)]
+pub struct Xpub {
+    /// The network this key is to be used on
+    pub network: Network,
+    /// How many derivations this key is from the master (which is 0)
+    pub depth: u8,
+    /// Fingerprint of the parent key
+    pub parent_fingerprint: Fingerprint,
+    /// Child number of the key used to derive from parent (0 for master)
+    pub child_number: ChildNumber,
+    /// Public key
+    pub public_key: secp256k1::PublicKey,
+    /// Chain code
+    pub chain_code: ChainCode,
+}
+#[cfg(feature = "serde")]
+crate::serde_utils::serde_string_impl!(Xpub, "a BIP-32 extended public key");
+
+/// A child number for a derived key
+#[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)]
+pub enum ChildNumber {
+    /// Non-hardened key
+    Normal {
+        /// Key index, within [0, 2^31 - 1]
+        index: u32,
+    },
+    /// Hardened key
+    Hardened {
+        /// Key index, within [0, 2^31 - 1]
+        index: u32,
+    },
+}
+
+impl ChildNumber {
+    /// Create a [`Normal`] from an index, returns an error if the index is not within
+    /// [0, 2^31 - 1].
+    ///
+    /// [`Normal`]: #variant.Normal
+    pub fn from_normal_idx(index: u32) -> Result<Self, Error> {
+        if index & (1 << 31) == 0 {
+            Ok(ChildNumber::Normal { index })
+        } else {
+            Err(Error::InvalidChildNumber(index))
+        }
+    }
+
+    /// Create a [`Hardened`] from an index, returns an error if the index is not within
+    /// [0, 2^31 - 1].
+    ///
+    /// [`Hardened`]: #variant.Hardened
+    pub fn from_hardened_idx(index: u32) -> Result<Self, Error> {
+        if index & (1 << 31) == 0 {
+            Ok(ChildNumber::Hardened { index })
+        } else {
+            Err(Error::InvalidChildNumber(index))
+        }
+    }
+
+    /// Returns `true` if the child number is a [`Normal`] value.
+    ///
+    /// [`Normal`]: #variant.Normal
+    pub fn is_normal(&self) -> bool { !self.is_hardened() }
+
+    /// Returns `true` if the child number is a [`Hardened`] value.
+    ///
+    /// [`Hardened`]: #variant.Hardened
+    pub fn is_hardened(&self) -> bool {
+        match self {
+            ChildNumber::Hardened { .. } => true,
+            ChildNumber::Normal { .. } => false,
+        }
+    }
+
+    /// Returns the child number that is a single increment from this one.
+    pub fn increment(self) -> Result<ChildNumber, Error> {
+        match self {
+            ChildNumber::Normal { index: idx } => ChildNumber::from_normal_idx(idx + 1),
+            ChildNumber::Hardened { index: idx } => ChildNumber::from_hardened_idx(idx + 1),
+        }
+    }
+}
+
+impl From<u32> for ChildNumber {
+    fn from(number: u32) -> Self {
+        if number & (1 << 31) != 0 {
+            ChildNumber::Hardened { index: number ^ (1 << 31) }
+        } else {
+            ChildNumber::Normal { index: number }
+        }
+    }
+}
+
+impl From<ChildNumber> for u32 {
+    fn from(cnum: ChildNumber) -> Self {
+        match cnum {
+            ChildNumber::Normal { index } => index,
+            ChildNumber::Hardened { index } => index | (1 << 31),
+        }
+    }
+}
+
+impl fmt::Display for ChildNumber {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            ChildNumber::Hardened { index } => {
+                fmt::Display::fmt(&index, f)?;
+                let alt = f.alternate();
+                f.write_str(if alt { "h" } else { "'" })
+            }
+            ChildNumber::Normal { index } => fmt::Display::fmt(&index, f),
+        }
+    }
+}
+
+impl FromStr for ChildNumber {
+    type Err = Error;
+
+    fn from_str(inp: &str) -> Result<ChildNumber, Error> {
+        let is_hardened = inp.chars().last().map_or(false, |l| l == '\'' || l == 'h');
+        Ok(if is_hardened {
+            ChildNumber::from_hardened_idx(
+                inp[0..inp.len() - 1].parse().map_err(|_| Error::InvalidChildNumberFormat)?,
+            )?
+        } else {
+            ChildNumber::from_normal_idx(inp.parse().map_err(|_| Error::InvalidChildNumberFormat)?)?
+        })
+    }
+}
+
+impl AsRef<[ChildNumber]> for ChildNumber {
+    fn as_ref(&self) -> &[ChildNumber] { slice::from_ref(self) }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ChildNumber {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        u32::deserialize(deserializer).map(ChildNumber::from)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for ChildNumber {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        u32::from(*self).serialize(serializer)
+    }
+}
+
+/// Trait that allows possibly failable conversion from a type into a
+/// derivation path
+pub trait IntoDerivationPath {
+    /// Convers a given type into a [`DerivationPath`] with possible error
+    fn into_derivation_path(self) -> Result<DerivationPath, Error>;
+}
+
+/// A BIP-32 derivation path.
+#[derive(Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
+pub struct DerivationPath(Vec<ChildNumber>);
+
+#[cfg(feature = "serde")]
+crate::serde_utils::serde_string_impl!(DerivationPath, "a BIP-32 derivation path");
+
+impl<I> Index<I> for DerivationPath
+where
+    Vec<ChildNumber>: Index<I>,
+{
+    type Output = <Vec<ChildNumber> as Index<I>>::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output { &self.0[index] }
+}
+
+impl Default for DerivationPath {
+    fn default() -> DerivationPath { DerivationPath::master() }
+}
+
+impl<T> IntoDerivationPath for T
+where
+    T: Into<DerivationPath>,
+{
+    fn into_derivation_path(self) -> Result<DerivationPath, Error> { Ok(self.into()) }
+}
+
+impl IntoDerivationPath for String {
+    fn into_derivation_path(self) -> Result<DerivationPath, Error> { self.parse() }
+}
+
+impl<'a> IntoDerivationPath for &'a str {
+    fn into_derivation_path(self) -> Result<DerivationPath, Error> { self.parse() }
+}
+
+impl From<Vec<ChildNumber>> for DerivationPath {
+    fn from(numbers: Vec<ChildNumber>) -> Self { DerivationPath(numbers) }
+}
+
+impl From<DerivationPath> for Vec<ChildNumber> {
+    fn from(path: DerivationPath) -> Self { path.0 }
+}
+
+impl<'a> From<&'a [ChildNumber]> for DerivationPath {
+    fn from(numbers: &'a [ChildNumber]) -> Self { DerivationPath(numbers.to_vec()) }
+}
+
+impl core::iter::FromIterator<ChildNumber> for DerivationPath {
+    fn from_iter<T>(iter: T) -> Self
+    where
+        T: IntoIterator<Item = ChildNumber>,
+    {
+        DerivationPath(Vec::from_iter(iter))
+    }
+}
+
+impl<'a> core::iter::IntoIterator for &'a DerivationPath {
+    type Item = &'a ChildNumber;
+    type IntoIter = slice::Iter<'a, ChildNumber>;
+    fn into_iter(self) -> Self::IntoIter { self.0.iter() }
+}
+
+impl AsRef<[ChildNumber]> for DerivationPath {
+    fn as_ref(&self) -> &[ChildNumber] { &self.0 }
+}
+
+impl FromStr for DerivationPath {
+    type Err = Error;
+
+    fn from_str(path: &str) -> Result<DerivationPath, Error> {
+        let mut parts = path.split('/');
+        // First parts must be `m`.
+        if parts.next().unwrap() != "m" {
+            return Err(Error::InvalidDerivationPathFormat);
+        }
+
+        let ret: Result<Vec<ChildNumber>, Error> = parts.map(str::parse).collect();
+        Ok(DerivationPath(ret?))
+    }
+}
+
+/// An iterator over children of a [DerivationPath].
+///
+/// It is returned by the methods [DerivationPath::children_from],
+/// [DerivationPath::normal_children] and [DerivationPath::hardened_children].
+pub struct DerivationPathIterator<'a> {
+    base: &'a DerivationPath,
+    next_child: Option<ChildNumber>,
+}
+
+impl<'a> DerivationPathIterator<'a> {
+    /// Start a new [DerivationPathIterator] at the given child.
+    pub fn start_from(path: &'a DerivationPath, start: ChildNumber) -> DerivationPathIterator<'a> {
+        DerivationPathIterator { base: path, next_child: Some(start) }
+    }
+}
+
+impl<'a> Iterator for DerivationPathIterator<'a> {
+    type Item = DerivationPath;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let ret = self.next_child?;
+        self.next_child = ret.increment().ok();
+        Some(self.base.child(ret))
+    }
+}
+
+impl DerivationPath {
+    /// Returns length of the derivation path
+    pub fn len(&self) -> usize { self.0.len() }
+
+    /// Returns `true` if the derivation path is empty
+    pub fn is_empty(&self) -> bool { self.0.is_empty() }
+
+    /// Returns derivation path for a master key (i.e. empty derivation path)
+    pub fn master() -> DerivationPath { DerivationPath(vec![]) }
+
+    /// Returns whether derivation path represents master key (i.e. it's length
+    /// is empty). True for `m` path.
+    pub fn is_master(&self) -> bool { self.0.is_empty() }
+
+    /// Create a new [DerivationPath] that is a child of this one.
+    pub fn child(&self, cn: ChildNumber) -> DerivationPath {
+        let mut path = self.0.clone();
+        path.push(cn);
+        DerivationPath(path)
+    }
+
+    /// Convert into a [DerivationPath] that is a child of this one.
+    pub fn into_child(self, cn: ChildNumber) -> DerivationPath {
+        let mut path = self.0;
+        path.push(cn);
+        DerivationPath(path)
+    }
+
+    /// Get an [Iterator] over the children of this [DerivationPath]
+    /// starting with the given [ChildNumber].
+    pub fn children_from(&self, cn: ChildNumber) -> DerivationPathIterator {
+        DerivationPathIterator::start_from(self, cn)
+    }
+
+    /// Get an [Iterator] over the unhardened children of this [DerivationPath].
+    pub fn normal_children(&self) -> DerivationPathIterator {
+        DerivationPathIterator::start_from(self, ChildNumber::Normal { index: 0 })
+    }
+
+    /// Get an [Iterator] over the hardened children of this [DerivationPath].
+    pub fn hardened_children(&self) -> DerivationPathIterator {
+        DerivationPathIterator::start_from(self, ChildNumber::Hardened { index: 0 })
+    }
+
+    /// Concatenate `self` with `path` and return the resulting new path.
+    ///
+    /// ```
+    /// use tapyrus::bip32::{DerivationPath, ChildNumber};
+    /// use std::str::FromStr;
+    ///
+    /// let base = DerivationPath::from_str("m/42").unwrap();
+    ///
+    /// let deriv_1 = base.extend(DerivationPath::from_str("m/0/1").unwrap());
+    /// let deriv_2 = base.extend(&[
+    ///     ChildNumber::from_normal_idx(0).unwrap(),
+    ///     ChildNumber::from_normal_idx(1).unwrap()
+    /// ]);
+    ///
+    /// assert_eq!(deriv_1, deriv_2);
+    /// ```
+    pub fn extend<T: AsRef<[ChildNumber]>>(&self, path: T) -> DerivationPath {
+        let mut new_path = self.clone();
+        new_path.0.extend_from_slice(path.as_ref());
+        new_path
+    }
+
+    /// Returns the derivation path as a vector of u32 integers.
+    /// Unhardened elements are copied as is.
+    /// 0x80000000 is added to the hardened elements.
+    ///
+    /// ```
+    /// use tapyrus::bip32::DerivationPath;
+    /// use std::str::FromStr;
+    ///
+    /// let path = DerivationPath::from_str("m/84'/0'/0'/0/1").unwrap();
+    /// const HARDENED: u32 = 0x80000000;
+    /// assert_eq!(path.to_u32_vec(), vec![84 + HARDENED, HARDENED, HARDENED, 0, 1]);
+    /// ```
+    pub fn to_u32_vec(&self) -> Vec<u32> { self.into_iter().map(|&el| el.into()).collect() }
+}
+
+impl fmt::Display for DerivationPath {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("m")?;
+        for cn in self.0.iter() {
+            f.write_str("/")?;
+            fmt::Display::fmt(cn, f)?;
+        }
+        Ok(())
+    }
+}
+
+impl fmt::Debug for DerivationPath {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self, f) }
+}
+
+/// Full information on the used extended public key: fingerprint of the
+/// master extended public key and a derivation path from it.
+pub type KeySource = (Fingerprint, DerivationPath);
+
+/// A BIP32 error
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// A pk->pk derivation was attempted on a hardened key
+    CannotDeriveFromHardenedKey,
+    /// A secp256k1 error occurred
+    Secp256k1(secp256k1::Error),
+    /// A child number was provided that was out of range
+    InvalidChildNumber(u32),
+    /// Invalid childnumber format.
+    InvalidChildNumberFormat,
+    /// Invalid derivation path format.
+    InvalidDerivationPathFormat,
+    /// Unknown version magic bytes
+    UnknownVersion([u8; 4]),
+    /// Encoded extended key data has wrong length
+    WrongExtendedKeyLength(usize),
+    /// Base58 encoding error
+    Base58(base58::Error),
+    /// Hexadecimal decoding error
+    Hex(hex::HexToArrayError),
+    /// `PublicKey` hex should be 66 or 130 digits long.
+    InvalidPublicKeyHexLength(usize),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            CannotDeriveFromHardenedKey =>
+                f.write_str("cannot derive hardened key from public key"),
+            Secp256k1(ref e) => write_err!(f, "secp256k1 error"; e),
+            InvalidChildNumber(ref n) =>
+                write!(f, "child number {} is invalid (not within [0, 2^31 - 1])", n),
+            InvalidChildNumberFormat => f.write_str("invalid child number format"),
+            InvalidDerivationPathFormat => f.write_str("invalid derivation path format"),
+            UnknownVersion(ref bytes) => write!(f, "unknown version magic bytes: {:?}", bytes),
+            WrongExtendedKeyLength(ref len) =>
+                write!(f, "encoded extended key data has wrong length {}", len),
+            Base58(ref e) => write_err!(f, "base58 encoding error"; e),
+            Hex(ref e) => write_err!(f, "Hexadecimal decoding error"; e),
+            InvalidPublicKeyHexLength(got) =>
+                write!(f, "PublicKey hex should be 66 or 130 digits long, got: {}", got),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            Secp256k1(ref e) => Some(e),
+            Base58(ref e) => Some(e),
+            Hex(ref e) => Some(e),
+            CannotDeriveFromHardenedKey
+            | InvalidChildNumber(_)
+            | InvalidChildNumberFormat
+            | InvalidDerivationPathFormat
+            | UnknownVersion(_)
+            | WrongExtendedKeyLength(_)
+            | InvalidPublicKeyHexLength(_) => None,
+        }
+    }
+}
+
+impl From<key::Error> for Error {
+    fn from(err: key::Error) -> Self {
+        match err {
+            key::Error::Base58(e) => Error::Base58(e),
+            key::Error::Secp256k1(e) => Error::Secp256k1(e),
+            key::Error::InvalidKeyPrefix(_) => Error::Secp256k1(secp256k1::Error::InvalidPublicKey),
+            key::Error::Hex(e) => Error::Hex(e),
+            key::Error::InvalidHexLength(got) => Error::InvalidPublicKeyHexLength(got),
+        }
+    }
+}
+
+impl From<secp256k1::Error> for Error {
+    fn from(e: secp256k1::Error) -> Error { Error::Secp256k1(e) }
+}
+
+impl From<base58::Error> for Error {
+    fn from(err: base58::Error) -> Self { Error::Base58(err) }
+}
+
+impl Xpriv {
+    /// Construct a new master key from a seed value
+    pub fn new_master(network: Network, seed: &[u8]) -> Result<Xpriv, Error> {
+        let mut hmac_engine: HmacEngine<sha512::Hash> = HmacEngine::new(b"Tapyrus seed");
+        hmac_engine.input(seed);
+        let hmac_result: Hmac<sha512::Hash> = Hmac::from_engine(hmac_engine);
+
+        Ok(Xpriv {
+            network,
+            depth: 0,
+            parent_fingerprint: Default::default(),
+            child_number: ChildNumber::from_normal_idx(0)?,
+            private_key: secp256k1::SecretKey::from_slice(&hmac_result[..32])?,
+            chain_code: ChainCode::from_hmac(hmac_result),
+        })
+    }
+
+    /// Constructs ECDSA compressed private key matching internal secret key representation.
+    pub fn to_priv(self) -> PrivateKey {
+        PrivateKey { compressed: true, network: self.network, inner: self.private_key }
+    }
+
+    /// Constructs BIP340 keypair for Schnorr signatures and Taproot use matching the internal
+    /// secret key representation.
+    pub fn to_keypair<C: secp256k1::Signing>(self, secp: &Secp256k1<C>) -> Keypair {
+        Keypair::from_seckey_slice(secp, &self.private_key[..])
+            .expect("BIP32 internal private key representation is broken")
+    }
+
+    /// Attempts to derive an extended private key from a path.
+    ///
+    /// The `path` argument can be both of type `DerivationPath` or `Vec<ChildNumber>`.
+    pub fn derive_priv<C: secp256k1::Signing, P: AsRef<[ChildNumber]>>(
+        &self,
+        secp: &Secp256k1<C>,
+        path: &P,
+    ) -> Result<Xpriv, Error> {
+        let mut sk: Xpriv = *self;
+        for cnum in path.as_ref() {
+            sk = sk.ckd_priv(secp, *cnum)?;
+        }
+        Ok(sk)
+    }
+
+    /// Private->Private child key derivation
+    fn ckd_priv<C: secp256k1::Signing>(
+        &self,
+        secp: &Secp256k1<C>,
+        i: ChildNumber,
+    ) -> Result<Xpriv, Error> {
+        let mut hmac_engine: HmacEngine<sha512::Hash> = HmacEngine::new(&self.chain_code[..]);
+        match i {
+            ChildNumber::Normal { .. } => {
+                // Non-hardened key: compute public data and use that
+                hmac_engine.input(
+                    &secp256k1::PublicKey::from_secret_key(secp, &self.private_key).serialize()[..],
+                );
+            }
+            ChildNumber::Hardened { .. } => {
+                // Hardened key: use only secret data to prevent public derivation
+                hmac_engine.input(&[0u8]);
+                hmac_engine.input(&self.private_key[..]);
+            }
+        }
+
+        hmac_engine.input(&u32::from(i).to_be_bytes());
+        let hmac_result: Hmac<sha512::Hash> = Hmac::from_engine(hmac_engine);
+        let sk = secp256k1::SecretKey::from_slice(&hmac_result[..32])
+            .expect("statistically impossible to hit");
+        let tweaked =
+            sk.add_tweak(&self.private_key.into()).expect("statistically impossible to hit");
+
+        Ok(Xpriv {
+            network: self.network,
+            depth: self.depth + 1,
+            parent_fingerprint: self.fingerprint(secp),
+            child_number: i,
+            private_key: tweaked,
+            chain_code: ChainCode::from_hmac(hmac_result),
+        })
+    }
+
+    /// Decoding extended private key from binary data according to BIP 32
+    pub fn decode(data: &[u8]) -> Result<Xpriv, Error> {
+        if data.len() != 78 {
+            return Err(Error::WrongExtendedKeyLength(data.len()));
+        }
+
+        let network = if data.starts_with(&VERSION_BYTES_PROD_PRIVATE) {
+            Network::Prod
+        } else if data.starts_with(&VERSION_BYTES_DEV_PRIVATE) {
+            Network::Dev
+        } else {
+            let (b0, b1, b2, b3) = (data[0], data[1], data[2], data[3]);
+            return Err(Error::UnknownVersion([b0, b1, b2, b3]));
+        };
+
+        Ok(Xpriv {
+            network,
+            depth: data[4],
+            parent_fingerprint: data[5..9]
+                .try_into()
+                .expect("9 - 5 == 4, which is the Fingerprint length"),
+            child_number: u32::from_be_bytes(data[9..13].try_into().expect("4 byte slice")).into(),
+            chain_code: data[13..45]
+                .try_into()
+                .expect("45 - 13 == 32, which is the ChainCode length"),
+            private_key: secp256k1::SecretKey::from_slice(&data[46..78])?,
+        })
+    }
+
+    /// Extended private key binary encoding according to BIP 32
+    pub fn encode(&self) -> [u8; 78] {
+        let mut ret = [0; 78];
+        ret[0..4].copy_from_slice(&match self.network {
+            Network::Prod => VERSION_BYTES_PROD_PRIVATE,
+            Network::Dev => VERSION_BYTES_DEV_PRIVATE,
+        });
+        ret[4] = self.depth;
+        ret[5..9].copy_from_slice(&self.parent_fingerprint[..]);
+        ret[9..13].copy_from_slice(&u32::from(self.child_number).to_be_bytes());
+        ret[13..45].copy_from_slice(&self.chain_code[..]);
+        ret[45] = 0;
+        ret[46..78].copy_from_slice(&self.private_key[..]);
+        ret
+    }
+
+    /// Returns the HASH160 of the public key belonging to the xpriv
+    pub fn identifier<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> XKeyIdentifier {
+        Xpub::from_priv(secp, self).identifier()
+    }
+
+    /// Returns the first four bytes of the identifier
+    pub fn fingerprint<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> Fingerprint {
+        self.identifier(secp)[0..4].try_into().expect("4 is the fingerprint length")
+    }
+}
+
+impl Xpub {
+    /// Derives a public key from a private key
+    pub fn from_priv<C: secp256k1::Signing>(secp: &Secp256k1<C>, sk: &Xpriv) -> Xpub {
+        Xpub {
+            network: sk.network,
+            depth: sk.depth,
+            parent_fingerprint: sk.parent_fingerprint,
+            child_number: sk.child_number,
+            public_key: secp256k1::PublicKey::from_secret_key(secp, &sk.private_key),
+            chain_code: sk.chain_code,
+        }
+    }
+
+    /// Constructs ECDSA compressed public key matching internal public key representation.
+    pub fn to_pub(self) -> PublicKey { PublicKey { compressed: true, inner: self.public_key } }
+
+    /// Constructs BIP340 x-only public key for BIP-340 signatures and Taproot use matching
+    /// the internal public key representation.
+    pub fn to_x_only_pub(self) -> XOnlyPublicKey { XOnlyPublicKey::from(self.public_key) }
+
+    /// Attempts to derive an extended public key from a path.
+    ///
+    /// The `path` argument can be any type implementing `AsRef<ChildNumber>`, such as `DerivationPath`, for instance.
+    pub fn derive_pub<C: secp256k1::Verification, P: AsRef<[ChildNumber]>>(
+        &self,
+        secp: &Secp256k1<C>,
+        path: &P,
+    ) -> Result<Xpub, Error> {
+        let mut pk: Xpub = *self;
+        for cnum in path.as_ref() {
+            pk = pk.ckd_pub(secp, *cnum)?
+        }
+        Ok(pk)
+    }
+
+    /// Compute the scalar tweak added to this key to get a child key
+    pub fn ckd_pub_tweak(
+        &self,
+        i: ChildNumber,
+    ) -> Result<(secp256k1::SecretKey, ChainCode), Error> {
+        match i {
+            ChildNumber::Hardened { .. } => Err(Error::CannotDeriveFromHardenedKey),
+            ChildNumber::Normal { index: n } => {
+                let mut hmac_engine: HmacEngine<sha512::Hash> =
+                    HmacEngine::new(&self.chain_code[..]);
+                hmac_engine.input(&self.public_key.serialize()[..]);
+                hmac_engine.input(&n.to_be_bytes());
+
+                let hmac_result: Hmac<sha512::Hash> = Hmac::from_engine(hmac_engine);
+
+                let private_key = secp256k1::SecretKey::from_slice(&hmac_result[..32])?;
+                let chain_code = ChainCode::from_hmac(hmac_result);
+                Ok((private_key, chain_code))
+            }
+        }
+    }
+
+    /// Public->Public child key derivation
+    pub fn ckd_pub<C: secp256k1::Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+        i: ChildNumber,
+    ) -> Result<Xpub, Error> {
+        let (sk, chain_code) = self.ckd_pub_tweak(i)?;
+        let tweaked = self.public_key.add_exp_tweak(secp, &sk.into())?;
+
+        Ok(Xpub {
+            network: self.network,
+            depth: self.depth + 1,
+            parent_fingerprint: self.fingerprint(),
+            child_number: i,
+            public_key: tweaked,
+            chain_code,
+        })
+    }
+
+    /// Decoding extended public key from binary data according to BIP 32
+    pub fn decode(data: &[u8]) -> Result<Xpub, Error> {
+        if data.len() != 78 {
+            return Err(Error::WrongExtendedKeyLength(data.len()));
+        }
+
+        let network = if data.starts_with(&VERSION_BYTES_PROD_PUBLIC) {
+            Network::Prod
+        } else if data.starts_with(&VERSION_BYTES_DEV_PUBLIC) {
+            Network::Dev
+        } else {
+            let (b0, b1, b2, b3) = (data[0], data[1], data[2], data[3]);
+            return Err(Error::UnknownVersion([b0, b1, b2, b3]));
+        };
+
+        Ok(Xpub {
+            network,
+            depth: data[4],
+            parent_fingerprint: data[5..9]
+                .try_into()
+                .expect("9 - 5 == 4, which is the Fingerprint length"),
+            child_number: u32::from_be_bytes(data[9..13].try_into().expect("4 byte slice")).into(),
+            chain_code: data[13..45]
+                .try_into()
+                .expect("45 - 13 == 32, which is the ChainCode length"),
+            public_key: secp256k1::PublicKey::from_slice(&data[45..78])?,
+        })
+    }
+
+    /// Extended public key binary encoding according to BIP 32
+    pub fn encode(&self) -> [u8; 78] {
+        let mut ret = [0; 78];
+        ret[0..4].copy_from_slice(&match self.network {
+            Network::Prod => VERSION_BYTES_PROD_PUBLIC,
+            Network::Dev => VERSION_BYTES_DEV_PUBLIC,
+        });
+        ret[4] = self.depth;
+        ret[5..9].copy_from_slice(&self.parent_fingerprint[..]);
+        ret[9..13].copy_from_slice(&u32::from(self.child_number).to_be_bytes());
+        ret[13..45].copy_from_slice(&self.chain_code[..]);
+        ret[45..78].copy_from_slice(&self.public_key.serialize()[..]);
+        ret
+    }
+
+    /// Returns the HASH160 of the chaincode
+    pub fn identifier(&self) -> XKeyIdentifier {
+        let mut engine = XKeyIdentifier::engine();
+        engine.write_all(&self.public_key.serialize()).expect("engines don't error");
+        XKeyIdentifier::from_engine(engine)
+    }
+
+    /// Returns the first four bytes of the identifier
+    pub fn fingerprint(&self) -> Fingerprint {
+        self.identifier()[0..4].try_into().expect("4 is the fingerprint length")
+    }
+}
+
+impl fmt::Display for Xpriv {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        base58::encode_check_to_fmt(fmt, &self.encode()[..])
+    }
+}
+
+impl FromStr for Xpriv {
+    type Err = Error;
+
+    fn from_str(inp: &str) -> Result<Xpriv, Error> {
+        let data = base58::decode_check(inp)?;
+
+        if data.len() != 78 {
+            return Err(base58::Error::InvalidLength(data.len()).into());
+        }
+
+        Xpriv::decode(&data)
+    }
+}
+
+impl fmt::Display for Xpub {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        base58::encode_check_to_fmt(fmt, &self.encode()[..])
+    }
+}
+
+impl FromStr for Xpub {
+    type Err = Error;
+
+    fn from_str(inp: &str) -> Result<Xpub, Error> {
+        let data = base58::decode_check(inp)?;
+
+        if data.len() != 78 {
+            return Err(base58::Error::InvalidLength(data.len()).into());
+        }
+
+        Xpub::decode(&data)
+    }
+}
+
+impl From<Xpub> for XKeyIdentifier {
+    fn from(key: Xpub) -> XKeyIdentifier { key.identifier() }
+}
+
+impl From<&Xpub> for XKeyIdentifier {
+    fn from(key: &Xpub) -> XKeyIdentifier { key.identifier() }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use hex::test_hex_unwrap as hex;
+    use secp256k1::{self, Secp256k1};
+
+    use super::ChildNumber::{Hardened, Normal};
+    use super::*;
+    use crate::network::Network::{self, Prod};
+
+    #[test]
+    fn test_parse_derivation_path() {
+        assert_eq!(DerivationPath::from_str("42"), Err(Error::InvalidDerivationPathFormat));
+        assert_eq!(DerivationPath::from_str("n/0'/0"), Err(Error::InvalidDerivationPathFormat));
+        assert_eq!(DerivationPath::from_str("4/m/5"), Err(Error::InvalidDerivationPathFormat));
+        assert_eq!(DerivationPath::from_str("m//3/0'"), Err(Error::InvalidChildNumberFormat));
+        assert_eq!(DerivationPath::from_str("m/0h/0x"), Err(Error::InvalidChildNumberFormat));
+        assert_eq!(
+            DerivationPath::from_str("m/2147483648"),
+            Err(Error::InvalidChildNumber(2147483648))
+        );
+
+        assert_eq!(DerivationPath::master(), DerivationPath::from_str("m").unwrap());
+        assert_eq!(DerivationPath::master(), DerivationPath::default());
+        assert_eq!(DerivationPath::from_str("m"), Ok(vec![].into()));
+        assert_eq!(
+            DerivationPath::from_str("m/0'"),
+            Ok(vec![ChildNumber::from_hardened_idx(0).unwrap()].into())
+        );
+        assert_eq!(
+            DerivationPath::from_str("m/0'/1"),
+            Ok(vec![
+                ChildNumber::from_hardened_idx(0).unwrap(),
+                ChildNumber::from_normal_idx(1).unwrap()
+            ]
+            .into())
+        );
+        assert_eq!(
+            DerivationPath::from_str("m/0h/1/2'"),
+            Ok(vec![
+                ChildNumber::from_hardened_idx(0).unwrap(),
+                ChildNumber::from_normal_idx(1).unwrap(),
+                ChildNumber::from_hardened_idx(2).unwrap(),
+            ]
+            .into())
+        );
+        assert_eq!(
+            DerivationPath::from_str("m/0'/1/2h/2"),
+            Ok(vec![
+                ChildNumber::from_hardened_idx(0).unwrap(),
+                ChildNumber::from_normal_idx(1).unwrap(),
+                ChildNumber::from_hardened_idx(2).unwrap(),
+                ChildNumber::from_normal_idx(2).unwrap(),
+            ]
+            .into())
+        );
+        assert_eq!(
+            DerivationPath::from_str("m/0'/1/2'/2/1000000000"),
+            Ok(vec![
+                ChildNumber::from_hardened_idx(0).unwrap(),
+                ChildNumber::from_normal_idx(1).unwrap(),
+                ChildNumber::from_hardened_idx(2).unwrap(),
+                ChildNumber::from_normal_idx(2).unwrap(),
+                ChildNumber::from_normal_idx(1000000000).unwrap(),
+            ]
+            .into())
+        );
+        let s = "m/0'/50/3'/5/545456";
+        assert_eq!(DerivationPath::from_str(s), s.into_derivation_path());
+        assert_eq!(DerivationPath::from_str(s), s.to_string().into_derivation_path());
+    }
+
+    #[test]
+    fn test_derivation_path_conversion_index() {
+        let path = DerivationPath::from_str("m/0h/1/2'").unwrap();
+        let numbers: Vec<ChildNumber> = path.clone().into();
+        let path2: DerivationPath = numbers.into();
+        assert_eq!(path, path2);
+        assert_eq!(
+            &path[..2],
+            &[ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap()]
+        );
+        let indexed: DerivationPath = path[..2].into();
+        assert_eq!(indexed, DerivationPath::from_str("m/0h/1").unwrap());
+        assert_eq!(indexed.child(ChildNumber::from_hardened_idx(2).unwrap()), path);
+    }
+
+    fn test_path<C: secp256k1::Signing + secp256k1::Verification>(
+        secp: &Secp256k1<C>,
+        network: Network,
+        seed: &[u8],
+        path: DerivationPath,
+        expected_sk: &str,
+        expected_pk: &str,
+    ) {
+        let mut sk = Xpriv::new_master(network, seed).unwrap();
+        let mut pk = Xpub::from_priv(secp, &sk);
+
+        // Check derivation convenience method for Xpriv
+        assert_eq!(&sk.derive_priv(secp, &path).unwrap().to_string()[..], expected_sk);
+
+        // Check derivation convenience method for Xpub, should error
+        // appropriately if any ChildNumber is hardened
+        if path.0.iter().any(|cnum| cnum.is_hardened()) {
+            assert_eq!(pk.derive_pub(secp, &path), Err(Error::CannotDeriveFromHardenedKey));
+        } else {
+            assert_eq!(&pk.derive_pub(secp, &path).unwrap().to_string()[..], expected_pk);
+        }
+
+        // Derive keys, checking hardened and non-hardened derivation one-by-one
+        for &num in path.0.iter() {
+            sk = sk.ckd_priv(secp, num).unwrap();
+            match num {
+                Normal { .. } => {
+                    let pk2 = pk.ckd_pub(secp, num).unwrap();
+                    pk = Xpub::from_priv(secp, &sk);
+                    assert_eq!(pk, pk2);
+                }
+                Hardened { .. } => {
+                    assert_eq!(pk.ckd_pub(secp, num), Err(Error::CannotDeriveFromHardenedKey));
+                    pk = Xpub::from_priv(secp, &sk);
+                }
+            }
+        }
+
+        // Check result against expected base58
+        assert_eq!(&sk.to_string()[..], expected_sk);
+        assert_eq!(&pk.to_string()[..], expected_pk);
+        // Check decoded base58 against result
+        let decoded_sk = Xpriv::from_str(expected_sk);
+        let decoded_pk = Xpub::from_str(expected_pk);
+        assert_eq!(Ok(sk), decoded_sk);
+        assert_eq!(Ok(pk), decoded_pk);
+    }
+
+    #[test]
+    fn test_increment() {
+        let idx = 9345497; // randomly generated, I promise
+        let cn = ChildNumber::from_normal_idx(idx).unwrap();
+        assert_eq!(cn.increment().ok(), Some(ChildNumber::from_normal_idx(idx + 1).unwrap()));
+        let cn = ChildNumber::from_hardened_idx(idx).unwrap();
+        assert_eq!(cn.increment().ok(), Some(ChildNumber::from_hardened_idx(idx + 1).unwrap()));
+
+        let max = (1 << 31) - 1;
+        let cn = ChildNumber::from_normal_idx(max).unwrap();
+        assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1 << 31)));
+        let cn = ChildNumber::from_hardened_idx(max).unwrap();
+        assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1 << 31)));
+
+        let cn = ChildNumber::from_normal_idx(350).unwrap();
+        let path = DerivationPath::from_str("m/42'").unwrap();
+        let mut iter = path.children_from(cn);
+        assert_eq!(iter.next(), Some("m/42'/350".parse().unwrap()));
+        assert_eq!(iter.next(), Some("m/42'/351".parse().unwrap()));
+
+        let path = DerivationPath::from_str("m/42'/350'").unwrap();
+        let mut iter = path.normal_children();
+        assert_eq!(iter.next(), Some("m/42'/350'/0".parse().unwrap()));
+        assert_eq!(iter.next(), Some("m/42'/350'/1".parse().unwrap()));
+
+        let path = DerivationPath::from_str("m/42'/350'").unwrap();
+        let mut iter = path.hardened_children();
+        assert_eq!(iter.next(), Some("m/42'/350'/0'".parse().unwrap()));
+        assert_eq!(iter.next(), Some("m/42'/350'/1'".parse().unwrap()));
+
+        let cn = ChildNumber::from_hardened_idx(42350).unwrap();
+        let path = DerivationPath::from_str("m/42'").unwrap();
+        let mut iter = path.children_from(cn);
+        assert_eq!(iter.next(), Some("m/42'/42350'".parse().unwrap()));
+        assert_eq!(iter.next(), Some("m/42'/42351'".parse().unwrap()));
+
+        let cn = ChildNumber::from_hardened_idx(max).unwrap();
+        let path = DerivationPath::from_str("m/42'").unwrap();
+        let mut iter = path.children_from(cn);
+        assert!(iter.next().is_some());
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_vector_1() {
+        let secp = Secp256k1::new();
+        let seed = hex!("000102030405060708090a0b0c0d0e0f");
+
+        // m
+        test_path(&secp, Prod, &seed, "m".parse().unwrap(),
+                  "xprv9s21ZrQH143K2xjLUb6KPjDjExyBLXq6K9u1gGQVMLyvewCLXdivoY7w3iRxAk1eX7k51Dxy71QdfRSQMmiMUGUi5iKfsKh2wfZVEGcqXEe",
+                  "xpub661MyMwAqRbcFSooacdKksATnzofjzYwgNpcUep6ugWuXjXV5B3BMLSQu1eaiuxJ5zdoKt6ZcnpMi8mz2XHDHg8qSNWZpNnKABKxGetVSeG");
+
+        // m/0h
+        test_path(&secp, Prod, &seed, "m/0h".parse().unwrap(),
+                  "xprv9uFM9iJccmW8MWthq313xGRzCStfizbMbuoFc7e3bherrNG4n7pxxeZnbt5xL3C4apsWhDp5xHqJVYTXaEZym1QxYutBNzsbA3KNN3brxYg",
+                  "xpub68EhZDqWT94RZzyAw4Y4KQNikUjA8TKCy8irQW3fA3BqjAbDKf9DWStGTAq9yngbomLc1kWLcTsif1Q3K81CAtajweZiJgzYoBf3ok5siog");
+
+        // m/0h/1
+        test_path(&secp, Prod, &seed, "m/0h/1".parse().unwrap(),
+                   "xprv9xby4JDYU1wVTmtDez13fFZYwujZNjCnuog6uMJDok16SnZnKaCxZNcqC4yGX7y7EzkCCtp8zdowyapkCAmZ48Qcw5SdPcAmYC4GyAaq17w",
+                   "xpub6BbKTokSJPVngFxgm1Y42PWHVwa3nBveH2bhhjhqN5Y5Katvs7XD7AwK3LAx9RQfdHjLNXYgMx9pav9de2VDZ3ovqZfhYsqhXdN1D8ZknGV");
+
+        // m/0h/1/2h
+        test_path(&secp, Prod, &seed, "m/0h/1/2h".parse().unwrap(),
+                  "xprv9yHeFHDADn4TthzzG64pa8fN4oJ1hXaErdbTwenLijZZepW8KRvFrXHUyXxV9YZefWYLnwLcRDBufF2ZcdNBeKagGtEYmC3deGVrKJfUN7h",
+                  "xpub6CGzenk449cm7C5TN7bpwGc6cq8W6zJ6DrX4k3BxH56YXcqGryEWQKbxpoGaV5SiD6JpEvE7vCrkQxHmyWka33JpLJuCjbR1XGBQrK7kCJR");
+
+        // m/0h/1/2h/2
+        test_path(&secp, Prod, &seed, "m/0h/1/2h/2".parse().unwrap(),
+                  "xprvA1sfG8WVX65Z2fnP4nbcKqhU4u8X2ZhDnafhLapjgar7kVFNJkHB9m46iRjyMRniTSU6Ftop4oQBarK2VaptXCHwBxN2JyeE3HZCdWj3naS",
+                  "xpub6Es1fe3PMTdrF9rrAp8cgyeCcvy1S2R59obJ8yEMEvP6dHaWrHbRhZNaZhD1U3BK91axZiTZFTV9Tizr1X5D4yemBn59HqpGjqc4ijMrN2Y");
+
+        // m/0h/1/2h/2/1000000000
+        test_path(&secp, Prod, &seed, "m/0h/1/2h/2/1000000000".parse().unwrap(),
+                  "xprvA39ZwpCsVGrRgnS4n7Ub6s4RPYMqsD64zPpdmm6pD6SNjEc2LTHha47jbqYxBSKNL4cuyMCxk1b44oiApcAd8uH89UYb4Hj7RmUQBJH3bmu",
+                  "xpub6G8vMKjmKeQiuGWXt91bU119waCLGfovMckEa9WRmRyMc2wAszbx7rSDT6tmshb7WRQsuEbYPCdGsUrCKDxAdoPv59neBYeAaEMGQPeAgNy");
+    }
+
+    #[test]
+    fn test_vector_2() {
+        let secp = Secp256k1::new();
+        let seed = hex!("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542");
+
+        // m
+        test_path(&secp, Prod, &seed, "m".parse().unwrap(),
+                  "xprv9s21ZrQH143K3EAWtaFfWyKZ4wZYY8EritwZ7t8Q1CjU2sAF2A6STEAcvE18D4NErHh4zdGYysW7GYbykLp5cnFeFUzgNQaevEX56YV4MfL",
+                  "xpub661MyMwAqRbcFiEyzbnft7GHcyQ2waxi67s9vGY1ZYGSufVPZhQh12V6mTVtGMVZVNZ6pUA1sJjkPQzcSp3Yy1KrbKbYB2j2prTCLQ5q5xU");
+
+        // m/0
+        test_path(&secp, Prod, &seed, "m/0".parse().unwrap(),
+                  "xprv9uNreJ4cFzMXpxuys3mL2oWZvBdDqLzRJcjKEaryur7g89ZJPidyoA2FHN65ugspw18VBNYhEcqwQKez6RPPvfvVp4jnZpv8zpEDEPmUas8",
+                  "xpub68ND3obW6Muq3SzSy5JLPwTJUDTiEoiGfqev2yGbUBeezwtSwFxELxLj8e9T4N92dNmfcdheGw29NPGe4i3rYeAecJxMmMgKoV6JfDCwDYu");
+
+        // m/0/2147483647h
+        test_path(&secp, Prod, &seed, "m/0/2147483647h".parse().unwrap(),
+                  "xprv9xAAhXL9iBW14jQBobrkXTJAuKgbtrbjKukd8miYZL6npywgwi8MqzENDt2zMfQhcduM5zLq1Efs3oNTQZJ2RTsbKrnyusrdxyewDk5cQtt",
+                  "xpub6B9X72s3YZ4JHDUeudPktbEuTMX6JKKah8gDwA8A7fdmhnGqVFScPnYr5CXoV7gbJyQSKU9pZhqjnA4gUHpGba1T2gBphsQi76NJBtePzrE");
+
+        // m/0/2147483647h/1
+        test_path(&secp, Prod, &seed, "m/0/2147483647h/1".parse().unwrap(),
+                  "xprv9xsheafKD5fYcGJWkNFdsX8St5XF13E9j8h5CVeKEgkpYrRvL6zQdm5Ex7gVC32CLFoVU3zKeGrrvLqJF1ZouBirmMWvK24eFTy9xN3vAch",
+                  "xpub6Bs446CD3TDqpkNyrPneEf5BS7MjQVx16Mcfzt3vo2HoRem4seJfBZPioQ2JE3KjLYBxxu3ezCbCg5nv1JJeBNKPXgPBZQLBQxcHC9bdg8a");
+
+        // m/0/2147483647h/1/2147483646h
+        test_path(&secp, Prod, &seed, "m/0/2147483647h/1/2147483646h".parse().unwrap(),
+                  "xprvA16mAad8fZ2LQvPiCyMbaonMQGfQCbEQXUkpUqJ34D6hjUsHa4tEFiubS9n9QKtMEwHS2zupnC6ENGyNWDcTQAGDhDYb9fqkE7KedNoN8jq",
+                  "xpub6E67a6A2VvaddQUBJztbwwj5xJVtc3xFthgRHDhecYdgcHCS7cCUoXE5HRhPgSDx4H1Y6qLbT5PtTjxomcvadXe2seaj4uzQG5kRs1o2Unb");
+
+        // m/0/2147483647h/1/2147483646h/2
+        test_path(&secp, Prod, &seed, "m/0/2147483647h/1/2147483646h/2".parse().unwrap(),
+                  "xprvA3miAHhnL1mo7oKJ9SgmQdUHfEmsbiPUyUorxoiuJXnQTp4kKiYAF6aDxLKpFTQ6mzsACWa7oC7p44S9h8dkCiHWcQjQL1vNyJWGn4BrCpP",
+                  "xpub6Gm4ZoEgAPL6LHPmFUDmmmR2DGcN1B7LLhjTmC8WrsKPLcPtsFrQntthobzSvu7t8uiBD1GkK6jek6Life3QvWygRYkAegjuFNTK1v1F858");
+    }
+
+    #[test]
+    fn test_vector_3() {
+        let secp = Secp256k1::new();
+        let seed = hex!("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be");
+
+        // m
+        test_path(&secp, Prod, &seed, "m".parse().unwrap(),
+                  "xprv9s21ZrQH143K3xbnDaEaYrFEsVkzYXtcHdiwwmug5RfE15ZETjXpBeWVBrJA6HFJWMLNK4U7U9MiWVyA1Q3uRoKdKhhKdozE6YALH8r5dEr",
+                  "xpub661MyMwAqRbcGSgFKbmauzByRXbUwzcTereYkAKHdmCCsstP1Gr4jSpy38Gw3DRGTi47zaaZCux4tEU334RNcp32NL6Y6KwDAsjW7EWAvK8");
+
+        // m/0h
+        test_path(&secp, Prod, &seed, "m/0h".parse().unwrap(),
+                  "xprv9uYKM3GKt1gSYCGcR6FABVUHVMZ1jqFPmHUAV6bctpKtDj99E2eZWNz6ZvJsvxeur9pBRpLdLpjaguLLXJ9gg6dMm41qb13jB3onoHdTD34",
+                  "xpub68XfkYoDiPEjkgM5X7nAYdR23PPW9HyF8WPmHV1ET9rs6XUHmZxp4BJaRBQALEUkmwWJmBF6L1ZzyPjWDRtNVidyqH9cJDyVgdWKeJoHDzE");
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    pub fn encode_decode_childnumber() {
+        serde_round_trip!(ChildNumber::from_normal_idx(0).unwrap());
+        serde_round_trip!(ChildNumber::from_normal_idx(1).unwrap());
+        serde_round_trip!(ChildNumber::from_normal_idx((1 << 31) - 1).unwrap());
+        serde_round_trip!(ChildNumber::from_hardened_idx(0).unwrap());
+        serde_round_trip!(ChildNumber::from_hardened_idx(1).unwrap());
+        serde_round_trip!(ChildNumber::from_hardened_idx((1 << 31) - 1).unwrap());
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    pub fn encode_fingerprint_chaincode() {
+        use serde_json;
+        let fp = Fingerprint::from([1u8, 2, 3, 42]);
+        #[rustfmt::skip]
+        let cc = ChainCode::from(
+            [1u8,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]
+        );
+
+        serde_round_trip!(fp);
+        serde_round_trip!(cc);
+
+        assert_eq!("\"0102032a\"", serde_json::to_string(&fp).unwrap());
+        assert_eq!(
+            "\"0102030405060708090001020304050607080900010203040506070809000102\"",
+            serde_json::to_string(&cc).unwrap()
+        );
+        assert_eq!("0102032a", fp.to_string());
+        assert_eq!(
+            "0102030405060708090001020304050607080900010203040506070809000102",
+            cc.to_string()
+        );
+    }
+
+    #[test]
+    fn fmt_child_number() {
+        assert_eq!("000005h", &format!("{:#06}", ChildNumber::from_hardened_idx(5).unwrap()));
+        assert_eq!("5h", &format!("{:#}", ChildNumber::from_hardened_idx(5).unwrap()));
+        assert_eq!("000005'", &format!("{:06}", ChildNumber::from_hardened_idx(5).unwrap()));
+        assert_eq!("5'", &format!("{}", ChildNumber::from_hardened_idx(5).unwrap()));
+        assert_eq!("42", &format!("{}", ChildNumber::from_normal_idx(42).unwrap()));
+        assert_eq!("000042", &format!("{:06}", ChildNumber::from_normal_idx(42).unwrap()));
+    }
+
+    #[test]
+    #[should_panic(expected = "Secp256k1(InvalidSecretKey)")]
+    fn schnorr_broken_privkey_zeros() {
+        /* this is how we generate key:
+        let mut sk = secp256k1::key::ONE_KEY;
+
+        let zeros = [0u8; 32];
+        unsafe {
+            sk.as_mut_ptr().copy_from(zeros.as_ptr(), 32);
+        }
+
+        let xpriv = Xpriv {
+            network: Network::Prod,
+            depth: 0,
+            parent_fingerprint: Default::default(),
+            child_number: ChildNumber::Normal { index: 0 },
+            private_key: sk,
+            chain_code: ChainCode::from([0u8; 32])
+        };
+
+        println!("{}", xpriv);
+         */
+
+        // Xpriv having secret key set to all zeros
+        let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzF93Y5wvzdUayhgkkFoicQZcP3y52uPPxFnfoLZB21Teqt1VvEHx";
+        Xpriv::from_str(xpriv_str).unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "Secp256k1(InvalidSecretKey)")]
+    fn schnorr_broken_privkey_ffs() {
+        // Xpriv having secret key set to all 0xFF's
+        let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFAzHGBP2UuGCqWLTAPLcMtD9y5gkZ6Eq3Rjuahrv17fENZ3QzxW";
+        Xpriv::from_str(xpriv_str).unwrap();
+    }
+}
diff --git a/tapyrus/src/blockdata/block.rs b/tapyrus/src/blockdata/block.rs
new file mode 100644
index 00000000..91565988
--- /dev/null
+++ b/tapyrus/src/blockdata/block.rs
@@ -0,0 +1,1001 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin blocks.
+//!
+//! A block is a bundle of transactions with a proof-of-work attached,
+//! which commits to an earlier block to form the blockchain. This
+//! module describes structures and functions needed to describe
+//! these blocks and the blockchain.
+//!
+
+use core::fmt;
+use core::str::FromStr;
+
+use hashes::hex::FromHex;
+use hashes::{Hash, HashEngine};
+
+use super::Weight;
+use crate::blockdata::script;
+use crate::blockdata::transaction::Transaction;
+use crate::consensus::encode::{serialize_hex, Error};
+use crate::consensus::{encode, serialize, Decodable, Encodable};
+use crate::crypto::key::PublicKey;
+use crate::crypto::schnorr::Signature;
+pub use crate::hash_types::BlockHash;
+use crate::hash_types::{BlockSigHash, TxMerkleNode, WitnessCommitment, WitnessMerkleNode, Wtxid, XFieldHash};
+use crate::internal_macros::impl_consensus_encoding;
+use crate::prelude::*;
+use crate::{crypto, io, merkle_tree, VarInt};
+
+/// Bitcoin block header.
+///
+/// Contains all the block's information except the actual transactions, but
+/// including a root of a [merkle tree] commiting to all transactions in the block.
+///
+/// [merkle tree]: https://en.wikipedia.org/wiki/Merkle_tree
+///
+/// ### Bitcoin Core References
+///
+/// * [CBlockHeader definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/block.h#L20)
+#[derive(PartialEq, Eq, Clone, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Header {
+    /// Block version, now repurposed for soft fork signalling.
+    pub version: Version,
+    /// Reference to the previous block in the chain.
+    pub prev_blockhash: BlockHash,
+    /// The root hash of the merkle tree of transactions in the block.
+    pub merkle_root: TxMerkleNode,
+    /// MerkleRoot based on fixing malleability transaction hash
+    pub im_merkle_root: TxMerkleNode,
+    /// The timestamp of the block, as claimed by the miner.
+    pub time: u32,
+    /// Extra field. This field can host any type of data defined in Tapyrus protocol.
+    pub xfield: XField,
+    /// Collection holds a signature for block hash which is consisted of block header without Proof.
+    pub proof: Option<Signature>,
+}
+
+impl Header {
+    /// The number of bytes that the block header contributes to the size of a block.
+    // Serialized length of fields (version, prev_blockhash, merkle_root, im_merkle_root, time)
+    pub const SIZE: usize = 4 + 32 + 32 + 32 + 4; // 104
+
+    /// Returns the block hash.
+    pub fn block_hash(&self) -> BlockHash {
+        let mut engine = BlockHash::engine();
+        self.consensus_encode(&mut engine).expect("engines don't error");
+        BlockHash::from_engine(engine)
+    }
+
+    /// Return the Aggregate public key in this BlockHeader
+    pub fn aggregated_public_key(&self) -> Option<PublicKey> {
+        match self.xfield {
+            XField::AggregatePublicKey(pk) => Some(pk),
+            _ => None,
+        }
+    }
+
+    /// Computes a signature hash for this block.
+    /// Tapyrus signer needs to sign this hash. The signature will be added to
+    /// the block header as the proof field and submitted to the tapyrus node.
+    pub fn signature_hash(&self) -> BlockSigHash {
+        let block = HeaderWithoutProof::from(self);
+        BlockSigHash::hash(&serialize(&block))
+    }
+
+    /// Return the max block size in this BlockHeader
+    pub fn max_block_size(&self) -> Option<u32> {
+        match self.xfield {
+            XField::MaxBlockSize(size) => Some(size),
+            _ => None,
+        }
+    }
+}
+
+impl_consensus_encoding!(
+    Header,
+    version,
+    prev_blockhash,
+    merkle_root,
+    im_merkle_root,
+    time,
+    xfield,
+    proof
+);
+
+impl fmt::Debug for Header {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Header")
+            .field("block_hash", &self.block_hash())
+            .field("version", &self.version)
+            .field("prev_blockhash", &self.prev_blockhash)
+            .field("merkle_root", &self.merkle_root)
+            .field("im_merkle_root", &self.im_merkle_root)
+            .field("time", &self.time)
+            .field("xfield", &self.xfield)
+            .field("proof", &self.proof)
+            .finish()
+    }
+}
+
+/// Bitcoin block version number.
+///
+/// Originally used as a protocol version, but repurposed for soft-fork signaling.
+///
+/// The inner value is a signed integer in Bitcoin Core for historical reasons, if version bits is
+/// being used the top three bits must be 001, this gives us a useful range of [0x20000000...0x3FFFFFFF].
+///
+/// > When a block nVersion does not have top bits 001, it is treated as if all bits are 0 for the purposes of deployments.
+///
+/// ### Relevant BIPs
+///
+/// * [BIP9 - Version bits with timeout and delay](https://github.com/bitcoin/bips/blob/master/bip-0009.mediawiki) (current usage)
+/// * [BIP34 - Block v2, Height in Coinbase](https://github.com/bitcoin/bips/blob/master/bip-0034.mediawiki)
+#[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Version(i32);
+
+impl Version {
+    /// The original Bitcoin Block v1.
+    pub const ONE: Self = Self(1);
+
+    /// BIP-34 Block v2.
+    pub const TWO: Self = Self(2);
+
+    /// BIP-9 compatible version number that does not signal for any softforks.
+    pub const NO_SOFT_FORK_SIGNALLING: Self = Self(Self::USE_VERSION_BITS as i32);
+
+    /// BIP-9 soft fork signal bits mask.
+    const VERSION_BITS_MASK: u32 = 0x1FFF_FFFF;
+
+    /// 32bit value starting with `001` to use version bits.
+    ///
+    /// The value has the top three bits `001` which enables the use of version bits to signal for soft forks.
+    const USE_VERSION_BITS: u32 = 0x2000_0000;
+
+    /// Creates a [`Version`] from a signed 32 bit integer value.
+    ///
+    /// This is the data type used in consensus code in Bitcoin Core.
+    pub fn from_consensus(v: i32) -> Self { Version(v) }
+
+    /// Returns the inner `i32` value.
+    ///
+    /// This is the data type used in consensus code in Bitcoin Core.
+    pub fn to_consensus(self) -> i32 { self.0 }
+
+    /// Checks whether the version number is signalling a soft fork at the given bit.
+    ///
+    /// A block is signalling for a soft fork under BIP-9 if the first 3 bits are `001` and
+    /// the version bit for the specific soft fork is toggled on.
+    pub fn is_signalling_soft_fork(&self, bit: u8) -> bool {
+        // Only bits [0, 28] inclusive are used for signalling.
+        if bit > 28 {
+            return false;
+        }
+
+        // To signal using version bits, the first three bits must be `001`.
+        if (self.0 as u32) & !Self::VERSION_BITS_MASK != Self::USE_VERSION_BITS {
+            return false;
+        }
+
+        // The bit is set if signalling a soft fork.
+        (self.0 as u32 & Self::VERSION_BITS_MASK) & (1 << bit) > 0
+    }
+}
+
+impl Default for Version {
+    fn default() -> Version { Self::NO_SOFT_FORK_SIGNALLING }
+}
+
+impl Encodable for Version {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(w)
+    }
+}
+
+impl Decodable for Version {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Decodable::consensus_decode(r).map(Version)
+    }
+}
+
+struct HeaderWithoutProof {
+    version: Version,
+    prev_blockhash: BlockHash,
+    merkle_root: TxMerkleNode,
+    im_merkle_root: TxMerkleNode,
+    time: u32,
+    xfield: XField,
+}
+
+impl HeaderWithoutProof {
+    fn from(header: &Header) -> Self {
+        Self {
+            version: header.version,
+            prev_blockhash: header.prev_blockhash,
+            merkle_root: header.merkle_root,
+            im_merkle_root: header.im_merkle_root,
+            time: header.time,
+            xfield: header.xfield.clone(),
+        }
+    }
+}
+
+impl_consensus_encoding!(
+    HeaderWithoutProof,
+    version,
+    prev_blockhash,
+    merkle_root,
+    im_merkle_root,
+    time,
+    xfield
+);
+
+/// An extra field that allows the block header to hold arbitrary data.
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
+pub enum XField {
+    /// xfield isn't used.
+    None,
+    /// Aggregate public key used to verify block proof.
+    AggregatePublicKey(PublicKey),
+    /// Max block size to change the block size limit.
+    MaxBlockSize(u32),
+    /// Unknown type
+    Unknown(u8, Vec<u8>),
+}
+
+impl XField {
+    /// Return xfieldType.
+    pub fn field_type(&self) -> u8 {
+        match self {
+            XField::None => 0u8,
+            XField::AggregatePublicKey(_) => 1u8,
+            XField::MaxBlockSize(_) => 2u8,
+            XField::Unknown(x_type, _) => *x_type,
+        }
+    }
+    /// Return field size
+    pub fn size(&self) -> usize {
+        match self {
+            XField::None => 1,
+            XField::AggregatePublicKey(_) => 35, // 1 + 1 + 33
+            XField::MaxBlockSize(_) => 5, // 1 + 4
+            XField::Unknown(_, data) => 1 + VarInt::from(data.len()).size() + data.len(),
+        }
+    }
+
+    /// Return hash of serialized XField for signing
+    pub fn signature_hash(&self) ->Result<XFieldHash, Error>  {
+        match self {
+            XField::None => Err(Error::XFieldNone),
+            XField::AggregatePublicKey(_) => Ok(XFieldHash::hash(&serialize(self))),
+            XField::MaxBlockSize(_) => Ok(XFieldHash::hash(&serialize(self))),
+            XField::Unknown(i, _) => Err(Error::UnknownXField(*i)),
+        }
+    }
+}
+
+impl FromStr for XField {
+    type Err = encode::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let bytes: Vec<u8> =
+            Vec::from_hex(s).map_err(|_| encode::Error::ParseFailed("invalid hex string"))?;
+        XField::consensus_decode(&mut &bytes[..])
+    }
+}
+
+impl core::fmt::Display for XField {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{}", serialize_hex(self))
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for XField {
+    /// User-facing serialization for `Script`.
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.collect_str(&self)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> ::serde::Deserialize<'de> for XField {
+    fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<XField, D::Error> {
+        struct XFieldVisitor;
+
+        impl<'de> ::serde::de::Visitor<'de> for XFieldVisitor {
+            type Value = XField;
+
+            fn expecting(&self, formatter: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                formatter.write_str("hex string")
+            }
+
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+            where
+                E: ::serde::de::Error,
+            {
+                if let Ok(s) = ::core::str::from_utf8(v) {
+                    XField::from_str(s).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,
+            {
+                XField::from_str(v).map_err(E::custom)
+            }
+        }
+
+        d.deserialize_str(XFieldVisitor)
+    }
+}
+
+impl Decodable for XField {
+    #[inline]
+    fn consensus_decode<D: io::Read + ?Sized>(mut d: &mut D) -> Result<Self, encode::Error> {
+        let x_type: u8 = Decodable::consensus_decode(&mut d)?;
+        match x_type {
+            0 => Ok(XField::None),
+            1 => {
+                let bytes: Vec<u8> = Decodable::consensus_decode(&mut d)?;
+                let pk = PublicKey::from_slice(&bytes)
+                    .map_err(|_| encode::Error::ParseFailed("aggregate public key"))?;
+                Ok(XField::AggregatePublicKey(pk))
+            }
+            2 => {
+                let size: u32 = Decodable::consensus_decode(&mut d)?;
+                Ok(XField::MaxBlockSize(size))
+            }
+            _ => {
+                let data: Vec<u8> = Decodable::consensus_decode(&mut d)?;
+                Ok(XField::Unknown(x_type, data))
+            }
+        }
+    }
+}
+
+impl Encodable for XField {
+    #[inline]
+    fn consensus_encode<S: io::Write + ?Sized>(&self, mut s: &mut S) -> Result<usize, io::Error> {
+        self.field_type().consensus_encode(&mut s)?;
+        match self {
+            XField::None => Ok(1),
+            XField::AggregatePublicKey(pk) => {
+                let len = pk.to_bytes().consensus_encode(&mut s)?;
+                Ok(1 + len)
+            }
+            XField::MaxBlockSize(size) => {
+                let len = size.consensus_encode(&mut s)?;
+                Ok(1 + len)
+            }
+            XField::Unknown(_type, data) => {
+                let len = data.consensus_encode(&mut s)?;
+                Ok(1 + len)
+            }
+        }
+    }
+}
+
+/// Bitcoin block.
+///
+/// A collection of transactions with an attached proof of work.
+///
+/// See [Bitcoin Wiki: Block][wiki-block] for more information.
+///
+/// [wiki-block]: https://en.bitcoin.it/wiki/Block
+///
+/// ### Bitcoin Core References
+///
+/// * [CBlock definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/block.h#L62)
+#[derive(PartialEq, Eq, Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Block {
+    /// The block header
+    pub header: Header,
+    /// List of transactions contained in the block
+    pub txdata: Vec<Transaction>,
+}
+
+impl_consensus_encoding!(Block, header, txdata);
+
+impl Block {
+    /// Returns the block hash.
+    pub fn block_hash(&self) -> BlockHash { self.header.block_hash() }
+
+    /// Checks if merkle root of header matches merkle root of the transaction list.
+    pub fn check_merkle_root(&self) -> bool {
+        match self.compute_merkle_root() {
+            Some(merkle_root) => self.header.merkle_root == merkle_root,
+            None => false,
+        }
+    }
+
+    /// Checks if witness commitment in coinbase matches the transaction list.
+    pub fn check_witness_commitment(&self) -> bool {
+        const MAGIC: [u8; 6] = [0x6a, 0x24, 0xaa, 0x21, 0xa9, 0xed];
+        // Witness commitment is optional if there are no transactions using SegWit in the block.
+        if self.txdata.iter().all(|t| t.input.iter().all(|i| i.witness.is_empty())) {
+            return true;
+        }
+
+        if self.txdata.is_empty() {
+            return false;
+        }
+
+        let coinbase = &self.txdata[0];
+        if !coinbase.is_coinbase() {
+            return false;
+        }
+
+        // Commitment is in the last output that starts with magic bytes.
+        if let Some(pos) = coinbase
+            .output
+            .iter()
+            .rposition(|o| o.script_pubkey.len() >= 38 && o.script_pubkey.as_bytes()[0..6] == MAGIC)
+        {
+            let commitment = WitnessCommitment::from_slice(
+                &coinbase.output[pos].script_pubkey.as_bytes()[6..38],
+            )
+            .unwrap();
+            // Witness reserved value is in coinbase input witness.
+            let witness_vec: Vec<_> = coinbase.input[0].witness.iter().collect();
+            if witness_vec.len() == 1 && witness_vec[0].len() == 32 {
+                if let Some(witness_root) = self.witness_root() {
+                    return commitment
+                        == Self::compute_witness_commitment(&witness_root, witness_vec[0]);
+                }
+            }
+        }
+
+        false
+    }
+
+    /// Computes the transaction merkle root.
+    pub fn compute_merkle_root(&self) -> Option<TxMerkleNode> {
+        let hashes = self.txdata.iter().map(|obj| obj.txid().to_raw_hash());
+        merkle_tree::calculate_root(hashes).map(|h| h.into())
+    }
+
+    /// Computes the witness commitment for the block's transaction list.
+    pub fn compute_witness_commitment(
+        witness_root: &WitnessMerkleNode,
+        witness_reserved_value: &[u8],
+    ) -> WitnessCommitment {
+        let mut encoder = WitnessCommitment::engine();
+        witness_root.consensus_encode(&mut encoder).expect("engines don't error");
+        encoder.input(witness_reserved_value);
+        WitnessCommitment::from_engine(encoder)
+    }
+
+    /// Computes the merkle root of transactions hashed for witness.
+    pub fn witness_root(&self) -> Option<WitnessMerkleNode> {
+        let hashes = self.txdata.iter().enumerate().map(|(i, t)| {
+            if i == 0 {
+                // Replace the first hash with zeroes.
+                Wtxid::all_zeros().to_raw_hash()
+            } else {
+                t.wtxid().to_raw_hash()
+            }
+        });
+        merkle_tree::calculate_root(hashes).map(|h| h.into())
+    }
+
+    /// Computes the merkle root of transactions using immutable hash
+    pub fn immutable_merkle_root(&self) -> Option<TxMerkleNode> {
+        let hashes = self.txdata.iter().map(|obj| obj.malfix_txid().to_raw_hash());
+        merkle_tree::calculate_root(hashes).map(|h| h.into())
+    }
+
+    /// Returns the weight of the block.
+    ///
+    /// > Block weight is defined as Base size * 3 + Total size.
+    pub fn weight(&self) -> Weight {
+        // This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
+        let wu = self.base_size() * 3 + self.total_size();
+        Weight::from_wu_usize(wu)
+    }
+
+    /// Returns the base block size.
+    ///
+    /// > Base size is the block size in bytes with the original transaction serialization without
+    /// > any witness-related data, as seen by a non-upgraded node.
+    fn base_size(&self) -> usize {
+        let mut size = Header::SIZE;
+        size += self.header.xfield.size();
+        size += 1; // length of proof field
+        if self.header.proof.is_some() {
+            size += 2 * crypto::schnorr::SECP256K1_SCALAR_SIZE;
+        }
+        size += VarInt::from(self.txdata.len()).size();
+        size += self.txdata.iter().map(|tx| tx.base_size()).sum::<usize>();
+
+        size
+    }
+
+    /// Returns the total block size.
+    ///
+    /// > Total size is the block size in bytes with transactions serialized as described in BIP144,
+    /// > including base data and witness data.
+    pub fn total_size(&self) -> usize {
+        let mut size = Header::SIZE;
+        size += self.header.xfield.size();
+        size += 1; // length of proof field
+        if self.header.proof.is_some() {
+            size += 2 * crypto::schnorr::SECP256K1_SCALAR_SIZE;
+        }
+        size += VarInt::from(self.txdata.len()).size();
+        size += self.txdata.iter().map(|tx| tx.total_size()).sum::<usize>();
+
+        size
+    }
+
+    /// Returns the stripped size of the block.
+    #[deprecated(since = "0.31.0", note = "use Block::base_size() instead")]
+    pub fn strippedsize(&self) -> usize { self.base_size() }
+
+    /// Returns the coinbase transaction, if one is present.
+    pub fn coinbase(&self) -> Option<&Transaction> { self.txdata.first() }
+
+    /// Returns the block height, as encoded in the coinbase transaction according to BIP34.
+    pub fn bip34_block_height(&self) -> Result<u64, Bip34Error> {
+        // Citing the spec:
+        // Add height as the first item in the coinbase transaction's scriptSig,
+        // and increase block version to 2. The format of the height is
+        // "minimally encoded serialized CScript"" -- first byte is number of bytes in the number
+        // (will be 0x03 on main net for the next 150 or so years with 2^23-1
+        // blocks), following bytes are little-endian representation of the
+        // number (including a sign bit). Height is the height of the mined
+        // block in the block chain, where the genesis block is height zero (0).
+
+        if self.header.version < Version::TWO {
+            return Err(Bip34Error::Unsupported);
+        }
+
+        let cb = self.coinbase().ok_or(Bip34Error::NotPresent)?;
+        let input = cb.input.first().ok_or(Bip34Error::NotPresent)?;
+        let push = input.script_sig.instructions_minimal().next().ok_or(Bip34Error::NotPresent)?;
+        match push.map_err(|_| Bip34Error::NotPresent)? {
+            script::Instruction::PushBytes(b) => {
+                // Check that the number is encoded in the minimal way.
+                let h = script::read_scriptint(b.as_bytes())
+                    .map_err(|_e| Bip34Error::UnexpectedPush(b.as_bytes().to_vec()))?;
+                if h < 0 {
+                    Err(Bip34Error::NegativeHeight)
+                } else {
+                    Ok(h as u64)
+                }
+            }
+            _ => Err(Bip34Error::NotPresent),
+        }
+    }
+}
+
+impl From<Header> for BlockHash {
+    fn from(header: Header) -> BlockHash { header.block_hash() }
+}
+
+impl From<&Header> for BlockHash {
+    fn from(header: &Header) -> BlockHash { header.block_hash() }
+}
+
+impl From<Block> for BlockHash {
+    fn from(block: Block) -> BlockHash { block.block_hash() }
+}
+
+impl From<&Block> for BlockHash {
+    fn from(block: &Block) -> BlockHash { block.block_hash() }
+}
+
+/// An error when looking up a BIP34 block height.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Bip34Error {
+    /// The block does not support BIP34 yet.
+    Unsupported,
+    /// No push was present where the BIP34 push was expected.
+    NotPresent,
+    /// The BIP34 push was larger than 8 bytes.
+    UnexpectedPush(Vec<u8>),
+    /// The BIP34 push was negative.
+    NegativeHeight,
+}
+
+impl fmt::Display for Bip34Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Bip34Error::*;
+
+        match *self {
+            Unsupported => write!(f, "block doesn't support BIP34"),
+            NotPresent => write!(f, "BIP34 push not present in block's coinbase"),
+            UnexpectedPush(ref p) => {
+                write!(f, "unexpected byte push of > 8 bytes: {:?}", p)
+            }
+            NegativeHeight => write!(f, "negative BIP34 height"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Bip34Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Bip34Error::*;
+
+        match *self {
+            Unsupported | NotPresent | UnexpectedPush(_) | NegativeHeight => None,
+        }
+    }
+}
+
+/// A block validation error.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ValidationError {
+    /// The header hash is not below the target.
+    BadProofOfWork,
+    /// The `target` field of a block header did not match the expected difficulty.
+    BadTarget,
+}
+
+impl fmt::Display for ValidationError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use ValidationError::*;
+
+        match *self {
+            BadProofOfWork => f.write_str("block target correct but not attained"),
+            BadTarget => f.write_str("block target incorrect"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ValidationError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use self::ValidationError::*;
+
+        match *self {
+            BadProofOfWork | BadTarget => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use hex::{test_hex_unwrap as hex, FromHex};
+
+    use super::*;
+    use crate::consensus::encode::{deserialize, serialize, Error};
+    use crate::crypto::key::PublicKey;
+    use crate::hash_types::BlockSigHash;
+
+    #[test]
+    #[ignore]
+    fn test_coinbase_and_bip34() {
+        // testnet block 100,000
+        const BLOCK_HEX: &str = "0200000035ab154183570282ce9afc0b494c9fc6a3cfea05aa8c1add2ecc56490000000038ba3d78e4500a5a7570dbe61960398add4410d278b21cd9708e6d9743f374d544fc055227f1001c29c1ea3b0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3703a08601000427f1001c046a510100522cfabe6d6d0000000000000000000068692066726f6d20706f6f6c7365727665726aac1eeeed88ffffffff0100f2052a010000001976a914912e2b234f941f30b18afbb4fa46171214bf66c888ac00000000";
+        let block: Block = deserialize(&hex!(BLOCK_HEX)).unwrap();
+
+        let cb_txid = "d574f343976d8e70d91cb278d21044dd8a396019e6db70755a0a50e4783dba38";
+        assert_eq!(block.coinbase().unwrap().txid().to_string(), cb_txid);
+
+        assert_eq!(block.bip34_block_height(), Ok(100_000));
+
+        // block with 9-byte bip34 push
+        const BAD_HEX: &str = "0200000035ab154183570282ce9afc0b494c9fc6a3cfea05aa8c1add2ecc56490000000038ba3d78e4500a5a7570dbe61960398add4410d278b21cd9708e6d9743f374d544fc055227f1001c29c1ea3b0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3d09a08601112233445566000427f1001c046a510100522cfabe6d6d0000000000000000000068692066726f6d20706f6f6c7365727665726aac1eeeed88ffffffff0100f2052a010000001976a914912e2b234f941f30b18afbb4fa46171214bf66c888ac00000000";
+        let bad: Block = deserialize(&hex!(BAD_HEX)).unwrap();
+
+        let push = Vec::<u8>::from_hex("a08601112233445566").unwrap();
+        assert_eq!(bad.bip34_block_height(), Err(super::Bip34Error::UnexpectedPush(push)));
+    }
+
+    #[test]
+    fn block_test() {
+        // Mainnet block 00000000b0c5a240b2a61d2e75692224efd4cbecdf6eaf4cc2cf477ca7c270e7
+        let some_block = hex!("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914c364243a74762685f916378ce87c5384ad39b594aca206426d9d244ef51d644d2d74d6e490121032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af40f1453cd332262d74edf65f96688724b80a15c852fd50151e4aabc41a0d9560d2cd38f0746c3d9c9e18b236f20e37d0ae1bda457ea029db8a55b20f38143517d00201000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0804ffff001d026e04ffffffff0100f2052a0100000043410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac00000000010000000321f75f3139a013f50f315b23b0c9a2b6eac31e2bec98e5891c924664889942260000000049483045022100cb2c6b346a978ab8c61b18b5e9397755cbd17d6eb2fe0083ef32e067fa6c785a02206ce44e613f31d9a6b0517e46f3db1576e9812cc98d159bfdaf759a5014081b5c01ffffffff79cda0945903627c3da1f85fc95d0b8ee3e76ae0cfdc9a65d09744b1f8fc85430000000049483045022047957cdd957cfd0becd642f6b84d82f49b6cb4c51a91f49246908af7c3cfdf4a022100e96b46621f1bffcf5ea5982f88cef651e9354f5791602369bf5a82a6cd61a62501fffffffffe09f5fe3ffbf5ee97a54eb5e5069e9da6b4856ee86fc52938c2f979b0f38e82000000004847304402204165be9a4cbab8049e1af9723b96199bfd3e85f44c6b4c0177e3962686b26073022028f638da23fc003760861ad481ead4099312c60030d4cb57820ce4d33812a5ce01ffffffff01009d966b01000000434104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac00000000");
+        let cutoff_block = hex!("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914c364243a74762685f916378ce87c5384ad39b594aca206426d9d244ef51d644d2d74d6e490121032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af000201000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0804ffff001d026e04ffffffff0100f2052a0100000043410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac00000000010000000321f75f3139a013f50f315b23b0c9a2b6eac31e2bec98e5891c924664889942260000000049483045022100cb2c6b346a978ab8c61b18b5e9397755cbd17d6eb2fe0083ef32e067fa6c785a02206ce44e613f31d9a6b0517e46f3db1576e9812cc98d159bfdaf759a5014081b5c01ffffffff79cda0945903627c3da1f85fc95d0b8ee3e76ae0cfdc9a65d09744b1f8fc85430000000049483045022047957cdd957cfd0becd642f6b84d82f49b6cb4c51a91f49246908af7c3cfdf4a022100e96b46621f1bffcf5ea5982f88cef651e9354f5791602369bf5a82a6cd61a62501fffffffffe09f5fe3ffbf5ee97a54eb5e5069e9da6b4856ee86fc52938c2f979b0f38e82000000004847304402204165be9a4cbab8049e1af9723b96199bfd3e85f44c6b4c0177e3962686b26073022028f638da23fc003760861ad481ead4099312c60030d4cb57820ce4d33812a5ce01ffffffff01009d966b01000000434104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac");
+
+        let prevhash = hex!("4ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000");
+        let merkle = hex!("bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914c");
+        let pk = PublicKey::from_str(
+            "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af",
+        )
+        .unwrap();
+        let decode: Result<Block, _> = deserialize(&some_block);
+        let bad_decode: Result<Block, _> = deserialize(&cutoff_block);
+
+        assert!(decode.is_ok());
+        assert!(bad_decode.is_err());
+        let real_decode = decode.unwrap();
+        assert_eq!(real_decode.header.version, Version(1));
+        assert_eq!(serialize(&real_decode.header.prev_blockhash), prevhash);
+        assert_eq!(real_decode.header.merkle_root, real_decode.compute_merkle_root().unwrap());
+        assert_eq!(real_decode.header.im_merkle_root, real_decode.immutable_merkle_root().unwrap());
+        assert_eq!(serialize(&real_decode.header.merkle_root), merkle);
+        assert_eq!(real_decode.header.time, 1231965655);
+        assert_eq!(real_decode.header.aggregated_public_key().unwrap(), pk);
+        // [test] TODO: check the transaction data
+
+        assert_eq!(real_decode.total_size(), some_block.len());
+        assert_eq!(real_decode.base_size(), some_block.len());
+        assert_eq!(
+            real_decode.weight(),
+            Weight::from_non_witness_data_size(some_block.len() as u64)
+        );
+
+        // should be also ok for a non-witness block as commitment is optional in that case
+        assert!(real_decode.check_witness_commitment());
+
+        assert_eq!(serialize(&real_decode), some_block);
+    }
+
+    #[test]
+    fn xfield_none_test() {
+        let bytes = Vec::from_hex("00").unwrap();
+        let decode: XField = deserialize(&bytes).unwrap();
+        assert_eq!(serialize(&decode), bytes);
+
+        assert_eq!(decode, XField::None);
+
+        let xfield = XField::from_str("00");
+        assert_eq!(xfield.unwrap(), XField::None);
+    }
+
+    #[test]
+    fn xfield_aggregate_public_key_test() {
+        let bytes =
+            Vec::from_hex("0121032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af")
+                .unwrap();
+        let decode: XField = deserialize(&bytes).unwrap();
+        assert_eq!(serialize(&decode), bytes);
+
+        let pk = PublicKey::from_str(
+            "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af",
+        )
+        .unwrap();
+        assert_eq!(decode, XField::AggregatePublicKey(pk));
+
+        let xfield = XField::from_str(
+            "0121032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af",
+        );
+        assert_eq!(xfield.unwrap(), XField::AggregatePublicKey(pk));
+    }
+
+    #[test]
+    fn xfield_unsupported_type_test() {
+        let bytes = Vec::from_hex("ff0101").unwrap();
+        let decode: XField = deserialize(&bytes).unwrap();
+        assert_eq!(serialize(&decode), bytes);
+
+        assert_eq!(decode, XField::Unknown(0xff, vec![0x01]));
+
+        let xfield = XField::from_str("ff0101");
+        assert_eq!(xfield.unwrap(), XField::Unknown(0xff, vec![0x01]));
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn xfield_serialize_test() {
+        let xfield = Vec::from_hex("00").unwrap();
+        let decode: XField = deserialize(&xfield).unwrap();
+        serde_round_trip!(decode);
+
+        let xfield =
+            Vec::from_hex("0121032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af")
+                .unwrap();
+        let decode: XField = deserialize(&xfield).unwrap();
+        serde_round_trip!(decode);
+
+        let xfield = Vec::from_hex("02000000ff").unwrap();
+        let decode: XField = deserialize(&xfield).unwrap();
+        serde_round_trip!(decode);
+    }
+
+    #[test]
+    fn signature_hash_test() {
+        let block = hex!("010000000000000000000000000000000000000000000000000000000000000000000000c1457ff3e5c527e69858108edf0ff1f49eea9c58d8d37300a164b3b4f8c8c7cef1a2e72770d547feae29f2dd40123a97c580d44fd4493de072416d53331997617b96f05d00403a4c09253c7b583e5260074380c9b99b895f938e37799d326ded984fb707e91fa4df2e0524a4ccf5fe224945b4fb94784b411a760eb730d95402d3383dd7ffdc01010000000100000000000000000000000000000000000000000000000000000000000000000000000022210366262690cbdf648132ce0c088962c6361112582364ede120f3780ab73438fc4bffffffff0100f2052a010000002776a9226d70757956774d32596a454d755a4b72687463526b614a787062715447417346484688ac00000000");
+        let decode: Result<Block, _> = deserialize(&block);
+        assert!(decode.is_ok());
+        assert_eq!(
+            decode.unwrap().header.signature_hash(),
+            BlockSigHash::from_str(
+                "3d856f50e0718f72bab6516c1ab020ce3390ebc97490b6d2bad4054dc7a40a93"
+            )
+            .unwrap()
+        );
+    }
+
+    #[test]
+    fn block_version_test() {
+        let block = hex!("ffffff7f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
+        let decode: Result<Block, _> = deserialize(&block);
+        assert!(decode.is_ok());
+        let real_decode = decode.unwrap();
+        assert_eq!(real_decode.header.version, Version(2147483647));
+
+        let block2 = hex!("0000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
+        let decode2: Result<Block, _> = deserialize(&block2);
+        assert!(decode2.is_ok());
+        let real_decode2 = decode2.unwrap();
+        assert_eq!(real_decode2.header.version, Version(-2147483648));
+    }
+
+    #[test]
+    fn soft_fork_signalling() {
+        for i in 0..31 {
+            let version_int = (0x20000000u32 ^ 1 << i) as i32;
+            let version = Version(version_int);
+            if i < 29 {
+                assert!(version.is_signalling_soft_fork(i));
+            } else {
+                assert!(!version.is_signalling_soft_fork(i));
+            }
+        }
+
+        let segwit_signal = Version(0x20000000 ^ 1 << 1);
+        assert!(!segwit_signal.is_signalling_soft_fork(0));
+        assert!(segwit_signal.is_signalling_soft_fork(1));
+        assert!(!segwit_signal.is_signalling_soft_fork(2));
+    }
+
+    #[test]
+    fn xfield_max_block_size_test() {
+        let bytes = Vec::from_hex("0200010000").unwrap();
+        let decode: XField = deserialize(&bytes).unwrap();
+        assert_eq!(serialize(&decode), bytes);
+
+        let maxblocksize:u32 = 0x100;
+        assert_eq!(decode, XField::MaxBlockSize(maxblocksize));
+        let xfield = XField::from_str("0200010000");
+        assert_eq!(xfield.unwrap(), XField::MaxBlockSize(maxblocksize));
+
+        // max u32
+        let max_size_bytes = Vec::from_hex("FFFFFFFF").unwrap();
+        let decoded_max:u32 = deserialize(&max_size_bytes).unwrap();
+        assert_eq!(XField::MaxBlockSize(u32::MAX).size(), 5);
+        assert_eq!(serialize(&decoded_max), max_size_bytes);
+
+        // zero
+        let zero_size_bytes = Vec::from_hex("00000000").unwrap();
+        let decoded_zero:u32 = deserialize(&zero_size_bytes).unwrap();
+        assert_eq!(XField::MaxBlockSize(0).size(), 5);
+        assert_eq!(serialize(&decoded_zero), zero_size_bytes);
+
+        // negative
+        let x:i32 = -1;
+        let hex_x = Vec::from_hex(&format!("{:08x}", x)).unwrap();
+        let decoded_x:u32 = deserialize(&hex_x).unwrap();
+        assert!(XField::from_str(&format!("{:08x}", decoded_x)).is_err());
+        assert!(XField::from_str(&format!("{:08x}", x)).is_err());
+
+        assert!(XField::from_str("pq").is_err());
+        assert!(XField::from_str("020001").is_err());
+    }
+
+    #[test]
+    #[should_panic]
+    fn xfield_max_block_size_panic_test() {
+        // larger than u32::MAX
+        let overflow_value:u64 = (u32::MAX as u64) + 1;
+        let overflow_bytes = hex!(&format!("{:016x}", overflow_value));
+        assert!(deserialize::<u32>(&overflow_bytes).is_err());
+        assert!(XField::from_str(&format!("{:016x}", overflow_value)).is_err());
+    }
+
+    #[test]
+    fn xfield_signature_hash_test_aggpubkey() {
+        let xfield = XField::AggregatePublicKey(PublicKey::from_str("02459adb8a8f052be94874aef7d4c3d3ddb71fcdaa869b1d515a92d63cb29c2806").unwrap());
+        assert_eq!(serialize(&xfield), hex!("012102459adb8a8f052be94874aef7d4c3d3ddb71fcdaa869b1d515a92d63cb29c2806"));
+        assert_eq!(xfield.signature_hash().unwrap(), XFieldHash::from_str("5eb6038f90ec3b530ebed8789afd4f3f49af83fa4b00f34238c93ce0327ff9ad").unwrap());
+    }
+
+    #[test]
+    fn xfield_signature_hash_test_maxblocksize() {
+        let xfield = XField::MaxBlockSize(200000);
+        assert_eq!(serialize(&xfield), hex!("02400d0300"));
+        assert_eq!(xfield.signature_hash().unwrap(), XFieldHash::from_str("b2a51fb82acc2125508f323fa9567340c32257997dfd4af4e70788031d5b1915").unwrap());
+    }
+
+    #[test]
+    fn xfield_signature_hash_test_aggpubkey1() {
+        let xfield = XField::AggregatePublicKey(PublicKey::from_str("0376c3265e7d81839c1b2312b95697d47cc5b3ab3369a92a5af52ef1c945792f50").unwrap());
+        assert_eq!(serialize(&xfield), hex!("01210376c3265e7d81839c1b2312b95697d47cc5b3ab3369a92a5af52ef1c945792f50"));
+        assert_eq!(xfield.signature_hash().unwrap(), XFieldHash::from_str("e70d5478d63e19ab2d9aa059340785b810f82cc288e83752e726a0f9817fcc88").unwrap());
+    }
+
+    #[test]
+    fn xfield_signature_hash_test_maxblocksize1() {
+        let xfield = XField::MaxBlockSize(400000);
+        assert_eq!(serialize(&xfield), hex!("02801a0600"));
+        assert_eq!(xfield.signature_hash().unwrap(), XFieldHash::from_str("7b5a43d2dae273d564ec0db616efe75a31725707fc3865124e3477684f5faec0").unwrap());
+    }
+
+    #[test]
+    fn xfield_signature_hash_test_none() {
+        let xfield = XField::None;
+        let result = xfield.signature_hash();
+
+        assert!(matches!(result, Err(Error::XFieldNone)));
+    }
+
+    #[test]
+    fn xfield_signature_hash_test_unknown() {
+        let xfield = XField::Unknown(3, hex!("012345"));
+        let result = xfield.signature_hash();
+
+        assert!(matches!(result, Err(Error::UnknownXField(3))));
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::{black_box, Bencher};
+
+    use super::Block;
+    use crate::consensus::{deserialize, Decodable, Encodable};
+    use crate::EmptyWrite;
+
+    #[bench]
+    #[ignore]
+    pub fn bench_stream_reader(bh: &mut Bencher) {
+        let big_block = include_bytes!("../../tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
+        assert_eq!(big_block.len(), 1_381_836);
+        let big_block = black_box(big_block);
+
+        bh.iter(|| {
+            let mut reader = &big_block[..];
+            let block = Block::consensus_decode(&mut reader).unwrap();
+            black_box(&block);
+        });
+    }
+
+    #[bench]
+    #[ignore]
+    pub fn bench_block_serialize(bh: &mut Bencher) {
+        let raw_block = include_bytes!("../../tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
+
+        let block: Block = deserialize(&raw_block[..]).unwrap();
+
+        let mut data = Vec::with_capacity(raw_block.len());
+
+        bh.iter(|| {
+            let result = block.consensus_encode(&mut data);
+            black_box(&result);
+            data.clear();
+        });
+    }
+
+    #[bench]
+    #[ignore]
+    pub fn bench_block_serialize_logic(bh: &mut Bencher) {
+        let raw_block = include_bytes!("../../tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
+
+        let block: Block = deserialize(&raw_block[..]).unwrap();
+
+        bh.iter(|| {
+            let size = block.consensus_encode(&mut EmptyWrite);
+            black_box(&size);
+        });
+    }
+
+    #[bench]
+    #[ignore]
+    pub fn bench_block_deserialize(bh: &mut Bencher) {
+        let raw_block = include_bytes!("../../tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw");
+
+        bh.iter(|| {
+            let block: Block = deserialize(&raw_block[..]).unwrap();
+            black_box(&block);
+        });
+    }
+}
diff --git a/tapyrus/src/blockdata/constants.rs b/tapyrus/src/blockdata/constants.rs
new file mode 100644
index 00000000..735cf4c7
--- /dev/null
+++ b/tapyrus/src/blockdata/constants.rs
@@ -0,0 +1,350 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Blockdata constants.
+//!
+//! This module provides various constants relating to the blockchain and
+//! consensus code. In particular, it defines the genesis block and its
+//! single transaction.
+//!
+
+use core::default::Default;
+use core::str::FromStr;
+
+use hashes::{sha256d, Hash};
+use hex_lit::hex;
+use internals::impl_array_newtype;
+
+use crate::alloc::string::ToString;
+use crate::amount::Amount;
+use crate::blockdata::block::{self, Block, XField};
+use crate::blockdata::locktime::absolute;
+use crate::blockdata::witness::Witness;
+use crate::consensus::deserialize;
+use crate::crypto::key::PublicKey;
+use crate::crypto::schnorr::Signature;
+use crate::internal_macros::impl_bytes_newtype;
+use crate::network::{NetworkId, ParseNetworkError};
+use crate::opcodes::all::*;
+use crate::transaction::{self, OutPoint, Sequence, Transaction, TxIn, TxOut};
+use crate::{script, MalFixTxid};
+
+#[deprecated(since = "0.31.0", note = "Use Weight::MAX_BLOCK instead")]
+/// The maximum allowed weight for a block, see BIP 141 (network rule).
+pub const MAX_BLOCK_WEIGHT: u32 = 4_000_000;
+
+#[deprecated(since = "0.31.0", note = "Use Weight::MIN_TRANSACTION instead")]
+/// The minimum transaction weight for a valid serialized transaction.
+pub const MIN_TRANSACTION_WEIGHT: u32 = 4 * 60;
+
+/// The factor that non-witness serialization data is multiplied by during weight calculation.
+pub const WITNESS_SCALE_FACTOR: usize = 4;
+/// The maximum allowed number of signature check operations in a block.
+pub const MAX_BLOCK_SIGOPS_COST: i64 = 80_000;
+/// Mainnet (tapyrus) pubkey address prefix.
+pub const PUBKEY_ADDRESS_PREFIX_MAIN: u8 = 0; // 0x00
+/// Mainnet (tapyrus) script address prefix.
+pub const SCRIPT_ADDRESS_PREFIX_MAIN: u8 = 5; // 0x05
+/// Mainnet (tapyrus) colored pubkey address prefix.
+pub const COLORED_PUBKEY_ADDRESS_PREFIX_MAIN: u8 = 1; // 0x01
+/// Mainnet (tapyrus) colored script address prefix.
+pub const COLORED_SCRIPT_ADDRESS_PREFIX_MAIN: u8 = 6; // 0x06
+
+/// Test (tesnet, signet, regtest) pubkey address prefix.
+pub const PUBKEY_ADDRESS_PREFIX_TEST: u8 = 111; // 0x6f
+/// Test (tesnet, signet, regtest) script address prefix.
+pub const SCRIPT_ADDRESS_PREFIX_TEST: u8 = 196; // 0xc4
+/// Test colored pubkey address prefix.
+pub const COLORED_PUBKEY_ADDRESS_PREFIX_TEST: u8 = 112; // 0x70
+/// Test colored script address prefix.
+pub const COLORED_SCRIPT_ADDRESS_PREFIX_TEST: u8 = 197; // 0xc5
+/// The maximum allowed script size.
+pub const MAX_SCRIPT_ELEMENT_SIZE: usize = 520;
+/// How may blocks between halvings.
+pub const SUBSIDY_HALVING_INTERVAL: u32 = 210_000;
+/// Maximum allowed value for an integer in Script.
+pub const MAX_SCRIPTNUM_VALUE: u32 = 0x80000000; // 2^31
+/// Number of blocks needed for an output from a coinbase transaction to be spendable.
+pub const COINBASE_MATURITY: u32 = 100;
+
+/// Constructs and returns the coinbase (and only) transaction of the Mainnet genesis block.
+fn mainnet_genesis_tx() -> Transaction {
+    // https://explorer.api.tapyrus.chaintope.com/tx/3231b5798aacd8ea40f3b580e741006a71335ed9a7538768ee4a193bc525c170
+    // Base
+    let mut ret = Transaction {
+        version: transaction::Version::ONE,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![],
+        output: vec![],
+    };
+
+    // Inputs
+    let in_script = script::Builder::new().into_script();
+    ret.input.push(TxIn {
+        previous_output: OutPoint::new(MalFixTxid::all_zeros(), 0),
+        script_sig: in_script,
+        sequence: Sequence::MAX,
+        witness: Witness::default(),
+    });
+
+    // Outputs
+    let script_bytes = hex!("314a586d6e436a646453394644366252797a4348376457716844667735486f38794c");
+    let out_script = script::Builder::new()
+        .push_opcode(OP_DUP)
+        .push_opcode(OP_HASH160)
+        .push_slice(script_bytes)
+        .push_opcode(OP_EQUALVERIFY)
+        .push_opcode(OP_CHECKSIG)
+        .into_script();
+    ret.output.push(TxOut { value: Amount::from_tap(50 * 100_000_000), script_pubkey: out_script });
+
+    // end
+    ret
+}
+
+/// Constructs and returns the coinbase (and only) transaction of the Testnet genesis block.
+fn testnet_genesis_tx() -> Transaction {
+    // https://testnet-explorer.tapyrus.dev.chaintope.com/tx/846521b8ff0b89fee8b99d089ffe403856e912c7fc34486d9dbbf03625ec188f
+    // Base
+    let mut ret = Transaction {
+        version: transaction::Version::ONE,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![],
+        output: vec![],
+    };
+
+    // Inputs
+    let in_script = script::Builder::new().into_script();
+    ret.input.push(TxIn {
+        previous_output: OutPoint::new(MalFixTxid::all_zeros(), 0),
+        script_sig: in_script,
+        sequence: Sequence::MAX,
+        witness: Witness::default(),
+    });
+
+    // Outputs
+    let script_bytes = hex!("31415132437447336a686f37385372457a4b6533766636647863456b4a74356e7a41");
+    let out_script = script::Builder::new()
+        .push_opcode(OP_DUP)
+        .push_opcode(OP_HASH160)
+        .push_slice(script_bytes)
+        .push_opcode(OP_EQUALVERIFY)
+        .push_opcode(OP_CHECKSIG)
+        .into_script();
+    ret.output.push(TxOut { value: Amount::from_tap(50 * 100_000_000), script_pubkey: out_script });
+
+    // end
+    ret
+}
+
+/// Constructs and returns the Mainnet genesis block.
+pub fn mainnet_genesis_block() -> Block {
+    // https://explorer.api.tapyrus.chaintope.com/block/92f729508ee8b0e4f46418f81f89806a952c739df03de1e666a8e2b5c40b549b
+    let txdata = vec![mainnet_genesis_tx()];
+    let hash: sha256d::Hash = txdata[0].txid().into();
+    let im_merkle_root = txdata[0].malfix_txid().to_raw_hash().into();
+    let merkle_root = hash.into();
+    let public_key =
+        PublicKey::from_str("02bb8a7fbba7da4e6a0519296e30211c33c7307ac19aba4e8f56cce2d3da36b751")
+            .unwrap();
+    let sig_data = hex!("fb1edbb9eac53c4a1e67c510c7fe7eefd6f5080c74df88a679cf3853e0784231979b3896b577ed3bb987d1a38fd0901d5f68f38cb0c07aea519885022428cede");
+    let sig: Signature = deserialize(&sig_data).unwrap();
+    Block {
+        header: block::Header {
+            version: block::Version::ONE,
+            prev_blockhash: Hash::all_zeros(),
+            merkle_root,
+            im_merkle_root,
+            time: 1637827301,
+            xfield: XField::AggregatePublicKey(public_key),
+            proof: Some(sig),
+        },
+        txdata,
+    }
+}
+
+/// Constructs and returns the Testnet genesis block.
+pub fn testnet_genesis_block() -> Block {
+    // https://testnet-explorer.tapyrus.dev.chaintope.com/block/038b114875c2f78f5a2fd7d8549a905f38ea5faee6e29a3d79e547151d6bdd8a
+    let txdata = vec![testnet_genesis_tx()];
+    let hash: sha256d::Hash = txdata[0].txid().into();
+    let im_merkle_root = txdata[0].malfix_txid().to_raw_hash().into();
+    let merkle_root = hash.into();
+    let public_key =
+        PublicKey::from_str("0366262690cbdf648132ce0c088962c6361112582364ede120f3780ab73438fc4b")
+            .unwrap();
+    let sig_data = hex!("2b1ed9996920f57a425f6f9797557c0e73d0c9fbafdebcaa796b136e0946ffa98d928f8130b6a572f83da39530b13784eeb7007465b673aa95091619e7ee2085");
+    let sig: Signature = deserialize(&sig_data).unwrap();
+    Block {
+        header: block::Header {
+            version: block::Version::ONE,
+            prev_blockhash: Hash::all_zeros(),
+            merkle_root,
+            im_merkle_root,
+            time: 1589269151,
+            xfield: XField::AggregatePublicKey(public_key),
+            proof: Some(sig),
+        },
+        txdata,
+    }
+}
+/// The uniquely identifying hash of the target blockchain.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ChainHash([u8; 32]);
+impl_array_newtype!(ChainHash, u8, 32);
+impl_bytes_newtype!(ChainHash, 32);
+
+impl ChainHash {
+    /// `ChainHash` for mainnet network.
+    pub const MAINNET: Self = Self([
+        155, 84, 11, 196, 181, 226, 168, 102, 230, 225, 61, 240, 157, 115, 44, 149, 106, 128, 137,
+        31, 248, 24, 100, 244, 228, 176, 232, 142, 80, 41, 247, 146,
+    ]);
+    /// `ChainHash` for testnet network.
+    pub const TESTNET: Self = Self([
+        138, 221, 107, 29, 21, 71, 229, 121, 61, 154, 226, 230, 174, 95, 234, 56, 95, 144, 154, 84,
+        216, 215, 47, 90, 143, 247, 194, 117, 72, 17, 139, 3,
+    ]);
+
+    /// Returns the hash of the `network` genesis block for use as a chain hash.
+    ///
+    /// See [BOLT 0](https://github.com/lightning/bolts/blob/ffeece3dab1c52efdb9b53ae476539320fa44938/00-introduction.md#chain_hash)
+    /// for specification.
+    pub fn using_genesis_block(network_id: NetworkId) -> Result<ChainHash, ParseNetworkError> {
+        // https://github.com/chaintope/tapyrus-core/blob/master/doc/tapyrus/network_id_and_magic_bytes.md
+        let magic = network_id.magic();
+        match magic {
+            0x00F0FF01 => Ok(Self::MAINNET),
+            0x74839A75 => Ok(Self::TESTNET),
+            _ => Err(ParseNetworkError("Network id is unknown.".to_string())),
+        }
+    }
+
+    /// Converts genesis block hash into `ChainHash`.
+    pub fn from_genesis_block_hash(block_hash: crate::BlockHash) -> Self {
+        ChainHash(block_hash.to_byte_array())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use core::str::FromStr;
+
+    use hex::test_hex_unwrap as hex;
+
+    use super::*;
+    use crate::blockdata::locktime::absolute;
+    use crate::blockdata::transaction;
+    use crate::consensus::encode::serialize;
+
+    #[test]
+    fn mainnet_genesis_first_transaction() {
+        let gen = mainnet_genesis_tx();
+
+        assert_eq!(gen.version, transaction::Version::ONE);
+        assert_eq!(gen.input.len(), 1);
+        assert_eq!(gen.input[0].previous_output.txid, Hash::all_zeros());
+        assert_eq!(gen.input[0].previous_output.vout, 0);
+        assert_eq!(gen.input[0].script_sig, script::Builder::new().into_script());
+
+        assert_eq!(gen.input[0].sequence, Sequence::MAX);
+        assert_eq!(gen.output.len(), 1);
+        assert_eq!(
+            serialize(&gen.output[0].script_pubkey),
+            hex!(
+                "2776a922314a586d6e436a646453394644366252797a4348376457716844667735486f38794c88ac"
+            )
+        );
+        assert_eq!(gen.output[0].value, Amount::from_str("50 TPC").unwrap());
+        assert_eq!(gen.lock_time, absolute::LockTime::ZERO);
+
+        assert_eq!(
+            gen.txid().to_string(),
+            "075565bbdccaefe1c8f9372414767b1a49f4463b01bd9f98c03680bc51ca5bb2"
+        );
+        assert_eq!(
+            gen.malfix_txid().to_string(),
+            "3231b5798aacd8ea40f3b580e741006a71335ed9a7538768ee4a193bc525c170"
+        );
+    }
+
+    #[test]
+    fn mainnet_genesis_full_block() {
+        let gen = mainnet_genesis_block();
+
+        assert_eq!(gen.header.version, block::Version::ONE);
+        assert_eq!(gen.header.prev_blockhash, Hash::all_zeros());
+        assert_eq!(
+            gen.header.merkle_root.to_string(),
+            "075565bbdccaefe1c8f9372414767b1a49f4463b01bd9f98c03680bc51ca5bb2"
+        );
+
+        assert_eq!(gen.header.time, 1637827301);
+        assert_eq!(
+            gen.header.block_hash().to_string(),
+            "92f729508ee8b0e4f46418f81f89806a952c739df03de1e666a8e2b5c40b549b"
+        );
+    }
+
+    #[test]
+    fn testnet_genesis_full_block() {
+        let gen = testnet_genesis_block();
+        assert_eq!(gen.header.version, block::Version::ONE);
+        assert_eq!(gen.header.prev_blockhash, Hash::all_zeros());
+        assert_eq!(
+            gen.header.merkle_root.to_string(),
+            "51b341a85575219820ad1175f93a22a83f190dfcd1139a995b5ce9d01b18cc44"
+        );
+        assert_eq!(gen.header.time, 1589269151);
+        assert_eq!(
+            gen.header.block_hash().to_string(),
+            "038b114875c2f78f5a2fd7d8549a905f38ea5faee6e29a3d79e547151d6bdd8a"
+        );
+    }
+
+    // The *_chain_hash tests are sanity/regression tests, they verify that the const byte array
+    // representing the genesis block is the same as that created by hashing the genesis block.
+    fn chain_hash_and_genesis_block(network_id: NetworkId) {
+        use hashes::sha256;
+
+        // The genesis block hash is a double-sha256 and it is displayed backwards.
+        let magic = network_id.magic();
+        let genesis_hash = match magic {
+            0x00F0FF01 => mainnet_genesis_block().block_hash(),
+            0x74839A75 => testnet_genesis_block().block_hash(),
+            _ => panic!("Network ID is not supported"),
+        };
+        // We abuse the sha256 hash here so we get a LowerHex impl that does not print the hex backwards.
+        let hash = sha256::Hash::from_slice(genesis_hash.as_byte_array()).unwrap();
+        let want = format!("{:02x}", hash);
+
+        let chain_hash = ChainHash::using_genesis_block(network_id).unwrap();
+        let got = format!("{:02x}", chain_hash);
+
+        // Compare strings because the spec specifically states how the chain hash must encode to hex.
+        assert_eq!(got, want);
+    }
+
+    macro_rules! chain_hash_genesis_block {
+        ($($test_name:ident, $network:expr);* $(;)*) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    chain_hash_and_genesis_block($network);
+                }
+            )*
+        }
+    }
+
+    chain_hash_genesis_block! {
+        mainnet_chain_hash_genesis_block, NetworkId::PRODUCTION;
+        testnet_chain_hash_genesis_block, NetworkId::TESTNET;
+    }
+
+    // Test vector taken from: https://github.com/lightning/bolts/blob/master/00-introduction.md
+    #[test]
+    fn mainnet_chain_hash_test_vector() {
+        let got = ChainHash::using_genesis_block(NetworkId::PRODUCTION).unwrap().to_string();
+        let want = "9b540bc4b5e2a866e6e13df09d732c956a80891ff81864f4e4b0e88e5029f792";
+        assert_eq!(got, want);
+    }
+}
diff --git a/tapyrus/src/blockdata/fee_rate.rs b/tapyrus/src/blockdata/fee_rate.rs
new file mode 100644
index 00000000..c400065f
--- /dev/null
+++ b/tapyrus/src/blockdata/fee_rate.rs
@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Implements `FeeRate` and assoctiated features.
+
+use core::fmt;
+use core::ops::{Div, Mul};
+
+use super::Weight;
+use crate::prelude::*;
+use crate::Amount;
+
+/// Represents fee rate.
+///
+/// This is an integer newtype representing fee rate in `tap/kwu`. It provides protection against mixing
+/// up the types as well as basic formatting features.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+pub struct FeeRate(u64);
+
+impl FeeRate {
+    /// 0 tap/kwu.
+    ///
+    /// Equivalent to [`MIN`](Self::MIN), may better express intent in some contexts.
+    pub const ZERO: FeeRate = FeeRate(0);
+
+    /// Minimum possible value (0 tap/kwu).
+    ///
+    /// Equivalent to [`ZERO`](Self::ZERO), may better express intent in some contexts.
+    pub const MIN: FeeRate = FeeRate::ZERO;
+
+    /// Maximum possible value.
+    pub const MAX: FeeRate = FeeRate(u64::MAX);
+
+    /// Minimum fee rate required to broadcast a transaction.
+    ///
+    /// The value matches the default Bitcoin Core policy at the time of library release.
+    pub const BROADCAST_MIN: FeeRate = FeeRate::from_tap_per_vb_unchecked(1);
+
+    /// Fee rate used to compute dust amount.
+    pub const DUST: FeeRate = FeeRate::from_tap_per_vb_unchecked(3);
+
+    /// Constructs `FeeRate` from tapyruses per 1000 weight units.
+    pub const fn from_tap_per_kwu(tap_kwu: u64) -> Self { FeeRate(tap_kwu) }
+
+    /// Constructs `FeeRate` from tapyruses per virtual bytes.
+    ///
+    /// # Errors
+    ///
+    /// Returns `None` on arithmetic overflow.
+    pub fn from_tap_per_vb(tap_vb: u64) -> Option<Self> {
+        // 1 vb == 4 wu
+        // 1 tap/vb == 1/4 tap/wu
+        // tap_vb tap/vb * 1000 / 4 == tap/kwu
+        Some(FeeRate(tap_vb.checked_mul(1000 / 4)?))
+    }
+
+    /// Constructs `FeeRate` from tapyruses per virtual bytes without overflow check.
+    pub const fn from_tap_per_vb_unchecked(tap_vb: u64) -> Self { FeeRate(tap_vb * (1000 / 4)) }
+
+    /// Returns raw fee rate.
+    ///
+    /// Can be used instead of `into()` to avoid inference issues.
+    pub const fn to_tap_per_kwu(self) -> u64 { self.0 }
+
+    /// Converts to tap/vB rounding down.
+    pub const fn to_tap_per_vb_floor(self) -> u64 { self.0 / (1000 / 4) }
+
+    /// Converts to tap/vB rounding up.
+    pub const fn to_tap_per_vb_ceil(self) -> u64 { (self.0 + (1000 / 4 - 1)) / (1000 / 4) }
+
+    /// Checked multiplication.
+    ///
+    /// Computes `self * rhs` returning `None` if overflow occurred.
+    pub fn checked_mul(self, rhs: u64) -> Option<Self> { self.0.checked_mul(rhs).map(Self) }
+
+    /// Checked division.
+    ///
+    /// Computes `self / rhs` returning `None` if `rhs == 0`.
+    pub fn checked_div(self, rhs: u64) -> Option<Self> { self.0.checked_div(rhs).map(Self) }
+
+    /// Checked weight multiplication.
+    ///
+    /// Computes the absolute fee amount for a given [`Weight`] at this fee rate.
+    ///
+    /// `None` is returned if an overflow occurred.
+    pub fn checked_mul_by_weight(self, rhs: Weight) -> Option<Amount> {
+        let taps = self.0.checked_mul(rhs.to_wu())?.checked_add(999)? / 1000;
+        Some(Amount::from_tap(taps))
+    }
+
+    /// Calculates fee by multiplying this fee rate by weight, in weight units, returning `None`
+    /// if overflow occurred.
+    ///
+    /// This is equivalent to `Self::checked_mul_by_weight()`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use tapyrus::{absolute, transaction, FeeRate, Transaction};
+    /// # // Dummy transaction.
+    /// # let tx = Transaction { version: transaction::Version::ONE, lock_time: absolute::LockTime::ZERO, input: vec![], output: vec![] };
+    ///
+    /// let rate = FeeRate::from_tap_per_vb(1).expect("1 tap/vbyte is valid");
+    /// let fee = rate.fee_wu(tx.weight()).unwrap();
+    /// assert_eq!(fee.to_tap(), tx.vsize() as u64);
+    /// ```
+    pub fn fee_wu(self, weight: Weight) -> Option<Amount> { self.checked_mul_by_weight(weight) }
+
+    /// Calculates fee by multiplying this fee rate by weight, in virtual bytes, returning `None`
+    /// if overflow occurred.
+    ///
+    /// This is equivalent to converting `vb` to `weight` using `Weight::from_vb` and then calling
+    /// `Self::fee_wu(weight)`.
+    pub fn fee_vb(self, vb: u64) -> Option<Amount> {
+        Weight::from_vb(vb).and_then(|w| self.fee_wu(w))
+    }
+}
+
+/// Alternative will display the unit.
+impl fmt::Display for FeeRate {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if f.alternate() {
+            write!(f, "{}.00 tap/vbyte", self.to_tap_per_vb_ceil())
+        } else {
+            fmt::Display::fmt(&self.0, f)
+        }
+    }
+}
+
+impl From<FeeRate> for u64 {
+    fn from(value: FeeRate) -> Self { value.to_tap_per_kwu() }
+}
+
+/// Computes ceiling so that fee computation is conservative.
+impl Mul<FeeRate> for Weight {
+    type Output = Amount;
+
+    fn mul(self, rhs: FeeRate) -> Self::Output {
+        Amount::from_tap((rhs.to_tap_per_kwu() * self.to_wu() + 999) / 1000)
+    }
+}
+
+impl Mul<Weight> for FeeRate {
+    type Output = Amount;
+
+    fn mul(self, rhs: Weight) -> Self::Output { rhs * self }
+}
+
+impl Div<Weight> for Amount {
+    type Output = FeeRate;
+
+    fn div(self, rhs: Weight) -> Self::Output { FeeRate(self.to_tap() * 1000 / rhs.to_wu()) }
+}
+
+crate::parse::impl_parse_str_from_int_infallible!(FeeRate, u64, from_tap_per_kwu);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fee_rate_const_test() {
+        assert_eq!(0, FeeRate::ZERO.to_tap_per_kwu());
+        assert_eq!(u64::MIN, FeeRate::MIN.to_tap_per_kwu());
+        assert_eq!(u64::MAX, FeeRate::MAX.to_tap_per_kwu());
+        assert_eq!(250, FeeRate::BROADCAST_MIN.to_tap_per_kwu());
+        assert_eq!(750, FeeRate::DUST.to_tap_per_kwu());
+    }
+
+    #[test]
+    fn fee_rate_from_tap_per_vb_test() {
+        let fee_rate = FeeRate::from_tap_per_vb(10).expect("expected feerate in tap/kwu");
+        assert_eq!(FeeRate(2500), fee_rate);
+    }
+
+    #[test]
+    fn fee_rate_from_tap_per_vb_overflow_test() {
+        let fee_rate = FeeRate::from_tap_per_vb(u64::MAX);
+        assert!(fee_rate.is_none());
+    }
+
+    #[test]
+    fn from_tap_per_vb_unchecked_test() {
+        let fee_rate = FeeRate::from_tap_per_vb_unchecked(10);
+        assert_eq!(FeeRate(2500), fee_rate);
+    }
+
+    #[test]
+    #[should_panic]
+    fn from_tap_per_vb_unchecked_panic_test() { FeeRate::from_tap_per_vb_unchecked(u64::MAX); }
+
+    #[test]
+    fn raw_feerate_test() {
+        let fee_rate = FeeRate(333);
+        assert_eq!(333, fee_rate.to_tap_per_kwu());
+        assert_eq!(1, fee_rate.to_tap_per_vb_floor());
+        assert_eq!(2, fee_rate.to_tap_per_vb_ceil());
+    }
+
+    #[test]
+    fn checked_mul_test() {
+        let fee_rate = FeeRate(10).checked_mul(10).expect("expected feerate in tap/kwu");
+        assert_eq!(FeeRate(100), fee_rate);
+
+        let fee_rate = FeeRate(10).checked_mul(u64::MAX);
+        assert!(fee_rate.is_none());
+    }
+
+    #[test]
+    fn checked_weight_mul_test() {
+        let weight = Weight::from_vb(10).unwrap();
+        let fee: Amount = FeeRate::from_tap_per_vb(10)
+            .unwrap()
+            .checked_mul_by_weight(weight)
+            .expect("expected Amount");
+        assert_eq!(Amount::from_tap(100), fee);
+
+        let fee = FeeRate(10).checked_mul_by_weight(Weight::MAX);
+        assert!(fee.is_none());
+
+        let weight = Weight::from_vb(3).unwrap();
+        let fee_rate = FeeRate::from_tap_per_vb(3).unwrap();
+        let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
+        assert_eq!(Amount::from_tap(9), fee);
+    }
+
+    #[test]
+    fn checked_div_test() {
+        let fee_rate = FeeRate(10).checked_div(10).expect("expected feerate in sat/kwu");
+        assert_eq!(FeeRate(1), fee_rate);
+
+        let fee_rate = FeeRate(10).checked_div(0);
+        assert!(fee_rate.is_none());
+    }
+
+    #[test]
+    fn fee_convenience_functions_agree() {
+        use hex::test_hex_unwrap as hex;
+
+        use crate::blockdata::transaction::Transaction;
+        use crate::consensus::Decodable;
+
+        const SOME_TX: &str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
+
+        let raw_tx = hex!(SOME_TX);
+        let tx: Transaction = Decodable::consensus_decode(&mut raw_tx.as_slice()).unwrap();
+
+        let rate = FeeRate::from_tap_per_vb(1).expect("1 sat/byte is valid");
+
+        assert_eq!(rate.fee_vb(tx.vsize() as u64), rate.fee_wu(tx.weight()));
+    }
+}
diff --git a/tapyrus/src/blockdata/locktime/absolute.rs b/tapyrus/src/blockdata/locktime/absolute.rs
new file mode 100644
index 00000000..427d4224
--- /dev/null
+++ b/tapyrus/src/blockdata/locktime/absolute.rs
@@ -0,0 +1,853 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Provides type [`LockTime`] that implements the logic around nLockTime/OP_CHECKLOCKTIMEVERIFY.
+//!
+//! There are two types of lock time: lock-by-blockheight and lock-by-blocktime, distinguished by
+//! whether `LockTime < LOCKTIME_THRESHOLD`.
+//!
+
+use core::cmp::{Ordering, PartialOrd};
+use core::{fmt, mem};
+
+use internals::write_err;
+#[cfg(all(test, mutate))]
+use mutagen::mutate;
+
+#[cfg(doc)]
+use crate::absolute;
+use crate::consensus::encode::{self, Decodable, Encodable};
+use crate::error::ParseIntError;
+use crate::io::{self, Read, Write};
+use crate::parse::{impl_parse_str_from_int_fallible, impl_parse_str_from_int_infallible};
+use crate::prelude::*;
+use crate::string::FromHexStr;
+
+/// The Threshold for deciding whether a lock time value is a height or a time (see [Bitcoin Core]).
+///
+/// `LockTime` values _below_ the threshold are interpreted as block heights, values _above_ (or
+/// equal to) the threshold are interpreted as block times (UNIX timestamp, seconds since epoch).
+///
+/// Bitcoin is able to safely use this value because a block height greater than 500,000,000 would
+/// never occur because it would represent a height in approximately 9500 years. Conversely, block
+/// times under 500,000,000 will never happen because they would represent times before 1986 which
+/// are, for obvious reasons, not useful within the Bitcoin network.
+///
+/// [Bitcoin Core]: https://github.com/bitcoin/bitcoin/blob/9ccaee1d5e2e4b79b0a7c29aadb41b97e4741332/src/script/script.h#L39
+pub const LOCK_TIME_THRESHOLD: u32 = 500_000_000;
+
+/// An absolute lock time value, representing either a block height or a UNIX timestamp (seconds
+/// since epoch).
+///
+/// Used for transaction lock time (`nLockTime` in Bitcoin Core and [`crate::Transaction::lock_time`]
+/// in this library) and also for the argument to opcode 'OP_CHECKLOCKTIMEVERIFY`.
+///
+/// ### Note on ordering
+///
+/// Because locktimes may be height- or time-based, and these metrics are incommensurate, there
+/// is no total ordering on locktimes. We therefore have implemented [`PartialOrd`] but not [`Ord`].
+/// For [`crate::Transaction`], which has a locktime field, we implement a total ordering to make
+/// it easy to store transactions in sorted data structures, and use the locktime's 32-bit integer
+/// consensus encoding to order it.
+///
+/// ### Relevant BIPs
+///
+/// * [BIP-65 OP_CHECKLOCKTIMEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
+/// * [BIP-113 Median time-past as endpoint for lock-time calculations](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki)
+///
+/// # Examples
+/// ```
+/// # use tapyrus::absolute::{LockTime, LockTime::*};
+/// # let n = LockTime::from_consensus(741521);          // n OP_CHECKLOCKTIMEVERIFY
+/// # let lock_time = LockTime::from_consensus(741521);  // nLockTime
+/// // To compare absolute lock times there are various `is_satisfied_*` methods, you may also use:
+/// let is_satisfied = match (n, lock_time) {
+///     (Blocks(n), Blocks(lock_time)) => n <= lock_time,
+///     (Seconds(n), Seconds(lock_time)) => n <= lock_time,
+///     _ => panic!("handle invalid comparison error"),
+/// };
+/// ```
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub enum LockTime {
+    /// A block height lock time value.
+    ///
+    /// # Examples
+    /// ```rust
+    /// use tapyrus::absolute::LockTime;
+    ///
+    /// let block: u32 = 741521;
+    /// let n = LockTime::from_height(block).expect("valid height");
+    /// assert!(n.is_block_height());
+    /// assert_eq!(n.to_consensus_u32(), block);
+    /// ```
+    Blocks(Height),
+    /// A UNIX timestamp lock time value.
+    ///
+    /// # Examples
+    /// ```rust
+    /// use tapyrus::absolute::LockTime;
+    ///
+    /// let seconds: u32 = 1653195600; // May 22nd, 5am UTC.
+    /// let n = LockTime::from_time(seconds).expect("valid time");
+    /// assert!(n.is_block_time());
+    /// assert_eq!(n.to_consensus_u32(), seconds);
+    /// ```
+    Seconds(Time),
+}
+
+impl LockTime {
+    /// 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: LockTime = LockTime::Blocks(Height::ZERO);
+
+    /// The number of bytes that the locktime contributes to the size of a transaction.
+    pub const SIZE: usize = 4; // Serialized length of a u32.
+
+    /// Constructs a `LockTime` from an nLockTime value or the argument to OP_CHEKCLOCKTIMEVERIFY.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tapyrus::absolute::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;
+    /// let lock_time = LockTime::from_consensus(n_lock_time);
+    /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
+    #[inline]
+    pub fn from_consensus(n: u32) -> Self {
+        if is_block_height(n) {
+            Self::Blocks(Height::from_consensus(n).expect("n is valid"))
+        } else {
+            Self::Seconds(Time::from_consensus(n).expect("n is valid"))
+        }
+    }
+
+    /// Constructs a `LockTime` from `n`, expecting `n` to be a valid block height.
+    ///
+    /// See [`LOCK_TIME_THRESHOLD`] for definition of a valid height value.
+    ///
+    /// # Examples
+    /// ```rust
+    /// # use tapyrus::absolute::LockTime;
+    /// assert!(LockTime::from_height(741521).is_ok());
+    /// assert!(LockTime::from_height(1653195600).is_err());
+    /// ```
+    #[inline]
+    pub fn from_height(n: u32) -> Result<Self, Error> {
+        let height = Height::from_consensus(n)?;
+        Ok(LockTime::Blocks(height))
+    }
+
+    /// Constructs a `LockTime` from `n`, expecting `n` to be a valid block time.
+    ///
+    /// See [`LOCK_TIME_THRESHOLD`] for definition of a valid time value.
+    ///
+    /// # Examples
+    /// ```rust
+    /// # use tapyrus::absolute::LockTime;
+    /// assert!(LockTime::from_time(1653195600).is_ok());
+    /// assert!(LockTime::from_time(741521).is_err());
+    /// ```
+    #[inline]
+    pub fn from_time(n: u32) -> Result<Self, Error> {
+        let time = Time::from_consensus(n)?;
+        Ok(LockTime::Seconds(time))
+    }
+
+    /// Returns true if both lock times use the same unit i.e., both height based or both time based.
+    #[inline]
+    pub fn is_same_unit(&self, other: LockTime) -> bool {
+        mem::discriminant(self) == mem::discriminant(&other)
+    }
+
+    /// Returns true if this lock time value is a block height.
+    #[inline]
+    pub fn is_block_height(&self) -> bool {
+        match *self {
+            LockTime::Blocks(_) => true,
+            LockTime::Seconds(_) => false,
+        }
+    }
+
+    /// Returns true if this lock time value is a block time (UNIX timestamp).
+    #[inline]
+    pub fn is_block_time(&self) -> bool { !self.is_block_height() }
+
+    /// Returns true if this timelock constraint is satisfied by the respective `height`/`time`.
+    ///
+    /// If `self` is a blockheight based lock then it is checked against `height` and if `self` is a
+    /// blocktime based lock it is checked against `time`.
+    ///
+    /// A 'timelock constraint' refers to the `n` from `n OP_CHEKCLOCKTIMEVERIFY`, this constraint
+    /// is satisfied if a transaction with nLockTime ([`crate::Transaction::lock_time`]) set to
+    /// `height`/`time` is valid.
+    ///
+    /// # Examples
+    /// ```no_run
+    /// # use tapyrus::absolute::{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") }
+    ///
+    /// let n = LockTime::from_consensus(741521); // `n OP_CHEKCLOCKTIMEVERIFY`.
+    /// if n.is_satisfied_by(get_height(), get_time()) {
+    ///     // Can create and mine a transaction that satisfies the OP_CLTV timelock constraint.
+    /// }
+    /// ````
+    #[inline]
+    #[cfg_attr(all(test, mutate), mutate)]
+    pub fn is_satisfied_by(&self, height: Height, time: Time) -> bool {
+        use LockTime::*;
+
+        match *self {
+            Blocks(n) => n <= height,
+            Seconds(n) => n <= time,
+        }
+    }
+
+    /// Returns true if satisfaction of `other` lock time implies satisfaction of this
+    /// [`absolute::LockTime`].
+    ///
+    /// A lock time can only be satisfied by n blocks being mined or n seconds passing. If you have
+    /// two lock times (same unit) then the larger lock time being satisfied implies (in a
+    /// mathematical sense) the smaller one being satisfied.
+    ///
+    /// This function is useful if you wish to check a lock time against various other locks e.g.,
+    /// filtering out locks which cannot be satisfied. Can also be used to remove the smaller value
+    /// of two `OP_CHECKLOCKTIMEVERIFY` operations within one branch of the script.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tapyrus::absolute::{LockTime, LockTime::*};
+    /// let lock_time = LockTime::from_consensus(741521);
+    /// let check = LockTime::from_consensus(741521 + 1);
+    /// assert!(lock_time.is_implied_by(check));
+    /// ```
+    #[inline]
+    #[cfg_attr(all(test, mutate), mutate)]
+    pub fn is_implied_by(&self, other: LockTime) -> bool {
+        use LockTime::*;
+
+        match (*self, other) {
+            (Blocks(this), Blocks(other)) => this <= other,
+            (Seconds(this), Seconds(other)) => this <= other,
+            _ => false, // Not the same units.
+        }
+    }
+
+    /// Returns the inner `u32` value. This is the value used when creating this `LockTime`
+    /// i.e., `n OP_CHECKLOCKTIMEVERIFY` or nLockTime.
+    ///
+    /// # Warning
+    ///
+    /// Do not compare values return by this method. The whole point of the `LockTime` type is to
+    /// assist in doing correct comparisons. Either use `is_satisfied_by`, `is_satisfied_by_lock`,
+    /// or use the pattern below:
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tapyrus::absolute::{LockTime, LockTime::*};
+    /// # let n = LockTime::from_consensus(741521);              // n OP_CHECKLOCKTIMEVERIFY
+    /// # let lock_time = LockTime::from_consensus(741521 + 1);  // nLockTime
+    ///
+    /// let is_satisfied = match (n, lock_time) {
+    ///     (Blocks(n), Blocks(lock_time)) => n <= lock_time,
+    ///     (Seconds(n), Seconds(lock_time)) => n <= lock_time,
+    ///     _ => panic!("invalid comparison"),
+    /// };
+    ///
+    /// // Or, if you have Rust 1.53 or greater
+    /// // let is_satisfied = n.partial_cmp(&lock_time).expect("invalid comparison").is_le();
+    /// ```
+    #[inline]
+    pub fn to_consensus_u32(self) -> u32 {
+        match self {
+            LockTime::Blocks(ref h) => h.to_consensus_u32(),
+            LockTime::Seconds(ref t) => t.to_consensus_u32(),
+        }
+    }
+}
+
+impl_parse_str_from_int_infallible!(LockTime, u32, from_consensus);
+
+impl From<Height> for LockTime {
+    #[inline]
+    fn from(h: Height) -> Self { LockTime::Blocks(h) }
+}
+
+impl From<Time> for LockTime {
+    #[inline]
+    fn from(t: Time) -> Self { LockTime::Seconds(t) }
+}
+
+impl PartialOrd for LockTime {
+    #[inline]
+    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),
+            (_, _) => None,
+        }
+    }
+}
+
+impl fmt::Debug for LockTime {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use LockTime::*;
+
+        match *self {
+            Blocks(ref h) => write!(f, "{} blocks", h),
+            Seconds(ref t) => write!(f, "{} seconds", t),
+        }
+    }
+}
+
+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),
+            }
+        } else {
+            match *self {
+                Blocks(ref h) => fmt::Display::fmt(h, f),
+                Seconds(ref t) => fmt::Display::fmt(t, f),
+            }
+        }
+    }
+}
+
+impl FromHexStr for LockTime {
+    type Error = Error;
+
+    #[inline]
+    fn from_hex_str_no_prefix<S: AsRef<str> + Into<String>>(s: S) -> Result<Self, Self::Error> {
+        let packed_lock_time = crate::parse::hex_u32(s)?;
+        Ok(Self::from_consensus(packed_lock_time))
+    }
+}
+
+impl Encodable for LockTime {
+    #[inline]
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let v = self.to_consensus_u32();
+        v.consensus_encode(w)
+    }
+}
+
+impl Decodable for LockTime {
+    #[inline]
+    fn consensus_decode<R: Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        u32::consensus_decode(r).map(LockTime::from_consensus)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for LockTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_u32(self.to_consensus_u32())
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for LockTime {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = u32;
+            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("a u32") }
+            // We cannot just implement visit_u32 because JSON (among other things) always
+            // calls visit_u64, even when called from Deserializer::deserialize_u32. The
+            // other visit_u*s have default implementations that forward to visit_u64.
+            fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<u32, E> {
+                use core::convert::TryInto;
+                v.try_into().map_err(|_| {
+                    E::invalid_value(serde::de::Unexpected::Unsigned(v), &"a 32-bit number")
+                })
+            }
+            // Also do the signed version, just for good measure.
+            fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<u32, E> {
+                use core::convert::TryInto;
+                v.try_into().map_err(|_| {
+                    E::invalid_value(serde::de::Unexpected::Signed(v), &"a 32-bit number")
+                })
+            }
+        }
+        deserializer.deserialize_u32(Visitor).map(LockTime::from_consensus)
+    }
+}
+
+/// 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 {
+    /// Absolute block height 0, the genesis block.
+    pub const ZERO: Self = Height(0);
+
+    /// The minimum absolute block height (0), the genesis block.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum absolute block height.
+    pub const MAX: Self = Height(LOCK_TIME_THRESHOLD - 1);
+
+    /// The minimum absolute block height (0), the genesis block.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Height::MIN`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
+    pub const fn min_value() -> Self { Self::MIN }
+
+    /// The maximum absolute block height.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Height::MAX`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
+    pub const fn max_value() -> Self { Self::MAX }
+
+    /// Constructs a new block height.
+    ///
+    /// # Errors
+    ///
+    /// If `n` does not represent a block height value (see documentation on [`LockTime`]).
+    ///
+    /// # Examples
+    /// ```rust
+    /// use tapyrus::locktime::absolute::Height;
+    ///
+    /// let h: u32 = 741521;
+    /// let height = Height::from_consensus(h).expect("invalid height value");
+    /// assert_eq!(height.to_consensus_u32(), h);
+    /// ```
+    #[inline]
+    pub fn from_consensus(n: u32) -> Result<Height, Error> {
+        if is_block_height(n) {
+            Ok(Self(n))
+        } else {
+            Err(ConversionError::invalid_height(n).into())
+        }
+    }
+
+    /// Converts this `Height` to its inner `u32` value.
+    ///
+    /// # Examples
+    /// ```rust
+    /// use tapyrus::absolute::LockTime;
+    ///
+    /// let n_lock_time: u32 = 741521;
+    /// let lock_time = LockTime::from_consensus(n_lock_time);
+    /// assert!(lock_time.is_block_height());
+    /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
+    #[inline]
+    pub fn to_consensus_u32(self) -> u32 { self.0 }
+}
+
+impl_parse_str_from_int_fallible!(Height, u32, from_consensus, Error);
+
+impl fmt::Display for Height {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+impl FromHexStr for Height {
+    type Error = Error;
+
+    #[inline]
+    fn from_hex_str_no_prefix<S: AsRef<str> + Into<String>>(s: S) -> Result<Self, Self::Error> {
+        let height = crate::parse::hex_u32(s)?;
+        Self::from_consensus(height)
+    }
+}
+
+/// A UNIX timestamp, seconds since epoch, guaranteed to always contain a valid time value.
+///
+/// Note that there is no manipulation of the inner value during construction or when using
+/// `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 {
+    /// The minimum absolute block time (Tue Nov 05 1985 00:53:20 GMT+0000).
+    pub const MIN: Self = Time(LOCK_TIME_THRESHOLD);
+
+    /// The maximum absolute block time (Sun Feb 07 2106 06:28:15 GMT+0000).
+    pub const MAX: Self = Time(u32::MAX);
+
+    /// The minimum absolute block time.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Time::MIN`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
+    pub const fn min_value() -> Self { Self::MIN }
+
+    /// The maximum absolute block time.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Time::MAX`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
+    pub const fn max_value() -> Self { Self::MAX }
+
+    /// Constructs a new block time.
+    ///
+    /// # Errors
+    ///
+    /// If `n` does not encode a UNIX time stamp (see documentation on [`LockTime`]).
+    ///
+    /// # Examples
+    /// ```rust
+    /// use tapyrus::locktime::absolute::Time;
+    ///
+    /// let t: u32 = 1653195600; // May 22nd, 5am UTC.
+    /// let time = Time::from_consensus(t).expect("invalid time value");
+    /// assert_eq!(time.to_consensus_u32(), t);
+    /// ```
+    #[inline]
+    pub fn from_consensus(n: u32) -> Result<Time, Error> {
+        if is_block_time(n) {
+            Ok(Self(n))
+        } else {
+            Err(ConversionError::invalid_time(n).into())
+        }
+    }
+
+    /// Converts this `Time` to its inner `u32` value.
+    ///
+    /// # Examples
+    /// ```rust
+    /// use tapyrus::absolute::LockTime;
+    ///
+    /// let n_lock_time: u32 = 1653195600; // May 22nd, 5am UTC.
+    /// let lock_time = LockTime::from_consensus(n_lock_time);
+    /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
+    /// ```
+    #[inline]
+    pub fn to_consensus_u32(self) -> u32 { self.0 }
+}
+
+impl_parse_str_from_int_fallible!(Time, u32, from_consensus, Error);
+
+impl fmt::Display for Time {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+impl FromHexStr for Time {
+    type Error = Error;
+
+    #[inline]
+    fn from_hex_str_no_prefix<S: AsRef<str> + Into<String>>(s: S) -> Result<Self, Self::Error> {
+        let time = crate::parse::hex_u32(s)?;
+        Time::from_consensus(time)
+    }
+}
+
+/// Returns true if `n` is a block height i.e., less than 500,000,000.
+fn is_block_height(n: u32) -> bool { n < LOCK_TIME_THRESHOLD }
+
+/// Returns true if `n` is a UNIX timestamp i.e., greater than or equal to 500,000,000.
+fn is_block_time(n: u32) -> bool { n >= LOCK_TIME_THRESHOLD }
+
+/// Catchall type for errors that relate to time locks.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// An error occurred while converting a `u32` to a lock time variant.
+    Conversion(ConversionError),
+    /// An error occurred while operating on lock times.
+    Operation(OperationError),
+    /// An error occurred while parsing a string into an `u32`.
+    Parse(ParseIntError),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use 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),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            Conversion(ref e) => Some(e),
+            Operation(ref e) => Some(e),
+            Parse(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<ConversionError> for Error {
+    #[inline]
+    fn from(e: ConversionError) -> Self { Error::Conversion(e) }
+}
+
+impl From<OperationError> for Error {
+    #[inline]
+    fn from(e: OperationError) -> Self { Error::Operation(e) }
+}
+
+impl From<ParseIntError> for Error {
+    #[inline]
+    fn from(e: ParseIntError) -> Self { Error::Parse(e) }
+}
+
+/// An error that occurs when converting a `u32` to a lock time variant.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ConversionError {
+    /// The expected timelock unit, height (blocks) or time (seconds).
+    unit: LockTimeUnit,
+    /// The invalid input value.
+    input: u32,
+}
+
+impl ConversionError {
+    /// Constructs a `ConversionError` from an invalid `n` when expecting a height value.
+    fn invalid_height(n: u32) -> Self { Self { unit: LockTimeUnit::Blocks, input: n } }
+
+    /// Constructs a `ConversionError` from an invalid `n` when expecting a time value.
+    fn invalid_time(n: u32) -> Self { Self { unit: LockTimeUnit::Seconds, input: n } }
+}
+
+impl fmt::Display for ConversionError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "invalid lock time value {}, {}", self.input, self.unit)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ConversionError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// Describes the two types of locking, lock-by-blockheight and lock-by-blocktime.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
+enum LockTimeUnit {
+    /// Lock by blockheight.
+    Blocks,
+    /// Lock by blocktime.
+    Seconds,
+}
+
+impl fmt::Display for LockTimeUnit {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use LockTimeUnit::*;
+
+        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),
+        }
+    }
+}
+
+/// Errors than occur when operating on lock times.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum OperationError {
+    /// Cannot compare different lock time units (height vs time).
+    InvalidComparison,
+}
+
+impl fmt::Display for OperationError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use OperationError::*;
+
+        match *self {
+            InvalidComparison =>
+                f.write_str("cannot compare different lock units (height vs time)"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for OperationError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use OperationError::*;
+
+        match *self {
+            InvalidComparison => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn display_and_alternate() {
+        let n = LockTime::from_consensus(741521);
+        let s = format!("{}", n);
+        assert_eq!(&s, "741521");
+
+        let got = format!("{:#}", n);
+        assert_eq!(got, "block-height 741521");
+    }
+
+    #[test]
+    fn time_from_str_hex_happy_path() {
+        let actual = Time::from_hex_str("0x6289C350").unwrap();
+        let expected = Time::from_consensus(0x6289C350).unwrap();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn time_from_str_hex_no_prefix_happy_path() {
+        let time = Time::from_hex_str_no_prefix("6289C350").unwrap();
+        assert_eq!(time, Time(0x6289C350));
+    }
+
+    #[test]
+    fn time_from_str_hex_invalid_hex_should_err() {
+        let hex = "0xzb93";
+        let result = Time::from_hex_str(hex);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn packed_lock_time_from_str_hex_happy_path() {
+        let actual = LockTime::from_hex_str("0xBA70D").unwrap();
+        let expected = LockTime::from_consensus(0xBA70D);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn packed_lock_time_from_str_hex_no_prefix_happy_path() {
+        let lock_time = LockTime::from_hex_str_no_prefix("BA70D").unwrap();
+        assert_eq!(lock_time, LockTime::from_consensus(0xBA70D));
+    }
+
+    #[test]
+    fn packed_lock_time_from_str_hex_invalid_hex_should_ergr() {
+        let hex = "0xzb93";
+        let result = LockTime::from_hex_str(hex);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn height_from_str_hex_happy_path() {
+        let actual = Height::from_hex_str("0xBA70D").unwrap();
+        let expected = Height(0xBA70D);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn height_from_str_hex_no_prefix_happy_path() {
+        let height = Height::from_hex_str_no_prefix("BA70D").unwrap();
+        assert_eq!(height, Height(0xBA70D));
+    }
+
+    #[test]
+    fn height_from_str_hex_invalid_hex_should_err() {
+        let hex = "0xzb93";
+        let result = Height::from_hex_str(hex);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn parses_correctly_to_height_or_time() {
+        let lock = LockTime::from_consensus(750_000);
+
+        assert!(lock.is_block_height());
+        assert!(!lock.is_block_time());
+
+        let t: u32 = 1653195600; // May 22nd, 5am UTC.
+        let lock = LockTime::from_consensus(t);
+
+        assert!(!lock.is_block_height());
+        assert!(lock.is_block_time());
+    }
+
+    #[test]
+    fn satisfied_by_height() {
+        let lock = LockTime::from_consensus(750_000);
+
+        let height = Height::from_consensus(800_000).expect("failed to parse height");
+
+        let t: u32 = 1653195600; // May 22nd, 5am UTC.
+        let time = Time::from_consensus(t).expect("invalid time value");
+
+        assert!(lock.is_satisfied_by(height, time))
+    }
+
+    #[test]
+    fn satisfied_by_time() {
+        let lock = LockTime::from_consensus(1053195600);
+
+        let t: u32 = 1653195600; // May 22nd, 5am UTC.
+        let time = Time::from_consensus(t).expect("invalid time value");
+
+        let height = Height::from_consensus(800_000).expect("failed to parse height");
+
+        assert!(lock.is_satisfied_by(height, time))
+    }
+
+    #[test]
+    fn satisfied_by_same_height() {
+        let h = 750_000;
+        let lock = LockTime::from_consensus(h);
+        let height = Height::from_consensus(h).expect("failed to parse height");
+
+        let t: u32 = 1653195600; // May 22nd, 5am UTC.
+        let time = Time::from_consensus(t).expect("invalid time value");
+
+        assert!(lock.is_satisfied_by(height, time))
+    }
+
+    #[test]
+    fn satisfied_by_same_time() {
+        let t: u32 = 1653195600; // May 22nd, 5am UTC.
+        let lock = LockTime::from_consensus(t);
+        let time = Time::from_consensus(t).expect("invalid time value");
+
+        let height = Height::from_consensus(800_000).expect("failed to parse height");
+
+        assert!(lock.is_satisfied_by(height, time))
+    }
+
+    #[test]
+    fn height_correctly_implies() {
+        let lock = LockTime::from_consensus(750_005);
+
+        assert!(!lock.is_implied_by(LockTime::from_consensus(750_004)));
+        assert!(lock.is_implied_by(LockTime::from_consensus(750_005)));
+        assert!(lock.is_implied_by(LockTime::from_consensus(750_006)));
+    }
+
+    #[test]
+    fn time_correctly_implies() {
+        let t: u32 = 1700000005;
+        let lock = LockTime::from_consensus(t);
+
+        assert!(!lock.is_implied_by(LockTime::from_consensus(1700000004)));
+        assert!(lock.is_implied_by(LockTime::from_consensus(1700000005)));
+        assert!(lock.is_implied_by(LockTime::from_consensus(1700000006)));
+    }
+
+    #[test]
+    fn incorrect_units_do_not_imply() {
+        let lock = LockTime::from_consensus(750_005);
+        assert!(!lock.is_implied_by(LockTime::from_consensus(1700000004)));
+    }
+}
diff --git a/tapyrus/src/blockdata/locktime/mod.rs b/tapyrus/src/blockdata/locktime/mod.rs
new file mode 100644
index 00000000..c09d3323
--- /dev/null
+++ b/tapyrus/src/blockdata/locktime/mod.rs
@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Provides absolute and relative locktimes.
+//!
+
+pub mod absolute;
+pub mod relative;
diff --git a/tapyrus/src/blockdata/locktime/relative.rs b/tapyrus/src/blockdata/locktime/relative.rs
new file mode 100644
index 00000000..e8f9089b
--- /dev/null
+++ b/tapyrus/src/blockdata/locktime/relative.rs
@@ -0,0 +1,396 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Provides type [`LockTime`] that implements the logic around nSequence/OP_CHECKSEQUENCEVERIFY.
+//!
+//! There are two types of lock time: lock-by-blockheight and lock-by-blocktime, distinguished by
+//! whether bit 22 of the `u32` consensus value is set.
+//!
+
+use core::convert::TryFrom;
+use core::fmt;
+
+#[cfg(all(test, mutate))]
+use mutagen::mutate;
+
+use crate::parse::impl_parse_str_from_int_infallible;
+use crate::prelude::*;
+#[cfg(doc)]
+use crate::relative;
+
+/// A relative lock time value, representing either a block height or time (512 second intervals).
+///
+/// The `relative::LockTime` type does not have any constructors, this is by design, please use
+/// `Sequence::to_relative_lock_time` to create a relative lock time.
+///
+/// ### Relevant BIPs
+///
+/// * [BIP 68 Relative lock-time using consensus-enforced sequence numbers](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
+/// * [BIP 112 CHECKSEQUENCEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki)
+#[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.
+    Blocks(Height),
+    /// A 512 second time interval value.
+    Time(Time),
+}
+
+impl LockTime {
+    /// Returns true if this [`relative::LockTime`] is satisfied by either height or time.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tapyrus::Sequence;
+    /// # use tapyrus::locktime::relative::{LockTime, Height, Time};
+    ///
+    /// # let height = 100;       // 100 blocks.
+    /// # let intervals = 70;     // Approx 10 hours.
+    /// # let current_height = || Height::from(height + 10);
+    /// # let current_time = || Time::from_512_second_intervals(intervals + 10);
+    /// # let lock = Sequence::from_height(height).to_relative_lock_time().expect("valid height");
+    ///
+    /// // Users that have chain data can get the current height and time to check against a lock.
+    /// let height_and_time = (current_time(), current_height());  // tuple order does not matter.
+    /// assert!(lock.is_satisfied_by(current_height(), current_time()));
+    /// ```
+    #[inline]
+    #[cfg_attr(all(test, mutate), mutate)]
+    pub fn is_satisfied_by(&self, h: Height, t: Time) -> bool {
+        if let Ok(true) = self.is_satisfied_by_height(h) {
+            true
+        } else {
+            matches!(self.is_satisfied_by_time(t), Ok(true))
+        }
+    }
+
+    /// Returns true if satisfaction of `other` lock time implies satisfaction of this
+    /// [`relative::LockTime`].
+    ///
+    /// A lock time can only be satisfied by n blocks being mined or n seconds passing. If you have
+    /// two lock times (same unit) then the larger lock time being satisfied implies (in a
+    /// mathematical sense) the smaller one being satisfied.
+    ///
+    /// This function is useful when checking sequence values against a lock, first one checks the
+    /// sequence represents a relative lock time by converting to `LockTime` then use this function
+    /// to see if satisfaction of the newly created lock time would imply satisfaction of `self`.
+    ///
+    /// Can also be used to remove the smaller value of two `OP_CHECKSEQUENCEVERIFY` operations
+    /// within one branch of the script.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tapyrus::Sequence;
+    /// # use tapyrus::locktime::relative::{LockTime, Height, Time};
+    ///
+    /// # let height = 100;       // 100 blocks.
+    /// # let lock = Sequence::from_height(height).to_relative_lock_time().expect("valid height");
+    /// # let test_sequence = Sequence::from_height(height + 10);
+    ///
+    /// let satisfied = match test_sequence.to_relative_lock_time() {
+    ///     None => false, // Handle non-lock-time case.
+    ///     Some(test_lock) => lock.is_implied_by(test_lock),
+    /// };
+    /// assert!(satisfied);
+    /// ```
+    #[inline]
+    #[cfg_attr(all(test, mutate), mutate)]
+    pub fn is_implied_by(&self, other: LockTime) -> bool {
+        use LockTime::*;
+
+        match (*self, other) {
+            (Blocks(this), Blocks(other)) => this.value() <= other.value(),
+            (Time(this), Time(other)) => this.value() <= other.value(),
+            _ => false, // Not the same units.
+        }
+    }
+
+    /// Returns true if this [`relative::LockTime`] is satisfied by [`Height`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this lock is not lock-by-height.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tapyrus::Sequence;
+    /// # use tapyrus::locktime::relative::{LockTime, Height, Time};
+    ///
+    /// let height: u16 = 100;
+    /// let lock = Sequence::from_height(height).to_relative_lock_time().expect("valid height");
+    /// assert!(lock.is_satisfied_by_height(Height::from(height+1)).expect("a height"));
+    /// ```
+    #[inline]
+    #[cfg_attr(all(test, mutate), mutate)]
+    pub fn is_satisfied_by_height(&self, h: Height) -> Result<bool, Error> {
+        use LockTime::*;
+
+        match *self {
+            Blocks(ref height) => Ok(height.value() <= h.value()),
+            Time(ref time) => Err(Error::IncompatibleTime(*self, *time)),
+        }
+    }
+
+    /// Returns true if this [`relative::LockTime`] is satisfied by [`Time`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this lock is not lock-by-time.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use tapyrus::Sequence;
+    /// # use tapyrus::locktime::relative::{LockTime, Height, Time};
+    ///
+    /// let intervals: u16 = 70; // approx 10 hours;
+    /// let lock = Sequence::from_512_second_intervals(intervals).to_relative_lock_time().expect("valid time");
+    /// assert!(lock.is_satisfied_by_time(Time::from_512_second_intervals(intervals + 10)).expect("a time"));
+    /// ```
+    #[inline]
+    #[cfg_attr(all(test, mutate), mutate)]
+    pub fn is_satisfied_by_time(&self, t: Time) -> Result<bool, Error> {
+        use LockTime::*;
+
+        match *self {
+            Time(ref time) => Ok(time.value() <= t.value()),
+            Blocks(ref height) => Err(Error::IncompatibleHeight(*self, *height)),
+        }
+    }
+}
+
+impl From<Height> for LockTime {
+    #[inline]
+    fn from(h: Height) -> Self { LockTime::Blocks(h) }
+}
+
+impl From<Time> for LockTime {
+    #[inline]
+    fn from(t: Time) -> Self { LockTime::Time(t) }
+}
+
+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),
+                Time(ref t) => write!(f, "block-time {} (512 second intervals)", t),
+            }
+        } else {
+            match *self {
+                Blocks(ref h) => fmt::Display::fmt(h, f),
+                Time(ref t) => fmt::Display::fmt(t, f),
+            }
+        }
+    }
+}
+
+/// A relative lock time lock-by-blockheight value.
+#[derive(Debug, Default, 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(u16);
+
+impl Height {
+    /// Relative block height 0, can be included in any block.
+    pub const ZERO: Self = Height(0);
+
+    /// The minimum relative block height (0), can be included in any block.
+    pub const MIN: Self = Self::ZERO;
+
+    /// The maximum relative block height.
+    pub const MAX: Self = Height(u16::MAX);
+
+    /// The minimum relative block height (0), can be included in any block.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Height::MIN`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
+    pub const fn min_value() -> Self { Self::MIN }
+
+    /// The maximum relative block height.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Height::MAX`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
+    pub const fn max_value() -> Self { Self::MAX }
+
+    /// Returns the inner `u16` value.
+    #[inline]
+    pub fn value(self) -> u16 { self.0 }
+}
+
+impl From<u16> for Height {
+    #[inline]
+    fn from(value: u16) -> Self { Height(value) }
+}
+
+impl_parse_str_from_int_infallible!(Height, u16, from);
+
+impl fmt::Display for Height {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+/// A relative lock time lock-by-blocktime value.
+///
+/// For BIP 68 relative lock-by-blocktime locks, time is measure in 512 second intervals.
+#[derive(Debug, Default, 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(u16);
+
+impl Time {
+    /// Relative block time 0, can be included in any block.
+    pub const ZERO: Self = Time(0);
+
+    /// The minimum relative block time (0), can be included in any block.
+    pub const MIN: Self = Time::ZERO;
+
+    /// The maximum relative block time (33,554,432 seconds or approx 388 days).
+    pub const MAX: Self = Time(u16::MAX);
+
+    /// The minimum relative block time.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Time::MIN`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MIN instead")]
+    pub const fn min_value() -> Self { Self::MIN }
+
+    /// The maximum relative block time.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Time::MAX`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
+    pub const fn max_value() -> Self { Self::MAX }
+
+    /// Create a [`Time`] using time intervals where each interval is equivalent to 512 seconds.
+    ///
+    /// Encoding finer granularity of time for relative lock-times is not supported in Bitcoin.
+    #[inline]
+    pub fn from_512_second_intervals(intervals: u16) -> Self { Time(intervals) }
+
+    /// Create a [`Time`] from seconds, converting the seconds into 512 second interval with ceiling
+    /// division.
+    ///
+    /// # Errors
+    ///
+    /// Will return an error if the input cannot be encoded in 16 bits.
+    #[inline]
+    pub fn from_seconds_ceil(seconds: u32) -> Result<Self, Error> {
+        if let Ok(interval) = u16::try_from((seconds + 511) / 512) {
+            Ok(Time::from_512_second_intervals(interval))
+        } else {
+            Err(Error::IntegerOverflow(seconds))
+        }
+    }
+
+    /// Returns the inner `u16` value.
+    #[inline]
+    pub fn value(self) -> u16 { self.0 }
+}
+
+impl_parse_str_from_int_infallible!(Time, u16, from_512_second_intervals);
+
+impl fmt::Display for Time {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+/// Errors related to relative lock times.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// Input time in seconds was too large to be encoded to a 16 bit 512 second interval.
+    IntegerOverflow(u32),
+    /// Tried to satisfy a lock-by-blocktime lock using a height value.
+    IncompatibleHeight(LockTime, Height),
+    /// Tried to satisfy a lock-by-blockheight lock using a time value.
+    IncompatibleTime(LockTime, Time),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            IntegerOverflow(val) => write!(
+                f,
+                "{} seconds is too large to be encoded to a 16 bit 512 second interval",
+                val
+            ),
+            IncompatibleHeight(lock, height) =>
+                write!(f, "tried to satisfy lock {} with height: {}", lock, height),
+            IncompatibleTime(lock, time) =>
+                write!(f, "tried to satisfy lock {} with time: {}", lock, time),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            IntegerOverflow(_) | IncompatibleHeight(_, _) | IncompatibleTime(_, _) => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn satisfied_by_height() {
+        let height = Height::from(10);
+        let time = Time::from_512_second_intervals(70);
+
+        let lock = LockTime::from(height);
+
+        assert!(!lock.is_satisfied_by(Height::from(9), time));
+        assert!(lock.is_satisfied_by(Height::from(10), time));
+        assert!(lock.is_satisfied_by(Height::from(11), time));
+    }
+
+    #[test]
+    fn satisfied_by_time() {
+        let height = Height::from(10);
+        let time = Time::from_512_second_intervals(70);
+
+        let lock = LockTime::from(time);
+
+        assert!(!lock.is_satisfied_by(height, Time::from_512_second_intervals(69)));
+        assert!(lock.is_satisfied_by(height, Time::from_512_second_intervals(70)));
+        assert!(lock.is_satisfied_by(height, Time::from_512_second_intervals(71)));
+    }
+
+    #[test]
+    fn height_correctly_implies() {
+        let height = Height::from(10);
+        let lock = LockTime::from(height);
+
+        assert!(!lock.is_implied_by(LockTime::from(Height::from(9))));
+        assert!(lock.is_implied_by(LockTime::from(Height::from(10))));
+        assert!(lock.is_implied_by(LockTime::from(Height::from(11))));
+    }
+
+    #[test]
+    fn time_correctly_implies() {
+        let time = Time::from_512_second_intervals(70);
+        let lock = LockTime::from(time);
+
+        assert!(!lock.is_implied_by(LockTime::from(Time::from_512_second_intervals(69))));
+        assert!(lock.is_implied_by(LockTime::from(Time::from_512_second_intervals(70))));
+        assert!(lock.is_implied_by(LockTime::from(Time::from_512_second_intervals(71))));
+    }
+
+    #[test]
+    fn incorrect_units_do_not_imply() {
+        let time = Time::from_512_second_intervals(70);
+        let height = Height::from(10);
+
+        let lock = LockTime::from(time);
+        assert!(!lock.is_implied_by(LockTime::from(height)));
+    }
+}
diff --git a/tapyrus/src/blockdata/mod.rs b/tapyrus/src/blockdata/mod.rs
new file mode 100644
index 00000000..234f1623
--- /dev/null
+++ b/tapyrus/src/blockdata/mod.rs
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin block data.
+//!
+//! This module defines structures and functions for storing the blocks and
+//! transactions which make up the Bitcoin system.
+//!
+
+pub mod block;
+pub mod constants;
+pub mod fee_rate;
+pub mod locktime;
+pub mod opcodes;
+pub mod script;
+pub mod transaction;
+pub mod weight;
+pub mod witness;
+
+pub use fee_rate::FeeRate;
+pub use weight::Weight;
diff --git a/tapyrus/src/blockdata/opcodes.rs b/tapyrus/src/blockdata/opcodes.rs
new file mode 100644
index 00000000..66cf864e
--- /dev/null
+++ b/tapyrus/src/blockdata/opcodes.rs
@@ -0,0 +1,900 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin script opcodes.
+//!
+//! Bitcoin's script uses a stack-based assembly language. This module defines
+//! all of the opcodes for that language.
+//!
+
+#![allow(non_camel_case_types)]
+
+use core::convert::From;
+use core::fmt;
+
+use internals::debug_from_display;
+#[cfg(feature = "serde")]
+use serde;
+
+#[cfg(feature = "serde")]
+use crate::prelude::*;
+
+/// A script Opcode.
+///
+/// We do not implement Ord on this type because there is no natural ordering on opcodes, but there
+/// may appear to be one (e.g. because all the push opcodes appear in a consecutive block) and we
+/// don't want to encourage subtly buggy code. Please use [`Opcode::classify`] to distinguish different
+/// types of opcodes.
+///
+/// <details>
+///   <summary>Example of Core bug caused by assuming ordering</summary>
+///
+///   Bitcoin Core's `IsPushOnly` considers `OP_RESERVED` to be a "push code", allowing this opcode
+///   in contexts where only pushes are supposed to be allowed.
+/// </details>
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct Opcode {
+    code: u8,
+}
+
+use self::all::*;
+
+macro_rules! all_opcodes {
+    ($($op:ident => $val:expr, $doc:expr);*) => {
+        /// Enables wildcard imports to bring into scope all opcodes and nothing else.
+        ///
+        /// The `all` module is provided so one can use a wildcard import `use tapyrus::opcodes::all::*` to
+        /// get all the `OP_FOO` opcodes without getting other types defined in `opcodes` (e.g. `Opcode`, `Class`).
+        ///
+        /// This module is guaranteed to never contain anything except opcode constants and all opcode
+        /// constants are guaranteed to begin with OP_.
+        pub mod all {
+            use super::Opcode;
+            $(
+                #[doc = $doc]
+                pub const $op: Opcode = Opcode { code: $val};
+            )*
+        }
+
+        /// Push an empty array onto the stack.
+        pub static OP_0: Opcode = OP_PUSHBYTES_0;
+        /// Empty stack is also FALSE.
+        pub static OP_FALSE: Opcode = OP_PUSHBYTES_0;
+        /// Number 1 is also TRUE.
+        pub static OP_TRUE: Opcode = OP_PUSHNUM_1;
+        /// Previously called OP_NOP2.
+        pub static OP_NOP2: Opcode = OP_CLTV;
+        /// Previously called OP_NOP3.
+        pub static OP_NOP3: Opcode = OP_CSV;
+
+        impl fmt::Display for Opcode {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                 match *self {
+                   $(
+                        $op => fmt::Display::fmt(stringify!($op), f),
+                    )+
+                }
+            }
+        }
+    }
+}
+
+all_opcodes! {
+    OP_PUSHBYTES_0 => 0x00, "Push an empty array onto the stack.";
+    OP_PUSHBYTES_1 => 0x01, "Push the next byte as an array onto the stack.";
+    OP_PUSHBYTES_2 => 0x02, "Push the next 2 bytes as an array onto the stack.";
+    OP_PUSHBYTES_3 => 0x03, "Push the next 3 bytes as an array onto the stack.";
+    OP_PUSHBYTES_4 => 0x04, "Push the next 4 bytes as an array onto the stack.";
+    OP_PUSHBYTES_5 => 0x05, "Push the next 5 bytes as an array onto the stack.";
+    OP_PUSHBYTES_6 => 0x06, "Push the next 6 bytes as an array onto the stack.";
+    OP_PUSHBYTES_7 => 0x07, "Push the next 7 bytes as an array onto the stack.";
+    OP_PUSHBYTES_8 => 0x08, "Push the next 8 bytes as an array onto the stack.";
+    OP_PUSHBYTES_9 => 0x09, "Push the next 9 bytes as an array onto the stack.";
+    OP_PUSHBYTES_10 => 0x0a, "Push the next 10 bytes as an array onto the stack.";
+    OP_PUSHBYTES_11 => 0x0b, "Push the next 11 bytes as an array onto the stack.";
+    OP_PUSHBYTES_12 => 0x0c, "Push the next 12 bytes as an array onto the stack.";
+    OP_PUSHBYTES_13 => 0x0d, "Push the next 13 bytes as an array onto the stack.";
+    OP_PUSHBYTES_14 => 0x0e, "Push the next 14 bytes as an array onto the stack.";
+    OP_PUSHBYTES_15 => 0x0f, "Push the next 15 bytes as an array onto the stack.";
+    OP_PUSHBYTES_16 => 0x10, "Push the next 16 bytes as an array onto the stack.";
+    OP_PUSHBYTES_17 => 0x11, "Push the next 17 bytes as an array onto the stack.";
+    OP_PUSHBYTES_18 => 0x12, "Push the next 18 bytes as an array onto the stack.";
+    OP_PUSHBYTES_19 => 0x13, "Push the next 19 bytes as an array onto the stack.";
+    OP_PUSHBYTES_20 => 0x14, "Push the next 20 bytes as an array onto the stack.";
+    OP_PUSHBYTES_21 => 0x15, "Push the next 21 bytes as an array onto the stack.";
+    OP_PUSHBYTES_22 => 0x16, "Push the next 22 bytes as an array onto the stack.";
+    OP_PUSHBYTES_23 => 0x17, "Push the next 23 bytes as an array onto the stack.";
+    OP_PUSHBYTES_24 => 0x18, "Push the next 24 bytes as an array onto the stack.";
+    OP_PUSHBYTES_25 => 0x19, "Push the next 25 bytes as an array onto the stack.";
+    OP_PUSHBYTES_26 => 0x1a, "Push the next 26 bytes as an array onto the stack.";
+    OP_PUSHBYTES_27 => 0x1b, "Push the next 27 bytes as an array onto the stack.";
+    OP_PUSHBYTES_28 => 0x1c, "Push the next 28 bytes as an array onto the stack.";
+    OP_PUSHBYTES_29 => 0x1d, "Push the next 29 bytes as an array onto the stack.";
+    OP_PUSHBYTES_30 => 0x1e, "Push the next 30 bytes as an array onto the stack.";
+    OP_PUSHBYTES_31 => 0x1f, "Push the next 31 bytes as an array onto the stack.";
+    OP_PUSHBYTES_32 => 0x20, "Push the next 32 bytes as an array onto the stack.";
+    OP_PUSHBYTES_33 => 0x21, "Push the next 33 bytes as an array onto the stack.";
+    OP_PUSHBYTES_34 => 0x22, "Push the next 34 bytes as an array onto the stack.";
+    OP_PUSHBYTES_35 => 0x23, "Push the next 35 bytes as an array onto the stack.";
+    OP_PUSHBYTES_36 => 0x24, "Push the next 36 bytes as an array onto the stack.";
+    OP_PUSHBYTES_37 => 0x25, "Push the next 37 bytes as an array onto the stack.";
+    OP_PUSHBYTES_38 => 0x26, "Push the next 38 bytes as an array onto the stack.";
+    OP_PUSHBYTES_39 => 0x27, "Push the next 39 bytes as an array onto the stack.";
+    OP_PUSHBYTES_40 => 0x28, "Push the next 40 bytes as an array onto the stack.";
+    OP_PUSHBYTES_41 => 0x29, "Push the next 41 bytes as an array onto the stack.";
+    OP_PUSHBYTES_42 => 0x2a, "Push the next 42 bytes as an array onto the stack.";
+    OP_PUSHBYTES_43 => 0x2b, "Push the next 43 bytes as an array onto the stack.";
+    OP_PUSHBYTES_44 => 0x2c, "Push the next 44 bytes as an array onto the stack.";
+    OP_PUSHBYTES_45 => 0x2d, "Push the next 45 bytes as an array onto the stack.";
+    OP_PUSHBYTES_46 => 0x2e, "Push the next 46 bytes as an array onto the stack.";
+    OP_PUSHBYTES_47 => 0x2f, "Push the next 47 bytes as an array onto the stack.";
+    OP_PUSHBYTES_48 => 0x30, "Push the next 48 bytes as an array onto the stack.";
+    OP_PUSHBYTES_49 => 0x31, "Push the next 49 bytes as an array onto the stack.";
+    OP_PUSHBYTES_50 => 0x32, "Push the next 50 bytes as an array onto the stack.";
+    OP_PUSHBYTES_51 => 0x33, "Push the next 51 bytes as an array onto the stack.";
+    OP_PUSHBYTES_52 => 0x34, "Push the next 52 bytes as an array onto the stack.";
+    OP_PUSHBYTES_53 => 0x35, "Push the next 53 bytes as an array onto the stack.";
+    OP_PUSHBYTES_54 => 0x36, "Push the next 54 bytes as an array onto the stack.";
+    OP_PUSHBYTES_55 => 0x37, "Push the next 55 bytes as an array onto the stack.";
+    OP_PUSHBYTES_56 => 0x38, "Push the next 56 bytes as an array onto the stack.";
+    OP_PUSHBYTES_57 => 0x39, "Push the next 57 bytes as an array onto the stack.";
+    OP_PUSHBYTES_58 => 0x3a, "Push the next 58 bytes as an array onto the stack.";
+    OP_PUSHBYTES_59 => 0x3b, "Push the next 59 bytes as an array onto the stack.";
+    OP_PUSHBYTES_60 => 0x3c, "Push the next 60 bytes as an array onto the stack.";
+    OP_PUSHBYTES_61 => 0x3d, "Push the next 61 bytes as an array onto the stack.";
+    OP_PUSHBYTES_62 => 0x3e, "Push the next 62 bytes as an array onto the stack.";
+    OP_PUSHBYTES_63 => 0x3f, "Push the next 63 bytes as an array onto the stack.";
+    OP_PUSHBYTES_64 => 0x40, "Push the next 64 bytes as an array onto the stack.";
+    OP_PUSHBYTES_65 => 0x41, "Push the next 65 bytes as an array onto the stack.";
+    OP_PUSHBYTES_66 => 0x42, "Push the next 66 bytes as an array onto the stack.";
+    OP_PUSHBYTES_67 => 0x43, "Push the next 67 bytes as an array onto the stack.";
+    OP_PUSHBYTES_68 => 0x44, "Push the next 68 bytes as an array onto the stack.";
+    OP_PUSHBYTES_69 => 0x45, "Push the next 69 bytes as an array onto the stack.";
+    OP_PUSHBYTES_70 => 0x46, "Push the next 70 bytes as an array onto the stack.";
+    OP_PUSHBYTES_71 => 0x47, "Push the next 71 bytes as an array onto the stack.";
+    OP_PUSHBYTES_72 => 0x48, "Push the next 72 bytes as an array onto the stack.";
+    OP_PUSHBYTES_73 => 0x49, "Push the next 73 bytes as an array onto the stack.";
+    OP_PUSHBYTES_74 => 0x4a, "Push the next 74 bytes as an array onto the stack.";
+    OP_PUSHBYTES_75 => 0x4b, "Push the next 75 bytes as an array onto the stack.";
+    OP_PUSHDATA1 => 0x4c, "Read the next byte as N; push the next N bytes as an array onto the stack.";
+    OP_PUSHDATA2 => 0x4d, "Read the next 2 bytes as N; push the next N bytes as an array onto the stack.";
+    OP_PUSHDATA4 => 0x4e, "Read the next 4 bytes as N; push the next N bytes as an array onto the stack.";
+    OP_PUSHNUM_NEG1 => 0x4f, "Push the array `0x81` onto the stack.";
+    OP_RESERVED => 0x50, "Synonym for OP_RETURN.";
+    OP_PUSHNUM_1 => 0x51, "Push the array `0x01` onto the stack.";
+    OP_PUSHNUM_2 => 0x52, "Push the array `0x02` onto the stack.";
+    OP_PUSHNUM_3 => 0x53, "Push the array `0x03` onto the stack.";
+    OP_PUSHNUM_4 => 0x54, "Push the array `0x04` onto the stack.";
+    OP_PUSHNUM_5 => 0x55, "Push the array `0x05` onto the stack.";
+    OP_PUSHNUM_6 => 0x56, "Push the array `0x06` onto the stack.";
+    OP_PUSHNUM_7 => 0x57, "Push the array `0x07` onto the stack.";
+    OP_PUSHNUM_8 => 0x58, "Push the array `0x08` onto the stack.";
+    OP_PUSHNUM_9 => 0x59, "Push the array `0x09` onto the stack.";
+    OP_PUSHNUM_10 => 0x5a, "Push the array `0x0a` onto the stack.";
+    OP_PUSHNUM_11 => 0x5b, "Push the array `0x0b` onto the stack.";
+    OP_PUSHNUM_12 => 0x5c, "Push the array `0x0c` onto the stack.";
+    OP_PUSHNUM_13 => 0x5d, "Push the array `0x0d` onto the stack.";
+    OP_PUSHNUM_14 => 0x5e, "Push the array `0x0e` onto the stack.";
+    OP_PUSHNUM_15 => 0x5f, "Push the array `0x0f` onto the stack.";
+    OP_PUSHNUM_16 => 0x60, "Push the array `0x10` onto the stack.";
+    OP_NOP => 0x61, "Does nothing.";
+    OP_VER => 0x62, "Synonym for OP_RETURN.";
+    OP_IF => 0x63, "Pop and execute the next statements if a nonzero element was popped.";
+    OP_NOTIF => 0x64, "Pop and execute the next statements if a zero element was popped.";
+    OP_VERIF => 0x65, "Fail the script unconditionally, does not even need to be executed.";
+    OP_VERNOTIF => 0x66, "Fail the script unconditionally, does not even need to be executed.";
+    OP_ELSE => 0x67, "Execute statements if those after the previous OP_IF were not, and vice-versa. \
+             If there is no previous OP_IF, this acts as a RETURN.";
+    OP_ENDIF => 0x68, "Pop and execute the next statements if a zero element was popped.";
+    OP_VERIFY => 0x69, "If the top value is zero or the stack is empty, fail; otherwise, pop the stack.";
+    OP_RETURN => 0x6a, "Fail the script immediately. (Must be executed.).";
+    OP_TOALTSTACK => 0x6b, "Pop one element from the main stack onto the alt stack.";
+    OP_FROMALTSTACK => 0x6c, "Pop one element from the alt stack onto the main stack.";
+    OP_2DROP => 0x6d, "Drops the top two stack items.";
+    OP_2DUP => 0x6e, "Duplicates the top two stack items as AB -> ABAB.";
+    OP_3DUP => 0x6f, "Duplicates the two three stack items as ABC -> ABCABC.";
+    OP_2OVER => 0x70, "Copies the two stack items of items two spaces back to the front, as xxAB -> ABxxAB.";
+    OP_2ROT => 0x71, "Moves the two stack items four spaces back to the front, as xxxxAB -> ABxxxx.";
+    OP_2SWAP => 0x72, "Swaps the top two pairs, as ABCD -> CDAB.";
+    OP_IFDUP => 0x73, "Duplicate the top stack element unless it is zero.";
+    OP_DEPTH => 0x74, "Push the current number of stack items onto the stack.";
+    OP_DROP => 0x75, "Drops the top stack item.";
+    OP_DUP => 0x76, "Duplicates the top stack item.";
+    OP_NIP => 0x77, "Drops the second-to-top stack item.";
+    OP_OVER => 0x78, "Copies the second-to-top stack item, as xA -> AxA.";
+    OP_PICK => 0x79, "Pop the top stack element as N. Copy the Nth stack element to the top.";
+    OP_ROLL => 0x7a, "Pop the top stack element as N. Move the Nth stack element to the top.";
+    OP_ROT => 0x7b, "Rotate the top three stack items, as [top next1 next2] -> [next2 top next1].";
+    OP_SWAP => 0x7c, "Swap the top two stack items.";
+    OP_TUCK => 0x7d, "Copy the top stack item to before the second item, as [top next] -> [top next top].";
+    OP_CAT => 0x7e, "Fail the script unconditionally, does not even need to be executed.";
+    OP_SUBSTR => 0x7f, "Fail the script unconditionally, does not even need to be executed.";
+    OP_LEFT => 0x80, "Fail the script unconditionally, does not even need to be executed.";
+    OP_RIGHT => 0x81, "Fail the script unconditionally, does not even need to be executed.";
+    OP_SIZE => 0x82, "Pushes the length of the top stack item onto the stack.";
+    OP_INVERT => 0x83, "Fail the script unconditionally, does not even need to be executed.";
+    OP_AND => 0x84, "Fail the script unconditionally, does not even need to be executed.";
+    OP_OR => 0x85, "Fail the script unconditionally, does not even need to be executed.";
+    OP_XOR => 0x86, "Fail the script unconditionally, does not even need to be executed.";
+    OP_EQUAL => 0x87, "Pushes 1 if the inputs are exactly equal, 0 otherwise.";
+    OP_EQUALVERIFY => 0x88, "Returns success if the inputs are exactly equal, failure otherwise.";
+    OP_RESERVED1 => 0x89, "Synonym for OP_RETURN.";
+    OP_RESERVED2 => 0x8a, "Synonym for OP_RETURN.";
+    OP_1ADD => 0x8b, "Increment the top stack element in place.";
+    OP_1SUB => 0x8c, "Decrement the top stack element in place.";
+    OP_2MUL => 0x8d, "Fail the script unconditionally, does not even need to be executed.";
+    OP_2DIV => 0x8e, "Fail the script unconditionally, does not even need to be executed.";
+    OP_NEGATE => 0x8f, "Multiply the top stack item by -1 in place.";
+    OP_ABS => 0x90, "Absolute value the top stack item in place.";
+    OP_NOT => 0x91, "Map 0 to 1 and everything else to 0, in place.";
+    OP_0NOTEQUAL => 0x92, "Map 0 to 0 and everything else to 1, in place.";
+    OP_ADD => 0x93, "Pop two stack items and push their sum.";
+    OP_SUB => 0x94, "Pop two stack items and push the second minus the top.";
+    OP_MUL => 0x95, "Fail the script unconditionally, does not even need to be executed.";
+    OP_DIV => 0x96, "Fail the script unconditionally, does not even need to be executed.";
+    OP_MOD => 0x97, "Fail the script unconditionally, does not even need to be executed.";
+    OP_LSHIFT => 0x98, "Fail the script unconditionally, does not even need to be executed.";
+    OP_RSHIFT => 0x99, "Fail the script unconditionally, does not even need to be executed.";
+    OP_BOOLAND => 0x9a, "Pop the top two stack items and push 1 if both are nonzero, else push 0.";
+    OP_BOOLOR => 0x9b, "Pop the top two stack items and push 1 if either is nonzero, else push 0.";
+    OP_NUMEQUAL => 0x9c, "Pop the top two stack items and push 1 if both are numerically equal, else push 0.";
+    OP_NUMEQUALVERIFY => 0x9d, "Pop the top two stack items and return success if both are numerically equal, else return failure.";
+    OP_NUMNOTEQUAL => 0x9e, "Pop the top two stack items and push 0 if both are numerically equal, else push 1.";
+    OP_LESSTHAN  => 0x9f, "Pop the top two items; push 1 if the second is less than the top, 0 otherwise.";
+    OP_GREATERTHAN  => 0xa0, "Pop the top two items; push 1 if the second is greater than the top, 0 otherwise.";
+    OP_LESSTHANOREQUAL  => 0xa1, "Pop the top two items; push 1 if the second is <= the top, 0 otherwise.";
+    OP_GREATERTHANOREQUAL  => 0xa2, "Pop the top two items; push 1 if the second is >= the top, 0 otherwise.";
+    OP_MIN => 0xa3, "Pop the top two items; push the smaller.";
+    OP_MAX => 0xa4, "Pop the top two items; push the larger.";
+    OP_WITHIN => 0xa5, "Pop the top three items; if the top is >= the second and < the third, push 1, otherwise push 0.";
+    OP_RIPEMD160 => 0xa6, "Pop the top stack item and push its RIPEMD160 hash.";
+    OP_SHA1 => 0xa7, "Pop the top stack item and push its SHA1 hash.";
+    OP_SHA256 => 0xa8, "Pop the top stack item and push its SHA256 hash.";
+    OP_HASH160 => 0xa9, "Pop the top stack item and push its RIPEMD(SHA256) hash.";
+    OP_HASH256 => 0xaa, "Pop the top stack item and push its SHA256(SHA256) hash.";
+    OP_CODESEPARATOR => 0xab, "Ignore this and everything preceding when deciding what to sign when signature-checking.";
+    OP_CHECKSIG => 0xac, "<https://en.tapyrus.it/wiki/OP_CHECKSIG> pushing 1/0 for success/failure.";
+    OP_CHECKSIGVERIFY => 0xad, "<https://en.tapyrus.it/wiki/OP_CHECKSIG> returning success/failure.";
+    OP_CHECKMULTISIG => 0xae, "Pop N, N pubkeys, M, M signatures, a dummy (due to bug in reference code), \
+                      and verify that all M signatures are valid. Push 1 for 'all valid', 0 otherwise.";
+    OP_CHECKMULTISIGVERIFY => 0xaf, "Like the above but return success/failure.";
+    OP_NOP1 => 0xb0, "Does nothing.";
+    OP_CLTV => 0xb1, "<https://github.com/tapyrus/bips/blob/master/bip-0065.mediawiki>";
+    OP_CSV => 0xb2, "<https://github.com/tapyrus/bips/blob/master/bip-0112.mediawiki>";
+    OP_NOP4 => 0xb3, "Does nothing.";
+    OP_NOP5 => 0xb4, "Does nothing.";
+    OP_NOP6 => 0xb5, "Does nothing.";
+    OP_NOP7 => 0xb6, "Does nothing.";
+    OP_NOP8 => 0xb7, "Does nothing.";
+    OP_NOP9 => 0xb8, "Does nothing.";
+    OP_NOP10 => 0xb9, "Does nothing.";
+    OP_CHECKSIGADD => 0xba, "OP_CHECKSIGADD post tapscript.";
+    OP_RETURN_187 => 0xbb, "Synonym for OP_RETURN.";
+    OP_COLOR => 0xbc, "Pop the top stack item and interpreted as a COLOR identifier.";
+    // Every other opcode acts as OP_RETURN
+    OP_RETURN_189 => 0xbd, "Synonym for OP_RETURN.";
+    OP_RETURN_190 => 0xbe, "Synonym for OP_RETURN.";
+    OP_RETURN_191 => 0xbf, "Synonym for OP_RETURN.";
+    OP_RETURN_192 => 0xc0, "Synonym for OP_RETURN.";
+    OP_RETURN_193 => 0xc1, "Synonym for OP_RETURN.";
+    OP_RETURN_194 => 0xc2, "Synonym for OP_RETURN.";
+    OP_RETURN_195 => 0xc3, "Synonym for OP_RETURN.";
+    OP_RETURN_196 => 0xc4, "Synonym for OP_RETURN.";
+    OP_RETURN_197 => 0xc5, "Synonym for OP_RETURN.";
+    OP_RETURN_198 => 0xc6, "Synonym for OP_RETURN.";
+    OP_RETURN_199 => 0xc7, "Synonym for OP_RETURN.";
+    OP_RETURN_200 => 0xc8, "Synonym for OP_RETURN.";
+    OP_RETURN_201 => 0xc9, "Synonym for OP_RETURN.";
+    OP_RETURN_202 => 0xca, "Synonym for OP_RETURN.";
+    OP_RETURN_203 => 0xcb, "Synonym for OP_RETURN.";
+    OP_RETURN_204 => 0xcc, "Synonym for OP_RETURN.";
+    OP_RETURN_205 => 0xcd, "Synonym for OP_RETURN.";
+    OP_RETURN_206 => 0xce, "Synonym for OP_RETURN.";
+    OP_RETURN_207 => 0xcf, "Synonym for OP_RETURN.";
+    OP_RETURN_208 => 0xd0, "Synonym for OP_RETURN.";
+    OP_RETURN_209 => 0xd1, "Synonym for OP_RETURN.";
+    OP_RETURN_210 => 0xd2, "Synonym for OP_RETURN.";
+    OP_RETURN_211 => 0xd3, "Synonym for OP_RETURN.";
+    OP_RETURN_212 => 0xd4, "Synonym for OP_RETURN.";
+    OP_RETURN_213 => 0xd5, "Synonym for OP_RETURN.";
+    OP_RETURN_214 => 0xd6, "Synonym for OP_RETURN.";
+    OP_RETURN_215 => 0xd7, "Synonym for OP_RETURN.";
+    OP_RETURN_216 => 0xd8, "Synonym for OP_RETURN.";
+    OP_RETURN_217 => 0xd9, "Synonym for OP_RETURN.";
+    OP_RETURN_218 => 0xda, "Synonym for OP_RETURN.";
+    OP_RETURN_219 => 0xdb, "Synonym for OP_RETURN.";
+    OP_RETURN_220 => 0xdc, "Synonym for OP_RETURN.";
+    OP_RETURN_221 => 0xdd, "Synonym for OP_RETURN.";
+    OP_RETURN_222 => 0xde, "Synonym for OP_RETURN.";
+    OP_RETURN_223 => 0xdf, "Synonym for OP_RETURN.";
+    OP_RETURN_224 => 0xe0, "Synonym for OP_RETURN.";
+    OP_RETURN_225 => 0xe1, "Synonym for OP_RETURN.";
+    OP_RETURN_226 => 0xe2, "Synonym for OP_RETURN.";
+    OP_RETURN_227 => 0xe3, "Synonym for OP_RETURN.";
+    OP_RETURN_228 => 0xe4, "Synonym for OP_RETURN.";
+    OP_RETURN_229 => 0xe5, "Synonym for OP_RETURN.";
+    OP_RETURN_230 => 0xe6, "Synonym for OP_RETURN.";
+    OP_RETURN_231 => 0xe7, "Synonym for OP_RETURN.";
+    OP_RETURN_232 => 0xe8, "Synonym for OP_RETURN.";
+    OP_RETURN_233 => 0xe9, "Synonym for OP_RETURN.";
+    OP_RETURN_234 => 0xea, "Synonym for OP_RETURN.";
+    OP_RETURN_235 => 0xeb, "Synonym for OP_RETURN.";
+    OP_RETURN_236 => 0xec, "Synonym for OP_RETURN.";
+    OP_RETURN_237 => 0xed, "Synonym for OP_RETURN.";
+    OP_RETURN_238 => 0xee, "Synonym for OP_RETURN.";
+    OP_RETURN_239 => 0xef, "Synonym for OP_RETURN.";
+    OP_RETURN_240 => 0xf0, "Synonym for OP_RETURN.";
+    OP_RETURN_241 => 0xf1, "Synonym for OP_RETURN.";
+    OP_RETURN_242 => 0xf2, "Synonym for OP_RETURN.";
+    OP_RETURN_243 => 0xf3, "Synonym for OP_RETURN.";
+    OP_RETURN_244 => 0xf4, "Synonym for OP_RETURN.";
+    OP_RETURN_245 => 0xf5, "Synonym for OP_RETURN.";
+    OP_RETURN_246 => 0xf6, "Synonym for OP_RETURN.";
+    OP_RETURN_247 => 0xf7, "Synonym for OP_RETURN.";
+    OP_RETURN_248 => 0xf8, "Synonym for OP_RETURN.";
+    OP_RETURN_249 => 0xf9, "Synonym for OP_RETURN.";
+    OP_RETURN_250 => 0xfa, "Synonym for OP_RETURN.";
+    OP_RETURN_251 => 0xfb, "Synonym for OP_RETURN.";
+    OP_RETURN_252 => 0xfc, "Synonym for OP_RETURN.";
+    OP_RETURN_253 => 0xfd, "Synonym for OP_RETURN.";
+    OP_RETURN_254 => 0xfe, "Synonym for OP_RETURN.";
+    OP_INVALIDOPCODE => 0xff, "Synonym for OP_RETURN."
+}
+
+/// Classification context for the opcode.
+///
+/// Some opcodes like [`OP_RESERVED`] abort the script in `ClassifyContext::Legacy` context,
+/// but will act as `OP_SUCCESSx` in `ClassifyContext::TapScript` (see BIP342 for full list).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ClassifyContext {
+    /// Opcode used in tapscript context.
+    TapScript,
+    /// Opcode used in legacy context.
+    Legacy,
+}
+
+impl Opcode {
+    /// Classifies an Opcode into a broad class.
+    #[inline]
+    pub fn classify(self, ctx: ClassifyContext) -> Class {
+        match (self, ctx) {
+            // 3 opcodes illegal in all contexts
+            (OP_VERIF, _) | (OP_VERNOTIF, _) | (OP_INVALIDOPCODE, _) => Class::IllegalOp,
+
+            // 15 opcodes illegal in Legacy context
+            #[rustfmt::skip]
+            (OP_CAT, ctx) | (OP_SUBSTR, ctx)
+            | (OP_LEFT, ctx) | (OP_RIGHT, ctx)
+            | (OP_INVERT, ctx)
+            | (OP_AND, ctx) | (OP_OR, ctx) | (OP_XOR, ctx)
+            | (OP_2MUL, ctx) | (OP_2DIV, ctx)
+            | (OP_MUL, ctx) | (OP_DIV, ctx) | (OP_MOD, ctx)
+            | (OP_LSHIFT, ctx) | (OP_RSHIFT, ctx) if ctx == ClassifyContext::Legacy => Class::IllegalOp,
+
+            // 86 opcodes of SuccessOp class only in TapScript context
+            (op, ClassifyContext::TapScript)
+                if op.code == 80
+                    || op.code == 98
+                    || (op.code >= 126 && op.code <= 129)
+                    || (op.code >= 131 && op.code <= 134)
+                    || (op.code >= 137 && op.code <= 138)
+                    || (op.code >= 141 && op.code <= 142)
+                    || (op.code >= 149 && op.code <= 153)
+                    || op.code == 187
+                    || (op.code >= 189 && op.code <= 254)=>
+                Class::SuccessOp,
+
+            // 11 opcodes of NoOp class
+            (OP_NOP, _) => Class::NoOp,
+            (op, _) if op.code >= OP_NOP1.code && op.code <= OP_NOP10.code => Class::NoOp,
+
+            // 1 opcode for `OP_RETURN`
+            (OP_RETURN, _) => Class::ReturnOp,
+
+            // 4 opcodes operating equally to `OP_RETURN` only in Legacy context
+            (OP_RESERVED, ctx) | (OP_RESERVED1, ctx) | (OP_RESERVED2, ctx) | (OP_VER, ctx)
+                if ctx == ClassifyContext::Legacy =>
+                Class::ReturnOp,
+
+            // 71 opcodes operating equally to `OP_RETURN` only in Legacy context
+            (op, ClassifyContext::Legacy) if op.code >= OP_CHECKSIGADD.code => Class::ReturnOp,
+
+            // 2 opcodes operating equally to `OP_RETURN` only in TapScript context
+            (OP_CHECKMULTISIG, ClassifyContext::TapScript)
+            | (OP_CHECKMULTISIGVERIFY, ClassifyContext::TapScript) => Class::ReturnOp,
+
+            // 1 opcode of PushNum class
+            (OP_PUSHNUM_NEG1, _) => Class::PushNum(-1),
+
+            // 16 opcodes of PushNum class
+            (op, _) if op.code >= OP_PUSHNUM_1.code && op.code <= OP_PUSHNUM_16.code =>
+                Class::PushNum(1 + self.code as i32 - OP_PUSHNUM_1.code as i32),
+
+            // 76 opcodes of PushBytes class
+            (op, _) if op.code <= OP_PUSHBYTES_75.code => Class::PushBytes(self.code as u32),
+
+            // opcodes of Ordinary class: 62 for Legacy and 60 for TapScript context
+            (_, _) => Class::Ordinary(Ordinary::with(self)),
+        }
+    }
+
+    /// Encodes [`Opcode`] as a byte.
+    #[inline]
+    pub const fn to_u8(self) -> u8 { self.code }
+
+    /// Encodes PUSHNUM [`Opcode`] as a `u8` representing its number (1-16).
+    ///
+    /// Does not convert `OP_FALSE` to 0. Only `1` to `OP_PUSHNUM_16` are covered.
+    ///
+    /// # Returns
+    ///
+    /// Returns `None` if `self` is not a PUSHNUM.
+    #[inline]
+    pub(crate) const fn decode_pushnum(self) -> Option<u8> {
+        const START: u8 = OP_PUSHNUM_1.code;
+        const END: u8 = OP_PUSHNUM_16.code;
+        match self.code {
+            START..=END => Some(self.code - START + 1),
+            _ => None,
+        }
+    }
+}
+
+impl From<u8> for Opcode {
+    #[inline]
+    fn from(b: u8) -> Opcode { Opcode { code: b } }
+}
+
+debug_from_display!(Opcode);
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Opcode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+/// Broad categories of opcodes with similar behavior.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum Class {
+    /// Pushes the given number onto the stack.
+    PushNum(i32),
+    /// Pushes the given number of bytes onto the stack.
+    PushBytes(u32),
+    /// Fails the script if executed.
+    ReturnOp,
+    /// Succeeds the script even if not executed.
+    SuccessOp,
+    /// Fails the script even if not executed.
+    IllegalOp,
+    /// Does nothing.
+    NoOp,
+    /// Any opcode not covered above.
+    Ordinary(Ordinary),
+}
+
+macro_rules! ordinary_opcode {
+    ($($op:ident),*) => (
+        #[repr(u8)]
+        #[doc(hidden)]
+        #[derive(Copy, Clone, PartialEq, Eq, Debug)]
+        pub enum Ordinary {
+            $( $op = $op.code ),*
+        }
+
+        impl fmt::Display for Ordinary {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                match *self {
+                   $(Ordinary::$op => { f.pad(stringify!($op)) }),*
+                }
+            }
+        }
+
+        impl Ordinary {
+            fn with(b: Opcode) -> Self {
+                match b {
+                    $( $op => { Ordinary::$op } ),*
+                    _ => unreachable!("construction of `Ordinary` type from non-ordinary opcode {}", b),
+                }
+            }
+
+            /// Try to create a [`Ordinary`] from an [`Opcode`].
+            pub fn from_opcode(b: Opcode) -> Option<Self> {
+                match b {
+                    $( $op => { Some(Ordinary::$op) } ),*
+                    _ => None,
+                }
+            }
+        }
+    );
+}
+
+// "Ordinary" opcodes -- should be 62 of these
+ordinary_opcode! {
+    // pushdata
+    OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4,
+    // control flow
+    OP_IF, OP_NOTIF, OP_ELSE, OP_ENDIF, OP_VERIFY,
+    // stack
+    OP_TOALTSTACK, OP_FROMALTSTACK,
+    OP_2DROP, OP_2DUP, OP_3DUP, OP_2OVER, OP_2ROT, OP_2SWAP,
+    OP_DROP, OP_DUP, OP_NIP, OP_OVER, OP_PICK, OP_ROLL, OP_ROT, OP_SWAP, OP_TUCK,
+    OP_IFDUP, OP_DEPTH, OP_SIZE,
+    // equality
+    OP_EQUAL, OP_EQUALVERIFY,
+    // arithmetic
+    OP_1ADD, OP_1SUB, OP_NEGATE, OP_ABS, OP_NOT, OP_0NOTEQUAL,
+    OP_ADD, OP_SUB, OP_BOOLAND, OP_BOOLOR,
+    OP_NUMEQUAL, OP_NUMEQUALVERIFY, OP_NUMNOTEQUAL, OP_LESSTHAN,
+    OP_GREATERTHAN, OP_LESSTHANOREQUAL, OP_GREATERTHANOREQUAL,
+    OP_MIN, OP_MAX, OP_WITHIN,
+    // crypto
+    OP_RIPEMD160, OP_SHA1, OP_SHA256, OP_HASH160, OP_HASH256,
+    OP_CODESEPARATOR, OP_CHECKSIG, OP_CHECKSIGVERIFY,
+    OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY,
+    OP_CHECKSIGADD,
+    // colored coins
+    OP_COLOR
+}
+
+impl Ordinary {
+    /// Encodes [`Opcode`] as a byte.
+    #[inline]
+    pub fn to_u8(self) -> u8 { self as u8 }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use super::*;
+
+    macro_rules! roundtrip {
+        ($unique:expr, $op:ident) => {
+            assert_eq!($op, Opcode::from($op.to_u8()));
+
+            let s1 = format!("{}", $op);
+            let s2 = format!("{:?}", $op);
+            assert_eq!(s1, s2);
+            assert_eq!(s1, stringify!($op));
+            assert!($unique.insert(s1));
+        };
+    }
+
+    #[test]
+    fn formatting_works() {
+        let op = all::OP_NOP;
+        let s = format!("{:>10}", op);
+        assert_eq!(s, "    OP_NOP");
+    }
+
+    #[test]
+    fn decode_pushnum() {
+        // Test all possible opcodes
+        // - Sanity check
+        assert_eq!(OP_PUSHNUM_1.code, 0x51_u8);
+        assert_eq!(OP_PUSHNUM_16.code, 0x60_u8);
+        for i in 0x00..=0xff_u8 {
+            let expected = match i {
+                // OP_PUSHNUM_1 ..= OP_PUSHNUM_16
+                0x51..=0x60 => Some(i - 0x50),
+                _ => None,
+            };
+            assert_eq!(Opcode::from(i).decode_pushnum(), expected);
+        }
+
+        // Test the named opcode constants
+        // - This is the OP right before PUSHNUMs start
+        assert!(OP_RESERVED.decode_pushnum().is_none());
+        assert_eq!(OP_PUSHNUM_1.decode_pushnum().expect("pushnum"), 1);
+        assert_eq!(OP_PUSHNUM_2.decode_pushnum().expect("pushnum"), 2);
+        assert_eq!(OP_PUSHNUM_3.decode_pushnum().expect("pushnum"), 3);
+        assert_eq!(OP_PUSHNUM_4.decode_pushnum().expect("pushnum"), 4);
+        assert_eq!(OP_PUSHNUM_5.decode_pushnum().expect("pushnum"), 5);
+        assert_eq!(OP_PUSHNUM_6.decode_pushnum().expect("pushnum"), 6);
+        assert_eq!(OP_PUSHNUM_7.decode_pushnum().expect("pushnum"), 7);
+        assert_eq!(OP_PUSHNUM_8.decode_pushnum().expect("pushnum"), 8);
+        assert_eq!(OP_PUSHNUM_9.decode_pushnum().expect("pushnum"), 9);
+        assert_eq!(OP_PUSHNUM_10.decode_pushnum().expect("pushnum"), 10);
+        assert_eq!(OP_PUSHNUM_11.decode_pushnum().expect("pushnum"), 11);
+        assert_eq!(OP_PUSHNUM_12.decode_pushnum().expect("pushnum"), 12);
+        assert_eq!(OP_PUSHNUM_13.decode_pushnum().expect("pushnum"), 13);
+        assert_eq!(OP_PUSHNUM_14.decode_pushnum().expect("pushnum"), 14);
+        assert_eq!(OP_PUSHNUM_15.decode_pushnum().expect("pushnum"), 15);
+        assert_eq!(OP_PUSHNUM_16.decode_pushnum().expect("pushnum"), 16);
+        // - This is the OP right after PUSHNUMs end
+        assert!(OP_NOP.decode_pushnum().is_none());
+    }
+
+    #[test]
+    fn classify_test() {
+        let op174 = OP_CHECKMULTISIG;
+        assert_eq!(
+            op174.classify(ClassifyContext::Legacy),
+            Class::Ordinary(Ordinary::OP_CHECKMULTISIG)
+        );
+        assert_eq!(op174.classify(ClassifyContext::TapScript), Class::ReturnOp);
+
+        let op175 = OP_CHECKMULTISIGVERIFY;
+        assert_eq!(
+            op175.classify(ClassifyContext::Legacy),
+            Class::Ordinary(Ordinary::OP_CHECKMULTISIGVERIFY)
+        );
+        assert_eq!(op175.classify(ClassifyContext::TapScript), Class::ReturnOp);
+
+        let op186 = OP_CHECKSIGADD;
+        assert_eq!(op186.classify(ClassifyContext::Legacy), Class::ReturnOp);
+        assert_eq!(
+            op186.classify(ClassifyContext::TapScript),
+            Class::Ordinary(Ordinary::OP_CHECKSIGADD)
+        );
+
+        let op187 = OP_RETURN_187;
+        assert_eq!(op187.classify(ClassifyContext::Legacy), Class::ReturnOp);
+        assert_eq!(op187.classify(ClassifyContext::TapScript), Class::SuccessOp);
+    }
+
+    #[test]
+    fn str_roundtrip() {
+        let mut unique = HashSet::new();
+        roundtrip!(unique, OP_PUSHBYTES_0);
+        roundtrip!(unique, OP_PUSHBYTES_1);
+        roundtrip!(unique, OP_PUSHBYTES_2);
+        roundtrip!(unique, OP_PUSHBYTES_3);
+        roundtrip!(unique, OP_PUSHBYTES_4);
+        roundtrip!(unique, OP_PUSHBYTES_5);
+        roundtrip!(unique, OP_PUSHBYTES_6);
+        roundtrip!(unique, OP_PUSHBYTES_7);
+        roundtrip!(unique, OP_PUSHBYTES_8);
+        roundtrip!(unique, OP_PUSHBYTES_9);
+        roundtrip!(unique, OP_PUSHBYTES_10);
+        roundtrip!(unique, OP_PUSHBYTES_11);
+        roundtrip!(unique, OP_PUSHBYTES_12);
+        roundtrip!(unique, OP_PUSHBYTES_13);
+        roundtrip!(unique, OP_PUSHBYTES_14);
+        roundtrip!(unique, OP_PUSHBYTES_15);
+        roundtrip!(unique, OP_PUSHBYTES_16);
+        roundtrip!(unique, OP_PUSHBYTES_17);
+        roundtrip!(unique, OP_PUSHBYTES_18);
+        roundtrip!(unique, OP_PUSHBYTES_19);
+        roundtrip!(unique, OP_PUSHBYTES_20);
+        roundtrip!(unique, OP_PUSHBYTES_21);
+        roundtrip!(unique, OP_PUSHBYTES_22);
+        roundtrip!(unique, OP_PUSHBYTES_23);
+        roundtrip!(unique, OP_PUSHBYTES_24);
+        roundtrip!(unique, OP_PUSHBYTES_25);
+        roundtrip!(unique, OP_PUSHBYTES_26);
+        roundtrip!(unique, OP_PUSHBYTES_27);
+        roundtrip!(unique, OP_PUSHBYTES_28);
+        roundtrip!(unique, OP_PUSHBYTES_29);
+        roundtrip!(unique, OP_PUSHBYTES_30);
+        roundtrip!(unique, OP_PUSHBYTES_31);
+        roundtrip!(unique, OP_PUSHBYTES_32);
+        roundtrip!(unique, OP_PUSHBYTES_33);
+        roundtrip!(unique, OP_PUSHBYTES_34);
+        roundtrip!(unique, OP_PUSHBYTES_35);
+        roundtrip!(unique, OP_PUSHBYTES_36);
+        roundtrip!(unique, OP_PUSHBYTES_37);
+        roundtrip!(unique, OP_PUSHBYTES_38);
+        roundtrip!(unique, OP_PUSHBYTES_39);
+        roundtrip!(unique, OP_PUSHBYTES_40);
+        roundtrip!(unique, OP_PUSHBYTES_41);
+        roundtrip!(unique, OP_PUSHBYTES_42);
+        roundtrip!(unique, OP_PUSHBYTES_43);
+        roundtrip!(unique, OP_PUSHBYTES_44);
+        roundtrip!(unique, OP_PUSHBYTES_45);
+        roundtrip!(unique, OP_PUSHBYTES_46);
+        roundtrip!(unique, OP_PUSHBYTES_47);
+        roundtrip!(unique, OP_PUSHBYTES_48);
+        roundtrip!(unique, OP_PUSHBYTES_49);
+        roundtrip!(unique, OP_PUSHBYTES_50);
+        roundtrip!(unique, OP_PUSHBYTES_51);
+        roundtrip!(unique, OP_PUSHBYTES_52);
+        roundtrip!(unique, OP_PUSHBYTES_53);
+        roundtrip!(unique, OP_PUSHBYTES_54);
+        roundtrip!(unique, OP_PUSHBYTES_55);
+        roundtrip!(unique, OP_PUSHBYTES_56);
+        roundtrip!(unique, OP_PUSHBYTES_57);
+        roundtrip!(unique, OP_PUSHBYTES_58);
+        roundtrip!(unique, OP_PUSHBYTES_59);
+        roundtrip!(unique, OP_PUSHBYTES_60);
+        roundtrip!(unique, OP_PUSHBYTES_61);
+        roundtrip!(unique, OP_PUSHBYTES_62);
+        roundtrip!(unique, OP_PUSHBYTES_63);
+        roundtrip!(unique, OP_PUSHBYTES_64);
+        roundtrip!(unique, OP_PUSHBYTES_65);
+        roundtrip!(unique, OP_PUSHBYTES_66);
+        roundtrip!(unique, OP_PUSHBYTES_67);
+        roundtrip!(unique, OP_PUSHBYTES_68);
+        roundtrip!(unique, OP_PUSHBYTES_69);
+        roundtrip!(unique, OP_PUSHBYTES_70);
+        roundtrip!(unique, OP_PUSHBYTES_71);
+        roundtrip!(unique, OP_PUSHBYTES_72);
+        roundtrip!(unique, OP_PUSHBYTES_73);
+        roundtrip!(unique, OP_PUSHBYTES_74);
+        roundtrip!(unique, OP_PUSHBYTES_75);
+        roundtrip!(unique, OP_PUSHDATA1);
+        roundtrip!(unique, OP_PUSHDATA2);
+        roundtrip!(unique, OP_PUSHDATA4);
+        roundtrip!(unique, OP_PUSHNUM_NEG1);
+        roundtrip!(unique, OP_RESERVED);
+        roundtrip!(unique, OP_PUSHNUM_1);
+        roundtrip!(unique, OP_PUSHNUM_2);
+        roundtrip!(unique, OP_PUSHNUM_3);
+        roundtrip!(unique, OP_PUSHNUM_4);
+        roundtrip!(unique, OP_PUSHNUM_5);
+        roundtrip!(unique, OP_PUSHNUM_6);
+        roundtrip!(unique, OP_PUSHNUM_7);
+        roundtrip!(unique, OP_PUSHNUM_8);
+        roundtrip!(unique, OP_PUSHNUM_9);
+        roundtrip!(unique, OP_PUSHNUM_10);
+        roundtrip!(unique, OP_PUSHNUM_11);
+        roundtrip!(unique, OP_PUSHNUM_12);
+        roundtrip!(unique, OP_PUSHNUM_13);
+        roundtrip!(unique, OP_PUSHNUM_14);
+        roundtrip!(unique, OP_PUSHNUM_15);
+        roundtrip!(unique, OP_PUSHNUM_16);
+        roundtrip!(unique, OP_NOP);
+        roundtrip!(unique, OP_VER);
+        roundtrip!(unique, OP_IF);
+        roundtrip!(unique, OP_NOTIF);
+        roundtrip!(unique, OP_VERIF);
+        roundtrip!(unique, OP_VERNOTIF);
+        roundtrip!(unique, OP_ELSE);
+        roundtrip!(unique, OP_ENDIF);
+        roundtrip!(unique, OP_VERIFY);
+        roundtrip!(unique, OP_RETURN);
+        roundtrip!(unique, OP_TOALTSTACK);
+        roundtrip!(unique, OP_FROMALTSTACK);
+        roundtrip!(unique, OP_2DROP);
+        roundtrip!(unique, OP_2DUP);
+        roundtrip!(unique, OP_3DUP);
+        roundtrip!(unique, OP_2OVER);
+        roundtrip!(unique, OP_2ROT);
+        roundtrip!(unique, OP_2SWAP);
+        roundtrip!(unique, OP_IFDUP);
+        roundtrip!(unique, OP_DEPTH);
+        roundtrip!(unique, OP_DROP);
+        roundtrip!(unique, OP_DUP);
+        roundtrip!(unique, OP_NIP);
+        roundtrip!(unique, OP_OVER);
+        roundtrip!(unique, OP_PICK);
+        roundtrip!(unique, OP_ROLL);
+        roundtrip!(unique, OP_ROT);
+        roundtrip!(unique, OP_SWAP);
+        roundtrip!(unique, OP_TUCK);
+        roundtrip!(unique, OP_CAT);
+        roundtrip!(unique, OP_SUBSTR);
+        roundtrip!(unique, OP_LEFT);
+        roundtrip!(unique, OP_RIGHT);
+        roundtrip!(unique, OP_SIZE);
+        roundtrip!(unique, OP_INVERT);
+        roundtrip!(unique, OP_AND);
+        roundtrip!(unique, OP_OR);
+        roundtrip!(unique, OP_XOR);
+        roundtrip!(unique, OP_EQUAL);
+        roundtrip!(unique, OP_EQUALVERIFY);
+        roundtrip!(unique, OP_RESERVED1);
+        roundtrip!(unique, OP_RESERVED2);
+        roundtrip!(unique, OP_1ADD);
+        roundtrip!(unique, OP_1SUB);
+        roundtrip!(unique, OP_2MUL);
+        roundtrip!(unique, OP_2DIV);
+        roundtrip!(unique, OP_NEGATE);
+        roundtrip!(unique, OP_ABS);
+        roundtrip!(unique, OP_NOT);
+        roundtrip!(unique, OP_0NOTEQUAL);
+        roundtrip!(unique, OP_ADD);
+        roundtrip!(unique, OP_SUB);
+        roundtrip!(unique, OP_MUL);
+        roundtrip!(unique, OP_DIV);
+        roundtrip!(unique, OP_MOD);
+        roundtrip!(unique, OP_LSHIFT);
+        roundtrip!(unique, OP_RSHIFT);
+        roundtrip!(unique, OP_BOOLAND);
+        roundtrip!(unique, OP_BOOLOR);
+        roundtrip!(unique, OP_NUMEQUAL);
+        roundtrip!(unique, OP_NUMEQUALVERIFY);
+        roundtrip!(unique, OP_NUMNOTEQUAL);
+        roundtrip!(unique, OP_LESSTHAN);
+        roundtrip!(unique, OP_GREATERTHAN);
+        roundtrip!(unique, OP_LESSTHANOREQUAL);
+        roundtrip!(unique, OP_GREATERTHANOREQUAL);
+        roundtrip!(unique, OP_MIN);
+        roundtrip!(unique, OP_MAX);
+        roundtrip!(unique, OP_WITHIN);
+        roundtrip!(unique, OP_RIPEMD160);
+        roundtrip!(unique, OP_SHA1);
+        roundtrip!(unique, OP_SHA256);
+        roundtrip!(unique, OP_HASH160);
+        roundtrip!(unique, OP_HASH256);
+        roundtrip!(unique, OP_CODESEPARATOR);
+        roundtrip!(unique, OP_CHECKSIG);
+        roundtrip!(unique, OP_CHECKSIGVERIFY);
+        roundtrip!(unique, OP_CHECKMULTISIG);
+        roundtrip!(unique, OP_CHECKMULTISIGVERIFY);
+        roundtrip!(unique, OP_NOP1);
+        roundtrip!(unique, OP_CLTV);
+        roundtrip!(unique, OP_CSV);
+        roundtrip!(unique, OP_NOP4);
+        roundtrip!(unique, OP_NOP5);
+        roundtrip!(unique, OP_NOP6);
+        roundtrip!(unique, OP_NOP7);
+        roundtrip!(unique, OP_NOP8);
+        roundtrip!(unique, OP_NOP9);
+        roundtrip!(unique, OP_NOP10);
+        roundtrip!(unique, OP_CHECKSIGADD);
+        roundtrip!(unique, OP_RETURN_187);
+        roundtrip!(unique, OP_COLOR);
+        roundtrip!(unique, OP_RETURN_189);
+        roundtrip!(unique, OP_RETURN_190);
+        roundtrip!(unique, OP_RETURN_191);
+        roundtrip!(unique, OP_RETURN_192);
+        roundtrip!(unique, OP_RETURN_193);
+        roundtrip!(unique, OP_RETURN_194);
+        roundtrip!(unique, OP_RETURN_195);
+        roundtrip!(unique, OP_RETURN_196);
+        roundtrip!(unique, OP_RETURN_197);
+        roundtrip!(unique, OP_RETURN_198);
+        roundtrip!(unique, OP_RETURN_199);
+        roundtrip!(unique, OP_RETURN_200);
+        roundtrip!(unique, OP_RETURN_201);
+        roundtrip!(unique, OP_RETURN_202);
+        roundtrip!(unique, OP_RETURN_203);
+        roundtrip!(unique, OP_RETURN_204);
+        roundtrip!(unique, OP_RETURN_205);
+        roundtrip!(unique, OP_RETURN_206);
+        roundtrip!(unique, OP_RETURN_207);
+        roundtrip!(unique, OP_RETURN_208);
+        roundtrip!(unique, OP_RETURN_209);
+        roundtrip!(unique, OP_RETURN_210);
+        roundtrip!(unique, OP_RETURN_211);
+        roundtrip!(unique, OP_RETURN_212);
+        roundtrip!(unique, OP_RETURN_213);
+        roundtrip!(unique, OP_RETURN_214);
+        roundtrip!(unique, OP_RETURN_215);
+        roundtrip!(unique, OP_RETURN_216);
+        roundtrip!(unique, OP_RETURN_217);
+        roundtrip!(unique, OP_RETURN_218);
+        roundtrip!(unique, OP_RETURN_219);
+        roundtrip!(unique, OP_RETURN_220);
+        roundtrip!(unique, OP_RETURN_221);
+        roundtrip!(unique, OP_RETURN_222);
+        roundtrip!(unique, OP_RETURN_223);
+        roundtrip!(unique, OP_RETURN_224);
+        roundtrip!(unique, OP_RETURN_225);
+        roundtrip!(unique, OP_RETURN_226);
+        roundtrip!(unique, OP_RETURN_227);
+        roundtrip!(unique, OP_RETURN_228);
+        roundtrip!(unique, OP_RETURN_229);
+        roundtrip!(unique, OP_RETURN_230);
+        roundtrip!(unique, OP_RETURN_231);
+        roundtrip!(unique, OP_RETURN_232);
+        roundtrip!(unique, OP_RETURN_233);
+        roundtrip!(unique, OP_RETURN_234);
+        roundtrip!(unique, OP_RETURN_235);
+        roundtrip!(unique, OP_RETURN_236);
+        roundtrip!(unique, OP_RETURN_237);
+        roundtrip!(unique, OP_RETURN_238);
+        roundtrip!(unique, OP_RETURN_239);
+        roundtrip!(unique, OP_RETURN_240);
+        roundtrip!(unique, OP_RETURN_241);
+        roundtrip!(unique, OP_RETURN_242);
+        roundtrip!(unique, OP_RETURN_243);
+        roundtrip!(unique, OP_RETURN_244);
+        roundtrip!(unique, OP_RETURN_245);
+        roundtrip!(unique, OP_RETURN_246);
+        roundtrip!(unique, OP_RETURN_247);
+        roundtrip!(unique, OP_RETURN_248);
+        roundtrip!(unique, OP_RETURN_249);
+        roundtrip!(unique, OP_RETURN_250);
+        roundtrip!(unique, OP_RETURN_251);
+        roundtrip!(unique, OP_RETURN_252);
+        roundtrip!(unique, OP_RETURN_253);
+        roundtrip!(unique, OP_RETURN_254);
+        roundtrip!(unique, OP_INVALIDOPCODE);
+        assert_eq!(unique.len(), 256);
+    }
+}
diff --git a/tapyrus/src/blockdata/script/borrowed.rs b/tapyrus/src/blockdata/script/borrowed.rs
new file mode 100644
index 00000000..e1fd7e40
--- /dev/null
+++ b/tapyrus/src/blockdata/script/borrowed.rs
@@ -0,0 +1,790 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::convert::{TryFrom, TryInto};
+use core::fmt;
+use core::ops::{
+    Bound, Index, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
+};
+use core::str::FromStr;
+
+use hashes::Hash;
+use secp256k1::{Secp256k1, Verification};
+
+use super::color_identifier::ColorIdentifier;
+use super::PushBytes;
+use crate::blockdata::opcodes::all::*;
+use crate::blockdata::opcodes::{self, Opcode};
+use crate::blockdata::script::witness_version::WitnessVersion;
+use crate::blockdata::script::{
+    bytes_to_asm_fmt, Builder, Instruction, InstructionIndices, Instructions, ScriptBuf,
+    ScriptHash, WScriptHash,
+};
+use crate::consensus::encode::deserialize;
+use crate::consensus::Encodable;
+use crate::key::{PublicKey, UntweakedPublicKey};
+use crate::policy::DUST_RELAY_TX_FEE;
+use crate::prelude::*;
+use crate::script::color_identifier::TokenTypes;
+use crate::taproot::{LeafVersion, TapLeafHash, TapNodeHash};
+
+/// Bitcoin script slice.
+///
+/// *[See also the `tapyrus::blockdata::script` module](crate::blockdata::script).*
+///
+/// `Script` is a script slice, the most primitive script type. It's usually seen in its borrowed
+/// form `&Script`. It is always encoded as a series of bytes representing the opcodes and data
+/// pushes.
+///
+/// ## Validity
+///
+/// `Script` does not have any validity invariants - it's essentially just a marked slice of
+/// bytes. This is similar to [`Path`](std::path::Path) vs [`OsStr`](std::ffi::OsStr) where they
+/// are trivially cast-able to each-other and `Path` doesn't guarantee being a usable FS path but
+/// having a newtype still has value because of added methods, readability and basic type checking.
+///
+/// Although at least data pushes could be checked not to overflow the script, bad scripts are
+/// allowed to be in a transaction (outputs just become unspendable) and there even are such
+/// transactions in the chain. Thus we must allow such scripts to be placed in the transaction.
+///
+/// ## Slicing safety
+///
+/// Slicing is similar to how `str` works: some ranges may be incorrect and indexing by
+/// `usize` is not supported. However, as opposed to `std`, we have no way of checking
+/// correctness without causing linear complexity so there are **no panics on invalid
+/// ranges!** If you supply an invalid range, you'll get a garbled script.
+///
+/// The range is considered valid if it's at a boundary of instruction. Care must be taken
+/// especially with push operations because you could get a reference to arbitrary
+/// attacker-supplied bytes that look like a valid script.
+///
+/// It is recommended to use `.instructions()` method to get an iterator over script
+/// instructions and work with that instead.
+///
+/// ## Memory safety
+///
+/// The type is `#[repr(transparent)]` for internal purposes only!
+/// No consumer crate may rely on the represenation of the struct!
+///
+/// ## References
+///
+///
+/// ### Bitcoin Core References
+///
+/// * [CScript definition](https://github.com/bitcoin/bitcoin/blob/d492dc1cdaabdc52b0766bf4cba4bd73178325d0/src/script/script.h#L410)
+///
+#[derive(PartialOrd, Ord, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct Script(pub(in crate::blockdata::script) [u8]);
+
+impl ToOwned for Script {
+    type Owned = ScriptBuf;
+
+    fn to_owned(&self) -> Self::Owned { ScriptBuf(self.0.to_owned()) }
+}
+
+impl Script {
+    /// Creates a new empty script.
+    #[inline]
+    pub fn new() -> &'static Script { Script::from_bytes(&[]) }
+
+    /// Treat byte slice as `Script`
+    #[inline]
+    pub fn from_bytes(bytes: &[u8]) -> &Script {
+        // SAFETY: copied from `std`
+        // The pointer was just created from a reference which is still alive.
+        // Casting slice pointer to a transparent struct wrapping that slice is sound (same
+        // layout).
+        unsafe { &*(bytes as *const [u8] as *const Script) }
+    }
+
+    /// Treat mutable byte slice as `Script`
+    #[inline]
+    pub fn from_bytes_mut(bytes: &mut [u8]) -> &mut Script {
+        // SAFETY: copied from `std`
+        // The pointer was just created from a reference which is still alive.
+        // Casting slice pointer to a transparent struct wrapping that slice is sound (same
+        // layout).
+        // Function signature prevents callers from accessing `bytes` while the returned reference
+        // is alive.
+        unsafe { &mut *(bytes as *mut [u8] as *mut Script) }
+    }
+
+    /// Returns the script data as a byte slice.
+    #[inline]
+    pub fn as_bytes(&self) -> &[u8] { &self.0 }
+
+    /// Returns the script data as a mutable byte slice.
+    #[inline]
+    pub fn as_mut_bytes(&mut self) -> &mut [u8] { &mut self.0 }
+
+    /// Creates a new script builder
+    pub fn builder() -> Builder { Builder::new() }
+
+    /// Returns 160-bit hash of the script.
+    #[inline]
+    pub fn script_hash(&self) -> ScriptHash { ScriptHash::hash(self.as_bytes()) }
+
+    /// Returns 256-bit hash of the script for P2WSH outputs.
+    #[inline]
+    pub fn wscript_hash(&self) -> WScriptHash { WScriptHash::hash(self.as_bytes()) }
+
+    /// Computes leaf hash of tapscript.
+    #[inline]
+    pub fn tapscript_leaf_hash(&self) -> TapLeafHash {
+        TapLeafHash::from_script(self, LeafVersion::TapScript)
+    }
+
+    /// Returns the length in bytes of the script.
+    #[inline]
+    pub fn len(&self) -> usize { self.0.len() }
+
+    /// Returns whether the script is the empty script.
+    #[inline]
+    pub fn is_empty(&self) -> bool { self.0.is_empty() }
+
+    /// Returns a copy of the script data.
+    #[inline]
+    pub fn to_bytes(&self) -> Vec<u8> { self.0.to_owned() }
+
+    /// Returns an iterator over script bytes.
+    #[inline]
+    pub fn bytes(&self) -> Bytes<'_> { Bytes(self.as_bytes().iter().copied()) }
+
+    /// Computes the P2WSH output corresponding to this witnessScript (aka the "witness redeem
+    /// script").
+    #[inline]
+    #[deprecated(since = "0.31.0", note = "use to_p2wsh instead")]
+    pub fn to_v0_p2wsh(&self) -> ScriptBuf { self.to_p2wsh() }
+
+    /// Computes the P2WSH output corresponding to this witnessScript (aka the "witness redeem
+    /// script").
+    #[inline]
+    pub fn to_p2wsh(&self) -> ScriptBuf { ScriptBuf::new_p2wsh(&self.wscript_hash()) }
+
+    /// Computes P2TR output with a given internal key and a single script spending path equal to
+    /// the current script, assuming that the script is a Tapscript.
+    #[inline]
+    #[deprecated(since = "0.31.0", note = "use to_p2tr instead")]
+    pub fn to_v1_p2tr<C: Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+        internal_key: UntweakedPublicKey,
+    ) -> ScriptBuf {
+        self.to_p2tr(secp, internal_key)
+    }
+
+    /// Computes P2TR output with a given internal key and a single script spending path equal to
+    /// the current script, assuming that the script is a Tapscript.
+    #[inline]
+    pub fn to_p2tr<C: Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+        internal_key: UntweakedPublicKey,
+    ) -> ScriptBuf {
+        let leaf_hash = self.tapscript_leaf_hash();
+        let merkle_root = TapNodeHash::from(leaf_hash);
+        ScriptBuf::new_p2tr(secp, internal_key, Some(merkle_root))
+    }
+
+    /// Returns witness version of the script, if any, assuming the script is a `scriptPubkey`.
+    #[inline]
+    pub fn witness_version(&self) -> Option<WitnessVersion> {
+        self.0.first().and_then(|opcode| WitnessVersion::try_from(Opcode::from(*opcode)).ok())
+    }
+
+    /// Checks whether a script pubkey is a P2SH output.
+    #[inline]
+    pub fn is_p2sh(&self) -> bool {
+        self.0.len() == 23
+            && self.0[0] == OP_HASH160.to_u8()
+            && self.0[1] == OP_PUSHBYTES_20.to_u8()
+            && self.0[22] == OP_EQUAL.to_u8()
+    }
+
+    /// Checks whether a script pubkey is a P2PKH output.
+    #[inline]
+    pub fn is_p2pkh(&self) -> bool {
+        self.0.len() == 25
+            && self.0[0] == OP_DUP.to_u8()
+            && self.0[1] == OP_HASH160.to_u8()
+            && self.0[2] == OP_PUSHBYTES_20.to_u8()
+            && self.0[23] == OP_EQUALVERIFY.to_u8()
+            && self.0[24] == OP_CHECKSIG.to_u8()
+    }
+
+    /// Checks whether a script is push only.
+    ///
+    /// Note: `OP_RESERVED` (`0x50`) and all the OP_PUSHNUM operations
+    /// are considered push operations.
+    #[inline]
+    pub fn is_push_only(&self) -> bool {
+        for inst in self.instructions() {
+            match inst {
+                Err(_) => return false,
+                Ok(Instruction::PushBytes(_)) => {}
+                Ok(Instruction::Op(op)) if op.to_u8() <= 0x60 => {}
+                // From Bitcoin Core
+                // if (opcode > OP_PUSHNUM_16 (0x60)) return false
+                Ok(Instruction::Op(_)) => return false,
+            }
+        }
+        true
+    }
+
+    /// Checks whether a script pubkey is a P2PK output.
+    ///
+    /// You can obtain the public key, if its valid,
+    /// by calling [`p2pk_public_key()`](Self::p2pk_public_key)
+    #[inline]
+    pub fn is_p2pk(&self) -> bool { self.p2pk_pubkey_bytes().is_some() }
+
+    /// Returns the public key if this script is P2PK with a **valid** public key.
+    ///
+    /// This may return `None` even when [`is_p2pk()`](Self::is_p2pk) returns true.
+    /// This happens when the public key is invalid (e.g. the point not being on the curve).
+    /// It also implies the script is unspendable.
+    #[inline]
+    pub fn p2pk_public_key(&self) -> Option<PublicKey> {
+        PublicKey::from_slice(self.p2pk_pubkey_bytes()?).ok()
+    }
+
+    /// Returns the bytes of the (possibly invalid) public key if this script is P2PK.
+    #[inline]
+    pub(in crate::blockdata::script) fn p2pk_pubkey_bytes(&self) -> Option<&[u8]> {
+        match self.len() {
+            67 if self.0[0] == OP_PUSHBYTES_65.to_u8() && self.0[66] == OP_CHECKSIG.to_u8() =>
+                Some(&self.0[1..66]),
+            35 if self.0[0] == OP_PUSHBYTES_33.to_u8() && self.0[34] == OP_CHECKSIG.to_u8() =>
+                Some(&self.0[1..34]),
+            _ => None,
+        }
+    }
+
+    /// Checks whether a script pubkey is a bare multisig output.
+    ///
+    /// In a bare multisig pubkey script the keys are not hashed, the script
+    /// is of the form:
+    ///
+    ///    `2 <pubkey1> <pubkey2> <pubkey3> 3 OP_CHECKMULTISIG`
+    #[inline]
+    pub fn is_multisig(&self) -> bool {
+        let required_sigs;
+
+        let mut instructions = self.instructions();
+        if let Some(Ok(Instruction::Op(op))) = instructions.next() {
+            if let Some(pushnum) = op.decode_pushnum() {
+                required_sigs = pushnum;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+
+        let mut num_pubkeys: u8 = 0;
+        while let Some(Ok(instruction)) = instructions.next() {
+            match instruction {
+                Instruction::PushBytes(_) => {
+                    num_pubkeys += 1;
+                }
+                Instruction::Op(op) => {
+                    if let Some(pushnum) = op.decode_pushnum() {
+                        if pushnum != num_pubkeys {
+                            return false;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+
+        if required_sigs > num_pubkeys {
+            return false;
+        }
+
+        if let Some(Ok(Instruction::Op(op))) = instructions.next() {
+            if op != OP_CHECKMULTISIG {
+                return false;
+            }
+        } else {
+            return false;
+        }
+
+        instructions.next().is_none()
+    }
+
+    /// Checks whether a script pubkey is a Segregated Witness (segwit) program.
+    #[inline]
+    pub fn is_witness_program(&self) -> bool {
+        // A scriptPubKey (or redeemScript as defined in BIP16/P2SH) that consists of a 1-byte
+        // push opcode (for 0 to 16) followed by a data push between 2 and 40 bytes gets a new
+        // special meaning. The value of the first push is called the "version byte". The following
+        // byte vector pushed is called the "witness program".
+        let script_len = self.0.len();
+        if !(4..=42).contains(&script_len) {
+            return false;
+        }
+        let ver_opcode = Opcode::from(self.0[0]); // Version 0 or PUSHNUM_1-PUSHNUM_16
+        let push_opbyte = self.0[1]; // Second byte push opcode 2-40 bytes
+        WitnessVersion::try_from(ver_opcode).is_ok()
+            && push_opbyte >= OP_PUSHBYTES_2.to_u8()
+            && push_opbyte <= OP_PUSHBYTES_40.to_u8()
+            // Check that the rest of the script has the correct size
+            && script_len - 2 == push_opbyte as usize
+    }
+
+    /// Checks whether a script pubkey is a P2WSH output.
+    #[inline]
+    #[deprecated(since = "0.31.0", note = "use is_p2wsh instead")]
+    pub fn is_v0_p2wsh(&self) -> bool { self.is_p2wsh() }
+
+    /// Checks whether a script pubkey is a P2WSH output.
+    #[inline]
+    pub fn is_p2wsh(&self) -> bool {
+        self.0.len() == 34
+            && self.witness_version() == Some(WitnessVersion::V0)
+            && self.0[1] == OP_PUSHBYTES_32.to_u8()
+    }
+
+    /// Checks whether a script pubkey is a P2WPKH output.
+    #[inline]
+    #[deprecated(since = "0.31.0", note = "use is_p2wpkh instead")]
+    pub fn is_v0_p2wpkh(&self) -> bool { self.is_p2wpkh() }
+
+    /// Checks whether a script pubkey is a P2WPKH output.
+    #[inline]
+    pub fn is_p2wpkh(&self) -> bool {
+        self.0.len() == 22
+            && self.witness_version() == Some(WitnessVersion::V0)
+            && self.0[1] == OP_PUSHBYTES_20.to_u8()
+    }
+
+    pub(crate) fn p2wpkh(&self) -> Option<&[u8; 20]> {
+        if self.is_p2wpkh() {
+            Some(self.0[2..].try_into().expect("is_v0_p2wpkh checks the length"))
+        } else {
+            None
+        }
+    }
+
+    /// Checks whether a script pubkey is a P2TR output.
+    #[inline]
+    #[deprecated(since = "0.31.0", note = "use is_p2tr instead")]
+    pub fn is_v1_p2tr(&self) -> bool { self.is_p2tr() }
+
+    /// Checks whether a script pubkey is a P2TR output.
+    #[inline]
+    pub fn is_p2tr(&self) -> bool {
+        self.0.len() == 34
+            && self.witness_version() == Some(WitnessVersion::V1)
+            && self.0[1] == OP_PUSHBYTES_32.to_u8()
+    }
+
+    /// Check if this is an OP_RETURN output.
+    #[inline]
+    pub fn is_op_return(&self) -> bool {
+        match self.0.first() {
+            Some(b) => *b == OP_RETURN.to_u8(),
+            None => false,
+        }
+    }
+
+    /// Checks whether a script can be proven to have no satisfying input.
+    #[inline]
+    pub fn is_provably_unspendable(&self) -> bool {
+        use crate::blockdata::opcodes::Class::{IllegalOp, ReturnOp};
+
+        match self.0.first() {
+            Some(b) => {
+                let first = Opcode::from(*b);
+                let class = first.classify(opcodes::ClassifyContext::Legacy);
+
+                class == ReturnOp || class == IllegalOp
+            }
+            None => false,
+        }
+    }
+
+    /// Check if a script pubkey is a cp2pkh output
+    pub fn is_cp2pkh(&self) -> bool {
+        self.0.len() == 60
+            && self.0[0] == OP_PUSHBYTES_33.to_u8()
+            && TokenTypes::is_valid(&self.0[1])
+            && self.0[34] == OP_COLOR.to_u8()
+            && self.0[35] == OP_DUP.to_u8()
+            && self.0[36] == OP_HASH160.to_u8()
+            && self.0[37] == OP_PUSHBYTES_20.to_u8()
+            && self.0[58] == OP_EQUALVERIFY.to_u8()
+            && self.0[59] == OP_CHECKSIG.to_u8()
+    }
+
+    /// Check if a script pubkey is a cp2sh output
+    pub fn is_cp2sh(&self) -> bool {
+        self.0.len() == 58
+            && self.0[0] == OP_PUSHBYTES_33.to_u8()
+            && TokenTypes::is_valid(&self.0[1])
+            && self.0[34] == OP_COLOR.to_u8()
+            && self.0[35] == OP_HASH160.to_u8()
+            && self.0[36] == OP_PUSHBYTES_20.to_u8()
+            && self.0[57] == OP_EQUAL.to_u8()
+    }
+
+    /// Check if a script pubkey is a colored coin script
+    pub fn is_colored(&self) -> bool {
+        self.is_cp2pkh() || self.is_cp2sh()
+    }
+
+    /// Computes the P2SH output corresponding to this redeem script.
+    pub fn to_p2sh(&self) -> ScriptBuf { ScriptBuf::new_p2sh(&self.script_hash()) }
+
+    /// Returns the script code used for spending a P2WPKH output if this script is a script pubkey
+    /// for a P2WPKH output. The `scriptCode` is described in [BIP143].
+    ///
+    /// [BIP143]: <https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki>
+    pub fn p2wpkh_script_code(&self) -> Option<ScriptBuf> {
+        self.p2wpkh().map(|wpkh| {
+            Builder::new()
+                .push_opcode(OP_DUP)
+                .push_opcode(OP_HASH160)
+                // The `self` script is 0x00, 0x14, <pubkey_hash>
+                .push_slice(wpkh)
+                .push_opcode(OP_EQUALVERIFY)
+                .push_opcode(OP_CHECKSIG)
+                .into_script()
+        })
+    }
+
+    /// Returns the minimum value an output with this script should have in order to be
+    /// broadcastable on today's Bitcoin network.
+    pub fn dust_value(&self) -> crate::Amount {
+        // If the script is colored, the output does not have a dust limit.
+        if self.is_colored() {
+            return crate::Amount::from_tap(1);
+        }
+
+        // This must never be lower than Bitcoin Core's GetDustThreshold() (as of v0.21) as it may
+        // otherwise allow users to create transactions which likely can never be broadcast/confirmed.
+        let taps = DUST_RELAY_TX_FEE as u64 / 1000 * // The default dust relay fee is 3000 tapyrus/kB (i.e. 3 tap/vByte)
+        if self.is_op_return() {
+            0
+        } else if self.is_witness_program() {
+            32 + 4 + 1 + (107 / 4) + 4 + // The spend cost copied from Core
+            8 + // The serialized size of the TxOut's amount field
+            self.consensus_encode(&mut sink()).expect("sinks don't error") as u64 // The serialized size of this script_pubkey
+        } else {
+            32 + 4 + 1 + 107 + 4 + // The spend cost copied from Core
+            8 + // The serialized size of the TxOut's amount field
+            self.consensus_encode(&mut sink()).expect("sinks don't error") as u64 // The serialized size of this script_pubkey
+        };
+
+        crate::Amount::from_tap(taps)
+    }
+
+    /// Counts the sigops for this Script using accurate counting.
+    ///
+    /// In Bitcoin Core, there are two ways to count sigops, "accurate" and "legacy".
+    /// This method uses "accurate" counting. This means that OP_CHECKMULTISIG and its
+    /// verify variant count for N sigops where N is the number of pubkeys used in the
+    /// multisig. However, it will count for 20 sigops if CHECKMULTISIG is not preceeded by an
+    /// OP_PUSHNUM from 1 - 16 (this would be an invalid script)
+    ///
+    /// Bitcoin Core uses accurate counting for sigops contained within redeemScripts (P2SH)
+    /// and witnessScripts (P2WSH) only. It uses legacy for sigops in scriptSigs and scriptPubkeys.
+    ///
+    /// (Note: taproot scripts don't count toward the sigop count of the block,
+    /// nor do they have CHECKMULTISIG operations. This function does not count OP_CHECKSIGADD,
+    /// so do not use this to try and estimate if a taproot script goes over the sigop budget.)
+    pub fn count_sigops(&self) -> usize { self.count_sigops_internal(true) }
+
+    /// Counts the sigops for this Script using legacy counting.
+    ///
+    /// In Bitcoin Core, there are two ways to count sigops, "accurate" and "legacy".
+    /// This method uses "legacy" counting. This means that OP_CHECKMULTISIG and its
+    /// verify variant count for 20 sigops.
+    ///
+    /// Bitcoin Core uses legacy counting for sigops contained within scriptSigs and
+    /// scriptPubkeys. It uses accurate for redeemScripts (P2SH) and witnessScripts (P2WSH).
+    ///
+    /// (Note: taproot scripts don't count toward the sigop count of the block,
+    /// nor do they have CHECKMULTISIG operations. This function does not count OP_CHECKSIGADD,
+    /// so do not use this to try and estimate if a taproot script goes over the sigop budget.)
+    pub fn count_sigops_legacy(&self) -> usize { self.count_sigops_internal(false) }
+
+    fn count_sigops_internal(&self, accurate: bool) -> usize {
+        let mut n = 0;
+        let mut pushnum_cache = None;
+        for inst in self.instructions() {
+            match inst {
+                Ok(Instruction::Op(opcode)) => {
+                    match opcode {
+                        // p2pk, p2pkh
+                        OP_CHECKSIG | OP_CHECKSIGVERIFY => {
+                            n += 1;
+                        }
+                        OP_CHECKMULTISIG | OP_CHECKMULTISIGVERIFY => {
+                            match (accurate, pushnum_cache) {
+                                (true, Some(pushnum)) => {
+                                    // Add the number of pubkeys in the multisig as sigop count
+                                    n += usize::from(pushnum);
+                                }
+                                _ => {
+                                    // MAX_PUBKEYS_PER_MULTISIG from Bitcoin Core
+                                    // https://github.com/bitcoin/bitcoin/blob/v25.0/src/script/script.h#L29-L30
+                                    n += 20;
+                                }
+                            }
+                        }
+                        _ => {
+                            pushnum_cache = opcode.decode_pushnum();
+                        }
+                    }
+                }
+                Ok(Instruction::PushBytes(_)) => {
+                    pushnum_cache = None;
+                }
+                // In Bitcoin Core it does `if (!GetOp(pc, opcode)) break;`
+                Err(_) => break,
+            }
+        }
+
+        n
+    }
+
+    /// Iterates over the script instructions.
+    ///
+    /// Each returned item is a nested enum covering opcodes, datapushes and errors.
+    /// At most one error will be returned and then the iterator will end. To instead iterate over
+    /// the script as sequence of bytes call the [`bytes`](Self::bytes) method.
+    ///
+    /// To force minimal pushes, use [`instructions_minimal`](Self::instructions_minimal).
+    #[inline]
+    pub fn instructions(&self) -> Instructions {
+        Instructions { data: self.0.iter(), enforce_minimal: false }
+    }
+
+    /// Iterates over the script instructions while enforcing minimal pushes.
+    ///
+    /// This is similar to [`instructions`](Self::instructions) but an error is returned if a push
+    /// is not minimal.
+    #[inline]
+    pub fn instructions_minimal(&self) -> Instructions {
+        Instructions { data: self.0.iter(), enforce_minimal: true }
+    }
+
+    /// Iterates over the script instructions and their indices.
+    ///
+    /// Unless the script contains an error, the returned item consists of an index pointing to the
+    /// position in the script where the instruction begins and the decoded instruction - either an
+    /// opcode or data push.
+    ///
+    /// To force minimal pushes, use [`Self::instruction_indices_minimal`].
+    #[inline]
+    pub fn instruction_indices(&self) -> InstructionIndices {
+        InstructionIndices::from_instructions(self.instructions())
+    }
+
+    /// Iterates over the script instructions and their indices while enforcing minimal pushes.
+    ///
+    /// This is similar to [`instruction_indices`](Self::instruction_indices) but an error is
+    /// returned if a push is not minimal.
+    #[inline]
+    pub fn instruction_indices_minimal(&self) -> InstructionIndices {
+        InstructionIndices::from_instructions(self.instructions_minimal())
+    }
+
+    /// Writes the assembly decoding of the script to the formatter.
+    pub fn fmt_asm(&self, f: &mut dyn fmt::Write) -> fmt::Result {
+        bytes_to_asm_fmt(self.as_ref(), f)
+    }
+
+    /// Returns the assembly decoding of the script.
+    pub fn to_asm_string(&self) -> String {
+        let mut buf = String::new();
+        self.fmt_asm(&mut buf).unwrap();
+        buf
+    }
+
+    /// Formats the script as lower-case hex.
+    ///
+    /// This is a more convenient and performant way to write `format!("{:x}", script)`.
+    /// For better performance you should generally prefer displaying the script but if `String` is
+    /// required (this is common in tests) this method is can be used.
+    pub fn to_hex_string(&self) -> String { self.as_bytes().to_lower_hex_string() }
+
+    /// Returns the first opcode of the script (if there is any).
+    pub fn first_opcode(&self) -> Option<Opcode> {
+        self.as_bytes().first().copied().map(From::from)
+    }
+
+    /// Iterates the script to find the last opcode.
+    ///
+    /// Returns `None` is the instruction is data push or if the script is empty.
+    pub(in crate::blockdata::script) fn last_opcode(&self) -> Option<Opcode> {
+        match self.instructions().last() {
+            Some(Ok(Instruction::Op(op))) => Some(op),
+            _ => None,
+        }
+    }
+
+    /// Iterates the script to find the last pushdata.
+    ///
+    /// Returns `None` if the instruction is an opcode or if the script is empty.
+    pub(crate) fn last_pushdata(&self) -> Option<&PushBytes> {
+        match self.instructions().last() {
+            // Handles op codes up to (but excluding) OP_PUSHNUM_NEG.
+            Some(Ok(Instruction::PushBytes(bytes))) => Some(bytes),
+            // OP_16 (0x60) and lower are considered "pushes" by Bitcoin Core (excl. OP_RESERVED).
+            // However we are only interested in the pushdata so we can ignore them.
+            _ => None,
+        }
+    }
+
+    /// Converts a [`Box<Script>`](Box) into a [`ScriptBuf`] without copying or allocating.
+    #[must_use = "`self` will be dropped if the result is not used"]
+    pub fn into_script_buf(self: Box<Self>) -> ScriptBuf {
+        let rw = Box::into_raw(self) as *mut [u8];
+        // SAFETY: copied from `std`
+        // The pointer was just created from a box without deallocating
+        // Casting a transparent struct wrapping a slice to the slice pointer is sound (same
+        // layout).
+        let inner = unsafe { Box::from_raw(rw) };
+        ScriptBuf(Vec::from(inner))
+    }
+
+
+    /// Return script type.
+    pub fn script_type(&self) -> ScriptType {
+        if self.is_p2pk() {
+            ScriptType::P2pk
+        } else if self.is_p2pkh() {
+            ScriptType::P2pkh
+        } else if self.is_multisig() {
+            ScriptType::P2ms
+        } else if self.is_p2sh() {
+            ScriptType::P2sh
+        } else if self.is_op_return() {
+            ScriptType::Nulldata
+        } else if self.is_cp2pkh() {
+            ScriptType::Cp2pkh
+        } else if self.is_cp2sh() {
+            ScriptType::Cp2sh
+        } else {
+            ScriptType::NonStandard
+        }
+    }
+
+    /// Return color_id for cp2pkh or cp2sh script.
+    pub fn color_id(&self) -> Option<ColorIdentifier> {
+        if self.is_colored() {
+            deserialize(&self.as_bytes()[1..34]).ok()
+        } else {
+            None
+        }
+    }
+}
+
+/// Iterator over bytes of a script
+pub struct Bytes<'a>(core::iter::Copied<core::slice::Iter<'a, u8>>);
+
+impl Iterator for Bytes<'_> {
+    type Item = u8;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> { self.0.next() }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
+
+    #[inline]
+    fn nth(&mut self, n: usize) -> Option<Self::Item> { self.0.nth(n) }
+}
+
+impl DoubleEndedIterator for Bytes<'_> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> { self.0.next_back() }
+
+    #[inline]
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> { self.0.nth_back(n) }
+}
+
+impl ExactSizeIterator for Bytes<'_> {}
+impl core::iter::FusedIterator for Bytes<'_> {}
+
+macro_rules! delegate_index {
+    ($($type:ty),* $(,)?) => {
+        $(
+            /// Script subslicing operation - read [slicing safety](#slicing-safety)!
+            impl Index<$type> for Script {
+                type Output = Self;
+
+                #[inline]
+                fn index(&self, index: $type) -> &Self::Output {
+                    Self::from_bytes(&self.0[index])
+                }
+            }
+        )*
+    }
+}
+
+delegate_index!(
+    Range<usize>,
+    RangeFrom<usize>,
+    RangeTo<usize>,
+    RangeFull,
+    RangeInclusive<usize>,
+    RangeToInclusive<usize>,
+    (Bound<usize>, Bound<usize>)
+);
+
+/// The types of scripts
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ScriptType {
+    /// pay-to-pubkey
+    P2pk,
+    /// pay-to-pubkey-hash
+    P2pkh,
+    /// pay-to-multisig
+    P2ms,
+    /// pay-to-script-hash
+    P2sh,
+    /// colored pay-to-pubkey-hash
+    Cp2pkh,
+    /// colored pay-to-script-hash
+    Cp2sh,
+    /// op_return script
+    Nulldata,
+    /// non-standard script
+    NonStandard,
+}
+
+impl fmt::Display for ScriptType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(match *self {
+            ScriptType::P2pk => "pubkey",
+            ScriptType::P2pkh => "pubkeyhash",
+            ScriptType::P2ms => "multisig",
+            ScriptType::P2sh => "scripthash",
+            ScriptType::Cp2pkh => "coloredpubkeyhash",
+            ScriptType::Cp2sh => "coloredscripthash",
+            ScriptType::Nulldata => "nulldata",
+            ScriptType::NonStandard => "nonstandard"
+        })
+    }
+}
+
+impl FromStr for ScriptType {
+    type Err = ();
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "pubkey" => Ok(ScriptType::P2pk),
+            "pubkeyhash" => Ok(ScriptType::P2pkh),
+            "multisig" => Ok(ScriptType::P2ms),
+            "scripthash" => Ok(ScriptType::P2sh),
+            "coloredpubkeyhash" => Ok(ScriptType::Cp2pkh),
+            "coloredscripthash" => Ok(ScriptType::Cp2sh),
+            "nulldata" => Ok(ScriptType::Nulldata),
+            "nonstandard" => Ok(ScriptType::NonStandard),
+            _ => Err(()),
+        }
+    }
+}
\ No newline at end of file
diff --git a/tapyrus/src/blockdata/script/builder.rs b/tapyrus/src/blockdata/script/builder.rs
new file mode 100644
index 00000000..06af410f
--- /dev/null
+++ b/tapyrus/src/blockdata/script/builder.rs
@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::default::Default;
+use core::fmt;
+
+use secp256k1::XOnlyPublicKey;
+
+use crate::blockdata::locktime::absolute;
+use crate::blockdata::opcodes::all::*;
+use crate::blockdata::opcodes::{self, Opcode};
+use crate::blockdata::script::{opcode_to_verify, write_scriptint, PushBytes, Script, ScriptBuf};
+use crate::blockdata::transaction::Sequence;
+use crate::key::PublicKey;
+use crate::prelude::*;
+
+/// An Object which can be used to construct a script piece by piece.
+#[derive(PartialEq, Eq, Clone)]
+pub struct Builder(ScriptBuf, Option<Opcode>);
+
+impl Builder {
+    /// Creates a new empty script.
+    pub fn new() -> Self { Builder(ScriptBuf::new(), None) }
+
+    /// Returns the length in bytes of the script.
+    pub fn len(&self) -> usize { self.0.len() }
+
+    /// Checks whether the script is the empty script.
+    pub fn is_empty(&self) -> bool { self.0.is_empty() }
+
+    /// 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.
+    pub fn push_int(self, data: i64) -> Builder {
+        // We can special-case -1, 1-16
+        if data == -1 || (1..=16).contains(&data) {
+            let opcode = Opcode::from((data - 1 + opcodes::OP_TRUE.to_u8() as i64) as u8);
+            self.push_opcode(opcode)
+        }
+        // We can also special-case zero
+        else if data == 0 {
+            self.push_opcode(opcodes::OP_0)
+        }
+        // Otherwise encode it as data
+        else {
+            self.push_int_non_minimal(data)
+        }
+    }
+
+    /// Adds instructions to push an integer onto the stack without optimization.
+    ///
+    /// This uses the explicit encoding regardless of the availability of dedicated opcodes.
+    pub(in crate::blockdata) fn push_int_non_minimal(self, data: i64) -> Builder {
+        let mut buf = [0u8; 8];
+        let len = write_scriptint(&mut buf, data);
+        self.push_slice(&<&PushBytes>::from(&buf)[..len])
+    }
+
+    /// Adds instructions to push some arbitrary data onto the stack.
+    pub fn push_slice<T: AsRef<PushBytes>>(mut self, data: T) -> Builder {
+        self.0.push_slice(data);
+        self.1 = None;
+        self
+    }
+
+    /// Adds instructions to push a public key onto the stack.
+    pub fn push_key(self, key: &PublicKey) -> Builder {
+        if key.compressed {
+            self.push_slice(key.inner.serialize())
+        } else {
+            self.push_slice(key.inner.serialize_uncompressed())
+        }
+    }
+
+    /// Adds instructions to push an XOnly public key onto the stack.
+    pub fn push_x_only_key(self, x_only_key: &XOnlyPublicKey) -> Builder {
+        self.push_slice(x_only_key.serialize())
+    }
+
+    /// Adds a single opcode to the script.
+    pub fn push_opcode(mut self, data: Opcode) -> Builder {
+        self.0.push_opcode(data);
+        self.1 = Some(data);
+        self
+    }
+
+    /// Adds an `OP_VERIFY` to the script or replaces the last opcode with VERIFY form.
+    ///
+    /// Some opcodes such as `OP_CHECKSIG` have a verify variant that works as if `VERIFY` was
+    /// in the script right after. To save space this function appends `VERIFY` only if
+    /// the most-recently-added opcode *does not* have an alternate `VERIFY` form. If it does
+    /// the last opcode is replaced. E.g., `OP_CHECKSIG` will become `OP_CHECKSIGVERIFY`.
+    ///
+    /// Note that existing `OP_*VERIFY` opcodes do not lead to the instruction being ignored
+    /// because `OP_VERIFY` consumes an item from the stack so ignoring them would change the
+    /// semantics.
+    pub fn push_verify(mut self) -> Builder {
+        // "duplicated code" because we need to update `1` field
+        match opcode_to_verify(self.1) {
+            Some(opcode) => {
+                (self.0).0.pop();
+                self.push_opcode(opcode)
+            }
+            None => self.push_opcode(OP_VERIFY),
+        }
+    }
+
+    /// Adds instructions to push an absolute lock time onto the stack.
+    pub fn push_lock_time(self, lock_time: absolute::LockTime) -> Builder {
+        self.push_int(lock_time.to_consensus_u32().into())
+    }
+
+    /// Adds instructions to push a sequence number onto the stack.
+    pub fn push_sequence(self, sequence: Sequence) -> Builder {
+        self.push_int(sequence.to_consensus_u32().into())
+    }
+
+    /// Converts the `Builder` into `ScriptBuf`.
+    pub fn into_script(self) -> ScriptBuf { self.0 }
+
+    /// Converts the `Builder` into script bytes
+    pub fn into_bytes(self) -> Vec<u8> { self.0.into() }
+
+    /// Returns the internal script
+    pub fn as_script(&self) -> &Script { &self.0 }
+
+    /// Returns script bytes
+    pub fn as_bytes(&self) -> &[u8] { self.0.as_bytes() }
+}
+
+impl Default for Builder {
+    fn default() -> Builder { Builder::new() }
+}
+
+/// Creates a new builder from an existing vector.
+impl From<Vec<u8>> for Builder {
+    fn from(v: Vec<u8>) -> Builder {
+        let script = ScriptBuf::from(v);
+        let last_op = script.last_opcode();
+        Builder(script, last_op)
+    }
+}
+
+impl fmt::Display for Builder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.0.fmt_asm(f) }
+}
+
+internals::debug_from_display!(Builder);
diff --git a/tapyrus/src/blockdata/script/color_identifier.rs b/tapyrus/src/blockdata/script/color_identifier.rs
new file mode 100644
index 00000000..7457584d
--- /dev/null
+++ b/tapyrus/src/blockdata/script/color_identifier.rs
@@ -0,0 +1,186 @@
+//! The colored Identifier is a special identifier that is used to identify a colored coin.
+//!
+//! > When OP_COLOR opcode appears in a script, the top element of the stack is popped which
+//! > interpreted as a COLOR identifier. The script will fail if there are no elements left
+//! > in the stack, or if the COLOR identifier does not matched the rules described below.
+//! > If the COLOR identifier matches to the rule, the coin of the UTXO represents the amount
+//! > of the coin for the COLOR identifier. Script which does not include OP_COLOR represents
+//! > to the amount of the default token TPC (tapyrus).
+//!
+//! [Colored Coin]: <https://github.com/chaintope/tapyrus-core/blob/master/doc/tapyrus/colored_coin.md>
+
+use core::convert::TryFrom;
+use core::fmt;
+use core::str::FromStr;
+use hex::FromHex;
+
+use hashes::{Hash, sha256};
+use crate::consensus::{Decodable, deserialize, Encodable, encode, serialize};
+use crate::blockdata::script::Script;
+use crate::blockdata::transaction::OutPoint;
+use crate::consensus::encode::serialize_hex;
+use crate::script::PushBytesBuf;
+use crate::io;
+use crate::prelude::*;
+
+/// ColorIdentifier
+#[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct ColorIdentifier {
+    /// Token type
+    pub token_type: TokenTypes,
+    /// Payload
+    payload: ColorIdentifierPayload,
+}
+
+impl ColorIdentifier {
+    /// initialize ColorIdentifier with type Reissuable
+    pub fn reissuable(script_pubkey: &Script) -> Self {
+        let mut enc = ColorIdentifierPayload::engine();
+        script_pubkey.consensus_encode(&mut enc).unwrap();
+        ColorIdentifier {
+            token_type: TokenTypes::Reissuable,
+            payload: ColorIdentifierPayload::from_engine(enc),
+        }
+    }
+
+    /// initialize ColorIdentifier with type Non Reissuable
+    pub fn non_reissuable(out_point: OutPoint) -> Self {
+        let mut enc = ColorIdentifierPayload::engine();
+        out_point.consensus_encode(&mut enc).unwrap();
+        ColorIdentifier {
+            token_type: TokenTypes::NonReissuable,
+            payload: ColorIdentifierPayload::from_engine(enc),
+        }
+    }
+
+    /// initialize ColorIdentifier with type Nft
+    pub fn nft(out_point: OutPoint) -> Self {
+        let mut enc = ColorIdentifierPayload::engine();
+        out_point.consensus_encode(&mut enc).unwrap();
+        ColorIdentifier {
+            token_type: TokenTypes::Nft,
+            payload: ColorIdentifierPayload::from_engine(enc),
+        }
+    }
+
+    /// Check if the color identifier is colored
+    pub fn is_colored(&self) -> bool {
+        self.token_type != TokenTypes::None
+    }
+
+    /// Check if the color identifier is TPC
+    pub fn is_default(&self) -> bool {
+        self.token_type == TokenTypes::None
+    }
+}
+
+impl Default for ColorIdentifier {
+    fn default() -> Self {
+        ColorIdentifier {
+            token_type: TokenTypes::None,
+            payload: ColorIdentifierPayload::all_zeros(),
+        }
+    }
+}
+
+impl Encodable for ColorIdentifier {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = self.token_type.consensus_encode(w)?;
+        len += self.payload.consensus_encode(w)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for ColorIdentifier {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let token_type = TokenTypes::consensus_decode(r)?;
+        let payload = ColorIdentifierPayload::consensus_decode(r)?;
+        Ok(ColorIdentifier {
+            token_type,
+            payload,
+        })
+    }
+}
+
+impl fmt::Display for ColorIdentifier {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", serialize_hex(self))
+    }
+}
+
+impl From<ColorIdentifier> for PushBytesBuf {
+    fn from(color_id: ColorIdentifier) -> Self {
+        PushBytesBuf::try_from(serialize(&color_id)).unwrap()
+    }
+}
+
+impl FromStr for ColorIdentifier {
+    type Err = encode::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let bytes = Vec::<u8>::from_hex(s).unwrap();
+        deserialize(&bytes)
+    }
+}
+
+hashes::hash_newtype! {
+    /// A color identifier payload hash
+    pub struct ColorIdentifierPayload(sha256::Hash);
+}
+
+crate::hash_types::impl_hashencode!(ColorIdentifierPayload);
+
+/// Token types
+#[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub enum TokenTypes {
+    /// TPC
+    None = 0x00,
+    /// Reissuable
+    Reissuable = 0xc1,
+    /// Non reissuable
+    NonReissuable = 0xc2,
+    /// Non fungible token
+    Nft = 0xc3,
+}
+
+impl TokenTypes {
+    /// return true if token type is supported
+    pub fn is_valid(token_type: &u8) -> bool {
+        [
+            TokenTypes::None,
+            TokenTypes::Reissuable,
+            TokenTypes::NonReissuable,
+            TokenTypes::Nft
+        ].iter().any(|e| *e as u8 == *token_type)
+    }
+}
+
+impl Encodable for TokenTypes {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        (*self as u8).consensus_encode(w)
+    }
+}
+
+impl Decodable for TokenTypes {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let token_type = u8::consensus_decode(r)?;
+        match token_type {
+            0x00 => Ok(TokenTypes::None),
+            0xc1 => Ok(TokenTypes::Reissuable),
+            0xc2 => Ok(TokenTypes::NonReissuable),
+            0xc3 => Ok(TokenTypes::Nft),
+            _ => Err(encode::Error::ParseFailed("Unknown token type")),
+        }
+    }
+}
+
+/// Error occured with colored coin
+#[derive(Debug)]
+pub enum ColoredCoinError {
+    /// original script is not based p2pkh and p2sh
+    UnsupportedScriptType,
+}
diff --git a/tapyrus/src/blockdata/script/instruction.rs b/tapyrus/src/blockdata/script/instruction.rs
new file mode 100644
index 00000000..6c3da7bf
--- /dev/null
+++ b/tapyrus/src/blockdata/script/instruction.rs
@@ -0,0 +1,256 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::convert::TryInto;
+
+use crate::blockdata::opcodes::{self, Opcode};
+use crate::blockdata::script::{read_uint_iter, Error, PushBytes, Script, ScriptBuf, UintError};
+
+/// A "parsed opcode" which allows iterating over a [`Script`] in a more sensible way.
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum Instruction<'a> {
+    /// Push a bunch of data.
+    PushBytes(&'a PushBytes),
+    /// Some non-push opcode.
+    Op(Opcode),
+}
+
+impl<'a> Instruction<'a> {
+    /// Returns the opcode if the instruction is not a data push.
+    pub fn opcode(&self) -> Option<Opcode> {
+        match self {
+            Instruction::Op(op) => Some(*op),
+            Instruction::PushBytes(_) => None,
+        }
+    }
+
+    /// Returns the pushed bytes if the instruction is a data push.
+    pub fn push_bytes(&self) -> Option<&PushBytes> {
+        match self {
+            Instruction::Op(_) => None,
+            Instruction::PushBytes(bytes) => Some(bytes),
+        }
+    }
+
+    /// Returns the number interpretted by the script parser
+    /// if it can be coerced into a number.
+    ///
+    /// This does not require the script num to be minimal.
+    pub fn script_num(&self) -> Option<i64> {
+        match self {
+            Instruction::Op(op) => {
+                let v = op.to_u8();
+                match v {
+                    // OP_PUSHNUM_1 ..= OP_PUSHNUM_16
+                    0x51..=0x60 => Some(v as i64 - 0x50),
+                    // OP_PUSHNUM_NEG1
+                    0x4f => Some(-1),
+                    _ => None,
+                }
+            }
+            Instruction::PushBytes(bytes) => {
+                match super::read_scriptint_non_minimal(bytes.as_bytes()) {
+                    Ok(v) => Some(v),
+                    _ => None,
+                }
+            }
+        }
+    }
+
+    /// Returns the number of bytes required to encode the instruction in script.
+    pub(super) fn script_serialized_len(&self) -> usize {
+        match self {
+            Instruction::Op(_) => 1,
+            Instruction::PushBytes(bytes) => ScriptBuf::reserved_len_for_slice(bytes.len()),
+        }
+    }
+}
+
+/// Iterator over a script returning parsed opcodes.
+#[derive(Debug, Clone)]
+pub struct Instructions<'a> {
+    pub(crate) data: core::slice::Iter<'a, u8>,
+    pub(crate) enforce_minimal: bool,
+}
+
+impl<'a> Instructions<'a> {
+    /// Views the remaining script as a slice.
+    ///
+    /// This is analogous to what [`core::str::Chars::as_str`] does.
+    pub fn as_script(&self) -> &'a Script { Script::from_bytes(self.data.as_slice()) }
+
+    /// Sets the iterator to end so that it won't iterate any longer.
+    pub(super) fn kill(&mut self) {
+        let len = self.data.len();
+        self.data.nth(len.max(1) - 1);
+    }
+
+    /// Takes a `len` bytes long slice from iterator and returns it, advancing the iterator.
+    ///
+    /// If the iterator is not long enough [`Error::EarlyEndOfScript`] is returned and the iterator
+    /// is killed to avoid returning an infinite stream of errors.
+    pub(super) fn take_slice_or_kill(&mut self, len: u32) -> Result<&'a PushBytes, Error> {
+        let len = len as usize;
+        if self.data.len() >= len {
+            let slice = &self.data.as_slice()[..len];
+            if len > 0 {
+                self.data.nth(len - 1);
+            }
+
+            Ok(slice.try_into().expect("len was created from u32, so can't happen"))
+        } else {
+            self.kill();
+            Err(Error::EarlyEndOfScript)
+        }
+    }
+
+    pub(super) fn next_push_data_len(
+        &mut self,
+        len: PushDataLenLen,
+        min_push_len: usize,
+    ) -> Option<Result<Instruction<'a>, Error>> {
+        let n = match read_uint_iter(&mut self.data, len as usize) {
+            Ok(n) => n,
+            // We do exhaustive matching to not forget to handle new variants if we extend
+            // `UintError` type.
+            // Overflow actually means early end of script (script is definitely shorter
+            // than `usize::MAX`)
+            Err(UintError::EarlyEndOfScript) | Err(UintError::NumericOverflow) => {
+                self.kill();
+                return Some(Err(Error::EarlyEndOfScript));
+            }
+        };
+        if self.enforce_minimal && n < min_push_len {
+            self.kill();
+            return Some(Err(Error::NonMinimalPush));
+        }
+        let result = n
+            .try_into()
+            .map_err(|_| Error::NumericOverflow)
+            .and_then(|n| self.take_slice_or_kill(n))
+            .map(Instruction::PushBytes);
+        Some(result)
+    }
+}
+
+/// Allowed length of push data length.
+///
+/// This makes it easier to prove correctness of `next_push_data_len`.
+pub(super) enum PushDataLenLen {
+    One = 1,
+    Two = 2,
+    Four = 4,
+}
+
+impl<'a> Iterator for Instructions<'a> {
+    type Item = Result<Instruction<'a>, Error>;
+
+    fn next(&mut self) -> Option<Result<Instruction<'a>, Error>> {
+        let &byte = self.data.next()?;
+
+        // classify parameter does not really matter here since we are only using
+        // it for pushes and nums
+        match Opcode::from(byte).classify(opcodes::ClassifyContext::Legacy) {
+            opcodes::Class::PushBytes(n) => {
+                // make sure safety argument holds across refactorings
+                let n: u32 = n;
+
+                let op_byte = self.data.as_slice().first();
+                match (self.enforce_minimal, op_byte, n) {
+                    (true, Some(&op_byte), 1)
+                        if op_byte == 0x81 || (op_byte > 0 && op_byte <= 16) =>
+                    {
+                        self.kill();
+                        Some(Err(Error::NonMinimalPush))
+                    }
+                    (_, None, 0) => {
+                        // the iterator is already empty, may as well use this information to avoid
+                        // whole take_slice_or_kill function
+                        Some(Ok(Instruction::PushBytes(PushBytes::empty())))
+                    }
+                    _ => Some(self.take_slice_or_kill(n).map(Instruction::PushBytes)),
+                }
+            }
+            opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA1) =>
+                self.next_push_data_len(PushDataLenLen::One, 76),
+            opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA2) =>
+                self.next_push_data_len(PushDataLenLen::Two, 0x100),
+            opcodes::Class::Ordinary(opcodes::Ordinary::OP_PUSHDATA4) =>
+                self.next_push_data_len(PushDataLenLen::Four, 0x10000),
+            // Everything else we can push right through
+            _ => Some(Ok(Instruction::Op(Opcode::from(byte)))),
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        if self.data.len() == 0 {
+            (0, Some(0))
+        } else {
+            // There will not be more instructions than bytes
+            (1, Some(self.data.len()))
+        }
+    }
+}
+
+impl<'a> core::iter::FusedIterator for Instructions<'a> {}
+
+/// Iterator over script instructions with their positions.
+///
+/// The returned indices can be used for slicing [`Script`] [safely](Script#slicing-safety).
+///
+/// This is analogous to [`core::str::CharIndices`].
+#[derive(Debug, Clone)]
+pub struct InstructionIndices<'a> {
+    instructions: Instructions<'a>,
+    pos: usize,
+}
+
+impl<'a> InstructionIndices<'a> {
+    /// Views the remaining script as a slice.
+    ///
+    /// This is analogous to what [`core::str::Chars::as_str`] does.
+    #[inline]
+    pub fn as_script(&self) -> &'a Script { self.instructions.as_script() }
+
+    /// Creates `Self` setting `pos` to 0.
+    pub(super) fn from_instructions(instructions: Instructions<'a>) -> Self {
+        InstructionIndices { instructions, pos: 0 }
+    }
+
+    pub(super) fn remaining_bytes(&self) -> usize { self.instructions.as_script().len() }
+
+    /// Modifies the iterator using `next_fn` returning the next item.
+    ///
+    /// This generically computes the new position and maps the value to be returned from iterator
+    /// method.
+    pub(super) fn next_with<F: FnOnce(&mut Self) -> Option<Result<Instruction<'a>, Error>>>(
+        &mut self,
+        next_fn: F,
+    ) -> Option<<Self as Iterator>::Item> {
+        let prev_remaining = self.remaining_bytes();
+        let prev_pos = self.pos;
+        let instruction = next_fn(self)?;
+        // No underflow: there must be less remaining bytes now than previously
+        let consumed = prev_remaining - self.remaining_bytes();
+        // No overflow: sum will never exceed slice length which itself can't exceed `usize`
+        self.pos += consumed;
+        Some(instruction.map(move |instruction| (prev_pos, instruction)))
+    }
+}
+
+impl<'a> Iterator for InstructionIndices<'a> {
+    /// The `usize` in the tuple represents index at which the returned `Instruction` is located.
+    type Item = Result<(usize, Instruction<'a>), Error>;
+
+    fn next(&mut self) -> Option<Self::Item> { self.next_with(|this| this.instructions.next()) }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) { self.instructions.size_hint() }
+
+    // the override avoids computing pos multiple times
+    fn nth(&mut self, n: usize) -> Option<Self::Item> {
+        self.next_with(|this| this.instructions.nth(n))
+    }
+}
+
+impl core::iter::FusedIterator for InstructionIndices<'_> {}
diff --git a/tapyrus/src/blockdata/script/mod.rs b/tapyrus/src/blockdata/script/mod.rs
new file mode 100644
index 00000000..c7f410d2
--- /dev/null
+++ b/tapyrus/src/blockdata/script/mod.rs
@@ -0,0 +1,746 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin scripts.
+//!
+//! *[See also the `Script` type](Script).*
+//!
+//! This module provides the structures and functions needed to support scripts.
+//!
+//! <details>
+//! <summary>What is Bitcoin script</summary>
+//!
+//! Scripts define Bitcoin's digital signature scheme: a signature is formed
+//! from a script (the second half of which is defined by a coin to be spent,
+//! and the first half provided by the spending transaction), and is valid iff
+//! the script leaves `TRUE` on the stack after being evaluated. Bitcoin's
+//! script is a stack-based assembly language similar in spirit to [Forth].
+//!
+//! Script is represented as a sequence of bytes on the wire, each byte representing an operation,
+//! or data to be pushed on the stack.
+//!
+//! See [Bitcoin Wiki: Script][wiki-script] for more information.
+//!
+//! [Forth]: https://en.wikipedia.org/wiki/Forth_(programming_language)
+//!
+//! [wiki-script]: https://en.bitcoin.it/wiki/Script
+//! </details>
+//!
+//! In this library we chose to keep the byte representation in memory and decode opcodes only when
+//! processing the script. This is similar to Rust choosing to represent strings as UTF-8-encoded
+//! bytes rather than slice of `char`s. In both cases the individual items can have different sizes
+//! and forcing them to be larger would waste memory and, in case of Bitcoin script, even some
+//! performance (forcing allocations).
+//!
+//! ## `Script` vs `ScriptBuf` vs `Builder`
+//!
+//! These are the most important types in this module and they are quite similar, so it may seem
+//! confusing what the differences are. `Script` is an unsized type much like `str` or `Path` are
+//! and `ScriptBuf` is an owned counterpart to `Script` just like `String` is an owned counterpart
+//! to `str`.
+//!
+//! However it is common to construct an owned script and then pass it around. For this case a
+//! builder API is more convenient. To support this we provide `Builder` type which is very similar
+//! to `ScriptBuf` but its methods take `self` instead of `&mut self` and return `Self`. It also
+//! contains a cache that may make some modifications faster. This cache is usually not needed
+//! outside of creating the script.
+//!
+//! At the time of writing there's only one operation using the cache - `push_verify`, so the cache
+//! is minimal but we may extend it in the future if needed.
+
+use alloc::rc::Rc;
+#[cfg(any(not(rust_v_1_60), target_has_atomic = "ptr"))]
+use alloc::sync::Arc;
+use core::borrow::{Borrow, BorrowMut};
+use core::cmp::Ordering;
+use core::fmt;
+use core::ops::{Deref, DerefMut};
+
+use hashes::{hash160, sha256};
+#[cfg(feature = "serde")]
+use serde;
+
+use crate::blockdata::opcodes::all::*;
+use crate::blockdata::opcodes::{self, Opcode};
+use crate::consensus::{encode, Decodable, Encodable};
+use crate::prelude::*;
+use crate::{io, OutPoint};
+
+mod borrowed;
+mod builder;
+mod instruction;
+mod owned;
+mod push_bytes;
+#[cfg(test)]
+mod tests;
+pub mod witness_program;
+pub mod witness_version;
+pub mod color_identifier;
+
+pub use self::borrowed::*;
+pub use self::builder::*;
+pub use self::instruction::*;
+pub use self::owned::*;
+pub use self::push_bytes::*;
+
+hashes::hash_newtype! {
+    /// A hash of Bitcoin Script bytecode.
+    pub struct ScriptHash(hash160::Hash);
+    /// SegWit version of a Bitcoin Script bytecode hash.
+    pub struct WScriptHash(sha256::Hash);
+}
+crate::hash_types::impl_asref_push_bytes!(ScriptHash, WScriptHash);
+
+impl From<ScriptBuf> for ScriptHash {
+    fn from(script: ScriptBuf) -> ScriptHash { script.script_hash() }
+}
+
+impl From<&ScriptBuf> for ScriptHash {
+    fn from(script: &ScriptBuf) -> ScriptHash { script.script_hash() }
+}
+
+impl From<&Script> for ScriptHash {
+    fn from(script: &Script) -> ScriptHash { script.script_hash() }
+}
+
+impl From<ScriptBuf> for WScriptHash {
+    fn from(script: ScriptBuf) -> WScriptHash { script.wscript_hash() }
+}
+
+impl From<&ScriptBuf> for WScriptHash {
+    fn from(script: &ScriptBuf) -> WScriptHash { script.wscript_hash() }
+}
+
+impl From<&Script> for WScriptHash {
+    fn from(script: &Script) -> WScriptHash { script.wscript_hash() }
+}
+
+/// Encodes an integer in script(minimal CScriptNum) format.
+///
+/// Writes bytes into the buffer and returns the number of bytes written.
+///
+/// Note that `write_scriptint`/`read_scriptint` do not roundtrip if the value written requires
+/// more than 4 bytes, this is in line with Bitcoin Core (see [`CScriptNum::serialize`]).
+///
+/// [`CScriptNum::serialize`]: <https://github.com/bitcoin/bitcoin/blob/8ae2808a4354e8dcc697f76bacc5e2f2befe9220/src/script/script.h#L345>
+pub fn write_scriptint(out: &mut [u8; 8], n: i64) -> usize {
+    let mut len = 0;
+    if n == 0 {
+        return len;
+    }
+
+    let neg = n < 0;
+
+    let mut abs = if neg { -n } else { n } as usize;
+    while abs > 0xFF {
+        out[len] = (abs & 0xFF) as u8;
+        len += 1;
+        abs >>= 8;
+    }
+    // If the number's value causes the sign bit to be set, we need an extra
+    // byte to get the correct value and correct sign bit
+    if abs & 0x80 != 0 {
+        out[len] = abs as u8;
+        len += 1;
+        out[len] = if neg { 0x80u8 } else { 0u8 };
+        len += 1;
+    }
+    // Otherwise we just set the sign bit ourselves
+    else {
+        abs |= if neg { 0x80 } else { 0 };
+        out[len] = abs as u8;
+        len += 1;
+    }
+    len
+}
+
+/// Decodes an integer in script(minimal CScriptNum) 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
+/// overflow since that's surprising --- and we don't want numbers that
+/// don't fit in 64 bits (for efficiency on modern processors) so we
+/// simply say, anything in excess of 32 bits is no longer a number.
+/// This is basically a ranged type implementation.
+///
+/// This code is based on the `CScriptNum` constructor in Bitcoin Core (see `script.h`).
+pub fn read_scriptint(v: &[u8]) -> Result<i64, Error> {
+    let last = match v.last() {
+        Some(last) => last,
+        None => return Ok(0),
+    };
+    if v.len() > 4 {
+        return Err(Error::NumericOverflow);
+    }
+    // Comment and code copied from Bitcoin Core:
+    // https://github.com/bitcoin/bitcoin/blob/447f50e4aed9a8b1d80e1891cda85801aeb80b4e/src/script/script.h#L247-L262
+    // If the most-significant-byte - excluding the sign bit - is zero
+    // then we're not minimal. Note how this test also rejects the
+    // negative-zero encoding, 0x80.
+    if (*last & 0x7f) == 0 {
+        // One exception: if there's more than one byte and the most
+        // significant bit of the second-most-significant-byte is set
+        // it would conflict with the sign bit. An example of this case
+        // is +-255, which encode to 0xff00 and 0xff80 respectively.
+        // (big-endian).
+        if v.len() <= 1 || (v[v.len() - 2] & 0x80) == 0 {
+            return Err(Error::NonMinimalPush);
+        }
+    }
+
+    Ok(scriptint_parse(v))
+}
+
+/// Decodes an integer in script format without non-minimal error.
+///
+/// The overflow error for slices over 4 bytes long is still there.
+/// See [`read_scriptint`] for a description of some subtleties of
+/// this function.
+pub fn read_scriptint_non_minimal(v: &[u8]) -> Result<i64, Error> {
+    if v.is_empty() {
+        return Ok(0);
+    }
+    if v.len() > 4 {
+        return Err(Error::NumericOverflow);
+    }
+
+    Ok(scriptint_parse(v))
+}
+
+// Caller to guarantee that `v` is not empty.
+fn scriptint_parse(v: &[u8]) -> i64 {
+    let (mut ret, sh) = v.iter().fold((0, 0), |(acc, sh), n| (acc + ((*n as i64) << sh), sh + 8));
+    if v[v.len() - 1] & 0x80 != 0 {
+        ret &= (1 << (sh - 1)) - 1;
+        ret = -ret;
+    }
+    ret
+}
+
+/// Decodes a boolean.
+///
+/// This is like "`read_scriptint` then map 0 to false and everything
+/// else as true", except that the overflow rules don't apply.
+#[inline]
+pub fn read_scriptbool(v: &[u8]) -> bool {
+    match v.split_last() {
+        Some((last, rest)) => !((last & !0x80 == 0x00) && rest.iter().all(|&b| b == 0)),
+        None => false,
+    }
+}
+
+// We internally use implementation based on iterator so that it automatically advances as needed
+// Errors are same as above, just different type.
+fn read_uint_iter(data: &mut core::slice::Iter<'_, u8>, size: usize) -> Result<usize, UintError> {
+    if data.len() < size {
+        Err(UintError::EarlyEndOfScript)
+    } else if size > usize::from(u16::MAX / 8) {
+        // Casting to u32 would overflow
+        Err(UintError::NumericOverflow)
+    } else {
+        let mut ret = 0;
+        for (i, item) in data.take(size).enumerate() {
+            ret = usize::from(*item)
+                // Casting is safe because we checked above to not repeat the same check in a loop
+                .checked_shl((i * 8) as u32)
+                .ok_or(UintError::NumericOverflow)?
+                .checked_add(ret)
+                .ok_or(UintError::NumericOverflow)?;
+        }
+        Ok(ret)
+    }
+}
+
+fn opcode_to_verify(opcode: Option<Opcode>) -> Option<Opcode> {
+    opcode.and_then(|opcode| match opcode {
+        OP_EQUAL => Some(OP_EQUALVERIFY),
+        OP_NUMEQUAL => Some(OP_NUMEQUALVERIFY),
+        OP_CHECKSIG => Some(OP_CHECKSIGVERIFY),
+        OP_CHECKMULTISIG => Some(OP_CHECKMULTISIGVERIFY),
+        _ => None,
+    })
+}
+
+// We keep all the `Script` and `ScriptBuf` impls together since its easier to see side-by-side.
+
+impl From<ScriptBuf> for Box<Script> {
+    fn from(v: ScriptBuf) -> Self { v.into_boxed_script() }
+}
+
+impl From<ScriptBuf> for Cow<'_, Script> {
+    fn from(value: ScriptBuf) -> Self { Cow::Owned(value) }
+}
+
+impl<'a> From<Cow<'a, Script>> for ScriptBuf {
+    fn from(value: Cow<'a, Script>) -> Self {
+        match value {
+            Cow::Owned(owned) => owned,
+            Cow::Borrowed(borrwed) => borrwed.into(),
+        }
+    }
+}
+
+impl<'a> From<Cow<'a, Script>> for Box<Script> {
+    fn from(value: Cow<'a, Script>) -> Self {
+        match value {
+            Cow::Owned(owned) => owned.into(),
+            Cow::Borrowed(borrwed) => borrwed.into(),
+        }
+    }
+}
+
+impl<'a> From<&'a Script> for Box<Script> {
+    fn from(value: &'a Script) -> Self { value.to_owned().into() }
+}
+
+impl<'a> From<&'a Script> for ScriptBuf {
+    fn from(value: &'a Script) -> Self { value.to_owned() }
+}
+
+impl<'a> From<&'a Script> for Cow<'a, Script> {
+    fn from(value: &'a Script) -> Self { Cow::Borrowed(value) }
+}
+
+/// Note: This will fail to compile on old Rust for targets that don't support atomics
+#[cfg(any(not(rust_v_1_60), target_has_atomic = "ptr"))]
+impl<'a> From<&'a Script> for Arc<Script> {
+    fn from(value: &'a Script) -> Self {
+        let rw: *const [u8] = Arc::into_raw(Arc::from(&value.0));
+        // SAFETY: copied from `std`
+        // The pointer was just created from an Arc without deallocating
+        // Casting a slice to a transparent struct wrapping that slice is sound (same
+        // layout).
+        unsafe { Arc::from_raw(rw as *const Script) }
+    }
+}
+
+impl<'a> From<&'a Script> for Rc<Script> {
+    fn from(value: &'a Script) -> Self {
+        let rw: *const [u8] = Rc::into_raw(Rc::from(&value.0));
+        // SAFETY: copied from `std`
+        // The pointer was just created from an Rc without deallocating
+        // Casting a slice to a transparent struct wrapping that slice is sound (same
+        // layout).
+        unsafe { Rc::from_raw(rw as *const Script) }
+    }
+}
+
+impl From<Vec<u8>> for ScriptBuf {
+    fn from(v: Vec<u8>) -> Self { ScriptBuf(v) }
+}
+
+impl From<ScriptBuf> for Vec<u8> {
+    fn from(v: ScriptBuf) -> Self { v.0 }
+}
+
+impl AsRef<Script> for Script {
+    #[inline]
+    fn as_ref(&self) -> &Script { self }
+}
+
+impl AsRef<Script> for ScriptBuf {
+    fn as_ref(&self) -> &Script { self }
+}
+
+impl AsRef<[u8]> for Script {
+    #[inline]
+    fn as_ref(&self) -> &[u8] { self.as_bytes() }
+}
+
+impl AsRef<[u8]> for ScriptBuf {
+    fn as_ref(&self) -> &[u8] { self.as_bytes() }
+}
+
+impl AsMut<Script> for Script {
+    fn as_mut(&mut self) -> &mut Script { self }
+}
+
+impl AsMut<Script> for ScriptBuf {
+    fn as_mut(&mut self) -> &mut Script { self }
+}
+
+impl AsMut<[u8]> for Script {
+    #[inline]
+    fn as_mut(&mut self) -> &mut [u8] { self.as_mut_bytes() }
+}
+
+impl AsMut<[u8]> for ScriptBuf {
+    fn as_mut(&mut self) -> &mut [u8] { self.as_mut_bytes() }
+}
+
+impl fmt::Debug for Script {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("Script(")?;
+        self.fmt_asm(f)?;
+        f.write_str(")")
+    }
+}
+
+impl fmt::Debug for ScriptBuf {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(self.as_script(), f) }
+}
+
+impl fmt::Display for Script {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_asm(f) }
+}
+
+impl fmt::Display for ScriptBuf {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(self.as_script(), f) }
+}
+
+impl fmt::LowerHex for Script {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(&self.as_bytes().as_hex(), f)
+    }
+}
+
+impl fmt::LowerHex for ScriptBuf {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(self.as_script(), f) }
+}
+
+impl fmt::UpperHex for Script {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::UpperHex::fmt(&self.as_bytes().as_hex(), f)
+    }
+}
+
+impl fmt::UpperHex for ScriptBuf {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::UpperHex::fmt(self.as_script(), f) }
+}
+
+impl Deref for ScriptBuf {
+    type Target = Script;
+
+    fn deref(&self) -> &Self::Target { Script::from_bytes(&self.0) }
+}
+
+impl DerefMut for ScriptBuf {
+    fn deref_mut(&mut self) -> &mut Self::Target { Script::from_bytes_mut(&mut self.0) }
+}
+
+impl Borrow<Script> for ScriptBuf {
+    fn borrow(&self) -> &Script { self }
+}
+
+impl BorrowMut<Script> for ScriptBuf {
+    fn borrow_mut(&mut self) -> &mut Script { self }
+}
+
+impl PartialEq<ScriptBuf> for Script {
+    fn eq(&self, other: &ScriptBuf) -> bool { self.eq(other.as_script()) }
+}
+
+impl PartialEq<Script> for ScriptBuf {
+    fn eq(&self, other: &Script) -> bool { self.as_script().eq(other) }
+}
+
+impl PartialOrd<Script> for ScriptBuf {
+    fn partial_cmp(&self, other: &Script) -> Option<Ordering> {
+        self.as_script().partial_cmp(other)
+    }
+}
+
+impl PartialOrd<ScriptBuf> for Script {
+    fn partial_cmp(&self, other: &ScriptBuf) -> Option<Ordering> {
+        self.partial_cmp(other.as_script())
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Script {
+    /// User-facing serialization for `Script`.
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        if serializer.is_human_readable() {
+            serializer.collect_str(&format_args!("{:x}", self))
+        } else {
+            serializer.serialize_bytes(self.as_bytes())
+        }
+    }
+}
+
+/// Can only deserialize borrowed bytes.
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for &'de Script {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        if deserializer.is_human_readable() {
+            use crate::serde::de::Error;
+
+            return Err(D::Error::custom(
+                "deserialization of `&Script` from human-readable formats is not possible",
+            ));
+        }
+
+        struct Visitor;
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = &'de Script;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("borrowed bytes")
+            }
+
+            fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                Ok(Script::from_bytes(v))
+            }
+        }
+        deserializer.deserialize_bytes(Visitor)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for ScriptBuf {
+    /// User-facing serialization for `Script`.
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for ScriptBuf {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        use core::fmt::Formatter;
+
+        use hex::FromHex;
+
+        if deserializer.is_human_readable() {
+            struct Visitor;
+            impl<'de> serde::de::Visitor<'de> for Visitor {
+                type Value = ScriptBuf;
+
+                fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+                    formatter.write_str("a script hex")
+                }
+
+                fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                where
+                    E: serde::de::Error,
+                {
+                    let v = Vec::from_hex(v).map_err(E::custom)?;
+                    Ok(ScriptBuf::from(v))
+                }
+            }
+            deserializer.deserialize_str(Visitor)
+        } else {
+            struct BytesVisitor;
+
+            impl<'de> serde::de::Visitor<'de> for BytesVisitor {
+                type Value = ScriptBuf;
+
+                fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+                    formatter.write_str("a script Vec<u8>")
+                }
+
+                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: serde::de::Error,
+                {
+                    Ok(ScriptBuf::from(v.to_vec()))
+                }
+
+                fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+                where
+                    E: serde::de::Error,
+                {
+                    Ok(ScriptBuf::from(v))
+                }
+            }
+            deserializer.deserialize_byte_buf(BytesVisitor)
+        }
+    }
+}
+
+impl Encodable for Script {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        crate::consensus::encode::consensus_encode_with_size(&self.0, w)
+    }
+}
+
+impl Encodable for ScriptBuf {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(w)
+    }
+}
+
+impl Decodable for ScriptBuf {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        Ok(ScriptBuf(Decodable::consensus_decode_from_finite_reader(r)?))
+    }
+}
+
+/// Writes the assembly decoding of the script bytes to the formatter.
+pub(super) fn bytes_to_asm_fmt(script: &[u8], f: &mut dyn fmt::Write) -> fmt::Result {
+    // This has to be a macro because it needs to break the loop
+    macro_rules! read_push_data_len {
+        ($iter:expr, $len:literal, $formatter:expr) => {
+            match read_uint_iter($iter, $len) {
+                Ok(n) => {
+                    n
+                },
+                Err(UintError::EarlyEndOfScript) => {
+                    $formatter.write_str("<unexpected end>")?;
+                    break;
+                }
+                // We got the data in a slice which implies it being shorter than `usize::MAX`
+                // So if we got overflow, we can confidently say the number is higher than length of
+                // the slice even though we don't know the exact number. This implies attempt to push
+                // past end.
+                Err(UintError::NumericOverflow) => {
+                    $formatter.write_str("<push past end>")?;
+                    break;
+                }
+            }
+        }
+    }
+
+    let mut iter = script.iter();
+    // Was at least one opcode emitted?
+    let mut at_least_one = false;
+    // `iter` needs to be borrowed in `read_push_data_len`, so we have to use `while let` instead
+    // of `for`.
+    while let Some(byte) = iter.next() {
+        let opcode = Opcode::from(*byte);
+
+        let data_len = if let opcodes::Class::PushBytes(n) =
+            opcode.classify(opcodes::ClassifyContext::Legacy)
+        {
+            n as usize
+        } else {
+            match opcode {
+                OP_PUSHDATA1 => {
+                    // side effects: may write and break from the loop
+                    read_push_data_len!(&mut iter, 1, f)
+                }
+                OP_PUSHDATA2 => {
+                    // side effects: may write and break from the loop
+                    read_push_data_len!(&mut iter, 2, f)
+                }
+                OP_PUSHDATA4 => {
+                    // side effects: may write and break from the loop
+                    read_push_data_len!(&mut iter, 4, f)
+                }
+                _ => 0,
+            }
+        };
+
+        if at_least_one {
+            f.write_str(" ")?;
+        } else {
+            at_least_one = true;
+        }
+        // Write the opcode
+        if opcode == OP_PUSHBYTES_0 {
+            f.write_str("OP_0")?;
+        } else {
+            write!(f, "{:?}", opcode)?;
+        }
+        // Write any pushdata
+        if data_len > 0 {
+            f.write_str(" ")?;
+            if data_len <= iter.len() {
+                for ch in iter.by_ref().take(data_len) {
+                    write!(f, "{:02x}", ch)?;
+                }
+            } else {
+                f.write_str("<push past end>")?;
+                break;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Ways that a script might fail. Not everything is split up as
+/// much as it could be; patches welcome if more detailed errors
+/// would help you.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// Something did a non-minimal push; for more information see
+    /// <https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#push-operators>
+    NonMinimalPush,
+    /// Some opcode expected a parameter but it was missing or truncated.
+    EarlyEndOfScript,
+    /// Tried to read an array off the stack as a number when it was more than 4 bytes.
+    NumericOverflow,
+    /// Can not find the spent output.
+    UnknownSpentOutput(OutPoint),
+    /// Can not serialize the spending transaction.
+    Serialization,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            NonMinimalPush => f.write_str("non-minimal datapush"),
+            EarlyEndOfScript => f.write_str("unexpected end of script"),
+            NumericOverflow =>
+                f.write_str("numeric overflow (number on stack larger than 4 bytes)"),
+            UnknownSpentOutput(ref point) => write!(f, "unknown spent output: {}", point),
+            Serialization =>
+                f.write_str("can not serialize the spending transaction in Transaction::verify()"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            NonMinimalPush
+            | EarlyEndOfScript
+            | NumericOverflow
+            | UnknownSpentOutput(_)
+            | Serialization => None,
+        }
+    }
+}
+
+// Our internal error proves that we only return these two cases from `read_uint_iter`.
+// Since it's private we don't bother with trait impls besides From.
+enum UintError {
+    EarlyEndOfScript,
+    NumericOverflow,
+}
+
+impl From<UintError> for Error {
+    fn from(error: UintError) -> Self {
+        match error {
+            UintError::EarlyEndOfScript => Error::EarlyEndOfScript,
+            UintError::NumericOverflow => Error::NumericOverflow,
+        }
+    }
+}
+
diff --git a/tapyrus/src/blockdata/script/owned.rs b/tapyrus/src/blockdata/script/owned.rs
new file mode 100644
index 00000000..0fb04c28
--- /dev/null
+++ b/tapyrus/src/blockdata/script/owned.rs
@@ -0,0 +1,416 @@
+// SPDX-License-Identifier: CC0-1.0
+
+#[cfg(doc)]
+use core::ops::Deref;
+
+use secp256k1::{Secp256k1, Verification};
+
+use crate::blockdata::opcodes::all::*;
+use crate::blockdata::opcodes::{self, Opcode};
+use crate::blockdata::script::witness_program::WitnessProgram;
+use crate::blockdata::script::witness_version::WitnessVersion;
+use crate::blockdata::script::{
+    opcode_to_verify, Builder, Instruction, PushBytes, Script, ScriptHash, WScriptHash,
+};
+use crate::key::{
+    PubkeyHash, PublicKey, TapTweak, TweakedPublicKey, UntweakedPublicKey, WPubkeyHash,
+};
+use crate::prelude::*;
+use crate::script::color_identifier::{ColoredCoinError, ColorIdentifier};
+use crate::script::PushBytesBuf;
+use crate::taproot::TapNodeHash;
+
+/// An owned, growable script.
+///
+/// `ScriptBuf` is the most common script type that has the ownership over the contents of the
+/// script. It has a close relationship with its borrowed counterpart, [`Script`].
+///
+/// Just as other similar types, this implements [`Deref`], so [deref coercions] apply. Also note
+/// that all the safety/validity restrictions that apply to [`Script`] apply to `ScriptBuf` as well.
+///
+/// [deref coercions]: https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-coercion
+#[derive(Default, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub struct ScriptBuf(pub(in crate::blockdata::script) Vec<u8>);
+
+impl ScriptBuf {
+    /// Creates a new empty script.
+    pub const fn new() -> Self { ScriptBuf(Vec::new()) }
+
+    /// Creates a new empty script with pre-allocated capacity.
+    pub fn with_capacity(capacity: usize) -> Self { ScriptBuf(Vec::with_capacity(capacity)) }
+
+    /// Pre-allocates at least `additional_len` bytes if needed.
+    ///
+    /// Reserves capacity for at least `additional_len` more bytes to be inserted in the given
+    /// script. The script may reserve more space to speculatively avoid frequent reallocations.
+    /// After calling `reserve`, capacity will be greater than or equal to
+    /// `self.len() + additional_len`. Does nothing if capacity is already sufficient.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the new capacity exceeds `isize::MAX bytes`.
+    pub fn reserve(&mut self, additional_len: usize) { self.0.reserve(additional_len); }
+
+    /// Pre-allocates exactly `additional_len` bytes if needed.
+    ///
+    /// Unlike `reserve`, this will not deliberately over-allocate to speculatively avoid frequent
+    /// allocations. After calling `reserve_exact`, capacity will be greater than or equal to
+    /// `self.len() + additional`. Does nothing if the capacity is already sufficient.
+    ///
+    /// Note that the allocator may give the collection more space than it requests. Therefore,
+    /// capacity can not be relied upon to be precisely minimal. Prefer [`reserve`](Self::reserve)
+    /// if future insertions are expected.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the new capacity exceeds `isize::MAX bytes`.
+    pub fn reserve_exact(&mut self, additional_len: usize) { self.0.reserve_exact(additional_len); }
+
+    /// Returns a reference to unsized script.
+    pub fn as_script(&self) -> &Script { Script::from_bytes(&self.0) }
+
+    /// Returns a mutable reference to unsized script.
+    pub fn as_mut_script(&mut self) -> &mut Script { Script::from_bytes_mut(&mut self.0) }
+
+    /// Creates a new script builder
+    pub fn builder() -> Builder { Builder::new() }
+
+    /// Generates P2PK-type of scriptPubkey.
+    pub fn new_p2pk(pubkey: &PublicKey) -> Self {
+        Builder::new().push_key(pubkey).push_opcode(OP_CHECKSIG).into_script()
+    }
+
+    /// Generates P2PKH-type of scriptPubkey.
+    pub fn new_p2pkh(pubkey_hash: &PubkeyHash) -> Self {
+        Builder::new()
+            .push_opcode(OP_DUP)
+            .push_opcode(OP_HASH160)
+            .push_slice(pubkey_hash)
+            .push_opcode(OP_EQUALVERIFY)
+            .push_opcode(OP_CHECKSIG)
+            .into_script()
+    }
+
+    /// Generates P2SH-type of scriptPubkey with a given hash of the redeem script.
+    pub fn new_p2sh(script_hash: &ScriptHash) -> Self {
+        Builder::new()
+            .push_opcode(OP_HASH160)
+            .push_slice(script_hash)
+            .push_opcode(OP_EQUAL)
+            .into_script()
+    }
+
+    /// Generates CP2PKH-type of scriptPubkey.
+    pub fn new_cp2pkh(color_id: &ColorIdentifier, pubkey_hash: &PubkeyHash) -> Self {
+        Builder::new()
+            .push_slice(PushBytesBuf::from(*color_id))
+            .push_opcode(OP_COLOR)
+            .push_opcode(OP_DUP)
+            .push_opcode(OP_HASH160)
+            .push_slice(pubkey_hash)
+            .push_opcode(OP_EQUALVERIFY)
+            .push_opcode(OP_CHECKSIG)
+            .into_script()
+    }
+
+    /// Generates CP2SH-type of scriptPubkey.
+    pub fn new_cp2sh(color_id: &ColorIdentifier, script_hash: &ScriptHash) -> Self {
+        Builder::new()
+            .push_slice(PushBytesBuf::from(*color_id))
+            .push_opcode(OP_COLOR)
+            .push_opcode(OP_HASH160)
+            .push_slice(script_hash)
+            .push_opcode(OP_EQUAL)
+            .into_script()
+    }
+
+    /// Create new script with color identifier
+    pub fn add_color(&self, color_id: ColorIdentifier) -> Result<Self, ColoredCoinError> {
+        if !self.is_p2pkh() && !self.is_p2sh() {
+            return Err(ColoredCoinError::UnsupportedScriptType);
+        }
+
+        let script = Builder::new()
+            .push_slice(PushBytesBuf::from(color_id))
+            .push_opcode(OP_COLOR)
+            .into_script();
+
+        let mut com = Vec::new();
+        com.extend_from_slice(script.as_bytes());
+        com.extend_from_slice(self.as_bytes());
+        Ok(ScriptBuf::from_bytes(com))
+    }
+
+    /// Returns a p2pkh or p2sh script with the color_id removed from cp2pkh or cp2sh
+    /// if script is not colored script, return itself.
+    pub fn remove_color(&self) -> Self {
+        if !self.is_colored() {
+            return self.clone()
+        }
+
+        ScriptBuf::from_bytes(self.as_bytes()[35..].to_vec())
+    }
+
+    /// Generates P2WPKH-type of scriptPubkey.
+    #[deprecated(since = "0.31.0", note = "use new_p2wpkh instead")]
+    pub fn new_v0_p2wpkh(pubkey_hash: &WPubkeyHash) -> Self { Self::new_p2wpkh(pubkey_hash) }
+
+    /// Generates P2WPKH-type of scriptPubkey.
+    pub fn new_p2wpkh(pubkey_hash: &WPubkeyHash) -> Self {
+        // pubkey hash is 20 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv0)
+        ScriptBuf::new_witness_program_unchecked(WitnessVersion::V0, pubkey_hash)
+    }
+
+    /// Generates P2WSH-type of scriptPubkey with a given hash of the redeem script.
+    #[deprecated(since = "0.31.0", note = "use new_p2wsh instead")]
+    pub fn new_v0_p2wsh(script_hash: &WScriptHash) -> Self { Self::new_p2wsh(script_hash) }
+
+    /// Generates P2WSH-type of scriptPubkey with a given hash of the redeem script.
+    pub fn new_p2wsh(script_hash: &WScriptHash) -> Self {
+        // script hash is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv0)
+        ScriptBuf::new_witness_program_unchecked(WitnessVersion::V0, script_hash)
+    }
+
+    /// Generates P2TR for script spending path using an internal public key and some optional
+    /// script tree merkle root.
+    #[deprecated(since = "0.31.0", note = "use new_p2tr instead")]
+    pub fn new_v1_p2tr<C: Verification>(
+        secp: &Secp256k1<C>,
+        internal_key: UntweakedPublicKey,
+        merkle_root: Option<TapNodeHash>,
+    ) -> Self {
+        Self::new_p2tr(secp, internal_key, merkle_root)
+    }
+
+    /// Generates P2TR for script spending path using an internal public key and some optional
+    /// script tree merkle root.
+    pub fn new_p2tr<C: Verification>(
+        secp: &Secp256k1<C>,
+        internal_key: UntweakedPublicKey,
+        merkle_root: Option<TapNodeHash>,
+    ) -> Self {
+        let (output_key, _) = internal_key.tap_tweak(secp, merkle_root);
+        // output key is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv1)
+        ScriptBuf::new_witness_program_unchecked(WitnessVersion::V1, output_key.serialize())
+    }
+
+    /// Generates P2TR for key spending path for a known [`TweakedPublicKey`].
+    #[deprecated(since = "0.31.0", note = "use new_p2tr_tweaked instead")]
+    pub fn new_v1_p2tr_tweaked(output_key: TweakedPublicKey) -> Self {
+        Self::new_p2tr_tweaked(output_key)
+    }
+
+    /// Generates P2TR for key spending path for a known [`TweakedPublicKey`].
+    pub fn new_p2tr_tweaked(output_key: TweakedPublicKey) -> Self {
+        // output key is 32 bytes long, so it's safe to use `new_witness_program_unchecked` (Segwitv1)
+        ScriptBuf::new_witness_program_unchecked(WitnessVersion::V1, output_key.serialize())
+    }
+
+    /// Generates P2WSH-type of scriptPubkey with a given [`WitnessProgram`].
+    pub fn new_witness_program(witness_program: &WitnessProgram) -> Self {
+        Builder::new()
+            .push_opcode(witness_program.version().into())
+            .push_slice(witness_program.program())
+            .into_script()
+    }
+
+    /// Generates P2WSH-type of scriptPubkey with a given [`WitnessVersion`] and the program bytes.
+    /// Does not do any checks on version or program length.
+    ///
+    /// Convenience method used by `new_p2wpkh`, `new_p2wsh`, `new_p2tr`, and `new_p2tr_tweaked`.
+    fn new_witness_program_unchecked<T: AsRef<PushBytes>>(
+        version: WitnessVersion,
+        program: T,
+    ) -> Self {
+        let program = program.as_ref();
+        debug_assert!(program.len() >= 2 && program.len() <= 40);
+        // In segwit v0, the program must be 20 or 32 bytes long.
+        debug_assert!(version != WitnessVersion::V0 || program.len() == 20 || program.len() == 32);
+        Builder::new().push_opcode(version.into()).push_slice(program).into_script()
+    }
+
+    /// Generates OP_RETURN-type of scriptPubkey for the given data.
+    pub fn new_op_return<T: AsRef<PushBytes>>(data: T) -> Self {
+        Builder::new().push_opcode(OP_RETURN).push_slice(data).into_script()
+    }
+
+    /// Creates a [`ScriptBuf`] from a hex string.
+    pub fn from_hex(s: &str) -> Result<Self, hex::HexToBytesError> {
+        use hex::FromHex;
+
+        let v = Vec::from_hex(s)?;
+        Ok(ScriptBuf::from_bytes(v))
+    }
+
+    /// Converts byte vector into script.
+    ///
+    /// This method doesn't (re)allocate.
+    pub fn from_bytes(bytes: Vec<u8>) -> Self { ScriptBuf(bytes) }
+
+    /// Converts the script into a byte vector.
+    ///
+    /// This method doesn't (re)allocate.
+    pub fn into_bytes(self) -> Vec<u8> { self.0 }
+
+    /// Adds a single opcode to the script.
+    pub fn push_opcode(&mut self, data: Opcode) { self.0.push(data.to_u8()); }
+
+    /// Adds instructions to push some arbitrary data onto the stack.
+    pub fn push_slice<T: AsRef<PushBytes>>(&mut self, data: T) {
+        let data = data.as_ref();
+        self.reserve(Self::reserved_len_for_slice(data.len()));
+        self.push_slice_no_opt(data);
+    }
+
+    /// Pushes the slice without reserving
+    fn push_slice_no_opt(&mut self, data: &PushBytes) {
+        // Start with a PUSH opcode
+        match data.len() as u64 {
+            n if n < opcodes::Ordinary::OP_PUSHDATA1 as u64 => {
+                self.0.push(n as u8);
+            }
+            n if n < 0x100 => {
+                self.0.push(opcodes::Ordinary::OP_PUSHDATA1.to_u8());
+                self.0.push(n as u8);
+            }
+            n if n < 0x10000 => {
+                self.0.push(opcodes::Ordinary::OP_PUSHDATA2.to_u8());
+                self.0.push((n % 0x100) as u8);
+                self.0.push((n / 0x100) as u8);
+            }
+            n if n < 0x100000000 => {
+                self.0.push(opcodes::Ordinary::OP_PUSHDATA4.to_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);
+            }
+            _ => panic!("tried to put a 4bn+ sized object into a script!"),
+        }
+        // Then push the raw bytes
+        self.0.extend_from_slice(data.as_bytes());
+    }
+
+    /// Computes the sum of `len` and the lenght of an appropriate push opcode.
+    pub(in crate::blockdata::script) fn reserved_len_for_slice(len: usize) -> usize {
+        len + match len {
+            0..=0x4b => 1,
+            0x4c..=0xff => 2,
+            0x100..=0xffff => 3,
+            // we don't care about oversized, the other fn will panic anyway
+            _ => 5,
+        }
+    }
+
+    /// Add a single instruction to the script.
+    ///
+    /// ## Panics
+    ///
+    /// The method panics if the instruction is a data push with length greater or equal to
+    /// 0x100000000.
+    pub fn push_instruction(&mut self, instruction: Instruction<'_>) {
+        match instruction {
+            Instruction::Op(opcode) => self.push_opcode(opcode),
+            Instruction::PushBytes(bytes) => self.push_slice(bytes),
+        }
+    }
+
+    /// Like push_instruction, but avoids calling `reserve` to not re-check the length.
+    pub fn push_instruction_no_opt(&mut self, instruction: Instruction<'_>) {
+        match instruction {
+            Instruction::Op(opcode) => self.push_opcode(opcode),
+            Instruction::PushBytes(bytes) => self.push_slice_no_opt(bytes),
+        }
+    }
+
+    /// Adds an `OP_VERIFY` to the script or replaces the last opcode with VERIFY form.
+    ///
+    /// Some opcodes such as `OP_CHECKSIG` have a verify variant that works as if `VERIFY` was
+    /// in the script right after. To save space this function appends `VERIFY` only if
+    /// the most-recently-added opcode *does not* have an alternate `VERIFY` form. If it does
+    /// the last opcode is replaced. E.g., `OP_CHECKSIG` will become `OP_CHECKSIGVERIFY`.
+    ///
+    /// Note that existing `OP_*VERIFY` opcodes do not lead to the instruction being ignored
+    /// because `OP_VERIFY` consumes an item from the stack so ignoring them would change the
+    /// semantics.
+    ///
+    /// This function needs to iterate over the script to find the last instruction. Prefer
+    /// `Builder` if you're creating the script from scratch or if you want to push `OP_VERIFY`
+    /// multiple times.
+    pub fn scan_and_push_verify(&mut self) { self.push_verify(self.last_opcode()); }
+
+    /// Adds an `OP_VERIFY` to the script or changes the most-recently-added opcode to `VERIFY`
+    /// alternative.
+    ///
+    /// See the public fn [`Self::scan_and_push_verify`] to learn more.
+    pub(in crate::blockdata::script) fn push_verify(&mut self, last_opcode: Option<Opcode>) {
+        match opcode_to_verify(last_opcode) {
+            Some(opcode) => {
+                self.0.pop();
+                self.push_opcode(opcode);
+            }
+            None => self.push_opcode(OP_VERIFY),
+        }
+    }
+
+    /// Converts this `ScriptBuf` into a [boxed](Box) [`Script`].
+    ///
+    /// This method reallocates if the capacity is greater than lenght of the script but should not
+    /// when they are equal. If you know beforehand that you need to create a script of exact size
+    /// use [`reserve_exact`](Self::reserve_exact) before adding data to the script so that the
+    /// reallocation can be avoided.
+    #[must_use = "`self` will be dropped if the result is not used"]
+    #[inline]
+    pub fn into_boxed_script(self) -> Box<Script> {
+        // Copied from PathBuf::into_boxed_path
+        let rw = Box::into_raw(self.0.into_boxed_slice()) as *mut Script;
+        unsafe { Box::from_raw(rw) }
+    }
+}
+
+impl<'a> core::iter::FromIterator<Instruction<'a>> for ScriptBuf {
+    fn from_iter<T>(iter: T) -> Self
+    where
+        T: IntoIterator<Item = Instruction<'a>>,
+    {
+        let mut script = ScriptBuf::new();
+        script.extend(iter);
+        script
+    }
+}
+
+impl<'a> Extend<Instruction<'a>> for ScriptBuf {
+    fn extend<T>(&mut self, iter: T)
+    where
+        T: IntoIterator<Item = Instruction<'a>>,
+    {
+        let iter = iter.into_iter();
+        // Most of Bitcoin scripts have only a few opcodes, so we can avoid reallocations in many
+        // cases.
+        if iter.size_hint().1.map(|max| max < 6).unwrap_or(false) {
+            let mut iter = iter.fuse();
+            // `MaybeUninit` might be faster but we don't want to introduce more `unsafe` than
+            // required.
+            let mut head = [None; 5];
+            let mut total_size = 0;
+            for (head, instr) in head.iter_mut().zip(&mut iter) {
+                total_size += instr.script_serialized_len();
+                *head = Some(instr);
+            }
+            // Incorrect impl of `size_hint` breaks `Iterator` contract so we're free to panic.
+            assert!(
+                iter.next().is_none(),
+                "Buggy implementation of `Iterator` on {} returns invalid upper bound",
+                core::any::type_name::<T::IntoIter>()
+            );
+            self.reserve(total_size);
+            for instr in head.iter().cloned().flatten() {
+                self.push_instruction_no_opt(instr);
+            }
+        } else {
+            for instr in iter {
+                self.push_instruction(instr);
+            }
+        }
+    }
+}
diff --git a/tapyrus/src/blockdata/script/push_bytes.rs b/tapyrus/src/blockdata/script/push_bytes.rs
new file mode 100644
index 00000000..c2fdd876
--- /dev/null
+++ b/tapyrus/src/blockdata/script/push_bytes.rs
@@ -0,0 +1,416 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Contains `PushBytes` & co
+
+use core::borrow::{Borrow, BorrowMut};
+use core::ops::{Deref, DerefMut};
+
+pub use primitive::*;
+
+#[allow(unused)]
+use crate::prelude::*;
+
+/// This module only contains required operations so that outside functions wouldn't accidentally
+/// break invariants. Therefore auditing this module should be sufficient.
+mod primitive {
+    use core::convert::{TryFrom, TryInto};
+    use core::ops::{
+        Bound, Index, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
+    };
+
+    use super::PushBytesError;
+    #[allow(unused)]
+    use crate::prelude::*;
+
+    #[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))]
+    fn check_limit(_: usize) -> Result<(), PushBytesError> { Ok(()) }
+
+    #[cfg(not(any(target_pointer_width = "16", target_pointer_width = "32")))]
+    fn check_limit(len: usize) -> Result<(), PushBytesError> {
+        if len < 0x100000000 {
+            Ok(())
+        } else {
+            Err(PushBytesError { len })
+        }
+    }
+
+    /// Byte slices that can be in Bitcoin script.
+    ///
+    /// The encoding of Bitcoin script restricts data pushes to be less than 2^32 bytes long.
+    /// This type represents slices that are guaranteed to be within the limit so they can be put in
+    /// the script safely.
+    #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+    #[repr(transparent)]
+    pub struct PushBytes([u8]);
+
+    impl PushBytes {
+        /// Creates `&Self` without checking the length.
+        ///
+        /// ## Safety
+        ///
+        /// The caller is responsible for checking that the length is less than the [`LIMIT`].
+        unsafe fn from_slice_unchecked(bytes: &[u8]) -> &Self {
+            &*(bytes as *const [u8] as *const PushBytes)
+        }
+
+        /// Creates `&mut Self` without checking the length.
+        ///
+        /// ## Safety
+        ///
+        /// The caller is responsible for checking that the length is less than the [`LIMIT`].
+        unsafe fn from_mut_slice_unchecked(bytes: &mut [u8]) -> &mut Self {
+            &mut *(bytes as *mut [u8] as *mut PushBytes)
+        }
+
+        /// Creates an empty `PushBytes`.
+        pub fn empty() -> &'static Self {
+            // 0 < LIMIT
+            unsafe { Self::from_slice_unchecked(&[]) }
+        }
+
+        /// Returns the underlying bytes.
+        pub fn as_bytes(&self) -> &[u8] { &self.0 }
+
+        /// Returns the underlying mutbale bytes.
+        pub fn as_mut_bytes(&mut self) -> &mut [u8] { &mut self.0 }
+    }
+
+    macro_rules! delegate_index {
+        ($($type:ty),* $(,)?) => {
+            $(
+                /// Script subslicing operation - read [slicing safety](#slicing-safety)!
+                impl Index<$type> for PushBytes {
+                    type Output = Self;
+
+                    #[inline]
+                    #[track_caller]
+                    fn index(&self, index: $type) -> &Self::Output {
+                        // Slicing can not make slices longer
+                        unsafe {
+                            Self::from_slice_unchecked(&self.0[index])
+                        }
+                    }
+                }
+            )*
+        }
+    }
+
+    delegate_index!(
+        Range<usize>,
+        RangeFrom<usize>,
+        RangeTo<usize>,
+        RangeFull,
+        RangeInclusive<usize>,
+        RangeToInclusive<usize>,
+        (Bound<usize>, Bound<usize>)
+    );
+
+    impl Index<usize> for PushBytes {
+        type Output = u8;
+
+        #[inline]
+        #[track_caller]
+        fn index(&self, index: usize) -> &Self::Output { &self.0[index] }
+    }
+
+    impl<'a> TryFrom<&'a [u8]> for &'a PushBytes {
+        type Error = PushBytesError;
+
+        fn try_from(bytes: &'a [u8]) -> Result<Self, Self::Error> {
+            check_limit(bytes.len())?;
+            // We've just checked the length
+            Ok(unsafe { PushBytes::from_slice_unchecked(bytes) })
+        }
+    }
+
+    impl<'a> TryFrom<&'a mut [u8]> for &'a mut PushBytes {
+        type Error = PushBytesError;
+
+        fn try_from(bytes: &'a mut [u8]) -> Result<Self, Self::Error> {
+            check_limit(bytes.len())?;
+            // We've just checked the length
+            Ok(unsafe { PushBytes::from_mut_slice_unchecked(bytes) })
+        }
+    }
+
+    macro_rules! from_array {
+        ($($len:literal),* $(,)?) => {
+            $(
+                impl<'a> From<&'a [u8; $len]> for &'a PushBytes {
+                    fn from(bytes: &'a [u8; $len]) -> Self {
+                        // Check that the macro wasn't called with a wrong number.
+                        const _: () = [(); 1][($len >= 0x100000000u64) as usize];
+                        // We know the size of array statically and we checked macro input.
+                        unsafe { PushBytes::from_slice_unchecked(bytes) }
+                    }
+                }
+
+                impl<'a> From<&'a mut [u8; $len]> for &'a mut PushBytes {
+                    fn from(bytes: &'a mut [u8; $len]) -> Self {
+                        // Macro check already above, no need to duplicate.
+                        // We know the size of array statically and we checked macro input.
+                        unsafe { PushBytes::from_mut_slice_unchecked(bytes) }
+                    }
+                }
+
+                impl AsRef<PushBytes> for [u8; $len] {
+                    fn as_ref(&self) -> &PushBytes {
+                        self.into()
+                    }
+                }
+
+                impl AsMut<PushBytes> for [u8; $len] {
+                    fn as_mut(&mut self) -> &mut PushBytes {
+                        self.into()
+                    }
+                }
+
+                impl From<[u8; $len]> for PushBytesBuf {
+                    fn from(bytes: [u8; $len]) -> Self {
+                        PushBytesBuf(Vec::from(&bytes as &[_]))
+                    }
+                }
+
+                impl<'a> From<&'a [u8; $len]> for PushBytesBuf {
+                    fn from(bytes: &'a [u8; $len]) -> Self {
+                        PushBytesBuf(Vec::from(bytes as &[_]))
+                    }
+                }
+            )*
+        }
+    }
+
+    // Sizes up to 73 to support all pubkey and signature sizes
+    from_array! {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+        71, 72, 73,
+    }
+
+    /// Owned, growable counterpart to `PushBytes`.
+    #[derive(Default, Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+    pub struct PushBytesBuf(Vec<u8>);
+
+    impl PushBytesBuf {
+        /// Creates a new empty `PushBytesBuf`.
+        pub fn new() -> Self { PushBytesBuf(Vec::new()) }
+
+        /// Creates a new empty `PushBytesBuf` with reserved capacity.
+        pub fn with_capacity(capacity: usize) -> Self { PushBytesBuf(Vec::with_capacity(capacity)) }
+
+        /// Reserve capacity for `additional_capacity` bytes.
+        pub fn reserve(&mut self, additional_capacity: usize) {
+            self.0.reserve(additional_capacity)
+        }
+
+        /// Try pushing a single byte.
+        ///
+        /// ## Errors
+        ///
+        /// This method fails if `self` would exceed the limit.
+        #[allow(deprecated)]
+        pub fn push(&mut self, byte: u8) -> Result<(), PushBytesError> {
+            // This is OK on 32 bit archs since vec has its own check and this check is pointless.
+            check_limit(self.0.len().saturating_add(1))?;
+            self.0.push(byte);
+            Ok(())
+        }
+
+        /// Try appending a slice to `PushBytesBuf`
+        ///
+        /// ## Errors
+        ///
+        /// This method fails if `self` would exceed the limit.
+        pub fn extend_from_slice(&mut self, bytes: &[u8]) -> Result<(), PushBytesError> {
+            let len = self.0.len().saturating_add(bytes.len());
+            check_limit(len)?;
+            self.0.extend_from_slice(bytes);
+            Ok(())
+        }
+
+        /// Remove the last byte from buffer if any.
+        pub fn pop(&mut self) -> Option<u8> { self.0.pop() }
+
+        /// Remove the byte at `index` and return it.
+        ///
+        /// ## Panics
+        ///
+        /// This method panics if `index` is out of bounds.
+        #[track_caller]
+        pub fn remove(&mut self, index: usize) -> u8 { self.0.remove(index) }
+
+        /// Remove all bytes from buffer without affecting capacity.
+        pub fn clear(&mut self) { self.0.clear() }
+
+        /// Remove bytes from buffer past `len`.
+        pub fn truncate(&mut self, len: usize) { self.0.truncate(len) }
+
+        /// Extracts `PushBytes` slice
+        pub fn as_push_bytes(&self) -> &PushBytes {
+            // length guaranteed by our invariant
+            unsafe { PushBytes::from_slice_unchecked(&self.0) }
+        }
+
+        /// Extracts mutable `PushBytes` slice
+        pub fn as_mut_push_bytes(&mut self) -> &mut PushBytes {
+            // length guaranteed by our invariant
+            unsafe { PushBytes::from_mut_slice_unchecked(&mut self.0) }
+        }
+
+        /// Accesses inner `Vec` - provided for `super` to impl other methods.
+        pub(super) fn inner(&self) -> &Vec<u8> { &self.0 }
+    }
+
+    impl From<PushBytesBuf> for Vec<u8> {
+        fn from(value: PushBytesBuf) -> Self { value.0 }
+    }
+
+    impl TryFrom<Vec<u8>> for PushBytesBuf {
+        type Error = PushBytesError;
+
+        fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
+            // check len
+            let _: &PushBytes = vec.as_slice().try_into()?;
+            Ok(PushBytesBuf(vec))
+        }
+    }
+
+    impl ToOwned for PushBytes {
+        type Owned = PushBytesBuf;
+
+        fn to_owned(&self) -> Self::Owned { PushBytesBuf(self.0.to_owned()) }
+    }
+}
+
+impl PushBytes {
+    /// Returns the number of bytes in buffer.
+    pub fn len(&self) -> usize { self.as_bytes().len() }
+
+    /// Returns true if the buffer contains zero bytes.
+    pub fn is_empty(&self) -> bool { self.as_bytes().is_empty() }
+}
+
+impl PushBytesBuf {
+    /// Returns the number of bytes in buffer.
+    pub fn len(&self) -> usize { self.inner().len() }
+
+    /// Returns the number of bytes the buffer can contain without reallocating.
+    pub fn capacity(&self) -> usize { self.inner().capacity() }
+
+    /// Returns true if the buffer contains zero bytes.
+    pub fn is_empty(&self) -> bool { self.inner().is_empty() }
+}
+
+impl AsRef<[u8]> for PushBytes {
+    fn as_ref(&self) -> &[u8] { self.as_bytes() }
+}
+
+impl AsMut<[u8]> for PushBytes {
+    fn as_mut(&mut self) -> &mut [u8] { self.as_mut_bytes() }
+}
+
+impl Deref for PushBytesBuf {
+    type Target = PushBytes;
+
+    fn deref(&self) -> &Self::Target { self.as_push_bytes() }
+}
+
+impl DerefMut for PushBytesBuf {
+    fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut_push_bytes() }
+}
+
+impl AsRef<PushBytes> for PushBytes {
+    fn as_ref(&self) -> &PushBytes { self }
+}
+
+impl AsMut<PushBytes> for PushBytes {
+    fn as_mut(&mut self) -> &mut PushBytes { self }
+}
+
+impl AsRef<PushBytes> for PushBytesBuf {
+    fn as_ref(&self) -> &PushBytes { self.as_push_bytes() }
+}
+
+impl AsMut<PushBytes> for PushBytesBuf {
+    fn as_mut(&mut self) -> &mut PushBytes { self.as_mut_push_bytes() }
+}
+
+impl Borrow<PushBytes> for PushBytesBuf {
+    fn borrow(&self) -> &PushBytes { self.as_push_bytes() }
+}
+
+impl BorrowMut<PushBytes> for PushBytesBuf {
+    fn borrow_mut(&mut self) -> &mut PushBytes { self.as_mut_push_bytes() }
+}
+
+/// Reports information about failed conversion into `PushBytes`.
+///
+/// This should not be needed by general public, except as an additional bound on `TryFrom` when
+/// converting to `WitnessProgram`.
+pub trait PushBytesErrorReport {
+    /// How many bytes the input had.
+    fn input_len(&self) -> usize;
+}
+
+impl PushBytesErrorReport for core::convert::Infallible {
+    #[inline]
+    fn input_len(&self) -> usize { match *self {} }
+}
+
+pub use error::*;
+
+#[cfg(any(target_pointer_width = "16", target_pointer_width = "32"))]
+mod error {
+    use core::fmt;
+
+    /// Error returned on attempt to create too large `PushBytes`.
+    #[allow(unused)]
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub struct PushBytesError {
+        never: core::convert::Infallible,
+    }
+
+    impl super::PushBytesErrorReport for PushBytesError {
+        #[inline]
+        fn input_len(&self) -> usize { match self.never {} }
+    }
+
+    impl fmt::Display for PushBytesError {
+        fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result { match self.never {} }
+    }
+}
+
+// we have 64 bits in mind, but even for esoteric sizes, this code is correct, since it's the
+// conservative one that checks for errors
+#[cfg(not(any(target_pointer_width = "16", target_pointer_width = "32")))]
+mod error {
+    use core::fmt;
+
+    /// Error returned on attempt to create too large `PushBytes`.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub struct PushBytesError {
+        /// How long the input was.
+        pub(super) len: usize,
+    }
+
+    impl super::PushBytesErrorReport for PushBytesError {
+        #[inline]
+        fn input_len(&self) -> usize { self.len }
+    }
+
+    impl fmt::Display for PushBytesError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            write!(
+                f,
+                "attempt to prepare {} bytes to be pushed into script but the limit is 2^32-1",
+                self.len
+            )
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for PushBytesError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
diff --git a/tapyrus/src/blockdata/script/tests.rs b/tapyrus/src/blockdata/script/tests.rs
new file mode 100644
index 00000000..982e567c
--- /dev/null
+++ b/tapyrus/src/blockdata/script/tests.rs
@@ -0,0 +1,1077 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::str::FromStr;
+
+use hashes::Hash;
+use hex_lit::hex;
+
+use super::*;
+use crate::blockdata::opcodes;
+use crate::consensus::encode::{deserialize, serialize};
+use crate::crypto::key::{PubkeyHash, PublicKey, WPubkeyHash, XOnlyPublicKey};
+use crate::script::color_identifier::{ColorIdentifier, TokenTypes};
+
+#[test]
+#[rustfmt::skip]
+fn script() {
+    let mut comp = vec![];
+    let mut script = Builder::new();
+    assert_eq!(script.as_bytes(), &comp[..]);
+
+    // small ints
+    script = script.push_int(1);  comp.push(81u8); assert_eq!(script.as_bytes(), &comp[..]);
+    script = script.push_int(0);  comp.push(0u8);  assert_eq!(script.as_bytes(), &comp[..]);
+    script = script.push_int(4);  comp.push(84u8); assert_eq!(script.as_bytes(), &comp[..]);
+    script = script.push_int(-1); comp.push(79u8); assert_eq!(script.as_bytes(), &comp[..]);
+    // forced scriptint
+    script = script.push_int_non_minimal(4); comp.extend([1u8, 4].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    // big ints
+    script = script.push_int(17); comp.extend([1u8, 17].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script = script.push_int(10000); comp.extend([2u8, 16, 39].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    // notice the sign bit set here, hence the extra zero/128 at the end
+    script = script.push_int(10000000); comp.extend([4u8, 128, 150, 152, 0].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+    script = script.push_int(-10000000); comp.extend([4u8, 128, 150, 152, 128].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+
+    // data
+    script = script.push_slice(b"NRA4VR"); comp.extend([6u8, 78, 82, 65, 52, 86, 82].iter().cloned()); assert_eq!(script.as_bytes(), &comp[..]);
+
+    // keys
+    const KEYSTR1: &str = "21032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af";
+    let key = PublicKey::from_str(&KEYSTR1[2..]).unwrap();
+    script = script.push_key(&key); comp.extend_from_slice(&hex!(KEYSTR1)); assert_eq!(script.as_bytes(), &comp[..]);
+    const KEYSTR2: &str = "41042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133";
+    let key = PublicKey::from_str(&KEYSTR2[2..]).unwrap();
+    script = script.push_key(&key); comp.extend_from_slice(&hex!(KEYSTR2)); assert_eq!(script.as_bytes(), &comp[..]);
+
+    // opcodes
+    script = script.push_opcode(OP_CHECKSIG); comp.push(0xACu8); assert_eq!(script.as_bytes(), &comp[..]);
+    script = script.push_opcode(OP_CHECKSIG); comp.push(0xACu8); assert_eq!(script.as_bytes(), &comp[..]);
+}
+
+#[test]
+fn p2pk_pubkey_bytes_valid_key_and_valid_script_returns_expected_key() {
+    let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
+    let key = PublicKey::from_str(key_str).unwrap();
+    let p2pk = Script::builder().push_key(&key).push_opcode(OP_CHECKSIG).into_script();
+    let actual = p2pk.p2pk_pubkey_bytes().unwrap();
+    assert_eq!(actual.to_vec(), key.to_bytes());
+}
+
+#[test]
+fn p2pk_pubkey_bytes_no_checksig_returns_none() {
+    let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
+    let key = PublicKey::from_str(key_str).unwrap();
+    let no_checksig = Script::builder().push_key(&key).into_script();
+    assert_eq!(no_checksig.p2pk_pubkey_bytes(), None);
+}
+
+#[test]
+fn p2pk_pubkey_bytes_emptry_script_returns_none() {
+    let empty_script = Script::builder().into_script();
+    assert!(empty_script.p2pk_pubkey_bytes().is_none());
+}
+
+#[test]
+fn p2pk_pubkey_bytes_no_key_returns_none() {
+    // scripts with no key should return None
+    let no_push_bytes = Script::builder().push_opcode(OP_CHECKSIG).into_script();
+    assert!(no_push_bytes.p2pk_pubkey_bytes().is_none());
+}
+
+#[test]
+fn p2pk_pubkey_bytes_different_op_code_returns_none() {
+    let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
+    let key = PublicKey::from_str(key_str).unwrap();
+    let different_op_code = Script::builder().push_key(&key).push_opcode(OP_NOP).into_script();
+    assert!(different_op_code.p2pk_pubkey_bytes().is_none());
+}
+
+#[test]
+fn p2pk_pubkey_bytes_incorrect_key_size_returns_none() {
+    // 63 byte key
+    let malformed_key = b"21032e58afe51f9ed8ad3cc7897f634d881fdbe49816429ded8156bebd2ffd1";
+    let invalid_p2pk_script =
+        Script::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
+    assert!(invalid_p2pk_script.p2pk_pubkey_bytes().is_none());
+}
+
+#[test]
+fn p2pk_pubkey_bytes_invalid_key_returns_some() {
+    let malformed_key = b"21032e58afe51f9ed8ad3cc7897f634d881fdbe49816429ded8156bebd2ffd1ux";
+    let invalid_key_script =
+        Script::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
+    assert!(invalid_key_script.p2pk_pubkey_bytes().is_some());
+}
+
+#[test]
+fn p2pk_pubkey_bytes_compressed_key_returns_expected_key() {
+    let compressed_key_str = "0311db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c";
+    let key = PublicKey::from_str(compressed_key_str).unwrap();
+    let p2pk = Script::builder().push_key(&key).push_opcode(OP_CHECKSIG).into_script();
+    let actual = p2pk.p2pk_pubkey_bytes().unwrap();
+    assert_eq!(actual.to_vec(), key.to_bytes());
+}
+
+#[test]
+fn p2pk_public_key_valid_key_and_valid_script_returns_expected_key() {
+    let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
+    let key = PublicKey::from_str(key_str).unwrap();
+    let p2pk = Script::builder().push_key(&key).push_opcode(OP_CHECKSIG).into_script();
+    let actual = p2pk.p2pk_public_key().unwrap();
+    assert_eq!(actual, key);
+}
+
+#[test]
+fn p2pk_public_key_no_checksig_returns_none() {
+    let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
+    let key = PublicKey::from_str(key_str).unwrap();
+    let no_checksig = Script::builder().push_key(&key).into_script();
+    assert_eq!(no_checksig.p2pk_public_key(), None);
+}
+
+#[test]
+fn p2pk_public_key_empty_script_returns_none() {
+    let empty_script = Script::builder().into_script();
+    assert!(empty_script.p2pk_public_key().is_none());
+}
+
+#[test]
+fn p2pk_public_key_no_key_returns_none() {
+    let no_push_bytes = Script::builder().push_opcode(OP_CHECKSIG).into_script();
+    assert!(no_push_bytes.p2pk_public_key().is_none());
+}
+
+#[test]
+fn p2pk_public_key_different_op_code_returns_none() {
+    let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
+    let key = PublicKey::from_str(key_str).unwrap();
+    let different_op_code = Script::builder().push_key(&key).push_opcode(OP_NOP).into_script();
+    assert!(different_op_code.p2pk_public_key().is_none());
+}
+
+#[test]
+fn p2pk_public_key_incorrect_size_returns_none() {
+    let malformed_key = b"21032e58afe51f9ed8ad3cc7897f634d881fdbe49816429ded8156bebd2ffd1";
+    let malformed_key_script =
+        Script::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
+    assert!(malformed_key_script.p2pk_public_key().is_none());
+}
+
+#[test]
+fn p2pk_public_key_invalid_key_returns_none() {
+    let malformed_key = b"21032e58afe51f9ed8ad3cc7897f634d881fdbe49816429ded8156bebd2ffd1ux";
+    let invalid_key_script =
+        Script::builder().push_slice(malformed_key).push_opcode(OP_CHECKSIG).into_script();
+    assert!(invalid_key_script.p2pk_public_key().is_none());
+}
+
+#[test]
+fn p2pk_public_key_compressed_key_returns_some() {
+    let compressed_key_str = "0311db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c";
+    let key = PublicKey::from_str(compressed_key_str).unwrap();
+    let p2pk = Script::builder().push_key(&key).push_opcode(OP_CHECKSIG).into_script();
+    let actual = p2pk.p2pk_public_key().unwrap();
+    assert_eq!(actual, key);
+}
+
+#[test]
+fn script_x_only_key() {
+    // Notice the "20" which prepends the keystr. That 20 is hexidecimal for "32". The Builder automatically adds the 32 opcode
+    // to our script in order to give a heads up to the script compiler that it should add the next 32 bytes to the stack.
+    // From: https://github.com/bitcoin-core/btcdeb/blob/e8c2750c4a4702768c52d15640ed03bf744d2601/doc/tapscript-example.md?plain=1#L43
+    const KEYSTR: &str = "209997a497d964fc1a62885b05a51166a65a90df00492c8d7cf61d6accf54803be";
+    let x_only_key = XOnlyPublicKey::from_str(&KEYSTR[2..]).unwrap();
+    let script = Builder::new().push_x_only_key(&x_only_key);
+    assert_eq!(script.into_bytes(), &hex!(KEYSTR) as &[u8]);
+}
+
+#[test]
+fn script_builder() {
+    // from txid 3bb5e6434c11fb93f64574af5d116736510717f2c595eb45b52c28e31622dfff which was in my mempool when I wrote the test
+    let script = Builder::new()
+        .push_opcode(OP_DUP)
+        .push_opcode(OP_HASH160)
+        .push_slice(hex!("16e1ae70ff0fa102905d4af297f6912bda6cce19"))
+        .push_opcode(OP_EQUALVERIFY)
+        .push_opcode(OP_CHECKSIG)
+        .into_script();
+    assert_eq!(script.to_hex_string(), "76a91416e1ae70ff0fa102905d4af297f6912bda6cce1988ac");
+}
+
+#[test]
+fn script_generators() {
+    let pubkey =
+        PublicKey::from_str("0234e6a79c5359c613762d537e0e19d86c77c1666d8c9ab050f23acd198e97f93e")
+            .unwrap();
+    assert!(ScriptBuf::new_p2pk(&pubkey).is_p2pk());
+
+    let pubkey_hash = PubkeyHash::hash(&pubkey.inner.serialize());
+    assert!(ScriptBuf::new_p2pkh(&pubkey_hash).is_p2pkh());
+
+    let wpubkey_hash = WPubkeyHash::hash(&pubkey.inner.serialize());
+    assert!(ScriptBuf::new_p2wpkh(&wpubkey_hash).is_p2wpkh());
+
+    let script = Builder::new().push_opcode(OP_NUMEQUAL).push_verify().into_script();
+    let script_hash = script.script_hash();
+    let p2sh = ScriptBuf::new_p2sh(&script_hash);
+    assert!(p2sh.is_p2sh());
+    assert_eq!(script.to_p2sh(), p2sh);
+
+    let wscript_hash = script.wscript_hash();
+    let p2wsh = ScriptBuf::new_p2wsh(&wscript_hash);
+    assert!(p2wsh.is_p2wsh());
+    assert_eq!(script.to_p2wsh(), p2wsh);
+
+    // Test data are taken from the second output of
+    // 2ccb3a1f745eb4eefcf29391460250adda5fab78aaddb902d25d3cd97d9d8e61 transaction
+    let data = hex!("aa21a9ed20280f53f2d21663cac89e6bd2ad19edbabb048cda08e73ed19e9268d0afea2a");
+    let op_return = ScriptBuf::new_op_return(data);
+    assert!(op_return.is_op_return());
+    assert_eq!(
+        op_return.to_hex_string(),
+        "6a24aa21a9ed20280f53f2d21663cac89e6bd2ad19edbabb048cda08e73ed19e9268d0afea2a"
+    );
+}
+
+#[test]
+fn script_builder_verify() {
+    let simple = Builder::new().push_verify().into_script();
+    assert_eq!(simple.to_hex_string(), "69");
+    let simple2 = Builder::from(vec![]).push_verify().into_script();
+    assert_eq!(simple2.to_hex_string(), "69");
+
+    let nonverify = Builder::new().push_verify().push_verify().into_script();
+    assert_eq!(nonverify.to_hex_string(), "6969");
+    let nonverify2 = Builder::from(vec![0x69]).push_verify().into_script();
+    assert_eq!(nonverify2.to_hex_string(), "6969");
+
+    let equal = Builder::new().push_opcode(OP_EQUAL).push_verify().into_script();
+    assert_eq!(equal.to_hex_string(), "88");
+    let equal2 = Builder::from(vec![0x87]).push_verify().into_script();
+    assert_eq!(equal2.to_hex_string(), "88");
+
+    let numequal = Builder::new().push_opcode(OP_NUMEQUAL).push_verify().into_script();
+    assert_eq!(numequal.to_hex_string(), "9d");
+    let numequal2 = Builder::from(vec![0x9c]).push_verify().into_script();
+    assert_eq!(numequal2.to_hex_string(), "9d");
+
+    let checksig = Builder::new().push_opcode(OP_CHECKSIG).push_verify().into_script();
+    assert_eq!(checksig.to_hex_string(), "ad");
+    let checksig2 = Builder::from(vec![0xac]).push_verify().into_script();
+    assert_eq!(checksig2.to_hex_string(), "ad");
+
+    let checkmultisig = Builder::new().push_opcode(OP_CHECKMULTISIG).push_verify().into_script();
+    assert_eq!(checkmultisig.to_hex_string(), "af");
+    let checkmultisig2 = Builder::from(vec![0xae]).push_verify().into_script();
+    assert_eq!(checkmultisig2.to_hex_string(), "af");
+
+    let trick_slice = Builder::new()
+        .push_slice([0xae]) // OP_CHECKMULTISIG
+        .push_verify()
+        .into_script();
+    assert_eq!(trick_slice.to_hex_string(), "01ae69");
+    let trick_slice2 = Builder::from(vec![0x01, 0xae]).push_verify().into_script();
+    assert_eq!(trick_slice2.to_hex_string(), "01ae69");
+}
+
+#[test]
+fn script_serialize() {
+    let hex_script = hex!("6c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52");
+    let script: Result<ScriptBuf, _> = deserialize(&hex_script);
+    assert!(script.is_ok());
+    assert_eq!(serialize(&script.unwrap()), &hex_script as &[u8]);
+}
+
+#[test]
+fn scriptint_round_trip() {
+    fn build_scriptint(n: i64) -> Vec<u8> {
+        let mut buf = [0u8; 8];
+        let len = write_scriptint(&mut buf, n);
+        assert!(len <= 8);
+        buf[..len].to_vec()
+    }
+
+    assert_eq!(build_scriptint(-1), vec![0x81]);
+    assert_eq!(build_scriptint(255), vec![255, 0]);
+    assert_eq!(build_scriptint(256), vec![0, 1]);
+    assert_eq!(build_scriptint(257), vec![1, 1]);
+    assert_eq!(build_scriptint(511), vec![255, 1]);
+    let test_vectors = [
+        10,
+        100,
+        255,
+        256,
+        1000,
+        10000,
+        25000,
+        200000,
+        5000000,
+        1000000000,
+        (1 << 31) - 1,
+        -((1 << 31) - 1),
+    ];
+    for &i in test_vectors.iter() {
+        assert_eq!(Ok(i), read_scriptint(&build_scriptint(i)));
+        assert_eq!(Ok(-i), read_scriptint(&build_scriptint(-i)));
+        assert_eq!(Ok(i), read_scriptint_non_minimal(&build_scriptint(i)));
+        assert_eq!(Ok(-i), read_scriptint_non_minimal(&build_scriptint(-i)));
+    }
+    assert!(read_scriptint(&build_scriptint(1 << 31)).is_err());
+    assert!(read_scriptint(&build_scriptint(-(1 << 31))).is_err());
+    assert!(read_scriptint_non_minimal(&build_scriptint(1 << 31)).is_err());
+    assert!(read_scriptint_non_minimal(&build_scriptint(-(1 << 31))).is_err());
+}
+
+#[test]
+fn non_minimal_scriptints() {
+    assert_eq!(read_scriptint(&[0x80, 0x00]), Ok(0x80));
+    assert_eq!(read_scriptint(&[0xff, 0x00]), Ok(0xff));
+    assert_eq!(read_scriptint(&[0x8f, 0x00, 0x00]), Err(Error::NonMinimalPush));
+    assert_eq!(read_scriptint(&[0x7f, 0x00]), Err(Error::NonMinimalPush));
+
+    assert_eq!(read_scriptint_non_minimal(&[0x80, 0x00]), Ok(0x80));
+    assert_eq!(read_scriptint_non_minimal(&[0xff, 0x00]), Ok(0xff));
+    assert_eq!(read_scriptint_non_minimal(&[0x8f, 0x00, 0x00]), Ok(0x8f));
+    assert_eq!(read_scriptint_non_minimal(&[0x7f, 0x00]), Ok(0x7f));
+}
+
+#[test]
+fn script_hashes() {
+    let script = ScriptBuf::from_hex("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").unwrap();
+    assert_eq!(script.script_hash().to_string(), "8292bcfbef1884f73c813dfe9c82fd7e814291ea");
+    assert_eq!(
+        script.wscript_hash().to_string(),
+        "3e1525eb183ad4f9b3c5fa3175bdca2a52e947b135bbb90383bf9f6408e2c324"
+    );
+    assert_eq!(
+        ScriptBuf::from_hex("20d85a959b0290bf19bb89ed43c916be835475d013da4b362117393e25a48229b8ac")
+            .unwrap()
+            .tapscript_leaf_hash()
+            .to_string(),
+        "5b75adecf53548f3ec6ad7d78383bf84cc57b55a3127c72b9a2481752dd88b21"
+    );
+}
+
+#[test]
+fn provably_unspendable_test() {
+    // p2pk
+    assert!(!ScriptBuf::from_hex("410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac").unwrap().is_provably_unspendable());
+    assert!(!ScriptBuf::from_hex("4104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac").unwrap().is_provably_unspendable());
+    // p2pkhash
+    assert!(!ScriptBuf::from_hex("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac")
+        .unwrap()
+        .is_provably_unspendable());
+    assert!(ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87")
+        .unwrap()
+        .is_provably_unspendable());
+}
+
+#[test]
+fn op_return_test() {
+    assert!(ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87")
+        .unwrap()
+        .is_op_return());
+    assert!(!ScriptBuf::from_hex("76a914ee61d57ab51b9d212335b1dba62794ac20d2bcf988ac")
+        .unwrap()
+        .is_op_return());
+    assert!(!ScriptBuf::from_hex("").unwrap().is_op_return());
+}
+
+#[test]
+fn multisig() {
+    // First multisig? 1-of-2
+    // In block 164467, txid 60a20bd93aa49ab4b28d514ec10b06e1829ce6818ec06cd3aabd013ebcdc4bb1
+    assert!(
+        ScriptBuf::from_hex("514104cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaff7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4410461cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d76519aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af52ae")
+            .unwrap()
+            .is_multisig()
+    );
+    // 2-of-2
+    assert!(
+        ScriptBuf::from_hex("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae")
+            .unwrap()
+            .is_multisig()
+    );
+
+    // Extra opcode after OP_CHECKMULTISIG
+    assert!(
+        !ScriptBuf::from_hex("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae52")
+            .unwrap()
+            .is_multisig()
+    );
+    // Required sigs > num pubkeys
+    assert!(
+        !ScriptBuf::from_hex("5321021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f452ae")
+            .unwrap()
+            .is_multisig()
+    );
+    // Num pubkeys != pushnum
+    assert!(
+        !ScriptBuf::from_hex("5221021c4ac2ecebc398e390e07f045aac5cc421f82f0739c1ce724d3d53964dc6537d21023a2e9155e0b62f76737605504819a2b4e5ce20653f6c397d7a178ae42ba702f453ae")
+            .unwrap()
+            .is_multisig()
+    );
+
+    // Taproot hash from another test
+    assert!(!ScriptBuf::from_hex(
+        "20d85a959b0290bf19bb89ed43c916be835475d013da4b362117393e25a48229b8ac"
+    )
+    .unwrap()
+    .is_multisig());
+    // OP_RETURN from another test
+    assert!(!ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87")
+        .unwrap()
+        .is_multisig());
+}
+
+#[test]
+fn script_type() {
+    let p2pk = ScriptBuf::from_hex("2102a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397ac").unwrap();
+    let p2pkh = ScriptBuf::from_hex("76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap();
+    let multisig = ScriptBuf::from_hex("522102a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff39721021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d2102df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb48553ae").unwrap();
+    let p2sh = ScriptBuf::from_hex("a9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap();
+    let op_return = ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").unwrap();
+    let cp2pkh = ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bc76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap();
+    let cp2sh = ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bca9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap();
+    let non_standard = ScriptBuf::from_hex("00").unwrap();
+
+    // p2pk
+    assert_eq!(p2pk.script_type(), ScriptType::P2pk);
+    assert_eq!(format!("{}", p2pk.script_type()), "pubkey");
+    assert_eq!(ScriptType::from_str("pubkey"), Ok(ScriptType::P2pk));
+    // p2pkh
+    assert_eq!(p2pkh.script_type(), ScriptType::P2pkh);
+    assert_eq!(format!("{}", p2pkh.script_type()), "pubkeyhash");
+    assert_eq!(ScriptType::from_str("pubkeyhash"), Ok(ScriptType::P2pkh));
+    // multisig
+    assert_eq!(multisig.script_type(), ScriptType::P2ms);
+    assert_eq!(format!("{}", multisig.script_type()), "multisig");
+    assert_eq!(ScriptType::from_str("multisig"), Ok(ScriptType::P2ms));
+    // p2sh
+    assert_eq!(p2sh.script_type(), ScriptType::P2sh);
+    assert_eq!(format!("{}", p2sh.script_type()), "scripthash");
+    assert_eq!(ScriptType::from_str("scripthash"), Ok(ScriptType::P2sh));
+    // op-return
+    assert_eq!(op_return.script_type(), ScriptType::Nulldata);
+    assert_eq!(format!("{}", op_return.script_type()), "nulldata");
+    assert_eq!(ScriptType::from_str("nulldata"), Ok(ScriptType::Nulldata));
+    // cp2pkh
+    assert_eq!(cp2pkh.script_type(), ScriptType::Cp2pkh);
+    assert_eq!(format!("{}", cp2pkh.script_type()), "coloredpubkeyhash");
+    assert_eq!(ScriptType::from_str("coloredpubkeyhash"), Ok(ScriptType::Cp2pkh));
+    // cp2sh
+    assert_eq!(cp2sh.script_type(), ScriptType::Cp2sh);
+    assert_eq!(format!("{}", cp2sh.script_type()), "coloredscripthash");
+    assert_eq!(ScriptType::from_str("coloredscripthash"), Ok(ScriptType::Cp2sh));
+    // non-standard
+    assert_eq!(non_standard.script_type(), ScriptType::NonStandard);
+    assert_eq!(format!("{}", non_standard.script_type()), "nonstandard");
+    assert_eq!(ScriptType::from_str("nonstandard"), Ok(ScriptType::NonStandard));
+}
+
+#[test]
+#[cfg(feature = "serde")]
+fn script_json_serialize() {
+    use serde_json;
+
+    let original = ScriptBuf::from_hex("827651a0698faaa9a8a7a687").unwrap();
+    let json = serde_json::to_value(&original).unwrap();
+    assert_eq!(json, serde_json::Value::String("827651a0698faaa9a8a7a687".to_owned()));
+    let des = serde_json::from_value::<ScriptBuf>(json).unwrap();
+    assert_eq!(original, des);
+}
+
+#[test]
+fn script_asm() {
+    assert_eq!(
+        ScriptBuf::from_hex("6363636363686868686800").unwrap().to_asm_string(),
+        "OP_IF OP_IF OP_IF OP_IF OP_IF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_0"
+    );
+    assert_eq!(
+        ScriptBuf::from_hex("6363636363686868686800").unwrap().to_asm_string(),
+        "OP_IF OP_IF OP_IF OP_IF OP_IF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_0"
+    );
+    assert_eq!(ScriptBuf::from_hex("2102715e91d37d239dea832f1460e91e368115d8ca6cc23a7da966795abad9e3b699ac").unwrap().to_asm_string(),
+               "OP_PUSHBYTES_33 02715e91d37d239dea832f1460e91e368115d8ca6cc23a7da966795abad9e3b699 OP_CHECKSIG");
+    // Elements Alpha peg-out transaction with some signatures removed for brevity. Mainly to test PUSHDATA1
+    assert_eq!(ScriptBuf::from_hex("0047304402202457e78cc1b7f50d0543863c27de75d07982bde8359b9e3316adec0aec165f2f02200203fd331c4e4a4a02f48cf1c291e2c0d6b2f7078a784b5b3649fca41f8794d401004cf1552103244e602b46755f24327142a0517288cebd159eccb6ccf41ea6edf1f601e9af952103bbbacc302d19d29dbfa62d23f37944ae19853cf260c745c2bea739c95328fcb721039227e83246bd51140fe93538b2301c9048be82ef2fb3c7fc5d78426ed6f609ad210229bf310c379b90033e2ecb07f77ecf9b8d59acb623ab7be25a0caed539e2e6472103703e2ed676936f10b3ce9149fa2d4a32060fb86fa9a70a4efe3f21d7ab90611921031e9b7c6022400a6bb0424bbcde14cff6c016b91ee3803926f3440abf5c146d05210334667f975f55a8455d515a2ef1c94fdfa3315f12319a14515d2a13d82831f62f57ae").unwrap().to_asm_string(),
+               "OP_0 OP_PUSHBYTES_71 304402202457e78cc1b7f50d0543863c27de75d07982bde8359b9e3316adec0aec165f2f02200203fd331c4e4a4a02f48cf1c291e2c0d6b2f7078a784b5b3649fca41f8794d401 OP_0 OP_PUSHDATA1 552103244e602b46755f24327142a0517288cebd159eccb6ccf41ea6edf1f601e9af952103bbbacc302d19d29dbfa62d23f37944ae19853cf260c745c2bea739c95328fcb721039227e83246bd51140fe93538b2301c9048be82ef2fb3c7fc5d78426ed6f609ad210229bf310c379b90033e2ecb07f77ecf9b8d59acb623ab7be25a0caed539e2e6472103703e2ed676936f10b3ce9149fa2d4a32060fb86fa9a70a4efe3f21d7ab90611921031e9b7c6022400a6bb0424bbcde14cff6c016b91ee3803926f3440abf5c146d05210334667f975f55a8455d515a2ef1c94fdfa3315f12319a14515d2a13d82831f62f57ae");
+    // Various weird scripts found in transaction 6d7ed9914625c73c0288694a6819196a27ef6c08f98e1270d975a8e65a3dc09a
+    // which triggerred overflow bugs on 32-bit machines in script formatting in the past.
+    assert_eq!(
+        ScriptBuf::from_hex("01").unwrap().to_asm_string(),
+        "OP_PUSHBYTES_1 <push past end>"
+    );
+    assert_eq!(
+        ScriptBuf::from_hex("0201").unwrap().to_asm_string(),
+        "OP_PUSHBYTES_2 <push past end>"
+    );
+    assert_eq!(ScriptBuf::from_hex("4c").unwrap().to_asm_string(), "<unexpected end>");
+    assert_eq!(
+        ScriptBuf::from_hex("4c0201").unwrap().to_asm_string(),
+        "OP_PUSHDATA1 <push past end>"
+    );
+    assert_eq!(ScriptBuf::from_hex("4d").unwrap().to_asm_string(), "<unexpected end>");
+    assert_eq!(
+        ScriptBuf::from_hex("4dffff01").unwrap().to_asm_string(),
+        "OP_PUSHDATA2 <push past end>"
+    );
+    assert_eq!(
+        ScriptBuf::from_hex("4effffffff01").unwrap().to_asm_string(),
+        "OP_PUSHDATA4 <push past end>"
+    );
+}
+
+#[test]
+fn script_buf_collect() {
+    assert_eq!(&core::iter::empty::<Instruction<'_>>().collect::<ScriptBuf>(), Script::new());
+    let script = ScriptBuf::from_hex("0047304402202457e78cc1b7f50d0543863c27de75d07982bde8359b9e3316adec0aec165f2f02200203fd331c4e4a4a02f48cf1c291e2c0d6b2f7078a784b5b3649fca41f8794d401004cf1552103244e602b46755f24327142a0517288cebd159eccb6ccf41ea6edf1f601e9af952103bbbacc302d19d29dbfa62d23f37944ae19853cf260c745c2bea739c95328fcb721039227e83246bd51140fe93538b2301c9048be82ef2fb3c7fc5d78426ed6f609ad210229bf310c379b90033e2ecb07f77ecf9b8d59acb623ab7be25a0caed539e2e6472103703e2ed676936f10b3ce9149fa2d4a32060fb86fa9a70a4efe3f21d7ab90611921031e9b7c6022400a6bb0424bbcde14cff6c016b91ee3803926f3440abf5c146d05210334667f975f55a8455d515a2ef1c94fdfa3315f12319a14515d2a13d82831f62f57ae").unwrap();
+    assert_eq!(script.instructions().collect::<Result<ScriptBuf, _>>().unwrap(), script);
+}
+
+#[test]
+fn script_p2sh_p2p2k_template() {
+    // random outputs I picked out of the mempool
+    assert!(ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac")
+        .unwrap()
+        .is_p2pkh());
+    assert!(!ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac")
+        .unwrap()
+        .is_p2sh());
+    assert!(!ScriptBuf::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ad")
+        .unwrap()
+        .is_p2pkh());
+    assert!(!ScriptBuf::from_hex("").unwrap().is_p2pkh());
+    assert!(ScriptBuf::from_hex("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87")
+        .unwrap()
+        .is_p2sh());
+    assert!(!ScriptBuf::from_hex("a914acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87")
+        .unwrap()
+        .is_p2pkh());
+    assert!(!ScriptBuf::from_hex("a314acc91e6fef5c7f24e5c8b3f11a664aa8f1352ffd87")
+        .unwrap()
+        .is_p2sh());
+}
+
+#[test]
+fn script_p2pk() {
+    assert!(ScriptBuf::from_hex(
+        "21021aeaf2f8638a129a3156fbe7e5ef635226b0bafd495ff03afe2c843d7e3a4b51ac"
+    )
+    .unwrap()
+    .is_p2pk());
+    assert!(ScriptBuf::from_hex("410496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858eeac").unwrap().is_p2pk());
+}
+
+#[test]
+fn p2sh_p2wsh_conversion() {
+    // Test vectors taken from Core tests/data/script_tests.json
+    // bare p2wsh
+    let redeem_script = ScriptBuf::from_hex("410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac").unwrap();
+    let expected_witout =
+        ScriptBuf::from_hex("0020b95237b48faaa69eb078e1170be3b5cbb3fddf16d0a991e14ad274f7b33a4f64")
+            .unwrap();
+    assert!(redeem_script.to_p2wsh().is_p2wsh());
+    assert_eq!(redeem_script.to_p2wsh(), expected_witout);
+
+    // p2sh
+    let redeem_script = ScriptBuf::from_hex("0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8").unwrap();
+    let expected_p2shout =
+        ScriptBuf::from_hex("a91491b24bf9f5288532960ac687abb035127b1d28a587").unwrap();
+    assert!(redeem_script.to_p2sh().is_p2sh());
+    assert_eq!(redeem_script.to_p2sh(), expected_p2shout);
+
+    // p2sh-p2wsh
+    let redeem_script = ScriptBuf::from_hex("410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac").unwrap();
+    let expected_witout =
+        ScriptBuf::from_hex("0020b95237b48faaa69eb078e1170be3b5cbb3fddf16d0a991e14ad274f7b33a4f64")
+            .unwrap();
+    let expected_out =
+        ScriptBuf::from_hex("a914f386c2ba255cc56d20cfa6ea8b062f8b5994551887").unwrap();
+    assert!(redeem_script.to_p2sh().is_p2sh());
+    assert!(redeem_script.to_p2sh().to_p2wsh().is_p2wsh());
+    assert_eq!(redeem_script.to_p2wsh(), expected_witout);
+    assert_eq!(redeem_script.to_p2wsh().to_p2sh(), expected_out);
+}
+
+macro_rules! unwrap_all {
+    ($($var:ident),*) => {
+        $(
+            let $var = $var.unwrap();
+        )*
+    }
+}
+
+#[test]
+fn test_iterator() {
+    let zero = ScriptBuf::from_hex("00").unwrap();
+    let zeropush = ScriptBuf::from_hex("0100").unwrap();
+
+    let nonminimal = ScriptBuf::from_hex("4c0169b2").unwrap(); // PUSHDATA1 for no reason
+    let minimal = ScriptBuf::from_hex("0169b2").unwrap(); // minimal
+    let nonminimal_alt = ScriptBuf::from_hex("026900b2").unwrap(); // non-minimal number but minimal push (should be OK)
+
+    let v_zero: Result<Vec<_>, Error> = zero.instruction_indices_minimal().collect();
+    let v_zeropush: Result<Vec<_>, Error> = zeropush.instruction_indices_minimal().collect();
+
+    let v_min: Result<Vec<_>, Error> = minimal.instruction_indices_minimal().collect();
+    let v_nonmin: Result<Vec<_>, Error> = nonminimal.instruction_indices_minimal().collect();
+    let v_nonmin_alt: Result<Vec<_>, Error> =
+        nonminimal_alt.instruction_indices_minimal().collect();
+    let slop_v_min: Result<Vec<_>, Error> = minimal.instruction_indices().collect();
+    let slop_v_nonmin: Result<Vec<_>, Error> = nonminimal.instruction_indices().collect();
+    let slop_v_nonmin_alt: Result<Vec<_>, Error> = nonminimal_alt.instruction_indices().collect();
+
+    unwrap_all!(
+        v_zero,
+        v_zeropush,
+        v_min,
+        v_nonmin_alt,
+        slop_v_min,
+        slop_v_nonmin,
+        slop_v_nonmin_alt
+    );
+
+    assert_eq!(v_zero, vec![(0, Instruction::PushBytes(PushBytes::empty()))]);
+    assert_eq!(v_zeropush, vec![(0, Instruction::PushBytes([0].as_ref()))]);
+
+    assert_eq!(
+        v_min,
+        vec![(0, Instruction::PushBytes([105].as_ref())), (2, Instruction::Op(opcodes::OP_NOP3))]
+    );
+
+    assert_eq!(v_nonmin.unwrap_err(), Error::NonMinimalPush);
+
+    assert_eq!(
+        v_nonmin_alt,
+        vec![
+            (0, Instruction::PushBytes([105, 0].as_ref())),
+            (3, Instruction::Op(opcodes::OP_NOP3))
+        ]
+    );
+
+    assert_eq!(v_min, slop_v_min);
+    // indices must differ
+    assert_ne!(v_min, slop_v_nonmin);
+    // but the instructions must be equal
+    for ((_, v_min_instr), (_, slop_v_nomin_instr)) in v_min.iter().zip(&slop_v_nonmin) {
+        assert_eq!(v_min_instr, slop_v_nomin_instr);
+    }
+    assert_eq!(v_nonmin_alt, slop_v_nonmin_alt);
+}
+
+#[test]
+fn script_ord() {
+    let script_1 = Builder::new().push_slice([1, 2, 3, 4]).into_script();
+    let script_2 = Builder::new().push_int(10).into_script();
+    let script_3 = Builder::new().push_int(15).into_script();
+    let script_4 = Builder::new().push_opcode(OP_RETURN).into_script();
+
+    assert!(script_1 < script_2);
+    assert!(script_2 < script_3);
+    assert!(script_3 < script_4);
+
+    assert!(script_1 <= script_1);
+    assert!(script_1 >= script_1);
+
+    assert!(script_4 > script_3);
+    assert!(script_3 > script_2);
+    assert!(script_2 > script_1);
+}
+
+#[test]
+#[cfg(feature = "bitcoinconsensus")]
+fn test_bitcoinconsensus() {
+    // a random segwit transaction from the blockchain using native segwit
+    let spent_bytes = hex!("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d");
+    let spent = Script::from_bytes(&spent_bytes);
+    let spending = hex!("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000");
+    spent.verify(0, crate::Amount::from_tap(18393430), &spending).unwrap();
+}
+
+#[test]
+fn defult_dust_value_tests() {
+    // Check that our dust_value() calculator correctly calculates the dust limit on common
+    // well-known scriptPubKey types.
+    let script_p2wpkh = Builder::new().push_int(0).push_slice([42; 20]).into_script();
+    assert!(script_p2wpkh.is_p2wpkh());
+    assert_eq!(script_p2wpkh.dust_value(), crate::Amount::from_tap(294));
+
+    let script_p2pkh = Builder::new()
+        .push_opcode(OP_DUP)
+        .push_opcode(OP_HASH160)
+        .push_slice([42; 20])
+        .push_opcode(OP_EQUALVERIFY)
+        .push_opcode(OP_CHECKSIG)
+        .into_script();
+    assert!(script_p2pkh.is_p2pkh());
+    assert_eq!(script_p2pkh.dust_value(), crate::Amount::from_tap(546));
+
+    let color_id = ColorIdentifier::from_str("c14ca2241021165f86cf706351de7e235d7f4b4895fcb4d9155a4e9245f95c2c9a").unwrap();
+    let script_cp2pkh = ScriptBuf::new_cp2pkh(&color_id, &PubkeyHash::from_byte_array([42; 20]));
+    assert!(script_cp2pkh.is_cp2pkh());
+    assert_eq!(script_cp2pkh.dust_value(), crate::Amount::from_tap(1));
+}
+
+#[test]
+fn test_script_get_sigop_count() {
+    assert_eq!(
+        Builder::new()
+            .push_opcode(OP_DUP)
+            .push_opcode(OP_HASH160)
+            .push_slice([42; 20])
+            .push_opcode(OP_EQUAL)
+            .into_script()
+            .count_sigops(),
+        0
+    );
+    assert_eq!(
+        Builder::new()
+            .push_opcode(OP_DUP)
+            .push_opcode(OP_HASH160)
+            .push_slice([42; 20])
+            .push_opcode(OP_EQUALVERIFY)
+            .push_opcode(OP_CHECKSIG)
+            .into_script()
+            .count_sigops(),
+        1
+    );
+    assert_eq!(
+        Builder::new()
+            .push_opcode(OP_DUP)
+            .push_opcode(OP_HASH160)
+            .push_slice([42; 20])
+            .push_opcode(OP_EQUALVERIFY)
+            .push_opcode(OP_CHECKSIGVERIFY)
+            .push_opcode(OP_PUSHNUM_1)
+            .into_script()
+            .count_sigops(),
+        1
+    );
+    let multi = Builder::new()
+        .push_opcode(OP_PUSHNUM_1)
+        .push_slice([3; 33])
+        .push_slice([3; 33])
+        .push_slice([3; 33])
+        .push_opcode(OP_PUSHNUM_3)
+        .push_opcode(OP_CHECKMULTISIG)
+        .into_script();
+    assert_eq!(multi.count_sigops(), 3);
+    assert_eq!(multi.count_sigops_legacy(), 20);
+    let multi_verify = Builder::new()
+        .push_opcode(OP_PUSHNUM_1)
+        .push_slice([3; 33])
+        .push_slice([3; 33])
+        .push_slice([3; 33])
+        .push_opcode(OP_PUSHNUM_3)
+        .push_opcode(OP_CHECKMULTISIGVERIFY)
+        .push_opcode(OP_PUSHNUM_1)
+        .into_script();
+    assert_eq!(multi_verify.count_sigops(), 3);
+    assert_eq!(multi_verify.count_sigops_legacy(), 20);
+    let multi_nopushnum_pushdata = Builder::new()
+        .push_opcode(OP_PUSHNUM_1)
+        .push_slice([3; 33])
+        .push_slice([3; 33])
+        .push_slice([3; 33])
+        .push_opcode(OP_CHECKMULTISIG)
+        .into_script();
+    assert_eq!(multi_nopushnum_pushdata.count_sigops(), 20);
+    assert_eq!(multi_nopushnum_pushdata.count_sigops_legacy(), 20);
+    let multi_nopushnum_op = Builder::new()
+        .push_opcode(OP_PUSHNUM_1)
+        .push_slice([3; 33])
+        .push_slice([3; 33])
+        .push_opcode(OP_DROP)
+        .push_opcode(OP_CHECKMULTISIG)
+        .into_script();
+    assert_eq!(multi_nopushnum_op.count_sigops(), 20);
+    assert_eq!(multi_nopushnum_op.count_sigops_legacy(), 20);
+}
+
+#[test]
+#[cfg(feature = "serde")]
+fn test_script_serde_human_and_not() {
+    let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
+
+    // Serialize
+    let json = serde_json::to_string(&script).unwrap();
+    assert_eq!(json, "\"000102\"");
+    let bincode = bincode::serialize(&script).unwrap();
+    assert_eq!(bincode, [3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2]); // bincode adds u64 for length, serde_cbor use varint
+
+    // Deserialize
+    assert_eq!(script, serde_json::from_str::<ScriptBuf>(&json).unwrap());
+    assert_eq!(script, bincode::deserialize::<ScriptBuf>(&bincode).unwrap());
+}
+
+#[test]
+fn test_instructions_are_fused() {
+    let script = ScriptBuf::new();
+    let mut instructions = script.instructions();
+    assert!(instructions.next().is_none());
+    assert!(instructions.next().is_none());
+    assert!(instructions.next().is_none());
+    assert!(instructions.next().is_none());
+}
+
+#[test]
+fn script_extend() {
+    fn cmp_scripts(new_script: &Script, orig_script: &[Instruction<'_>]) {
+        let mut new_instr = new_script.instructions();
+        let mut orig_instr = orig_script.iter().cloned();
+        for (new, orig) in new_instr.by_ref().zip(orig_instr.by_ref()) {
+            assert_eq!(new.unwrap(), orig);
+        }
+        assert!(new_instr.next().is_none() && orig_instr.next().is_none())
+    }
+
+    let script_5_items = [
+        Instruction::Op(OP_DUP),
+        Instruction::Op(OP_HASH160),
+        Instruction::PushBytes([42; 20].as_ref()),
+        Instruction::Op(OP_EQUALVERIFY),
+        Instruction::Op(OP_CHECKSIG),
+    ];
+    let new_script = script_5_items.iter().cloned().collect::<ScriptBuf>();
+    cmp_scripts(&new_script, &script_5_items);
+
+    let script_6_items = [
+        Instruction::Op(OP_DUP),
+        Instruction::Op(OP_HASH160),
+        Instruction::PushBytes([42; 20].as_ref()),
+        Instruction::Op(OP_EQUALVERIFY),
+        Instruction::Op(OP_CHECKSIG),
+        Instruction::Op(OP_NOP),
+    ];
+    let new_script = script_6_items.iter().cloned().collect::<ScriptBuf>();
+    cmp_scripts(&new_script, &script_6_items);
+
+    let script_7_items = [
+        Instruction::Op(OP_DUP),
+        Instruction::Op(OP_HASH160),
+        Instruction::PushBytes([42; 20].as_ref()),
+        Instruction::Op(OP_EQUALVERIFY),
+        Instruction::Op(OP_CHECKSIG),
+        Instruction::Op(OP_NOP),
+    ];
+    let new_script = script_7_items.iter().cloned().collect::<ScriptBuf>();
+    cmp_scripts(&new_script, &script_7_items);
+}
+
+#[test]
+fn read_scriptbool_zero_is_false() {
+    let v: Vec<u8> = vec![0x00, 0x00, 0x00, 0x00];
+    assert!(!read_scriptbool(&v));
+
+    let v: Vec<u8> = vec![0x00, 0x00, 0x00, 0x80]; // With sign bit set.
+    assert!(!read_scriptbool(&v));
+}
+
+#[test]
+fn read_scriptbool_non_zero_is_true() {
+    let v: Vec<u8> = vec![0x01, 0x00, 0x00, 0x00];
+    assert!(read_scriptbool(&v));
+
+    let v: Vec<u8> = vec![0x01, 0x00, 0x00, 0x80]; // With sign bit set.
+    assert!(read_scriptbool(&v));
+}
+
+#[test]
+fn instruction_script_num_parse() {
+    let push_bytes = [
+        (PushBytesBuf::from([]), Some(0)),
+        (PushBytesBuf::from([0x00]), Some(0)),
+        (PushBytesBuf::from([0x01]), Some(1)),
+        // Check all the negative 1s
+        (PushBytesBuf::from([0x81]), Some(-1)),
+        (PushBytesBuf::from([0x01, 0x80]), Some(-1)),
+        (PushBytesBuf::from([0x01, 0x00, 0x80]), Some(-1)),
+        (PushBytesBuf::from([0x01, 0x00, 0x00, 0x80]), Some(-1)),
+        // Check all the negative 0s
+        (PushBytesBuf::from([0x80]), Some(0)),
+        (PushBytesBuf::from([0x00, 0x80]), Some(0)),
+        (PushBytesBuf::from([0x00, 0x00, 0x80]), Some(0)),
+        (PushBytesBuf::from([0x00, 0x00, 0x00, 0x80]), Some(0)),
+        // Too long
+        (PushBytesBuf::from([0x01, 0x00, 0x00, 0x00, 0x80]), None),
+        // Check the position of all the bytes
+        (PushBytesBuf::from([0xef, 0xbe, 0xad, 0x5e]), Some(0x5eadbeef)),
+        // Add negative
+        (PushBytesBuf::from([0xef, 0xbe, 0xad, 0xde]), Some(-0x5eadbeef)),
+    ];
+    let ops = [
+        (Instruction::Op(opcodes::all::OP_PUSHDATA4), None),
+        (Instruction::Op(opcodes::all::OP_PUSHNUM_NEG1), Some(-1)),
+        (Instruction::Op(opcodes::all::OP_RESERVED), None),
+        (Instruction::Op(opcodes::all::OP_PUSHNUM_1), Some(1)),
+        (Instruction::Op(opcodes::all::OP_PUSHNUM_16), Some(16)),
+        (Instruction::Op(opcodes::all::OP_NOP), None),
+    ];
+    for (input, expected) in &push_bytes {
+        assert_eq!(Instruction::PushBytes(input).script_num(), *expected);
+    }
+    for (input, expected) in &ops {
+        assert_eq!(input.script_num(), *expected);
+    }
+
+    // script_num() is predicated on OP_0/OP_FALSE (0x00)
+    // being treated as an empty PushBytes
+    assert_eq!(
+        Script::from_bytes(&[0x00]).instructions().next(),
+        Some(Ok(Instruction::PushBytes(PushBytes::empty()))),
+    );
+}
+
+#[test]
+fn script_cp2pkh() {
+    // cp2pkh
+    assert!(ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bc76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap().is_cp2pkh());
+    // cp2sh
+    assert!(!ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bca9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap().is_cp2pkh());
+    // p2pkh
+    assert!(!ScriptBuf::from_hex("76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap().is_cp2pkh());
+    // invalid type
+    assert!(!ScriptBuf::from_hex("21c4ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bc76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap().is_cp2pkh());
+}
+
+#[test]
+fn script_cp2sh() {
+    // cp2sh
+    assert!(ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bca9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap().is_cp2sh());
+    // cp2pkh
+    assert!(!ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bc76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap().is_cp2sh());
+    // p2sh
+    assert!(!ScriptBuf::from_hex("a9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap().is_cp2sh());
+    // invalid type
+    assert!(!ScriptBuf::from_hex("21c4ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bca9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap().is_cp2sh());
+}
+
+#[test]
+fn is_colored_test() {
+    // cp2pkh
+    assert!(ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bc76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap().is_colored());
+    // cp2sh
+    assert!(ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bca9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap().is_colored());
+    // p2pkh
+    assert!(!ScriptBuf::from_hex("76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap().is_colored());
+    // p2sh
+    assert!(!ScriptBuf::from_hex("a9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap().is_colored());
+}
+
+#[test]
+fn color_identifier_test() {
+    let script = ScriptBuf::from_hex("76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap();
+    let color_id = ColorIdentifier::reissuable(&script);
+    assert_eq!(color_id.token_type, TokenTypes::Reissuable);
+    assert!(color_id.is_colored());
+    assert!(!color_id.is_default());
+
+    let color_id = ColorIdentifier::non_reissuable(OutPoint::default());
+    assert_eq!(color_id.token_type, TokenTypes::NonReissuable);
+    assert!(color_id.is_colored());
+    assert!(!color_id.is_default());
+
+    let color_id = ColorIdentifier::nft(OutPoint::default());
+    assert_eq!(color_id.token_type, TokenTypes::Nft);
+    assert!(color_id.is_colored());
+    assert!(!color_id.is_default());
+
+    let color_id = ColorIdentifier::default();
+    assert_eq!(color_id.token_type, TokenTypes::None);
+    assert!(!color_id.is_colored());
+    assert!(color_id.is_default());
+}
+
+#[test]
+fn token_type_is_valid() {
+    assert!(TokenTypes::is_valid(&0xc1));
+    assert!(TokenTypes::is_valid(&0xc2));
+    assert!(TokenTypes::is_valid(&0xc3));
+    assert!(!TokenTypes::is_valid(&0xc4));
+}
+
+#[test]
+fn add_color_test() {
+    let out_point = OutPoint { txid: "0101010101010101010101010101010101010101010101010101010101010101".parse().expect("txid"), vout: 1 };
+    let color_id = ColorIdentifier::nft(out_point);
+    let p2pkh = ScriptBuf::from_hex("76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").expect("p2pkh");
+    let p2sh = ScriptBuf::from_hex("a9147620a79e8657d066cff10e21228bf983cf546ac687").expect("p2sh");
+    let op_return = ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").expect("op_return");
+
+    // p2pkh -> cp2pkh
+    let cp2pkh = p2pkh.add_color(color_id).unwrap();
+    assert!(cp2pkh.is_cp2pkh());
+    assert_eq!(cp2pkh.to_bytes(), hex!("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bc76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac"));
+
+    // p2sh -> cp2sh
+    let cp2sh = p2sh.add_color(color_id).unwrap();
+    assert!(cp2sh.is_cp2sh());
+    assert_eq!(cp2sh.to_bytes(), hex!("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bca9147620a79e8657d066cff10e21228bf983cf546ac687"));
+
+    // op_return -> err
+    let op_return = op_return.add_color(color_id);
+    assert!(op_return.is_err());
+}
+
+#[test]
+fn remove_color_test() {
+    let cp2pkh = ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bc76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").expect("cp2pkh");
+    let cp2sh = ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bca9147620a79e8657d066cff10e21228bf983cf546ac687").expect("cp2sh");
+    let p2pkh = ScriptBuf::from_hex("76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").expect("p2pkh");
+    let p2sh = ScriptBuf::from_hex("a9147620a79e8657d066cff10e21228bf983cf546ac687").expect("p2sh");
+    let op_return = ScriptBuf::from_hex("6aa9149eb21980dc9d413d8eac27314938b9da920ee53e87").expect("op_return");
+
+    // cp2pkh -> p2pkh
+    let res = cp2pkh.remove_color();
+    assert!(res.is_p2pkh());
+    assert_eq!(res.to_bytes(), hex!("76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac"));
+
+    // cp2sh -> p2sh
+    let res = cp2sh.remove_color();
+    assert!(res.is_p2sh());
+    assert_eq!(res.to_bytes(), hex!("a9147620a79e8657d066cff10e21228bf983cf546ac687"));
+
+    // p2pkh -> p2pkh
+    let res = p2pkh.remove_color();
+    assert!(res.is_p2pkh());
+    assert_eq!(res, p2pkh);
+
+    // p2sh -> p2sh
+    let res = p2sh.remove_color();
+    assert!(res.is_p2sh());
+    assert_eq!(res, p2sh);
+
+    // op_return -> op_return
+    let res = op_return.remove_color();
+    assert!(res.is_op_return());
+    assert_eq!(res, op_return);
+}
+
+#[test]
+fn serialize_color_id() {
+    let out_point = OutPoint { txid: "0101010101010101010101010101010101010101010101010101010101010101".parse().expect("txid"), vout: 1 };
+    let color_id = ColorIdentifier::nft(out_point);
+
+    assert_eq!(format!("{}", color_id), "c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46");
+
+    let hex_script = hex!("c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46");
+    let script: Result<ColorIdentifier, _> = deserialize(&hex_script);
+    assert!(script.is_ok());
+    let color_id = script.unwrap();
+    assert_eq!(color_id.token_type, TokenTypes::Nft);
+    assert_eq!(serialize(&color_id), hex_script);
+}
+
+#[test]
+fn script_to_color_id() {
+    let p2pkh = ScriptBuf::from_hex("76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap();
+    let cp2pkh = ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bc76a91446c2fbfbecc99a63148fa076de58cf29b0bcf0b088ac").unwrap();
+    let cp2sh = ScriptBuf::from_hex("21c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46bca9147620a79e8657d066cff10e21228bf983cf546ac687").unwrap();
+    let non_standard = ScriptBuf::from_hex("00").unwrap();
+
+    assert_eq!(p2pkh.color_id(), None);
+    assert_eq!(cp2pkh.color_id().unwrap(), ColorIdentifier::from_str("c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46").unwrap());
+    assert_eq!(cp2sh.color_id().unwrap(), ColorIdentifier::from_str("c3ec2fd806701a3f55808cbec3922c38dafaa3070c48c803e9043ee3642c660b46").unwrap());
+    assert_eq!(non_standard.color_id(), None);
+}
\ No newline at end of file
diff --git a/tapyrus/src/blockdata/script/witness_program.rs b/tapyrus/src/blockdata/script/witness_program.rs
new file mode 100644
index 00000000..d030f64c
--- /dev/null
+++ b/tapyrus/src/blockdata/script/witness_program.rs
@@ -0,0 +1,89 @@
+//! The segregated witness program as defined by [BIP141].
+//!
+//! > A scriptPubKey (or redeemScript as defined in BIP16/P2SH) that consists of a 1-byte push
+//! > opcode (for 0 to 16) followed by a data push between 2 and 40 bytes gets a new special
+//! > meaning. The value of the first push is called the "version byte". The following byte
+//! > vector pushed is called the "witness program".
+//!
+//! [BIP141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
+
+use core::convert::TryInto;
+use core::fmt;
+
+use crate::blockdata::script::witness_version::WitnessVersion;
+use crate::blockdata::script::{PushBytes, PushBytesBuf, PushBytesErrorReport};
+
+/// The segregated witness program.
+///
+/// The segregated witness program is technically only the program bytes _excluding_ the witness
+/// version, however we maintain length invariants on the `program` that are governed by the version
+/// number, therefore we carry the version number around along with the program bytes.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WitnessProgram {
+    /// The segwit version associated with this witness program.
+    version: WitnessVersion,
+    /// The witness program (between 2 and 40 bytes).
+    program: PushBytesBuf,
+}
+
+impl WitnessProgram {
+    /// Creates a new witness program.
+    pub fn new<P>(version: WitnessVersion, program: P) -> Result<Self, Error>
+    where
+        P: TryInto<PushBytesBuf>,
+        <P as TryInto<PushBytesBuf>>::Error: PushBytesErrorReport,
+    {
+        use Error::*;
+
+        let program = program.try_into().map_err(|error| InvalidLength(error.input_len()))?;
+        if program.len() < 2 || program.len() > 40 {
+            return Err(InvalidLength(program.len()));
+        }
+
+        // Specific segwit v0 check. These addresses can never spend funds sent to them.
+        if version == WitnessVersion::V0 && (program.len() != 20 && program.len() != 32) {
+            return Err(InvalidSegwitV0Length(program.len()));
+        }
+        Ok(WitnessProgram { version, program })
+    }
+
+    /// Returns the witness program version.
+    pub fn version(&self) -> WitnessVersion { self.version }
+
+    /// Returns the witness program.
+    pub fn program(&self) -> &PushBytes { &self.program }
+}
+
+/// Witness program error.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// The witness program must be between 2 and 40 bytes in length.
+    InvalidLength(usize),
+    /// A v0 witness program must be either of length 20 or 32.
+    InvalidSegwitV0Length(usize),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            InvalidLength(len) =>
+                write!(f, "witness program must be between 2 and 40 bytes: length={}", len),
+            InvalidSegwitV0Length(len) =>
+                write!(f, "a v0 witness program must be either 20 or 32 bytes: length={}", len),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            InvalidLength(_) | InvalidSegwitV0Length(_) => None,
+        }
+    }
+}
diff --git a/tapyrus/src/blockdata/script/witness_version.rs b/tapyrus/src/blockdata/script/witness_version.rs
new file mode 100644
index 00000000..2809f4f9
--- /dev/null
+++ b/tapyrus/src/blockdata/script/witness_version.rs
@@ -0,0 +1,260 @@
+//! The segregated witness version byte as defined by [BIP141].
+//!
+//! > A scriptPubKey (or redeemScript as defined in BIP16/P2SH) that consists of a 1-byte push
+//! > opcode (for 0 to 16) followed by a data push between 2 and 40 bytes gets a new special
+//! > meaning. The value of the first push is called the "version byte". The following byte
+//! > vector pushed is called the "witness program".
+//!
+//! [BIP141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
+
+use core::convert::TryFrom;
+use core::fmt;
+use core::str::FromStr;
+
+use bech32::Fe32;
+use internals::write_err;
+
+use crate::blockdata::opcodes::all::*;
+use crate::blockdata::opcodes::Opcode;
+use crate::blockdata::script::Instruction;
+use crate::error::ParseIntError;
+
+/// Version of the segregated witness program.
+///
+/// Helps limit possible versions of the witness according to the specification. If a plain `u8`
+/// type was used instead it would mean that the version may be > 16, which would be incorrect.
+///
+/// First byte of `scriptPubkey` in transaction output for transactions starting with opcodes
+/// ranging from 0 to 16 (inclusive).
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[repr(u8)]
+pub enum WitnessVersion {
+    /// Initial version of witness program. Used for P2WPKH and P2WPK outputs
+    V0 = 0,
+    /// Version of witness program used for Taproot P2TR outputs.
+    V1 = 1,
+    /// Future (unsupported) version of witness program.
+    V2 = 2,
+    /// Future (unsupported) version of witness program.
+    V3 = 3,
+    /// Future (unsupported) version of witness program.
+    V4 = 4,
+    /// Future (unsupported) version of witness program.
+    V5 = 5,
+    /// Future (unsupported) version of witness program.
+    V6 = 6,
+    /// Future (unsupported) version of witness program.
+    V7 = 7,
+    /// Future (unsupported) version of witness program.
+    V8 = 8,
+    /// Future (unsupported) version of witness program.
+    V9 = 9,
+    /// Future (unsupported) version of witness program.
+    V10 = 10,
+    /// Future (unsupported) version of witness program.
+    V11 = 11,
+    /// Future (unsupported) version of witness program.
+    V12 = 12,
+    /// Future (unsupported) version of witness program.
+    V13 = 13,
+    /// Future (unsupported) version of witness program.
+    V14 = 14,
+    /// Future (unsupported) version of witness program.
+    V15 = 15,
+    /// Future (unsupported) version of witness program.
+    V16 = 16,
+}
+
+impl WitnessVersion {
+    /// Returns integer version number representation for a given [`WitnessVersion`] value.
+    ///
+    /// NB: this is not the same as an integer representation of the opcode signifying witness
+    /// version in tapyrus script. Thus, there is no function to directly convert witness version
+    /// into a byte since the conversion requires context (tapyrus script or just a version number).
+    pub fn to_num(self) -> u8 { self as u8 }
+
+    /// Converts this witness version to a GF32 field element.
+    pub fn to_fe(self) -> Fe32 {
+        Fe32::try_from(self.to_num()).expect("0-16 are valid fe32 values")
+    }
+}
+
+/// Prints [`WitnessVersion`] number (from 0 to 16) as integer, without any prefix or suffix.
+impl fmt::Display for WitnessVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", *self as u8) }
+}
+
+impl FromStr for WitnessVersion {
+    type Err = FromStrError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let version: u8 = crate::parse::int(s).map_err(FromStrError::Unparsable)?;
+        Ok(WitnessVersion::try_from(version)?)
+    }
+}
+
+impl TryFrom<bech32::Fe32> for WitnessVersion {
+    type Error = TryFromError;
+
+    fn try_from(value: Fe32) -> Result<Self, Self::Error> { Self::try_from(value.to_u8()) }
+}
+
+impl TryFrom<u8> for WitnessVersion {
+    type Error = TryFromError;
+
+    fn try_from(no: u8) -> Result<Self, Self::Error> {
+        use WitnessVersion::*;
+
+        Ok(match no {
+            0 => V0,
+            1 => V1,
+            2 => V2,
+            3 => V3,
+            4 => V4,
+            5 => V5,
+            6 => V6,
+            7 => V7,
+            8 => V8,
+            9 => V9,
+            10 => V10,
+            11 => V11,
+            12 => V12,
+            13 => V13,
+            14 => V14,
+            15 => V15,
+            16 => V16,
+            invalid => return Err(TryFromError { invalid }),
+        })
+    }
+}
+
+impl TryFrom<Opcode> for WitnessVersion {
+    type Error = TryFromError;
+
+    fn try_from(opcode: Opcode) -> Result<Self, Self::Error> {
+        match opcode.to_u8() {
+            0 => Ok(WitnessVersion::V0),
+            version if version >= OP_PUSHNUM_1.to_u8() && version <= OP_PUSHNUM_16.to_u8() =>
+                WitnessVersion::try_from(version - OP_PUSHNUM_1.to_u8() + 1),
+            invalid => Err(TryFromError { invalid }),
+        }
+    }
+}
+
+impl<'a> TryFrom<Instruction<'a>> for WitnessVersion {
+    type Error = TryFromInstructionError;
+
+    fn try_from(instruction: Instruction) -> Result<Self, Self::Error> {
+        match instruction {
+            Instruction::Op(op) => Ok(WitnessVersion::try_from(op)?),
+            Instruction::PushBytes(bytes) if bytes.is_empty() => Ok(WitnessVersion::V0),
+            Instruction::PushBytes(_) => Err(TryFromInstructionError::DataPush),
+        }
+    }
+}
+
+impl From<WitnessVersion> for Fe32 {
+    fn from(version: WitnessVersion) -> Self { version.to_fe() }
+}
+
+impl From<WitnessVersion> for Opcode {
+    fn from(version: WitnessVersion) -> Opcode {
+        match version {
+            WitnessVersion::V0 => OP_PUSHBYTES_0,
+            no => Opcode::from(OP_PUSHNUM_1.to_u8() + no.to_num() - 1),
+        }
+    }
+}
+
+/// Error parsing [`WitnessVersion`] from a string.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum FromStrError {
+    /// Unable to parse integer from string.
+    Unparsable(ParseIntError),
+    /// String contained an invalid witness version number.
+    Invalid(TryFromError),
+}
+
+impl fmt::Display for FromStrError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use FromStrError::*;
+
+        match *self {
+            Unparsable(ref e) => write_err!(f, "integer parse error"; e),
+            Invalid(ref e) => write_err!(f, "invalid version number"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for FromStrError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use FromStrError::*;
+
+        match *self {
+            Unparsable(ref e) => Some(e),
+            Invalid(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<TryFromError> for FromStrError {
+    fn from(e: TryFromError) -> Self { Self::Invalid(e) }
+}
+
+/// Error attempting to create a [`WitnessVersion`] from an [`Instruction`]
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum TryFromInstructionError {
+    /// Cannot not convert OP to a witness version.
+    TryFrom(TryFromError),
+    /// Cannot create a witness version from non-zero data push.
+    DataPush,
+}
+
+impl fmt::Display for TryFromInstructionError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use TryFromInstructionError::*;
+
+        match *self {
+            TryFrom(ref e) => write_err!(f, "opcode is not a valid witness version"; e),
+            DataPush => write!(f, "non-zero data push opcode is not a valid witness version"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TryFromInstructionError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TryFromInstructionError::*;
+
+        match *self {
+            TryFrom(ref e) => Some(e),
+            DataPush => None,
+        }
+    }
+}
+
+impl From<TryFromError> for TryFromInstructionError {
+    fn from(e: TryFromError) -> Self { Self::TryFrom(e) }
+}
+
+/// Error attempting to create a [`WitnessVersion`] from an integer.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct TryFromError {
+    /// The invalid non-witness version integer.
+    pub invalid: u8,
+}
+
+impl fmt::Display for TryFromError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "invalid witness script version: {}", self.invalid)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TryFromError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
diff --git a/tapyrus/src/blockdata/transaction.rs b/tapyrus/src/blockdata/transaction.rs
new file mode 100644
index 00000000..a95eb5d9
--- /dev/null
+++ b/tapyrus/src/blockdata/transaction.rs
@@ -0,0 +1,1902 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin transactions.
+//!
+//! A transaction describes a transfer of money. It consumes previously-unspent
+//! transaction outputs and produces new ones, satisfying the condition to spend
+//! the old outputs (typically a digital signature with a specific key must be
+//! provided) and defining the condition to spend the new ones. The use of digital
+//! signatures ensures that coins cannot be spent by unauthorized parties.
+//!
+//! This module provides the structures and functions needed to support transactions.
+//!
+
+use core::convert::TryFrom;
+use core::default::Default;
+use core::{cmp, fmt, str};
+
+use hashes::{self, sha256d, Hash};
+use internals::write_err;
+
+use super::Weight;
+use crate::blockdata::locktime::absolute::{self, Height, Time};
+use crate::blockdata::locktime::relative;
+use crate::blockdata::script::{Script, ScriptBuf};
+use crate::blockdata::witness::Witness;
+#[cfg(feature = "bitcoinconsensus")]
+pub use crate::consensus::validation::TxVerifyError;
+use crate::consensus::{encode, Decodable, Encodable};
+use crate::hash_types::{MalFixTxid, Txid, Wtxid};
+use crate::internal_macros::impl_consensus_encoding;
+use crate::parse::impl_parse_str_from_int_infallible;
+use crate::prelude::*;
+#[cfg(doc)]
+use crate::sighash::{EcdsaSighashType, TapSighashType};
+use crate::string::FromHexStr;
+use crate::{io, Amount, VarInt};
+
+/// A reference to a transaction output.
+///
+/// ### Bitcoin Core References
+///
+/// * [COutPoint definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/transaction.h#L26)
+#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct OutPoint {
+    /// The referenced transaction's txid.
+    pub txid: MalFixTxid,
+    /// The index of the referenced output in its transaction's vout.
+    pub vout: u32,
+}
+#[cfg(feature = "serde")]
+crate::serde_utils::serde_struct_human_string_impl!(OutPoint, "an OutPoint", txid, vout);
+
+impl OutPoint {
+    /// The number of bytes that an outpoint contributes to the size of a transaction.
+    const SIZE: usize = 32 + 4; // The serialized lengths of txid and vout.
+
+    /// Creates a new [`OutPoint`].
+    #[inline]
+    pub fn new(txid: MalFixTxid, vout: u32) -> OutPoint { OutPoint { txid, vout } }
+
+    /// Creates a "null" `OutPoint`.
+    ///
+    /// This value is used for coinbase transactions because they don't have any previous outputs.
+    #[inline]
+    pub fn null() -> OutPoint { OutPoint { txid: Hash::all_zeros(), vout: u32::MAX } }
+
+    /// Checks if an `OutPoint` is "null".
+    #[inline]
+    pub fn is_null(&self) -> bool { *self == OutPoint::null() }
+}
+
+impl Default for OutPoint {
+    fn default() -> Self { OutPoint::null() }
+}
+
+impl fmt::Display for OutPoint {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}:{}", self.txid, self.vout)
+    }
+}
+
+/// An error in parsing an OutPoint.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ParseOutPointError {
+    /// Error in TXID part.
+    MalFixTxid(hex::HexToArrayError),
+    /// Error in vout part.
+    Vout(crate::error::ParseIntError),
+    /// Error in general format.
+    Format,
+    /// Size exceeds max.
+    TooLong,
+    /// Vout part is not strictly numeric without leading zeroes.
+    VoutNotCanonical,
+}
+
+impl fmt::Display for ParseOutPointError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use ParseOutPointError::*;
+
+        match *self {
+            MalFixTxid(ref e) => write_err!(f, "error parsing TXID"; e),
+            Vout(ref e) => write_err!(f, "error parsing vout"; e),
+            Format => write!(f, "OutPoint not in <txid>:<vout> format"),
+            TooLong => write!(f, "vout should be at most 10 digits"),
+            VoutNotCanonical => write!(f, "no leading zeroes or + allowed in vout part"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseOutPointError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use ParseOutPointError::*;
+
+        match self {
+            MalFixTxid(e) => Some(e),
+            Vout(e) => Some(e),
+            Format | TooLong | VoutNotCanonical => None,
+        }
+    }
+}
+
+/// Parses a string-encoded transaction index (vout).
+///
+/// Does not permit leading zeroes or non-digit characters.
+fn parse_vout(s: &str) -> Result<u32, ParseOutPointError> {
+    if s.len() > 1 {
+        let first = s.chars().next().unwrap();
+        if first == '0' || first == '+' {
+            return Err(ParseOutPointError::VoutNotCanonical);
+        }
+    }
+    crate::parse::int(s).map_err(ParseOutPointError::Vout)
+}
+
+impl core::str::FromStr for OutPoint {
+    type Err = ParseOutPointError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s.len() > 75 {
+            // 64 + 1 + 10
+            return Err(ParseOutPointError::TooLong);
+        }
+        let find = s.find(':');
+        if find.is_none() || find != s.rfind(':') {
+            return Err(ParseOutPointError::Format);
+        }
+        let colon = find.unwrap();
+        if colon == 0 || colon == s.len() - 1 {
+            return Err(ParseOutPointError::Format);
+        }
+        Ok(OutPoint {
+            txid: s[..colon].parse().map_err(ParseOutPointError::MalFixTxid)?,
+            vout: parse_vout(&s[colon + 1..])?,
+        })
+    }
+}
+
+/// Bitcoin transaction input.
+///
+/// It contains the location of the previous transaction's output,
+/// that it spends and set of scripts that satisfy its spending
+/// conditions.
+///
+/// ### Bitcoin Core References
+///
+/// * [CTxIn definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/transaction.h#L65)
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct TxIn {
+    /// The reference to the previous output that is being used as an input.
+    pub previous_output: OutPoint,
+    /// The script which pushes values on the stack which will cause
+    /// the referenced output's script to be accepted.
+    pub script_sig: ScriptBuf,
+    /// The sequence number, which suggests to miners which of two
+    /// conflicting transactions should be preferred, or 0xFFFFFFFF
+    /// to ignore this feature. This is generally never used since
+    /// the miner behavior cannot be enforced.
+    pub sequence: Sequence,
+    /// Witness data: an array of byte-arrays.
+    /// Note that this field is *not* (de)serialized with the rest of the TxIn in
+    /// Encodable/Decodable, as it is (de)serialized at the end of the full
+    /// Transaction. It *is* (de)serialized with the rest of the TxIn in other
+    /// (de)serialization routines.
+    pub witness: Witness,
+}
+
+impl TxIn {
+    /// Returns true if this input enables the [`absolute::LockTime`] (aka `nLockTime`) of its
+    /// [`Transaction`].
+    ///
+    /// `nLockTime` is enabled if *any* input enables it. See [`Transaction::is_lock_time_enabled`]
+    ///  to check the overall state. If none of the inputs enables it, the lock time value is simply
+    ///  ignored. If this returns false and OP_CHECKLOCKTIMEVERIFY is used in the redeem script with
+    ///  this input then the script execution will fail [BIP-0065].
+    ///
+    /// [BIP-65](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
+    pub fn enables_lock_time(&self) -> bool { self.sequence != Sequence::MAX }
+
+    /// The weight of the TxIn when it's included in a legacy transaction (i.e., a transaction
+    /// having only legacy inputs).
+    ///
+    /// The witness weight is ignored here even when the witness is non-empty.
+    /// If you want the witness to be taken into account, use `TxIn::segwit_weight` instead.
+    ///
+    /// Keep in mind that when adding a TxIn to a transaction, the total weight of the transaction
+    /// might increase more than `TxIn::legacy_weight`. This happens when the new input added causes
+    /// the input length `VarInt` to increase its encoding length.
+    pub fn legacy_weight(&self) -> Weight {
+        Weight::from_non_witness_data_size(self.base_size() as u64)
+    }
+
+    /// The weight of the TxIn when it's included in a segwit transaction (i.e., a transaction
+    /// having at least one segwit input).
+    ///
+    /// This always takes into account the witness, even when empty, in which
+    /// case 1WU for the witness length varint (`00`) is included.
+    ///
+    /// Keep in mind that when adding a TxIn to a transaction, the total weight of the transaction
+    /// might increase more than `TxIn::segwit_weight`. This happens when:
+    /// - the new input added causes the input length `VarInt` to increase its encoding length
+    /// - the new input is the first segwit input added - this will add an additional 2WU to the
+    ///   transaction weight to take into account the segwit marker
+    #[deprecated(since = "0.5.0", note = "Use `TxIn::legacy_weight` instead")]
+    pub fn segwit_weight(&self) -> Weight {
+        Weight::from_non_witness_data_size(self.base_size() as u64)
+            + Weight::from_witness_data_size(self.witness.size() as u64)
+    }
+
+    /// Returns the base size of this input.
+    ///
+    /// Base size excludes the witness data (see [`Self::total_size`]).
+    pub fn base_size(&self) -> usize {
+        let mut size = OutPoint::SIZE;
+
+        size += VarInt::from(self.script_sig.len()).size();
+        size += self.script_sig.len();
+
+        size + Sequence::SIZE
+    }
+
+    /// Returns the total number of bytes that this input contributes to a transaction.
+    ///
+    /// Total size includes the witness data (for base size see [`Self::base_size`]).
+    pub fn total_size(&self) -> usize { self.base_size() + self.witness.size() }
+}
+
+impl Default for TxIn {
+    fn default() -> TxIn {
+        TxIn {
+            previous_output: OutPoint::default(),
+            script_sig: ScriptBuf::new(),
+            sequence: Sequence::MAX,
+            witness: Witness::default(),
+        }
+    }
+}
+
+/// Bitcoin transaction input sequence number.
+///
+/// The sequence field is used for:
+/// - Indicating whether absolute lock-time (specified in `lock_time` field of [`Transaction`])
+///   is enabled.
+/// - Indicating and encoding [BIP-68] relative lock-times.
+/// - Indicating whether a transaction opts-in to [BIP-125] replace-by-fee.
+///
+/// Note that transactions spending an output with `OP_CHECKLOCKTIMEVERIFY`MUST NOT use
+/// `Sequence::MAX` for the corresponding input. [BIP-65]
+///
+/// [BIP-65]: <https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>
+/// [BIP-68]: <https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki>
+/// [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki>
+#[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 Sequence(pub u32);
+
+impl Sequence {
+    /// The maximum allowable sequence number.
+    ///
+    /// This sequence number disables absolute lock time and replace-by-fee.
+    pub const MAX: Self = Sequence(0xFFFFFFFF);
+    /// Zero value sequence.
+    ///
+    /// This sequence number enables replace-by-fee and absolute lock time.
+    pub const ZERO: Self = Sequence(0);
+    /// The sequence number that enables absolute lock time but disables replace-by-fee
+    /// and relative lock time.
+    pub const ENABLE_LOCKTIME_NO_RBF: Self = Sequence::MIN_NO_RBF;
+    /// 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);
+
+    /// The number of bytes that a sequence number contributes to the size of a transaction.
+    const SIZE: usize = 4; // Serialized length of a u32.
+
+    /// The lowest sequence number that does not opt-in for replace-by-fee.
+    ///
+    /// A transaction is considered to have opted in to replacement of itself
+    /// if any of it's inputs have a `Sequence` number less than this value
+    /// (Explicit Signalling [BIP-125]).
+    ///
+    /// [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki]>
+    const MIN_NO_RBF: Self = Sequence(0xFFFFFFFE);
+    /// BIP-68 relative lock time disable flag mask.
+    const LOCK_TIME_DISABLE_FLAG_MASK: u32 = 0x80000000;
+    /// BIP-68 relative lock time type flag mask.
+    const LOCK_TYPE_MASK: u32 = 0x00400000;
+
+    /// The maximum allowable sequence number.
+    ///
+    /// This is provided for consistency with Rust 1.41.1, newer code should use [`Sequence::MAX`].
+    #[deprecated(since = "0.31.0", note = "Use Self::MAX instead")]
+    pub const fn max_value() -> Self { Self::MAX }
+
+    /// Returns `true` if the sequence number enables absolute lock-time ([`Transaction::lock_time`]).
+    #[inline]
+    pub fn enables_absolute_lock_time(&self) -> bool { *self != Sequence::MAX }
+
+    /// Returns `true` if the sequence number indicates that the transaction is finalized.
+    ///
+    /// Instead of this method please consider using `!enables_absolute_lock_time` because it
+    /// is equivalent and improves readability for those not steeped in Bitcoin folklore.
+    ///
+    /// ## Historical note
+    ///
+    /// The term 'final' is an archaic Bitcoin term, it may have come about because the sequence
+    /// number in the original Bitcoin code was intended to be incremented in order to replace a
+    /// transaction, so once the sequence number got to `u64::MAX` it could no longer be increased,
+    /// hence it was 'final'.
+    ///
+    ///
+    /// Some other references to the term:
+    /// - `CTxIn::SEQUENCE_FINAL` in the Bitcoin Core code.
+    /// - [BIP-112]: "BIP 68 prevents a non-final transaction from being selected for inclusion in a
+    ///   block until the corresponding input has reached the specified age"
+    ///
+    /// [BIP-112]: <https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>
+    #[inline]
+    pub fn is_final(&self) -> bool { !self.enables_absolute_lock_time() }
+
+    /// Returns true if the transaction opted-in to BIP125 replace-by-fee.
+    ///
+    /// Replace by fee is signaled by the sequence being less than 0xfffffffe which is checked by
+    /// this method. Note, this is the highest "non-final" value (see [`Sequence::is_final`]).
+    #[inline]
+    pub fn is_rbf(&self) -> bool { *self < Sequence::MIN_NO_RBF }
+
+    /// Returns `true` if the sequence has a relative lock-time.
+    #[inline]
+    pub fn is_relative_lock_time(&self) -> bool {
+        self.0 & Sequence::LOCK_TIME_DISABLE_FLAG_MASK == 0
+    }
+
+    /// 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)
+    }
+
+    /// 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)
+    }
+
+    /// Creates a relative lock-time using block height.
+    #[inline]
+    pub fn from_height(height: u16) -> Self { Sequence(u32::from(height)) }
+
+    /// Creates a relative lock-time using time intervals where each interval is equivalent
+    /// to 512 seconds.
+    ///
+    /// Encoding finer granularity of time for relative lock-times is not supported in Bitcoin
+    #[inline]
+    pub fn from_512_second_intervals(intervals: u16) -> Self {
+        Sequence(u32::from(intervals) | Sequence::LOCK_TYPE_MASK)
+    }
+
+    /// Creates a relative lock-time from seconds, converting the seconds into 512 second
+    /// interval with floor division.
+    ///
+    /// Will return an error if the input cannot be encoded in 16 bits.
+    #[inline]
+    pub fn from_seconds_floor(seconds: u32) -> Result<Self, relative::Error> {
+        if let Ok(interval) = u16::try_from(seconds / 512) {
+            Ok(Sequence::from_512_second_intervals(interval))
+        } else {
+            Err(relative::Error::IntegerOverflow(seconds))
+        }
+    }
+
+    /// Creates a relative lock-time from seconds, converting the seconds into 512 second
+    /// interval with ceiling division.
+    ///
+    /// Will return an error if the input cannot be encoded in 16 bits.
+    #[inline]
+    pub fn from_seconds_ceil(seconds: u32) -> Result<Self, relative::Error> {
+        if let Ok(interval) = u16::try_from((seconds + 511) / 512) {
+            Ok(Sequence::from_512_second_intervals(interval))
+        } else {
+            Err(relative::Error::IntegerOverflow(seconds))
+        }
+    }
+
+    /// Creates a sequence from a u32 value.
+    #[inline]
+    pub fn from_consensus(n: u32) -> Self { Sequence(n) }
+
+    /// Returns the inner 32bit integer value of Sequence.
+    #[inline]
+    pub fn to_consensus_u32(self) -> u32 { self.0 }
+
+    /// Creates a [`relative::LockTime`] from this [`Sequence`] number.
+    #[inline]
+    pub fn to_relative_lock_time(&self) -> Option<relative::LockTime> {
+        use crate::locktime::relative::{Height, LockTime, Time};
+
+        if !self.is_relative_lock_time() {
+            return None;
+        }
+
+        let lock_value = self.low_u16();
+
+        if self.is_time_locked() {
+            Some(LockTime::from(Time::from_512_second_intervals(lock_value)))
+        } else {
+            Some(LockTime::from(Height::from(lock_value)))
+        }
+    }
+
+    /// Returns the low 16 bits from sequence number.
+    ///
+    /// BIP-68 only uses the low 16 bits for relative lock value.
+    fn low_u16(&self) -> u16 { self.0 as u16 }
+}
+
+impl FromHexStr for Sequence {
+    type Error = crate::parse::ParseIntError;
+
+    fn from_hex_str_no_prefix<S: AsRef<str> + Into<String>>(s: S) -> Result<Self, Self::Error> {
+        let sequence = crate::parse::hex_u32(s)?;
+        Ok(Self::from_consensus(sequence))
+    }
+}
+
+impl Default for Sequence {
+    /// The default value of sequence is 0xffffffff.
+    fn default() -> Self { Sequence::MAX }
+}
+
+impl From<Sequence> for u32 {
+    fn from(sequence: Sequence) -> u32 { sequence.0 }
+}
+
+impl fmt::Display for Sequence {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+impl fmt::LowerHex for Sequence {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
+}
+
+impl fmt::UpperHex for Sequence {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::UpperHex::fmt(&self.0, f) }
+}
+
+impl_parse_str_from_int_infallible!(Sequence, u32, from_consensus);
+
+/// Bitcoin transaction output.
+///
+/// Defines new coins to be created as a result of the transaction,
+/// along with spending conditions ("script", aka "output script"),
+/// which an input spending it must satisfy.
+///
+/// An output that is not yet spent by an input is called Unspent Transaction Output ("UTXO").
+///
+/// ### Bitcoin Core References
+///
+/// * [CTxOut definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/transaction.h#L148)
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct TxOut {
+    /// The value of the output, in tapyruses.
+    pub value: Amount,
+    /// The script which must be satisfied for the output to be spent.
+    pub script_pubkey: ScriptBuf,
+}
+
+impl TxOut {
+    /// This is used as a "null txout" in consensus signing code.
+    pub const NULL: Self =
+        TxOut { value: Amount::from_tap(0xffffffffffffffff), script_pubkey: ScriptBuf::new() };
+
+    /// The weight of this output.
+    ///
+    /// Keep in mind that when adding a [`TxOut`] to a [`Transaction`] the total weight of the
+    /// transaction might increase more than `TxOut::weight`. This happens when the new output added
+    /// causes the output length `VarInt` to increase its encoding length.
+    ///
+    /// # Panics
+    ///
+    /// If output size * 4 overflows, this should never happen under normal conditions. Use
+    /// `Weght::from_vb_checked(self.size() as u64)` if you are concerned.
+    pub fn weight(&self) -> Weight {
+        // Size is equivalent to virtual size since all bytes of a TxOut are non-witness bytes.
+        Weight::from_vb(self.size() as u64).expect("should never happen under normal conditions")
+    }
+
+    /// Returns the total number of bytes that this output contributes to a transaction.
+    ///
+    /// There is no difference between base size vs total size for outputs.
+    pub fn size(&self) -> usize { size_from_script_pubkey(&self.script_pubkey) }
+
+    /// Creates a `TxOut` with given script and the smallest possible `value` that is **not** dust
+    /// per current Core policy.
+    ///
+    /// The current dust fee rate is 3 tap/vB.
+    pub fn minimal_non_dust(script_pubkey: ScriptBuf) -> Self {
+        let len = size_from_script_pubkey(&script_pubkey);
+        let len = len
+            + if script_pubkey.is_witness_program() {
+                32 + 4 + 1 + (107 / 4) + 4
+            } else {
+                32 + 4 + 1 + 107 + 4
+            };
+        let dust_amount = (len as u64) * 3;
+
+        TxOut {
+            value: Amount::from_tap(dust_amount + 1), // minimal non-dust amount is one higher than dust amount
+            script_pubkey,
+        }
+    }
+}
+
+/// Returns the total number of bytes that this script pubkey would contribute to a transaction.
+fn size_from_script_pubkey(script_pubkey: &Script) -> usize {
+    let len = script_pubkey.len();
+    Amount::SIZE + VarInt::from(len).size() + len
+}
+
+/// Bitcoin transaction.
+///
+/// An authenticated movement of coins.
+///
+/// See [Bitcoin Wiki: Transaction][wiki-transaction] for more information.
+///
+/// [wiki-transaction]: https://en.bitcoin.it/wiki/Transaction
+///
+/// ### Bitcoin Core References
+///
+/// * [CTtransaction definition](https://github.com/bitcoin/bitcoin/blob/345457b542b6a980ccfbc868af0970a6f91d1b82/src/primitives/transaction.h#L279)
+///
+/// ### Serialization notes
+///
+/// If any inputs have nonempty witnesses, the entire transaction is serialized
+/// in the post-BIP141 Segwit format which includes a list of witnesses. If all
+/// inputs have empty witnesses, the transaction is serialized in the pre-BIP141
+/// format.
+///
+/// There is one major exception to this: to avoid deserialization ambiguity,
+/// if the transaction has no inputs, it is serialized in the BIP141 style. Be
+/// aware that this differs from the transaction format in PSBT, which _never_
+/// uses BIP141. (Ordinarily there is no conflict, since in PSBT transactions
+/// are always unsigned and therefore their inputs have empty witnesses.)
+///
+/// The specific ambiguity is that Segwit uses the flag bytes `0001` where an old
+/// serializer would read the number of transaction inputs. The old serializer
+/// would interpret this as "no inputs, one output", which means the transaction
+/// is invalid, and simply reject it. Segwit further specifies that this encoding
+/// should *only* be used when some input has a nonempty witness; that is,
+/// witness-less transactions should be encoded in the traditional format.
+///
+/// However, in protocols where transactions may legitimately have 0 inputs, e.g.
+/// when parties are cooperatively funding a transaction, the "00 means Segwit"
+/// heuristic does not work. Since Segwit requires such a transaction be encoded
+/// in the original transaction format (since it has no inputs and therefore
+/// no input witnesses), a traditionally encoded transaction may have the `0001`
+/// Segwit flag in it, which confuses most Segwit parsers including the one in
+/// Bitcoin Core.
+///
+/// We therefore deviate from the spec by always using the Segwit witness encoding
+/// for 0-input transactions, which results in unambiguously parseable transactions.
+///
+/// ### A note on ordering
+///
+/// This type implements `Ord`, even though it contains a locktime, which is not
+/// itself `Ord`. This was done to simplify applications that may need to hold
+/// transactions inside a sorted container. We have ordered the locktimes based
+/// on their representation as a `u32`, which is not a semantically meaningful
+/// order, and therefore the ordering on `Transaction` itself is not semantically
+/// meaningful either.
+///
+/// The ordering is, however, consistent with the ordering present in this library
+/// before this change, so users should not notice any breakage (here) when
+/// transitioning from 0.29 to 0.30.
+#[derive(Clone, PartialEq, Eq, Debug, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Transaction {
+    /// The protocol version, is currently expected to be 1 or 2 (BIP 68).
+    pub version: Version,
+    /// Block height or timestamp. Transaction cannot be included in a block until this height/time.
+    ///
+    /// ### Relevant BIPs
+    ///
+    /// * [BIP-65 OP_CHECKLOCKTIMEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
+    /// * [BIP-113 Median time-past as endpoint for lock-time calculations](https://github.com/bitcoin/bips/blob/master/bip-0113.mediawiki)
+    pub lock_time: absolute::LockTime,
+    /// List of transaction inputs.
+    pub input: Vec<TxIn>,
+    /// List of transaction outputs.
+    pub output: Vec<TxOut>,
+}
+
+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))
+    }
+}
+
+impl Transaction {
+    // https://github.com/bitcoin/bitcoin/blob/44b05bf3fef2468783dcebf651654fdd30717e7e/src/policy/policy.h#L27
+    /// Maximum transaction weight for Bitcoin Core 25.0.
+    pub const MAX_STANDARD_WEIGHT: Weight = Weight::from_wu(400_000);
+
+    /// Computes a "normalized TXID" which does not include any signatures.
+    ///
+    /// This gives a way to identify a transaction that is "the same" as
+    /// another in the sense of having same inputs and outputs.
+    pub fn ntxid(&self) -> sha256d::Hash {
+        let cloned_tx = Transaction {
+            version: self.version,
+            lock_time: self.lock_time,
+            input: self
+                .input
+                .iter()
+                .map(|txin| TxIn {
+                    script_sig: ScriptBuf::new(),
+                    witness: Witness::default(),
+                    ..*txin
+                })
+                .collect(),
+            output: self.output.clone(),
+        };
+        cloned_tx.txid().into()
+    }
+
+    /// Computes the [`Txid`].
+    ///
+    /// Hashes the transaction **excluding** the segwit data (i.e. the marker, flag bytes, and the
+    /// witness fields themselves). For non-segwit transactions which do not have any segwit data,
+    /// this will be equal to [`Transaction::wtxid()`].
+    pub fn txid(&self) -> Txid {
+        let mut enc = Txid::engine();
+        self.version.consensus_encode(&mut enc).expect("engines don't error");
+        self.input.consensus_encode(&mut enc).expect("engines don't error");
+        self.output.consensus_encode(&mut enc).expect("engines don't error");
+        self.lock_time.consensus_encode(&mut enc).expect("engines don't error");
+        Txid::from_engine(enc)
+    }
+
+    /// Computes the segwit version of the transaction id.
+    ///
+    /// Hashes the transaction **including** all segwit data (i.e. the marker, flag bytes, and the
+    /// witness fields themselves). For non-segwit transactions which do not have any segwit data,
+    /// this will be equal to [`Transaction::txid()`].
+    pub fn wtxid(&self) -> Wtxid {
+        let mut enc = Wtxid::engine();
+        self.consensus_encode(&mut enc).expect("engines don't error");
+        Wtxid::from_engine(enc)
+    }
+
+    /// Computes an "immutable TXID".  The double SHA256 taken from a transaction
+    /// after stripping it of all input scripts including their length prefixes.
+    pub fn malfix_txid(&self) -> MalFixTxid {
+        let mut enc = sha256d::Hash::engine();
+        self.version.consensus_encode(&mut enc).unwrap();
+        VarInt(self.input.len() as u64).consensus_encode(&mut enc).unwrap();
+        for input in &self.input {
+            input.previous_output.consensus_encode(&mut enc).unwrap();
+            input.sequence.consensus_encode(&mut enc).unwrap();
+        }
+        self.output.consensus_encode(&mut enc).unwrap();
+        self.lock_time.consensus_encode(&mut enc).unwrap();
+        MalFixTxid::from_engine(enc)
+    }
+
+    /// Returns the weight of this transaction, as defined by BIP-141.
+    ///
+    /// > Transaction weight is defined as Base transaction size * 3 + Total transaction size (ie.
+    /// > the same method as calculating Block weight from Base size and Total size).
+    ///
+    /// For transactions with an empty witness, this is simply the consensus-serialized size times
+    /// four. For transactions with a witness, this is the non-witness consensus-serialized size
+    /// multiplied by three plus the with-witness consensus-serialized size.
+    ///
+    /// For transactions with no inputs, this function will return a value 2 less than the actual
+    /// weight of the serialized transaction. The reason is that zero-input transactions, post-segwit,
+    /// cannot be unambiguously serialized; we make a choice that adds two extra bytes. For more
+    /// details see [BIP 141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    /// which uses a "input count" of `0x00` as a `marker` for a Segwit-encoded transaction.
+    ///
+    /// If you need to use 0-input transactions, we strongly recommend you do so using the PSBT
+    /// API. The unsigned transaction encoded within PSBT is always a non-segwit transaction
+    /// and can therefore avoid this ambiguity.
+    #[inline]
+    pub fn weight(&self) -> Weight {
+        // This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
+        let wu = self.base_size() * 3 + self.total_size();
+        Weight::from_wu_usize(wu)
+    }
+
+    /// Returns the base transaction size.
+    ///
+    /// > Base transaction size is the size of the transaction serialised with the witness data stripped.
+    pub fn base_size(&self) -> usize {
+        let mut size: usize = 4; // Serialized length of a u32 for the version number.
+
+        size += VarInt::from(self.input.len()).size();
+        size += self.input.iter().map(|input| input.base_size()).sum::<usize>();
+
+        size += VarInt::from(self.output.len()).size();
+        size += self.output.iter().map(|input| input.size()).sum::<usize>();
+
+        size + absolute::LockTime::SIZE
+    }
+
+    /// Returns the total transaction size.
+    ///
+    /// > Total transaction size is the transaction size in bytes serialized as described in BIP144,
+    /// > including base data and witness data.
+    #[inline]
+    pub fn total_size(&self) -> usize {
+        let mut size: usize = 4; // Serialized length of a u32 for the version number.
+
+        size += VarInt::from(self.input.len()).size();
+        size += self
+            .input
+            .iter()
+            .map(|input| { input.base_size() })
+            .sum::<usize>();
+
+        size += VarInt::from(self.output.len()).size();
+        size += self.output.iter().map(|output| output.size()).sum::<usize>();
+
+        size + absolute::LockTime::SIZE
+    }
+
+    /// Returns the "virtual size" (vsize) of this transaction.
+    ///
+    /// Will be `ceil(weight / 4.0)`. Note this implements the virtual size as per [`BIP141`], which
+    /// is different to what is implemented in Bitcoin Core. The computation should be the same for
+    /// any remotely sane transaction, and a standardness-rule-correct version is available in the
+    /// [`policy`] module.
+    ///
+    /// > Virtual transaction size is defined as Transaction weight / 4 (rounded up to the next integer).
+    ///
+    /// [`BIP141`]: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki
+    /// [`policy`]: ../../policy/index.html
+    #[inline]
+    pub fn vsize(&self) -> usize {
+        // No overflow because it's computed from data in memory
+        self.weight().to_vbytes_ceil() as usize
+    }
+
+    /// Returns the size of this transaction excluding the witness data.
+    #[deprecated(since = "0.31.0", note = "Use Transaction::base_size() instead")]
+    pub fn strippedsize(&self) -> usize { self.base_size() }
+
+    /// Checks if this is a coinbase transaction.
+    ///
+    /// The first transaction in the block distributes the mining reward and is called the coinbase
+    /// transaction. It is impossible to check if the transaction is first in the block, so this
+    /// function checks the structure of the transaction instead.
+    /// In Tapyrus, a coinbase transaction has a default txid ("0000000000000000000000000000000000000000000000000000000000000000") in its input.
+    /// See [Tapyrus Transaction Structure](https://github.com/chaintope/tapyrus-core/blob/master/doc/tapyrus/fix_transaction_malleability.md#tapyrus-transaction-structure) for more information.
+    #[doc(alias = "is_coin_base")] // method previously had this name
+    pub fn is_coinbase(&self) -> bool {
+        self.input.len() == 1 && self.input[0].previous_output.txid == Hash::all_zeros()
+    }
+
+    /// Checks if this is a coinbase transaction.
+    #[deprecated(since = "0.31.0", note = "use is_coinbase instead")]
+    pub fn is_coin_base(&self) -> bool { self.is_coinbase() }
+
+    /// Returns `true` if the transaction itself opted in to be BIP-125-replaceable (RBF).
+    ///
+    /// # Warning
+    ///
+    /// **Incorrectly relying on RBF may lead to monetary loss!**
+    ///
+    /// This **does not** cover the case where a transaction becomes replaceable due to ancestors
+    /// being RBF. Please note that transactions **may be replaced** even if they **do not** include
+    /// the RBF signal: <https://bitcoinops.org/en/newsletters/2022/10/19/#transaction-replacement-option>.
+    pub fn is_explicitly_rbf(&self) -> bool {
+        self.input.iter().any(|input| input.sequence.is_rbf())
+    }
+
+    /// Returns true if this [`Transaction`]'s absolute timelock is satisfied at `height`/`time`.
+    ///
+    /// # Returns
+    ///
+    /// By definition if the lock time is not enabled the transaction's absolute timelock is
+    /// considered to be satisfied i.e., there are no timelock constraints restricting this
+    /// transaction from being mined immediately.
+    pub fn is_absolute_timelock_satisfied(&self, height: Height, time: Time) -> bool {
+        if !self.is_lock_time_enabled() {
+            return true;
+        }
+        self.lock_time.is_satisfied_by(height, time)
+    }
+
+    /// Returns `true` if this transactions nLockTime is enabled ([BIP-65]).
+    ///
+    /// [BIP-65]: https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki
+    pub fn is_lock_time_enabled(&self) -> bool { self.input.iter().any(|i| i.enables_lock_time()) }
+
+    /// Returns an iterator over lengths of `script_pubkey`s in the outputs.
+    ///
+    /// This is useful in combination with [`predict_weight`] if you have the transaction already
+    /// constructed with a dummy value in the fee output which you'll adjust after calculating the
+    /// weight.
+    pub fn script_pubkey_lens(&self) -> impl Iterator<Item = usize> + '_ {
+        self.output.iter().map(|txout| txout.script_pubkey.len())
+    }
+
+    /// Counts the total number of sigops.
+    ///
+    /// This value is for pre-taproot transactions only.
+    ///
+    /// > In taproot, a different mechanism is used. Instead of having a global per-block limit,
+    /// > there is a per-transaction-input limit, proportional to the size of that input.
+    /// > ref: <https://bitcoin.stackexchange.com/questions/117356/what-is-sigop-signature-operation#117359>
+    ///
+    /// The `spent` parameter is a closure/function that looks up the output being spent by each input
+    /// It takes in an [`OutPoint`] and returns a [`TxOut`]. If you can't provide this, a placeholder of
+    /// `|_| None` can be used. Without access to the previous [`TxOut`], any sigops in a redeemScript (P2SH)
+    /// as well as any segwit sigops will not be counted for that input.
+    pub fn total_sigop_cost<S>(&self, mut spent: S) -> usize
+    where
+        S: FnMut(&OutPoint) -> Option<TxOut>,
+    {
+        let mut cost = self.count_p2pk_p2pkh_sigops().saturating_mul(4);
+
+        // coinbase tx is correctly handled because `spent` will always returns None.
+        cost = cost.saturating_add(self.count_p2sh_sigops(&mut spent).saturating_mul(4));
+        cost.saturating_add(self.count_witness_sigops(&mut spent))
+    }
+
+    /// Gets the sigop count.
+    ///
+    /// Counts sigops for this transaction's input scriptSigs and output scriptPubkeys i.e., doesn't
+    /// count sigops in the redeemScript for p2sh or the sigops in the witness (use
+    /// `count_p2sh_sigops` and `count_witness_sigops` respectively).
+    fn count_p2pk_p2pkh_sigops(&self) -> usize {
+        let mut count: usize = 0;
+        for input in &self.input {
+            // 0 for p2wpkh, p2wsh, and p2sh (including wrapped segwit).
+            count = count.saturating_add(input.script_sig.count_sigops_legacy());
+        }
+        for output in &self.output {
+            count = count.saturating_add(output.script_pubkey.count_sigops_legacy());
+        }
+        count
+    }
+
+    /// Does not include wrapped segwit (see `count_witness_sigops`).
+    fn count_p2sh_sigops<S>(&self, spent: &mut S) -> usize
+    where
+        S: FnMut(&OutPoint) -> Option<TxOut>,
+    {
+        fn count_sigops(prevout: &TxOut, input: &TxIn) -> usize {
+            let mut count: usize = 0;
+            if prevout.script_pubkey.is_p2sh() {
+                if let Some(redeem) = input.script_sig.last_pushdata() {
+                    count =
+                        count.saturating_add(Script::from_bytes(redeem.as_bytes()).count_sigops());
+                }
+            }
+            count
+        }
+
+        let mut count: usize = 0;
+        for input in &self.input {
+            if let Some(prevout) = spent(&input.previous_output) {
+                count = count.saturating_add(count_sigops(&prevout, input));
+            }
+        }
+        count
+    }
+
+    /// Includes wrapped segwit (returns 0 for taproot spends).
+    fn count_witness_sigops<S>(&self, spent: &mut S) -> usize
+    where
+        S: FnMut(&OutPoint) -> Option<TxOut>,
+    {
+        fn count_sigops_with_witness_program(witness: &Witness, witness_program: &Script) -> usize {
+            if witness_program.is_p2wpkh() {
+                1
+            } else if witness_program.is_p2wsh() {
+                // Treat the last item of the witness as the witnessScript
+                return witness
+                    .last()
+                    .map(Script::from_bytes)
+                    .map(|s| s.count_sigops())
+                    .unwrap_or(0);
+            } else {
+                0
+            }
+        }
+
+        fn count_sigops(prevout: TxOut, input: &TxIn) -> usize {
+            let script_sig = &input.script_sig;
+            let witness = &input.witness;
+
+            let witness_program = if prevout.script_pubkey.is_witness_program() {
+                &prevout.script_pubkey
+            } else if prevout.script_pubkey.is_p2sh() && script_sig.is_push_only() {
+                // If prevout is P2SH and scriptSig is push only
+                // then we wrap the last push (redeemScript) in a Script
+                if let Some(push_bytes) = script_sig.last_pushdata() {
+                    Script::from_bytes(push_bytes.as_bytes())
+                } else {
+                    return 0;
+                }
+            } else {
+                return 0;
+            };
+
+            // This will return 0 if the redeemScript wasn't a witness program
+            count_sigops_with_witness_program(witness, witness_program)
+        }
+
+        let mut count: usize = 0;
+        for input in &self.input {
+            if let Some(prevout) = spent(&input.previous_output) {
+                count = count.saturating_add(count_sigops(prevout, input));
+            }
+        }
+        count
+    }
+}
+
+/// The transaction version.
+///
+/// Currently, as specified by [BIP-68], only version 1 and 2 are considered standard.
+///
+/// Standardness of the inner `i32` is not an invariant because you are free to create transactions
+/// of any version, transactions with non-standard version numbers will not be relayed by the
+/// Bitcoin network.
+///
+/// [BIP-68]: https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki
+#[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Version(pub i32);
+
+impl Version {
+    /// The original Bitcoin transaction version (pre-BIP-68).
+    pub const ONE: Self = Self(1);
+
+    /// The second Bitcoin transaction version (post-BIP-68).
+    pub const TWO: Self = Self(2);
+
+    /// Creates a non-standard transaction version.
+    pub fn non_standard(version: i32) -> Version { Self(version) }
+
+    /// Returns true if this transaction version number is considered standard.
+    pub fn is_standard(&self) -> bool { *self == Version::ONE || *self == Version::TWO }
+}
+
+impl Encodable for Version {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(w)
+    }
+}
+
+impl Decodable for Version {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Decodable::consensus_decode(r).map(Version)
+    }
+}
+
+impl_consensus_encoding!(TxOut, value, script_pubkey);
+
+impl Encodable for OutPoint {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let len = self.txid.consensus_encode(w)?;
+        Ok(len + self.vout.consensus_encode(w)?)
+    }
+}
+impl Decodable for OutPoint {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(OutPoint {
+            txid: Decodable::consensus_decode(r)?,
+            vout: Decodable::consensus_decode(r)?,
+        })
+    }
+}
+
+impl Encodable for TxIn {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.previous_output.consensus_encode(w)?;
+        len += self.script_sig.consensus_encode(w)?;
+        len += self.sequence.consensus_encode(w)?;
+        Ok(len)
+    }
+}
+impl Decodable for TxIn {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        Ok(TxIn {
+            previous_output: Decodable::consensus_decode_from_finite_reader(r)?,
+            script_sig: Decodable::consensus_decode_from_finite_reader(r)?,
+            sequence: Decodable::consensus_decode_from_finite_reader(r)?,
+            witness: Witness::default(),
+        })
+    }
+}
+
+impl Encodable for Sequence {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(w)
+    }
+}
+
+impl Decodable for Sequence {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Decodable::consensus_decode(r).map(Sequence)
+    }
+}
+
+impl Encodable for Transaction {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.version.consensus_encode(w)?;
+        len += self.input.consensus_encode(w)?;
+        len += self.output.consensus_encode(w)?;
+        len += self.lock_time.consensus_encode(w)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for Transaction {
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        Ok(Transaction {
+            version: Version::consensus_decode_from_finite_reader(r)?,
+            input: Vec::<TxIn>::consensus_decode_from_finite_reader(r)?,
+            output: Decodable::consensus_decode_from_finite_reader(r)?,
+            lock_time: Decodable::consensus_decode_from_finite_reader(r)?,
+        })
+    }
+}
+
+impl From<Transaction> for Txid {
+    fn from(tx: Transaction) -> Txid { tx.txid() }
+}
+
+impl From<&Transaction> for Txid {
+    fn from(tx: &Transaction) -> Txid { tx.txid() }
+}
+
+impl From<Transaction> for Wtxid {
+    fn from(tx: Transaction) -> Wtxid { tx.wtxid() }
+}
+
+impl From<&Transaction> for Wtxid {
+    fn from(tx: &Transaction) -> Wtxid { tx.wtxid() }
+}
+
+impl From<Transaction> for MalFixTxid {
+    fn from(tx: Transaction) -> MalFixTxid { tx.malfix_txid() }
+}
+
+impl From<&Transaction> for MalFixTxid {
+    fn from(tx: &Transaction) -> MalFixTxid { tx.malfix_txid() }
+}
+
+/// Predicts the weight of a to-be-constructed transaction.
+///
+/// This function computes the weight of a transaction which is not fully known. All that is needed
+/// is the lengths of scripts and witness elements.
+///
+/// # Arguments
+///
+/// * `inputs` - an iterator which returns `InputWeightPrediction` for each input of the
+///   to-be-constructed transaction.
+/// * `output_script_lens` - an iterator which returns the length of `script_pubkey` of each output
+///   of the to-be-constructed transaction.
+///
+/// Note that lengths of the scripts and witness elements must be non-serialized, IOW *without* the
+/// preceding compact size. The lenght of preceding compact size is computed and added inside the
+/// function for convenience.
+///
+/// If you  have the transaction already constructed (except for signatures) with a dummy value for
+/// fee output you can use the return value of [`Transaction::script_pubkey_lens`] method directly
+/// as the second argument.
+///
+/// # Usage
+///
+/// When signing a transaction one doesn't know the signature before knowing the transaction fee and
+/// the transaction fee is not known before knowing the transaction size which is not known before
+/// knowing the signature. This apparent dependency cycle can be broken by knowing the length of the
+/// signature without knowing the contents of the signature e.g., we know all Schnorr signatures
+/// are 64 bytes long.
+///
+/// Additionally, some protocols may require calculating the amounts before knowing various parts
+/// of the transaction (assuming their length is known).
+///
+/// # Notes on integer overflow
+///
+/// Overflows are intentionally not checked because one of the following holds:
+///
+/// * The transaction is valid (obeys the block size limit) and the code feeds correct values to
+///   this function - no overflow can happen.
+/// * The transaction will be so large it doesn't fit in the memory - overflow will happen but
+///   then the transaction will fail to construct and even if one serialized it on disk directly
+///   it'd be invalid anyway so overflow doesn't matter.
+/// * The values fed into this function are inconsistent with the actual lengths the transaction
+///   will have - the code is already broken and checking overflows doesn't help. Unfortunately
+///   this probably cannot be avoided.
+pub fn predict_weight<I, O>(inputs: I, output_script_lens: O) -> Weight
+where
+    I: IntoIterator<Item = InputWeightPrediction>,
+    O: IntoIterator<Item = usize>,
+{
+    // This fold() does three things:
+    // 1) Counts the inputs and returns the sum as `input_count`.
+    // 2) Sums all of the input weights and returns the sum as `partial_input_weight`
+    //    For every input: script_size * 4 + witness_size
+    //    Since script_size is non-witness data, it gets a 4x multiplier.
+    // 3) Counts the number of inputs that have a witness data and returns the count as
+    //    `num_inputs_with_witnesses`.
+    let (input_count, partial_input_weight, inputs_with_witnesses) = inputs.into_iter().fold(
+        (0, 0, 0),
+        |(count, partial_input_weight, inputs_with_witnesses), prediction| {
+            (
+                count + 1,
+                partial_input_weight + prediction.script_size * 4 + prediction.witness_size,
+                inputs_with_witnesses + (prediction.witness_size > 0) as usize,
+            )
+        },
+    );
+
+    // This fold() does two things:
+    // 1) Counts the outputs and returns the sum as `output_count`.
+    // 2) Sums the output script sizes and returns the sum as `output_scripts_size`.
+    //    script_len + the length of a VarInt struct that stores the value of script_len
+    let (output_count, output_scripts_size) = output_script_lens.into_iter().fold(
+        (0, 0),
+        |(output_count, total_scripts_size), script_len| {
+            let script_size = script_len + VarInt(script_len as u64).size();
+            (output_count + 1, total_scripts_size + script_size)
+        },
+    );
+    predict_weight_internal(
+        input_count,
+        partial_input_weight,
+        inputs_with_witnesses,
+        output_count,
+        output_scripts_size,
+    )
+}
+
+const fn predict_weight_internal(
+    input_count: usize,
+    partial_input_weight: usize,
+    inputs_with_witnesses: usize,
+    output_count: usize,
+    output_scripts_size: usize,
+) -> Weight {
+    // Lengths of txid, index and sequence: (32, 4, 4).
+    // Multiply the lengths by 4 since the fields are all non-witness fields.
+    let input_weight = partial_input_weight + input_count * 4 * (32 + 4 + 4);
+
+    // The value field of a TxOut is 8 bytes.
+    let output_size = 8 * output_count + output_scripts_size;
+    let non_input_size =
+    // version:
+        4 +
+    // count varints:
+        VarInt(input_count as u64).size() +
+        VarInt(output_count as u64).size() +
+        output_size +
+    // lock_time
+        4;
+    let weight = if inputs_with_witnesses == 0 {
+        non_input_size * 4 + input_weight
+    } else {
+        non_input_size * 4 + input_weight + input_count - inputs_with_witnesses + 2
+    };
+    Weight::from_wu(weight as u64)
+}
+
+/// Predicts the weight of a to-be-constructed transaction in const context.
+///
+/// This is a `const` version of [`predict_weight`] which only allows slices due to current Rust
+/// limitations around `const fn`. Because of these limitations it may be less efficient than
+/// `predict_weight` and thus is intended to be only used in `const` context.
+///
+/// Please see the documentation of `predict_weight` to learn more about this function.
+pub const fn predict_weight_from_slices(
+    inputs: &[InputWeightPrediction],
+    output_script_lens: &[usize],
+) -> Weight {
+    let mut partial_input_weight = 0;
+    let mut inputs_with_witnesses = 0;
+
+    // for loops not supported in const fn
+    let mut i = 0;
+    while i < inputs.len() {
+        let prediction = inputs[i];
+        partial_input_weight += prediction.script_size * 4 + prediction.witness_size;
+        inputs_with_witnesses += (prediction.witness_size > 0) as usize;
+        i += 1;
+    }
+
+    let mut output_scripts_size = 0;
+
+    i = 0;
+    while i < output_script_lens.len() {
+        let script_len = output_script_lens[i];
+        output_scripts_size += script_len + VarInt(script_len as u64).size();
+        i += 1;
+    }
+
+    predict_weight_internal(
+        inputs.len(),
+        partial_input_weight,
+        inputs_with_witnesses,
+        output_script_lens.len(),
+        output_scripts_size,
+    )
+}
+
+/// Weight prediction of an individual input.
+///
+/// This helper type collects information about an input to be used in [`predict_weight`] function.
+/// It can only be created using the [`new`](InputWeightPrediction::new) function or using other
+/// associated constants/methods.
+#[derive(Copy, Clone, Debug)]
+pub struct InputWeightPrediction {
+    script_size: usize,
+    witness_size: usize,
+}
+
+impl InputWeightPrediction {
+    /// Input weight prediction corresponding to spending of P2WPKH output with the largest possible
+    /// DER-encoded signature.
+    ///
+    /// If the input in your transaction uses P2WPKH you can use this instead of
+    /// [`InputWeightPrediction::new`].
+    ///
+    /// This is useful when you **do not** use [signature grinding] and want to ensure you are not
+    /// under-paying. See [`ground_p2wpkh`](Self::ground_p2wpkh) if you do use signature grinding.
+    ///
+    /// [signature grinding]: https://bitcoin.stackexchange.com/questions/111660/what-is-signature-grinding
+    pub const P2WPKH_MAX: Self = InputWeightPrediction::from_slice(0, &[73, 33]);
+
+    /// Input weight prediction corresponding to spending of taproot output using the key and
+    /// default sighash.
+    ///
+    /// If the input in your transaction uses Taproot key spend you can use this instead of
+    /// [`InputWeightPrediction::new`].
+    pub const P2TR_KEY_DEFAULT_SIGHASH: Self = InputWeightPrediction::from_slice(0, &[64]);
+
+    /// Input weight prediction corresponding to spending of taproot output using the key and
+    /// **non**-default sighash.
+    ///
+    /// If the input in your transaction uses Taproot key spend you can use this instead of
+    /// [`InputWeightPrediction::new`].
+    pub const P2TR_KEY_NON_DEFAULT_SIGHASH: Self = InputWeightPrediction::from_slice(0, &[65]);
+
+    /// Input weight prediction corresponding to spending of P2WPKH output using [signature
+    /// grinding].
+    ///
+    /// If the input in your transaction uses P2WPKH and you use signature grinding you can use this
+    /// instead of [`InputWeightPrediction::new`]. See [`P2WPKH_MAX`](Self::P2WPKH_MAX) if you don't
+    /// use signature grinding.
+    ///
+    /// Note: `bytes_to_grind` is usually `1` because of exponential cost of higher values.
+    ///
+    /// # Panics
+    ///
+    /// The funcion panics in const context and debug builds if `bytes_to_grind` is higher than 62.
+    ///
+    /// [signature grinding]: https://bitcoin.stackexchange.com/questions/111660/what-is-signature-grinding
+    pub const fn ground_p2wpkh(bytes_to_grind: usize) -> Self {
+        // Written to trigger const/debug panic for unreasonably high values.
+        let der_signature_size = 10 + (62 - bytes_to_grind);
+        InputWeightPrediction::from_slice(0, &[der_signature_size, 33])
+    }
+
+    /// Computes the prediction for a single input.
+    pub fn new<T>(input_script_len: usize, witness_element_lengths: T) -> Self
+    where
+        T: IntoIterator,
+        T::Item: Borrow<usize>,
+    {
+        let (count, total_size) =
+            witness_element_lengths.into_iter().fold((0, 0), |(count, total_size), elem_len| {
+                let elem_len = *elem_len.borrow();
+                let elem_size = elem_len + VarInt(elem_len as u64).size();
+                (count + 1, total_size + elem_size)
+            });
+        let witness_size = if count > 0 { total_size + VarInt(count as u64).size() } else { 0 };
+        let script_size = input_script_len + VarInt(input_script_len as u64).size();
+
+        InputWeightPrediction { script_size, witness_size }
+    }
+
+    /// Computes the prediction for a single input in `const` context.
+    ///
+    /// This is a `const` version of [`new`](Self::new) which only allows slices due to current Rust
+    /// limitations around `const fn`. Because of these limitations it may be less efficient than
+    /// `new` and thus is intended to be only used in `const` context.
+    pub const fn from_slice(input_script_len: usize, witness_element_lengths: &[usize]) -> Self {
+        let mut i = 0;
+        let mut total_size = 0;
+        // for loops not supported in const fn
+        while i < witness_element_lengths.len() {
+            let elem_len = witness_element_lengths[i];
+            let elem_size = elem_len + VarInt(elem_len as u64).size();
+            total_size += elem_size;
+            i += 1;
+        }
+        let witness_size = if !witness_element_lengths.is_empty() {
+            total_size + VarInt(witness_element_lengths.len() as u64).size()
+        } else {
+            0
+        };
+        let script_size = input_script_len + VarInt(input_script_len as u64).size();
+
+        InputWeightPrediction { script_size, witness_size }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use hex::{test_hex_unwrap as hex, FromHex};
+
+    use super::*;
+    use crate::blockdata::constants::WITNESS_SCALE_FACTOR;
+    use crate::blockdata::locktime::absolute;
+    use crate::blockdata::script::ScriptBuf;
+    use crate::consensus::encode::{deserialize, serialize};
+    use crate::sighash::EcdsaSighashType;
+
+    const SOME_TX: &str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
+
+    #[test]
+    fn encode_to_unsized_writer() {
+        let mut buf = [0u8; 1024];
+        let raw_tx = hex!(SOME_TX);
+        let tx: Transaction = Decodable::consensus_decode(&mut raw_tx.as_slice()).unwrap();
+
+        let size = tx.consensus_encode(&mut &mut buf[..]).unwrap();
+        assert_eq!(size, SOME_TX.len() / 2);
+        assert_eq!(raw_tx, &buf[..size]);
+    }
+
+    #[test]
+    fn outpoint() {
+        assert_eq!(OutPoint::from_str("i don't care"), Err(ParseOutPointError::Format));
+        assert_eq!(
+            OutPoint::from_str(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:1:1"
+            ),
+            Err(ParseOutPointError::Format)
+        );
+        assert_eq!(
+            OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:"),
+            Err(ParseOutPointError::Format)
+        );
+        assert_eq!(
+            OutPoint::from_str(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:11111111111"
+            ),
+            Err(ParseOutPointError::TooLong)
+        );
+        assert_eq!(
+            OutPoint::from_str(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:01"
+            ),
+            Err(ParseOutPointError::VoutNotCanonical)
+        );
+        assert_eq!(
+            OutPoint::from_str(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:+42"
+            ),
+            Err(ParseOutPointError::VoutNotCanonical)
+        );
+        assert_eq!(
+            OutPoint::from_str("i don't care:1"),
+            Err(ParseOutPointError::MalFixTxid("i don't care".parse::<MalFixTxid>().unwrap_err()))
+        );
+        assert_eq!(
+            OutPoint::from_str(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c945X:1"
+            ),
+            Err(ParseOutPointError::MalFixTxid(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c945X"
+                    .parse::<MalFixTxid>()
+                    .unwrap_err()
+            ))
+        );
+        assert_eq!(
+            OutPoint::from_str(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:lol"
+            ),
+            Err(ParseOutPointError::Vout(crate::parse::int::<u32, _>("lol").unwrap_err()))
+        );
+
+        assert_eq!(
+            OutPoint::from_str(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:42"
+            ),
+            Ok(OutPoint {
+                txid: "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456"
+                    .parse()
+                    .unwrap(),
+                vout: 42,
+            })
+        );
+        assert_eq!(
+            OutPoint::from_str(
+                "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:0"
+            ),
+            Ok(OutPoint {
+                txid: "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456"
+                    .parse()
+                    .unwrap(),
+                vout: 0,
+            })
+        );
+    }
+
+    #[test]
+    fn txin() {
+        let txin: Result<TxIn, _> = deserialize(&hex!("a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff"));
+        assert!(txin.is_ok());
+    }
+
+    #[test]
+    fn txin_default() {
+        let txin = TxIn::default();
+        assert_eq!(txin.previous_output, OutPoint::default());
+        assert_eq!(txin.script_sig, ScriptBuf::new());
+        assert_eq!(txin.sequence, Sequence::from_consensus(0xFFFFFFFF));
+        assert_eq!(txin.previous_output, OutPoint::default());
+        assert_eq!(txin.witness.len(), 0);
+    }
+
+    #[test]
+    fn is_coinbase() {
+        let hex_coinbase_tx = Vec::<u8>::from_hex("0100000001000000000000000000000000000000000000000000000000000000000000000000000000222103addb2555f37abf8f28f11f498bec7bd1460e7243c1813847c49a7ae326a97d1cffffffff0100f2052a010000001976a914a15f16ea2ba840d178e4c19781abca5f4fb1b4c288ac00000000").unwrap();
+        let coinbase_tx: Transaction = deserialize(&hex_coinbase_tx).unwrap();
+        assert!(coinbase_tx.is_coinbase());
+        let hex_tx = Vec::<u8>::from_hex("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000").unwrap();
+        let tx: Transaction = deserialize(&hex_tx).unwrap();
+        assert!(!tx.is_coinbase());
+    }
+
+    #[test]
+    fn nonsegwit_transaction() {
+        let tx_bytes = hex!("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000");
+        let tx: Result<Transaction, _> = deserialize(&tx_bytes);
+        assert!(tx.is_ok());
+        let realtx = tx.unwrap();
+        // All these tests aren't really needed because if they fail, the hash check at the end
+        // will also fail. But these will show you where the failure is so I'll leave them in.
+        assert_eq!(realtx.version, Version::ONE);
+        assert_eq!(realtx.input.len(), 1);
+        // In particular this one is easy to get backward -- in tapyrus hashes are encoded
+        // as little-endian 256-bit numbers rather than as data strings.
+        assert_eq!(
+            format!("{:x}", realtx.input[0].previous_output.txid),
+            "ce9ea9f6f5e422c6a9dbcddb3b9a14d1c78fab9ab520cb281aa2a74a09575da1".to_string()
+        );
+        assert_eq!(realtx.input[0].previous_output.vout, 1);
+        assert_eq!(realtx.output.len(), 1);
+        assert_eq!(realtx.lock_time, absolute::LockTime::ZERO);
+
+        assert_eq!(
+            format!("{:x}", realtx.txid()),
+            "a6eab3c14ab5272a58a5ba91505ba1a4b6d7a3a9fcbd187b6cd99a7b6d548cb7".to_string()
+        );
+        assert_eq!(
+            format!("{:x}", realtx.wtxid()),
+            "a6eab3c14ab5272a58a5ba91505ba1a4b6d7a3a9fcbd187b6cd99a7b6d548cb7".to_string()
+        );
+        assert_eq!(realtx.weight().to_wu() as usize, tx_bytes.len() * WITNESS_SCALE_FACTOR);
+        assert_eq!(realtx.total_size(), tx_bytes.len());
+        assert_eq!(realtx.vsize(), tx_bytes.len());
+        assert_eq!(realtx.base_size(), tx_bytes.len());
+    }
+
+    // We temporarily abuse `Transaction` for testing consensus serde adapter.
+    #[cfg(feature = "serde")]
+    #[test]
+    fn consensus_serde() {
+        use crate::consensus::serde as con_serde;
+        let json = "\"0100000001000000000000000000000000000000000000000000000000000000000000000000000000240102210398c4a0689c455467589b5265da3b0cc16b6357a5c5f6c63f5dbed3ff079f3c50ffffffff0100f2052a010000001976a914cb111825061110d38b3d5b849dd24323d1f5559d88ac00000000\"";
+        let mut deserializer = serde_json::Deserializer::from_str(json);
+        let tx =
+            con_serde::With::<con_serde::Hex>::deserialize::<'_, Transaction, _>(&mut deserializer)
+                .unwrap();
+        let tx_bytes = Vec::from_hex(&json[1..(json.len() - 1)]).unwrap();
+        let expected = deserialize::<Transaction>(&tx_bytes).unwrap();
+        assert_eq!(tx, expected);
+        let mut bytes = Vec::new();
+        let mut serializer = serde_json::Serializer::new(&mut bytes);
+        con_serde::With::<con_serde::Hex>::serialize(&tx, &mut serializer).unwrap();
+        assert_eq!(bytes, json.as_bytes())
+    }
+
+    #[test]
+    fn transaction_version() {
+        let tx_bytes = hex!("ffffff7f0100000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
+        let tx: Result<Transaction, _> = deserialize(&tx_bytes);
+        assert!(tx.is_ok());
+        let realtx = tx.unwrap();
+        assert_eq!(realtx.version, Version::non_standard(2147483647));
+
+        let tx2_bytes = hex!("000000800100000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
+        let tx2: Result<Transaction, _> = deserialize(&tx2_bytes);
+        assert!(tx2.is_ok());
+        let realtx2 = tx2.unwrap();
+        assert_eq!(realtx2.version, Version::non_standard(-2147483648));
+    }
+
+    #[test]
+    fn tx_no_input_deserialization() {
+        let tx_bytes = hex!(
+            "01000000000100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000"
+        );
+        let tx: Transaction = deserialize(&tx_bytes).expect("deserialize tx");
+
+        assert_eq!(tx.input.len(), 0);
+        assert_eq!(tx.output.len(), 1);
+
+        let reser = serialize(&tx);
+        assert_eq!(tx_bytes, reser);
+    }
+
+    #[test]
+    fn ntxid() {
+        let tx_bytes = hex!("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000");
+        let mut tx: Transaction = deserialize(&tx_bytes).unwrap();
+
+        let old_ntxid = tx.ntxid();
+        assert_eq!(
+            format!("{:x}", old_ntxid),
+            "c3573dbea28ce24425c59a189391937e00d255150fa973d59d61caf3a06b601d"
+        );
+        // changing sigs does not affect it
+        tx.input[0].script_sig = ScriptBuf::new();
+        assert_eq!(old_ntxid, tx.ntxid());
+        // changing pks does
+        tx.output[0].script_pubkey = ScriptBuf::new();
+        assert!(old_ntxid != tx.ntxid());
+    }
+
+    #[test]
+    fn test_malfix_txid() {
+        // Paradium genesis block
+        let hex_tx = hex!(
+            "0100000001000000000000000000000000000000000000000000000000000000\
+             000000000000000000240102210398c4a0689c455467589b5265da3b0cc16b63\
+             57a5c5f6c63f5dbed3ff079f3c50ffffffff0100f2052a010000001976a914cb\
+             111825061110d38b3d5b849dd24323d1f5559d88ac00000000"
+        );
+        let tx: Transaction = deserialize(&hex_tx).unwrap();
+        assert_eq!(
+            format!("{:x}", tx.txid()),
+            "efaf069367948e9e4c99ca04cf885f41cd8dce6b9dddd310c9034f5e65396323"
+        );
+        assert_eq!(
+            format!("{:x}", tx.ntxid()),
+            "c12d06b287c4d95968071733c9e0ab33d93e2c354bc77a56dc6119913732a5dc"
+        );
+        assert_eq!(
+            format!("{:x}", tx.malfix_txid()),
+            "18ab15aaa859c9030f8c449fa074a90eb04b02fc2aca5de0ebbe851e6886efd0"
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn txn_encode_decode() {
+        let tx_bytes = hex!("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000");
+        let tx: Transaction = deserialize(&tx_bytes).unwrap();
+        serde_round_trip!(tx);
+    }
+
+    #[test]
+    fn sighashtype_fromstr_display() {
+        let sighashtypes = vec![
+            ("SIGHASH_ALL", EcdsaSighashType::All),
+            ("SIGHASH_NONE", EcdsaSighashType::None),
+            ("SIGHASH_SINGLE", EcdsaSighashType::Single),
+            ("SIGHASH_ALL|SIGHASH_ANYONECANPAY", EcdsaSighashType::AllPlusAnyoneCanPay),
+            ("SIGHASH_NONE|SIGHASH_ANYONECANPAY", EcdsaSighashType::NonePlusAnyoneCanPay),
+            ("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY", EcdsaSighashType::SinglePlusAnyoneCanPay),
+        ];
+        for (s, sht) in sighashtypes {
+            assert_eq!(sht.to_string(), s);
+            assert_eq!(EcdsaSighashType::from_str(s).unwrap(), sht);
+        }
+        let sht_mistakes = vec![
+            "SIGHASH_ALL | SIGHASH_ANYONECANPAY",
+            "SIGHASH_NONE |SIGHASH_ANYONECANPAY",
+            "SIGHASH_SINGLE| SIGHASH_ANYONECANPAY",
+            "SIGHASH_ALL SIGHASH_ANYONECANPAY",
+            "SIGHASH_NONE |",
+            "SIGHASH_SIGNLE",
+            "sighash_none",
+            "Sighash_none",
+            "SigHash_None",
+            "SigHash_NONE",
+        ];
+        for s in sht_mistakes {
+            assert_eq!(
+                EcdsaSighashType::from_str(s).unwrap_err().to_string(),
+                format!("unrecognized SIGHASH string '{}'", s)
+            );
+        }
+    }
+
+    #[test]
+    #[ignore] // TODO: re-enable this test after replace using the libbitcoinconsensus to libtapyrusconsensus
+    #[cfg(feature = "bitcoinconsensus")]
+    fn transaction_verify() {
+        use std::collections::HashMap;
+
+        use crate::blockdata::witness::Witness;
+
+        // a random recent segwit transaction from blockchain using both old and segwit inputs
+        let mut spending: Transaction = deserialize(hex!("020000000001031cfbc8f54fbfa4a33a30068841371f80dbfe166211242213188428f437445c91000000006a47304402206fbcec8d2d2e740d824d3d36cc345b37d9f65d665a99f5bd5c9e8d42270a03a8022013959632492332200c2908459547bf8dbf97c65ab1a28dec377d6f1d41d3d63e012103d7279dfb90ce17fe139ba60a7c41ddf605b25e1c07a4ddcb9dfef4e7d6710f48feffffff476222484f5e35b3f0e43f65fc76e21d8be7818dd6a989c160b1e5039b7835fc00000000171600140914414d3c94af70ac7e25407b0689e0baa10c77feffffffa83d954a62568bbc99cc644c62eb7383d7c2a2563041a0aeb891a6a4055895570000000017160014795d04cc2d4f31480d9a3710993fbd80d04301dffeffffff06fef72f000000000017a91476fd7035cd26f1a32a5ab979e056713aac25796887a5000f00000000001976a914b8332d502a529571c6af4be66399cd33379071c588ac3fda0500000000001976a914fc1d692f8de10ae33295f090bea5fe49527d975c88ac522e1b00000000001976a914808406b54d1044c429ac54c0e189b0d8061667e088ac6eb68501000000001976a914dfab6085f3a8fb3e6710206a5a959313c5618f4d88acbba20000000000001976a914eb3026552d7e3f3073457d0bee5d4757de48160d88ac0002483045022100bee24b63212939d33d513e767bc79300051f7a0d433c3fcf1e0e3bf03b9eb1d70220588dc45a9ce3a939103b4459ce47500b64e23ab118dfc03c9caa7d6bfc32b9c601210354fd80328da0f9ae6eef2b3a81f74f9a6f66761fadf96f1d1d22b1fd6845876402483045022100e29c7e3a5efc10da6269e5fc20b6a1cb8beb92130cc52c67e46ef40aaa5cac5f0220644dd1b049727d991aece98a105563416e10a5ac4221abac7d16931842d5c322012103960b87412d6e169f30e12106bdf70122aabb9eb61f455518322a18b920a4dfa887d30700")
+            .as_slice()).unwrap();
+        let spent1: Transaction = deserialize(hex!("020000000001040aacd2c49f5f3c0968cfa8caf9d5761436d95385252e3abb4de8f5dcf8a582f20000000017160014bcadb2baea98af0d9a902e53a7e9adff43b191e9feffffff96cd3c93cac3db114aafe753122bd7d1afa5aa4155ae04b3256344ecca69d72001000000171600141d9984579ceb5c67ebfbfb47124f056662fe7adbfeffffffc878dd74d3a44072eae6178bb94b9253177db1a5aaa6d068eb0e4db7631762e20000000017160014df2a48cdc53dae1aba7aa71cb1f9de089d75aac3feffffffe49f99275bc8363f5f593f4eec371c51f62c34ff11cc6d8d778787d340d6896c0100000017160014229b3b297a0587e03375ab4174ef56eeb0968735feffffff03360d0f00000000001976a9149f44b06f6ee92ddbc4686f71afe528c09727a5c788ac24281b00000000001976a9140277b4f68ff20307a2a9f9b4487a38b501eb955888ac227c0000000000001976a9148020cd422f55eef8747a9d418f5441030f7c9c7788ac0247304402204aa3bd9682f9a8e101505f6358aacd1749ecf53a62b8370b97d59243b3d6984f02200384ad449870b0e6e89c92505880411285ecd41cf11e7439b973f13bad97e53901210205b392ffcb83124b1c7ce6dd594688198ef600d34500a7f3552d67947bbe392802473044022033dfd8d190a4ae36b9f60999b217c775b96eb10dee3a1ff50fb6a75325719106022005872e4e36d194e49ced2ebcf8bb9d843d842e7b7e0eb042f4028396088d292f012103c9d7cbf369410b090480de2aa15c6c73d91b9ffa7d88b90724614b70be41e98e0247304402207d952de9e59e4684efed069797e3e2d993e9f98ec8a9ccd599de43005fe3f713022076d190cc93d9513fc061b1ba565afac574e02027c9efbfa1d7b71ab8dbb21e0501210313ad44bc030cc6cb111798c2bf3d2139418d751c1e79ec4e837ce360cc03b97a024730440220029e75edb5e9413eb98d684d62a077b17fa5b7cc19349c1e8cc6c4733b7b7452022048d4b9cae594f03741029ff841e35996ef233701c1ea9aa55c301362ea2e2f68012103590657108a72feb8dc1dec022cf6a230bb23dc7aaa52f4032384853b9f8388baf9d20700")
+            .as_slice()).unwrap();
+        let spent2: Transaction = deserialize(hex!("0200000000010166c3d39490dc827a2594c7b17b7d37445e1f4b372179649cd2ce4475e3641bbb0100000017160014e69aa750e9bff1aca1e32e57328b641b611fc817fdffffff01e87c5d010000000017a914f3890da1b99e44cd3d52f7bcea6a1351658ea7be87024830450221009eb97597953dc288de30060ba02d4e91b2bde1af2ecf679c7f5ab5989549aa8002202a98f8c3bd1a5a31c0d72950dd6e2e3870c6c5819a6c3db740e91ebbbc5ef4800121023f3d3b8e74b807e32217dea2c75c8d0bd46b8665b3a2d9b3cb310959de52a09bc9d20700")
+            .as_slice()).unwrap();
+        let spent3: Transaction = deserialize(hex!("01000000027a1120a30cef95422638e8dab9dedf720ec614b1b21e451a4957a5969afb869d000000006a47304402200ecc318a829a6cad4aa9db152adbf09b0cd2de36f47b53f5dade3bc7ef086ca702205722cda7404edd6012eedd79b2d6f24c0a0c657df1a442d0a2166614fb164a4701210372f4b97b34e9c408741cd1fc97bcc7ffdda6941213ccfde1cb4075c0f17aab06ffffffffc23b43e5a18e5a66087c0d5e64d58e8e21fcf83ce3f5e4f7ecb902b0e80a7fb6010000006b483045022100f10076a0ea4b4cf8816ed27a1065883efca230933bf2ff81d5db6258691ff75202206b001ef87624e76244377f57f0c84bc5127d0dd3f6e0ef28b276f176badb223a01210309a3a61776afd39de4ed29b622cd399d99ecd942909c36a8696cfd22fc5b5a1affffffff0200127a000000000017a914f895e1dd9b29cb228e9b06a15204e3b57feaf7cc8769311d09000000001976a9144d00da12aaa51849d2583ae64525d4a06cd70fde88ac00000000")
+            .as_slice()).unwrap();
+
+        let mut spent = HashMap::new();
+        spent.insert(spent1.malfix_txid(), spent1);
+        spent.insert(spent2.malfix_txid(), spent2);
+        spent.insert(spent3.malfix_txid(), spent3);
+        let mut spent2 = spent.clone();
+        let mut spent3 = spent.clone();
+
+        spending
+            .verify(|point: &OutPoint| {
+                if let Some(tx) = spent.remove(&point.txid) {
+                    return tx.output.get(point.vout as usize).cloned();
+                }
+                None
+            })
+            .unwrap();
+
+        // test that we fail with repeated use of same input
+        let mut double_spending = spending.clone();
+        let re_use = double_spending.input[0].clone();
+        double_spending.input.push(re_use);
+
+        assert!(double_spending
+            .verify(|point: &OutPoint| {
+                if let Some(tx) = spent2.remove(&point.txid) {
+                    return tx.output.get(point.vout as usize).cloned();
+                }
+                None
+            })
+            .is_err());
+
+        // test that we get a failure if we corrupt a signature
+        let mut witness: Vec<_> = spending.input[1].witness.to_vec();
+        witness[0][10] = 42;
+        spending.input[1].witness = Witness::from_slice(&witness);
+
+        let error = spending
+            .verify(|point: &OutPoint| {
+                if let Some(tx) = spent3.remove(&point.txid) {
+                    return tx.output.get(point.vout as usize).cloned();
+                }
+                None
+            })
+            .err()
+            .unwrap();
+
+        match error {
+            TxVerifyError::ScriptVerification(_) => {}
+            _ => panic!("Wrong error type"),
+        }
+    }
+
+    #[test]
+    fn sequence_number() {
+        let seq_final = Sequence::from_consensus(0xFFFFFFFF);
+        let seq_non_rbf = Sequence::from_consensus(0xFFFFFFFE);
+        let block_time_lock = Sequence::from_consensus(0xFFFF);
+        let unit_time_lock = Sequence::from_consensus(0x40FFFF);
+        let lock_time_disabled = Sequence::from_consensus(0x80000000);
+
+        assert!(seq_final.is_final());
+        assert!(!seq_final.is_rbf());
+        assert!(!seq_final.is_relative_lock_time());
+        assert!(!seq_non_rbf.is_rbf());
+        assert!(block_time_lock.is_relative_lock_time());
+        assert!(block_time_lock.is_height_locked());
+        assert!(block_time_lock.is_rbf());
+        assert!(unit_time_lock.is_relative_lock_time());
+        assert!(unit_time_lock.is_time_locked());
+        assert!(unit_time_lock.is_rbf());
+        assert!(!lock_time_disabled.is_relative_lock_time());
+    }
+
+    #[test]
+    fn sequence_from_str_hex_happy_path() {
+        let sequence = Sequence::from_hex_str("0xFFFFFFFF").unwrap();
+        assert_eq!(sequence, Sequence::MAX);
+    }
+
+    #[test]
+    fn sequence_from_str_hex_no_prefix_happy_path() {
+        let sequence = Sequence::from_hex_str_no_prefix("FFFFFFFF").unwrap();
+        assert_eq!(sequence, Sequence::MAX);
+    }
+
+    #[test]
+    fn sequence_from_str_hex_invalid_hex_should_err() {
+        let hex = "0xzb93";
+        let result = Sequence::from_hex_str(hex);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn txin_txout_weight() {
+        // [(is_segwit, tx_hex, expected_weight)]
+        let txs = [
+                // three legacy inputs (P2PKH)
+                ("0100000003e4d7be4314204a239d8e00691128dca7927e19a7339c7948bde56f669d27d797010000006b483045022100b988a858e2982e2daaf0755b37ad46775d6132057934877a5badc91dee2f66ff022020b967c1a2f0916007662ec609987e951baafa6d4fda23faaad70715611d6a2501210254a2dccd8c8832d4677dc6f0e562eaaa5d11feb9f1de2c50a33832e7c6190796ffffffff9e22eb1b3f24c260187d716a8a6c2a7efb5af14a30a4792a6eeac3643172379c000000006a47304402207df07f0cd30dca2cf7bed7686fa78d8a37fe9c2254dfdca2befed54e06b779790220684417b8ff9f0f6b480546a9e90ecee86a625b3ea1e4ca29b080da6bd6c5f67e01210254a2dccd8c8832d4677dc6f0e562eaaa5d11feb9f1de2c50a33832e7c6190796ffffffff1123df3bfb503b59769731da103d4371bc029f57979ebce68067768b958091a1000000006a47304402207a016023c2b0c4db9a7d4f9232fcec2193c2f119a69125ad5bcedcba56dd525e02206a734b3a321286c896759ac98ebfd9d808df47f1ce1fbfbe949891cc3134294701210254a2dccd8c8832d4677dc6f0e562eaaa5d11feb9f1de2c50a33832e7c6190796ffffffff0200c2eb0b000000001976a914e5eb3e05efad136b1405f5c2f9adb14e15a35bb488ac88cfff1b000000001976a9144846db516db3130b7a3c92253599edec6bc9630b88ac00000000", Weight::from_wu(2080)),
+                // one legacy input (P2PKH)
+                ("0100000001c336895d9fa674f8b1e294fd006b1ac8266939161600e04788c515089991b50a030000006a47304402204213769e823984b31dcb7104f2c99279e74249eacd4246dabcf2575f85b365aa02200c3ee89c84344ae326b637101a92448664a8d39a009c8ad5d147c752cbe112970121028b1b44b4903c9103c07d5a23e3c7cf7aeb0ba45ddbd2cfdce469ab197381f195fdffffff040000000000000000536a4c5058325bb7b7251cf9e36cac35d691bd37431eeea426d42cbdecca4db20794f9a4030e6cb5211fabf887642bcad98c9994430facb712da8ae5e12c9ae5ff314127d33665000bb26c0067000bb0bf00322a50c300000000000017a9145ca04fdc0a6d2f4e3f67cfeb97e438bb6287725f8750c30000000000001976a91423086a767de0143523e818d4273ddfe6d9e4bbcc88acc8465003000000001976a914c95cbacc416f757c65c942f9b6b8a20038b9b12988ac00000000", Weight::from_wu(1396)),
+            ];
+
+        let empty_transaction_weight = Transaction {
+            version: Version::TWO,
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![],
+            output: vec![],
+        }
+        .weight();
+
+        for (tx, expected_weight) in &txs {
+            let txin_weight = TxIn::legacy_weight;
+            let tx: Transaction = deserialize(Vec::from_hex(tx).unwrap().as_slice()).unwrap();
+
+            let calculated_weight = empty_transaction_weight
+                + tx.input.iter().fold(Weight::ZERO, |sum, i| sum + txin_weight(i))
+                + tx.output.iter().fold(Weight::ZERO, |sum, o| sum + o.weight());
+
+            assert_eq!(calculated_weight, *expected_weight);
+            assert_eq!(tx.weight(), *expected_weight);
+        }
+    }
+
+    #[test]
+    fn tx_sigop_count() {
+        let tx_hexes = [
+            // 12 sigops (1 P2SH 2-of-3 MS in (3x4), P2SH outs (0))
+            (
+                "010000000115fe9ec3dc964e41f5267ea26cfe505f202bf3b292627496b04bece84da9\
+                b18903000000fc004730440220442827f1085364bda58c5884cee7b289934083362db6d\
+                fb627dc46f6cdbf5793022078cfa524252c381f2a572f0c41486e2838ca94aa268f2384\
+                d0e515744bf0e1e9014730440220160e49536bb29a49c7626744ee83150174c22fa40d5\
+                8fb4cd554a907a6a7b825022045f6cf148504b334064686795f0968c689e542f475b8ef\
+                5a5fa42383948226a3014c69522103e54bc61efbcb8eeff3a5ab2a92a75272f5f6820e3\
+                8e3d28edb54beb06b86c0862103a553e30733d7a8df6d390d59cc136e2c9d9cf4e808f3\
+                b6ab009beae68dd60822210291c5a54bb8b00b6f72b90af0ac0ecaf78fab026d8eded28\
+                2ad95d4d65db268c953aeffffffff024c4f0d000000000017a9146ebf0484bd5053f727\
+                c755a750aa4c815dfa112887a06b12020000000017a91410065dd50b3a7f299fef3b1c5\
+                3b8216399916ab08700000000",
+                12,
+                return_p2sh as fn(&OutPoint) -> Option<TxOut>,
+                0,
+            ),
+            // 80 sigops (1 P2PKH ins (0), 1 BARE MS outs (20x4))
+            (
+                "0100000001628c1726fecd23331ae9ff2872341b82d2c03180aa64f9bceefe457448db\
+                e579020000006a47304402204799581a5b34ae5adca21ef22c55dbfcee58527127c95d0\
+                1413820fe7556ed970220391565b24dc47ce57fe56bf029792f821a392cdb5a3d45ed85\
+                c158997e7421390121037b2fb5b602e51c493acf4bf2d2423bcf63a09b3b99dfb7bd3c8\
+                d74733b5d66f5ffffffff011c0300000000000069512103a29472a1848105b2225f0eca\
+                5c35ada0b0abbc3c538818a53eca177f4f4dcd9621020c8fd41b65ae6b980c072c5a9f3\
+                aec9f82162c92eb4c51d914348f4390ac39122102222222222222222222222222222222\
+                222222222222222222222222222222222253ae00000000",
+                80,
+                return_none,
+                80,
+            ),
+        ];
+
+        // All we need is to trigger 3 cases for prevout
+        fn return_p2sh(_outpoint: &OutPoint) -> Option<TxOut> {
+            Some(
+                deserialize(&hex!(
+                    "cc721b000000000017a91428203c10cc8f18a77412caaa83dabaf62b8fbb0f87"
+                ))
+                .unwrap(),
+            )
+        }
+        fn return_none(_outpoint: &OutPoint) -> Option<TxOut> { None }
+
+        for (hx, expected, spent_fn, expected_none) in tx_hexes.iter() {
+            let tx_bytes = hex!(hx);
+            let tx: Transaction = deserialize(&tx_bytes).unwrap();
+            assert_eq!(tx.total_sigop_cost(spent_fn), *expected);
+            assert_eq!(tx.total_sigop_cost(return_none), *expected_none);
+        }
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use hex_lit::hex;
+    use test::{black_box, Bencher};
+
+    use super::Transaction;
+    use crate::consensus::{deserialize, Encodable};
+    use crate::EmptyWrite;
+
+    const SOME_TX: &str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
+
+    #[bench]
+    pub fn bench_transaction_size(bh: &mut Bencher) {
+        let raw_tx = hex!(SOME_TX);
+
+        let mut tx: Transaction = deserialize(&raw_tx).unwrap();
+
+        bh.iter(|| {
+            black_box(black_box(&mut tx).total_size());
+        });
+    }
+
+    #[bench]
+    pub fn bench_transaction_serialize(bh: &mut Bencher) {
+        let raw_tx = hex!(SOME_TX);
+        let tx: Transaction = deserialize(&raw_tx).unwrap();
+
+        let mut data = Vec::with_capacity(raw_tx.len());
+
+        bh.iter(|| {
+            let result = tx.consensus_encode(&mut data);
+            black_box(&result);
+            data.clear();
+        });
+    }
+
+    #[bench]
+    pub fn bench_transaction_serialize_logic(bh: &mut Bencher) {
+        let raw_tx = hex!(SOME_TX);
+        let tx: Transaction = deserialize(&raw_tx).unwrap();
+
+        bh.iter(|| {
+            let size = tx.consensus_encode(&mut EmptyWrite);
+            black_box(&size);
+        });
+    }
+
+    #[bench]
+    pub fn bench_transaction_deserialize(bh: &mut Bencher) {
+        let raw_tx = hex!(SOME_TX);
+
+        bh.iter(|| {
+            let tx: Transaction = deserialize(&raw_tx).unwrap();
+            black_box(&tx);
+        });
+    }
+}
diff --git a/tapyrus/src/blockdata/weight.rs b/tapyrus/src/blockdata/weight.rs
new file mode 100644
index 00000000..6f6fa872
--- /dev/null
+++ b/tapyrus/src/blockdata/weight.rs
@@ -0,0 +1,311 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Implements `Weight` and associated features.
+
+use core::fmt;
+use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
+
+use crate::prelude::*;
+
+/// Represents block weight - the weight of a transaction or block.
+///
+/// This is an integer newtype representing weigth in `wu`. It provides protection against mixing
+/// up the types as well as basic formatting features.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+pub struct Weight(u64);
+
+impl Weight {
+    /// 0 wu.
+    ///
+    /// Equivalent to [`MIN`](Self::MIN), may better express intent in some contexts.
+    pub const ZERO: Weight = Weight(0);
+
+    /// Minimum possible value (0 wu).
+    ///
+    /// Equivalent to [`ZERO`](Self::ZERO), may better express intent in some contexts.
+    pub const MIN: Weight = Weight(u64::MIN);
+
+    /// Maximum possible value.
+    pub const MAX: Weight = Weight(u64::MAX);
+
+    /// The factor that non-witness serialization data is multiplied by during weight calculation.
+    pub const WITNESS_SCALE_FACTOR: u64 = crate::blockdata::constants::WITNESS_SCALE_FACTOR as u64;
+
+    /// The maximum allowed weight for a block, see BIP 141 (network rule).
+    pub const MAX_BLOCK: Weight = Weight(4_000_000);
+
+    /// The minimum transaction weight for a valid serialized transaction.
+    pub const MIN_TRANSACTION: Weight = Weight(Self::WITNESS_SCALE_FACTOR * 60);
+
+    /// Directly constructs `Weight` from weight units.
+    pub const fn from_wu(wu: u64) -> Self { Weight(wu) }
+
+    /// Directly constructs `Weight` from usize weight units.
+    pub const fn from_wu_usize(wu: usize) -> Self { Weight(wu as u64) }
+
+    /// Constructs `Weight` from kilo weight units returning `None` if an overflow occurred.
+    pub fn from_kwu(wu: u64) -> Option<Self> { wu.checked_mul(1000).map(Weight) }
+
+    /// Constructs `Weight` from virtual bytes, returning `None` on overflow.
+    pub fn from_vb(vb: u64) -> Option<Self> {
+        vb.checked_mul(Self::WITNESS_SCALE_FACTOR).map(Weight::from_wu)
+    }
+
+    /// Constructs `Weight` from virtual bytes without an overflow check.
+    pub const fn from_vb_unchecked(vb: u64) -> Self { Weight::from_wu(vb * 4) }
+
+    /// Constructs `Weight` from witness size.
+    pub const fn from_witness_data_size(witness_size: u64) -> Self { Weight(witness_size) }
+
+    /// Constructs `Weight` from non-witness size.
+    pub const fn from_non_witness_data_size(non_witness_size: u64) -> Self {
+        Weight(non_witness_size * Self::WITNESS_SCALE_FACTOR)
+    }
+
+    /// Returns raw weight units.
+    ///
+    /// Can be used instead of `into()` to avoid inference issues.
+    pub const fn to_wu(self) -> u64 { self.0 }
+
+    /// Converts to kilo weight units rounding down.
+    pub const fn to_kwu_floor(self) -> u64 { self.0 / 1000 }
+
+    /// Converts to vB rounding down.
+    pub const fn to_vbytes_floor(self) -> u64 { self.0 / Self::WITNESS_SCALE_FACTOR }
+
+    /// Converts to vB rounding up.
+    pub const fn to_vbytes_ceil(self) -> u64 {
+        (self.0 + Self::WITNESS_SCALE_FACTOR - 1) / Self::WITNESS_SCALE_FACTOR
+    }
+
+    /// Checked addition.
+    ///
+    /// Computes `self + rhs` returning `None` if an overflow occurred.
+    pub fn checked_add(self, rhs: Self) -> Option<Self> { self.0.checked_add(rhs.0).map(Self) }
+
+    /// Checked subtraction.
+    ///
+    /// Computes `self - rhs` returning `None` if an overflow occurred.
+    pub fn checked_sub(self, rhs: Self) -> Option<Self> { self.0.checked_sub(rhs.0).map(Self) }
+
+    /// Checked multiplication.
+    ///
+    /// Computes `self * rhs` returning `None` if an overflow occurred.
+    pub fn checked_mul(self, rhs: u64) -> Option<Self> { self.0.checked_mul(rhs).map(Self) }
+
+    /// Checked division.
+    ///
+    /// Computes `self / rhs` returning `None` if `rhs == 0`.
+    pub fn checked_div(self, rhs: u64) -> Option<Self> { self.0.checked_div(rhs).map(Self) }
+
+    /// Scale by witness factor.
+    ///
+    /// Computes `self * WITNESS_SCALE_FACTOR` returning `None` if an overflow occurred.
+    pub fn scale_by_witness_factor(self) -> Option<Self> {
+        Self::checked_mul(self, Self::WITNESS_SCALE_FACTOR)
+    }
+}
+
+/// Alternative will display the unit.
+impl fmt::Display for Weight {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if f.alternate() {
+            write!(f, "{} wu", self.0)
+        } else {
+            fmt::Display::fmt(&self.0, f)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn weight_constructor() {
+        assert_eq!(Weight::ZERO, Weight::from_wu(0));
+        assert_eq!(Weight::ZERO, Weight::from_wu_usize(0_usize));
+    }
+
+    #[test]
+    fn kilo_weight_constructor() {
+        assert_eq!(Weight(1_000), Weight::from_kwu(1).expect("expected weight unit"));
+    }
+
+    #[test]
+    #[should_panic]
+    fn kilo_weight_constructor_panic() {
+        Weight::from_kwu(u64::MAX).expect("expected weight unit");
+    }
+
+    #[test]
+    fn from_vb() {
+        let vb = Weight::from_vb(1).expect("expected weight unit");
+        assert_eq!(Weight(4), vb);
+
+        let vb = Weight::from_vb(u64::MAX);
+        assert_eq!(None, vb);
+    }
+
+    #[test]
+    fn from_vb_unchecked() {
+        let vb = Weight::from_vb_unchecked(1);
+        assert_eq!(Weight(4), vb);
+    }
+
+    #[test]
+    #[should_panic]
+    fn from_vb_unchecked_panic() { Weight::from_vb_unchecked(u64::MAX); }
+
+    #[test]
+    fn from_witness_data_size() {
+        let witness_data_size = 1;
+        assert_eq!(Weight(witness_data_size), Weight::from_witness_data_size(witness_data_size));
+    }
+
+    #[test]
+    fn from_non_witness_data_size() {
+        assert_eq!(Weight(4), Weight::from_non_witness_data_size(1));
+    }
+
+    #[test]
+    fn to_kwu_floor() {
+        assert_eq!(1, Weight(1_000).to_kwu_floor());
+    }
+
+    #[test]
+    fn to_vb_floor() {
+        assert_eq!(1, Weight(4).to_vbytes_floor());
+        assert_eq!(1, Weight(5).to_vbytes_floor());
+    }
+
+    #[test]
+    fn to_vb_ceil() {
+        assert_eq!(1, Weight(4).to_vbytes_ceil());
+        assert_eq!(2, Weight(5).to_vbytes_ceil());
+    }
+
+    #[test]
+    fn checked_add() {
+        let result = Weight(1).checked_add(Weight(1)).expect("expected weight unit");
+        assert_eq!(Weight(2), result);
+
+        let result = Weight::MAX.checked_add(Weight(1));
+        assert_eq!(None, result);
+    }
+
+    #[test]
+    fn checked_sub() {
+        let result = Weight(1).checked_sub(Weight(1)).expect("expected weight unit");
+        assert_eq!(Weight::ZERO, result);
+
+        let result = Weight::MIN.checked_sub(Weight(1));
+        assert_eq!(None, result);
+    }
+
+    #[test]
+    fn checked_mul() {
+        let result = Weight(2).checked_mul(2).expect("expected weight unit");
+        assert_eq!(Weight(4), result);
+
+        let result = Weight::MAX.checked_mul(2);
+        assert_eq!(None, result);
+    }
+
+    #[test]
+    fn checked_div() {
+        let result = Weight(2).checked_div(2).expect("expected weight unit");
+        assert_eq!(Weight(1), result);
+
+        let result = Weight(2).checked_div(0);
+        assert_eq!(None, result);
+    }
+
+    #[test]
+    fn scale_by_witness_factor() {
+        let result = Weight(1).scale_by_witness_factor().expect("expected weight unit");
+        assert_eq!(Weight(4), result);
+
+        let result = Weight::MAX.scale_by_witness_factor();
+        assert_eq!(None, result);
+    }
+}
+
+impl From<Weight> for u64 {
+    fn from(value: Weight) -> Self { value.to_wu() }
+}
+
+impl Add for Weight {
+    type Output = Weight;
+
+    fn add(self, rhs: Weight) -> Self::Output { Weight(self.0 + rhs.0) }
+}
+
+impl AddAssign for Weight {
+    fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0 }
+}
+
+impl Sub for Weight {
+    type Output = Weight;
+
+    fn sub(self, rhs: Weight) -> Self::Output { Weight(self.0 - rhs.0) }
+}
+
+impl SubAssign for Weight {
+    fn sub_assign(&mut self, rhs: Self) { self.0 -= rhs.0 }
+}
+
+impl Mul<u64> for Weight {
+    type Output = Weight;
+
+    fn mul(self, rhs: u64) -> Self::Output { Weight(self.0 * rhs) }
+}
+
+impl Mul<Weight> for u64 {
+    type Output = Weight;
+
+    fn mul(self, rhs: Weight) -> Self::Output { Weight(self * rhs.0) }
+}
+
+impl MulAssign<u64> for Weight {
+    fn mul_assign(&mut self, rhs: u64) { self.0 *= rhs }
+}
+
+impl Div<u64> for Weight {
+    type Output = Weight;
+
+    fn div(self, rhs: u64) -> Self::Output { Weight(self.0 / rhs) }
+}
+
+impl Div<Weight> for Weight {
+    type Output = u64;
+
+    fn div(self, rhs: Weight) -> Self::Output { self.to_wu() / rhs.to_wu() }
+}
+
+impl DivAssign<u64> for Weight {
+    fn div_assign(&mut self, rhs: u64) { self.0 /= rhs }
+}
+
+impl core::iter::Sum for Weight {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = Self>,
+    {
+        Weight(iter.map(Weight::to_wu).sum())
+    }
+}
+
+impl<'a> core::iter::Sum<&'a Weight> for Weight {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = &'a Weight>,
+    {
+        iter.cloned().sum()
+    }
+}
+
+crate::parse::impl_parse_str_from_int_infallible!(Weight, u64, from_wu);
diff --git a/tapyrus/src/blockdata/witness.rs b/tapyrus/src/blockdata/witness.rs
new file mode 100644
index 00000000..d7f431b7
--- /dev/null
+++ b/tapyrus/src/blockdata/witness.rs
@@ -0,0 +1,792 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Witness
+//!
+//! This module contains the [`Witness`] struct and related methods to operate on it
+//!
+
+use core::convert::TryInto;
+use core::fmt;
+use core::ops::Index;
+
+use crate::consensus::encode::{Error, MAX_VEC_SIZE};
+use crate::consensus::{Decodable, Encodable, WriteExt};
+use crate::crypto::ecdsa;
+use crate::io::{self, Read, Write};
+use crate::prelude::*;
+use crate::sighash::EcdsaSighashType;
+use crate::taproot::TAPROOT_ANNEX_PREFIX;
+use crate::{Script, VarInt};
+
+/// The Witness is the data used to unlock tapyrus 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, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Witness {
+    /// Contains the witness `Vec<Vec<u8>>` serialization without the initial varint indicating the
+    /// number of elements (which is stored in `witness_elements`).
+    content: Vec<u8>,
+
+    /// The number of elements in the witness.
+    ///
+    /// Stored separately (instead of as a VarInt 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. This area is 4 *
+    /// stack_size bytes at the end of the content vector which stores the indices of each item.
+    indices_start: usize,
+}
+
+impl fmt::Debug for Witness {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        if f.alternate() {
+            fmt_debug_pretty(self, f)
+        } else {
+            fmt_debug(self, f)
+        }
+    }
+}
+
+fn fmt_debug(w: &Witness, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+    #[rustfmt::skip]
+    let comma_or_close = |current_index, last_index| {
+        if current_index == last_index { "]" } else { ", " }
+    };
+
+    f.write_str("Witness: { ")?;
+    write!(f, "indices: {}, ", w.witness_elements)?;
+    write!(f, "indices_start: {}, ", w.indices_start)?;
+    f.write_str("witnesses: [")?;
+
+    let instructions = w.iter();
+    match instructions.len().checked_sub(1) {
+        Some(last_instruction) => {
+            for (i, instruction) in instructions.enumerate() {
+                let bytes = instruction.iter();
+                match bytes.len().checked_sub(1) {
+                    Some(last_byte) => {
+                        f.write_str("[")?;
+                        for (j, byte) in bytes.enumerate() {
+                            write!(f, "{:#04x}", byte)?;
+                            f.write_str(comma_or_close(j, last_byte))?;
+                        }
+                    }
+                    None => {
+                        // This is possible because the varint is not part of the instruction (see Iter).
+                        write!(f, "[]")?;
+                    }
+                }
+                f.write_str(comma_or_close(i, last_instruction))?;
+            }
+        }
+        None => {
+            // Witnesses can be empty because the 0x00 var int is not stored in content.
+            write!(f, "]")?;
+        }
+    }
+
+    f.write_str(" }")
+}
+
+fn fmt_debug_pretty(w: &Witness, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+    f.write_str("Witness: {\n")?;
+    writeln!(f, "    indices: {},", w.witness_elements)?;
+    writeln!(f, "    indices_start: {},", w.indices_start)?;
+    f.write_str("    witnesses: [\n")?;
+
+    for instruction in w.iter() {
+        f.write_str("        [")?;
+        for (j, byte) in instruction.iter().enumerate() {
+            if j > 0 {
+                f.write_str(", ")?;
+            }
+            write!(f, "{:#04x}", byte)?;
+        }
+        f.write_str("],\n")?;
+    }
+
+    writeln!(f, "    ],")?;
+    writeln!(f, "}}")
+}
+
+/// An iterator returning individual witness elements.
+pub struct Iter<'a> {
+    inner: &'a [u8],
+    indices_start: usize,
+    current_index: usize,
+}
+
+impl Decodable for Witness {
+    fn consensus_decode<R: Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        let witness_elements = VarInt::consensus_decode(r)?.0 as usize;
+        // Minimum size of witness element is 1 byte, so if the count is
+        // greater than MAX_VEC_SIZE we must return an error.
+        if witness_elements > MAX_VEC_SIZE {
+            return Err(self::Error::OversizedVectorAllocation {
+                requested: witness_elements,
+                max: MAX_VEC_SIZE,
+            });
+        }
+        if witness_elements == 0 {
+            Ok(Witness::default())
+        } else {
+            // Leave space at the head for element positions.
+            // We will rotate them to the end of the Vec later.
+            let witness_index_space = witness_elements * 4;
+            let mut cursor = witness_index_space;
+
+            // this number should be determined as high enough to cover most witness, and low enough
+            // to avoid wasting space without reallocating
+            let mut content = vec![0u8; cursor + 128];
+
+            for i in 0..witness_elements {
+                let element_size_varint = VarInt::consensus_decode(r)?;
+                let element_size_varint_len = element_size_varint.size();
+                let element_size = element_size_varint.0 as usize;
+                let required_len = cursor
+                    .checked_add(element_size)
+                    .ok_or(self::Error::OversizedVectorAllocation {
+                        requested: usize::MAX,
+                        max: MAX_VEC_SIZE,
+                    })?
+                    .checked_add(element_size_varint_len)
+                    .ok_or(self::Error::OversizedVectorAllocation {
+                        requested: usize::MAX,
+                        max: MAX_VEC_SIZE,
+                    })?;
+
+                if required_len > MAX_VEC_SIZE + witness_index_space {
+                    return Err(self::Error::OversizedVectorAllocation {
+                        requested: required_len,
+                        max: MAX_VEC_SIZE,
+                    });
+                }
+
+                // We will do content.rotate_left(witness_index_space) later.
+                // Encode the position's value AFTER we rotate left.
+                encode_cursor(&mut content, 0, i, cursor - witness_index_space);
+
+                resize_if_needed(&mut content, required_len);
+                element_size_varint.consensus_encode(
+                    &mut &mut content[cursor..cursor + element_size_varint_len],
+                )?;
+                cursor += element_size_varint_len;
+                r.read_exact(&mut content[cursor..cursor + element_size])?;
+                cursor += element_size;
+            }
+            content.truncate(cursor);
+            // Index space is now at the end of the Vec
+            content.rotate_left(witness_index_space);
+            Ok(Witness { content, witness_elements, indices_start: cursor - witness_index_space })
+        }
+    }
+}
+
+/// Correctness Requirements: value must always fit within u32
+#[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 end = start + 4;
+    if end > bytes.len() {
+        None
+    } else {
+        Some(u32::from_ne_bytes(bytes[start..end].try_into().expect("is u32 size")) as usize)
+    }
+}
+
+fn resize_if_needed(vec: &mut Vec<u8>, required_len: usize) {
+    if required_len >= vec.len() {
+        let mut new_len = vec.len().max(1);
+        while new_len <= required_len {
+            new_len *= 2;
+        }
+        vec.resize(new_len, 0);
+    }
+}
+
+impl Encodable for Witness {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let len = VarInt::from(self.witness_elements);
+        len.consensus_encode(w)?;
+        let content_with_indices_len = self.content.len();
+        let indices_size = self.witness_elements * 4;
+        let content_len = content_with_indices_len - indices_size;
+        w.emit_slice(&self.content[..content_len])?;
+        Ok(content_len + len.size())
+    }
+}
+
+impl Witness {
+    /// Creates a new empty [`Witness`].
+    pub fn new() -> Self { Witness::default() }
+
+    /// Creates a witness required to spend a P2WPKH output.
+    ///
+    /// The witness will be made up of the DER encoded signature + sighash_type followed by the
+    /// serialized public key. Also useful for spending a P2SH-P2WPKH output.
+    ///
+    /// It is expected that `pubkey` is related to the secret key used to create `signature`.
+    pub fn p2wpkh(signature: &ecdsa::Signature, pubkey: &secp256k1::PublicKey) -> Witness {
+        let mut witness = Witness::new();
+        witness.push_slice(&signature.serialize());
+        witness.push_slice(&pubkey.serialize());
+        witness
+    }
+
+    /// Creates a [`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() + VarInt::from(elem.as_ref().len()).size())
+            .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 elem_len_varint = VarInt::from(elem.as_ref().len());
+            elem_len_varint
+                .consensus_encode(&mut &mut content[cursor..cursor + elem_len_varint.size()])
+                .expect("writers on vec don't errors, space granted by content_size");
+            cursor += elem_len_varint.size();
+            content[cursor..cursor + elem.as_ref().len()].copy_from_slice(elem.as_ref());
+            cursor += elem.as_ref().len();
+        }
+
+        Witness { witness_elements, content, indices_start: content_size }
+    }
+
+    /// Convenience method to create an array of byte-arrays from this witness.
+    pub fn to_vec(&self) -> Vec<Vec<u8>> { self.iter().map(|s| s.to_vec()).collect() }
+
+    /// Returns `true` if the witness contains no element.
+    pub fn is_empty(&self) -> bool { self.witness_elements == 0 }
+
+    /// Returns a struct implementing [`Iterator`].
+    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.
+    pub fn len(&self) -> usize { self.witness_elements }
+
+    /// Returns the bytes required when this Witness is consensus encoded.
+    #[deprecated(since = "0.31.0", note = "use size instead")]
+    pub fn serialized_len(&self) -> usize { self.size() }
+
+    /// Returns the number of bytes this witness contributes to a transactions total size.
+    pub fn size(&self) -> usize {
+        let mut size: usize = 0;
+
+        size += VarInt::from(self.witness_elements).size();
+        size += self
+            .iter()
+            .map(|witness_element| {
+                VarInt::from(witness_element.len()).size() + witness_element.len()
+            })
+            .sum::<usize>();
+
+        size
+    }
+
+    /// Clear the witness.
+    pub fn clear(&mut self) {
+        self.content.clear();
+        self.witness_elements = 0;
+        self.indices_start = 0;
+    }
+
+    /// Push a new element on the witness, requires an allocation.
+    pub fn push<T: AsRef<[u8]>>(&mut self, new_element: T) {
+        self.push_slice(new_element.as_ref());
+    }
+
+    /// Push a new element slice onto the witness stack.
+    fn push_slice(&mut self, new_element: &[u8]) {
+        self.witness_elements += 1;
+        let previous_content_end = self.indices_start;
+        let element_len_varint = VarInt::from(new_element.len());
+        let current_content_len = self.content.len();
+        let new_item_total_len = element_len_varint.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_varint = previous_content_end + element_len_varint.size();
+        element_len_varint
+            .consensus_encode(&mut &mut self.content[previous_content_end..end_varint])
+            .expect("writers on vec don't error, space granted through previous resize");
+        self.content[end_varint..end_varint + new_element.len()].copy_from_slice(new_element);
+    }
+
+    /// Pushes a DER-encoded ECDSA signature with a signature hash type as a new element on the
+    /// witness, requires an allocation.
+    #[deprecated(since = "0.30.0", note = "use push_ecdsa_signature instead")]
+    pub fn push_bitcoin_signature(
+        &mut self,
+        signature: &secp256k1::ecdsa::SerializedSignature,
+        hash_type: EcdsaSighashType,
+    ) {
+        // Note that a maximal length ECDSA signature is 72 bytes, plus the sighash type makes 73
+        let mut sig = [0; 73];
+        sig[..signature.len()].copy_from_slice(signature);
+        sig[signature.len()] = hash_type as u8;
+        self.push(&sig[..signature.len() + 1]);
+    }
+
+    /// Pushes, as a new element on the witness, an ECDSA signature.
+    ///
+    /// Pushes the DER encoded signature + sighash_type, requires an allocation.
+    pub fn push_ecdsa_signature(&mut self, signature: &ecdsa::Signature) {
+        self.push_slice(&signature.serialize())
+    }
+
+    fn element_at(&self, index: usize) -> Option<&[u8]> {
+        let varint = VarInt::consensus_decode(&mut &self.content[index..]).ok()?;
+        let start = index + varint.size();
+        Some(&self.content[start..start + varint.0 as usize])
+    }
+
+    /// Returns the last element in the witness, if any.
+    pub fn last(&self) -> Option<&[u8]> {
+        if self.witness_elements == 0 {
+            None
+        } else {
+            self.nth(self.witness_elements - 1)
+        }
+    }
+
+    /// Returns the second-to-last element in the witness, if any.
+    pub fn second_to_last(&self) -> Option<&[u8]> {
+        if self.witness_elements <= 1 {
+            None
+        } else {
+            self.nth(self.witness_elements - 2)
+        }
+    }
+
+    /// Return the nth element in the witness, if any
+    pub fn nth(&self, index: usize) -> Option<&[u8]> {
+        let pos = decode_cursor(&self.content, self.indices_start, index)?;
+        self.element_at(pos)
+    }
+
+    /// Get Tapscript following BIP341 rules regarding accounting for an annex.
+    ///
+    /// This does not guarantee that this represents a P2TR [`Witness`]. It
+    /// merely gets the second to last or third to last element depending on
+    /// the first byte of the last element being equal to 0x50. See
+    /// [Script::is_v1_p2tr](crate::blockdata::script::Script::is_v1_p2tr) to
+    /// check whether this is actually a Taproot witness.
+    pub fn tapscript(&self) -> Option<&Script> {
+        let len = self.len();
+        self.last()
+            .map(|last_elem| {
+                // From BIP341:
+                // If there are at least two witness elements, and the first byte of
+                // the last element is 0x50, this last element is called annex a
+                // and is removed from the witness stack.
+                if len >= 2 && last_elem.first() == Some(&TAPROOT_ANNEX_PREFIX) {
+                    // account for the extra item removed from the end
+                    3
+                } else {
+                    // otherwise script is 2nd from last
+                    2
+                }
+            })
+            .filter(|&script_pos_from_last| len >= script_pos_from_last)
+            .and_then(|script_pos_from_last| self.nth(len - script_pos_from_last))
+            .map(Script::from_bytes)
+    }
+}
+
+impl Index<usize> for Witness {
+    type Output = [u8];
+
+    fn index(&self, index: usize) -> &Self::Output { self.nth(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 varint = VarInt::consensus_decode(&mut &self.inner[index..]).ok()?;
+        let start = index + varint.size();
+        let end = start + varint.0 as usize;
+        let slice = &self.inner[start..end];
+        self.current_index += 1;
+        Some(slice)
+    }
+
+    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<'a> ExactSizeIterator for Iter<'a> {}
+
+impl<'a> IntoIterator for &'a Witness {
+    type IntoIter = Iter<'a>;
+    type Item = &'a [u8];
+
+    fn into_iter(self) -> Self::IntoIter { self.iter() }
+}
+
+// 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))?;
+
+        for elem in self.iter() {
+            if human_readable {
+                seq.serialize_element(&crate::serde_utils::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> {
+                use hex::FromHex;
+                use hex::HexToBytesError::*;
+                use serde::de::{self, Unexpected};
+
+                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 = Vec::<u8>::from_hex(&elem).map_err(|e| match e {
+                        InvalidChar(b) => match core::char::from_u32(b.into()) {
+                            Some(c) => de::Error::invalid_value(
+                                Unexpected::Char(c),
+                                &"a valid hex character",
+                            ),
+                            None => de::Error::invalid_value(
+                                Unexpected::Unsigned(b.into()),
+                                &"a valid hex character",
+                            ),
+                        },
+                        OddLengthString(len) =>
+                            de::Error::invalid_length(len, &"an even length string"),
+                    })?;
+                    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(Witness::from_slice(&vec))
+        }
+    }
+}
+
+impl From<Vec<Vec<u8>>> for Witness {
+    fn from(vec: Vec<Vec<u8>>) -> Self { Witness::from_slice(&vec) }
+}
+
+impl From<&[&[u8]]> for Witness {
+    fn from(slice: &[&[u8]]) -> Self { Witness::from_slice(slice) }
+}
+
+impl From<&[Vec<u8>]> for Witness {
+    fn from(slice: &[Vec<u8>]) -> Self { Witness::from_slice(slice) }
+}
+
+impl From<Vec<&[u8]>> for Witness {
+    fn from(vec: Vec<&[u8]>) -> Self { Witness::from_slice(&vec) }
+}
+
+#[cfg(test)]
+mod test {
+    use hex::test_hex_unwrap as hex;
+
+    use super::*;
+    use crate::consensus::{deserialize, serialize};
+
+    fn append_u32_vec(mut v: Vec<u8>, n: &[u32]) -> Vec<u8> {
+        for &num in n {
+            v.extend_from_slice(&num.to_ne_bytes());
+        }
+        v
+    }
+
+    #[test]
+    fn witness_debug_can_display_empty_instruction() {
+        let witness = Witness {
+            witness_elements: 1,
+            content: append_u32_vec(vec![], &[0]),
+            indices_start: 2,
+        };
+        println!("{:?}", witness);
+    }
+
+    #[test]
+    fn test_push() {
+        let mut witness = Witness::default();
+        assert_eq!(witness.last(), None);
+        assert_eq!(witness.second_to_last(), None);
+        assert_eq!(witness.nth(0), None);
+        assert_eq!(witness.nth(1), None);
+        assert_eq!(witness.nth(2), None);
+        assert_eq!(witness.nth(3), None);
+        witness.push(vec![0u8]);
+        let expected = Witness {
+            witness_elements: 1,
+            content: append_u32_vec(vec![1u8, 0], &[0]),
+            indices_start: 2,
+        };
+        assert_eq!(witness, expected);
+        assert_eq!(witness.last(), Some(&[0u8][..]));
+        assert_eq!(witness.second_to_last(), None);
+        assert_eq!(witness.nth(0), Some(&[0u8][..]));
+        assert_eq!(witness.nth(1), None);
+        assert_eq!(witness.nth(2), None);
+        assert_eq!(witness.nth(3), None);
+        assert_eq!(&witness[0], &[0u8][..]);
+        witness.push(vec![2u8, 3u8]);
+        let expected = Witness {
+            witness_elements: 2,
+            content: append_u32_vec(vec![1u8, 0, 2, 2, 3], &[0, 2]),
+            indices_start: 5,
+        };
+        assert_eq!(witness, expected);
+        assert_eq!(witness.last(), Some(&[2u8, 3u8][..]));
+        assert_eq!(witness.second_to_last(), Some(&[0u8][..]));
+        assert_eq!(witness.nth(0), Some(&[0u8][..]));
+        assert_eq!(witness.nth(1), Some(&[2u8, 3u8][..]));
+        assert_eq!(witness.nth(2), None);
+        assert_eq!(witness.nth(3), None);
+        assert_eq!(&witness[0], &[0u8][..]);
+        assert_eq!(&witness[1], &[2u8, 3u8][..]);
+        witness.push(vec![4u8, 5u8]);
+        let expected = Witness {
+            witness_elements: 3,
+            content: append_u32_vec(vec![1u8, 0, 2, 2, 3, 2, 4, 5], &[0, 2, 5]),
+            indices_start: 8,
+        };
+        assert_eq!(witness, expected);
+        assert_eq!(witness.last(), Some(&[4u8, 5u8][..]));
+        assert_eq!(witness.second_to_last(), Some(&[2u8, 3u8][..]));
+        assert_eq!(witness.nth(0), Some(&[0u8][..]));
+        assert_eq!(witness.nth(1), Some(&[2u8, 3u8][..]));
+        assert_eq!(witness.nth(2), Some(&[4u8, 5u8][..]));
+        assert_eq!(witness.nth(3), None);
+        assert_eq!(&witness[0], &[0u8][..]);
+        assert_eq!(&witness[1], &[2u8, 3u8][..]);
+        assert_eq!(&witness[2], &[4u8, 5u8][..]);
+    }
+
+    #[test]
+    fn test_iter_len() {
+        let mut witness = Witness::default();
+        for i in 0..5 {
+            assert_eq!(witness.iter().len(), i);
+            witness.push(vec![0u8]);
+        }
+        let mut iter = witness.iter();
+        for i in (0..=5).rev() {
+            assert_eq!(iter.len(), i);
+            iter.next();
+        }
+    }
+
+    #[test]
+    fn test_push_ecdsa_sig() {
+        // The very first signature in block 734,958
+        let sig_bytes =
+            hex!("304402207c800d698f4b0298c5aac830b822f011bb02df41eb114ade9a6702f364d5e39c0220366900d2a60cab903e77ef7dd415d46509b1f78ac78906e3296f495aa1b1b541");
+        let sig = secp256k1::ecdsa::Signature::from_der(&sig_bytes).unwrap();
+        let mut witness = Witness::default();
+        let signature = crate::ecdsa::Signature { sig, hash_ty: EcdsaSighashType::All };
+        witness.push_ecdsa_signature(&signature);
+        let expected_witness = vec![hex!(
+            "304402207c800d698f4b0298c5aac830b822f011bb02df41eb114ade9a6702f364d5e39c0220366900d2a60cab903e77ef7dd415d46509b1f78ac78906e3296f495aa1b1b54101")
+            ];
+        assert_eq!(witness.to_vec(), expected_witness);
+    }
+
+    #[test]
+    fn test_witness() {
+        let w0 = hex!("03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105");
+        let w1 = hex!("000000");
+        let witness_vec = vec![w0.clone(), w1.clone()];
+        let witness_serialized: Vec<u8> = serialize(&witness_vec);
+        let witness = Witness {
+            content: append_u32_vec(witness_serialized[1..].to_vec(), &[0, 34]),
+            witness_elements: 2,
+            indices_start: 38,
+        };
+        for (i, el) in witness.iter().enumerate() {
+            assert_eq!(witness_vec[i], el);
+        }
+        assert_eq!(witness.last(), Some(&w1[..]));
+        assert_eq!(witness.second_to_last(), Some(&w0[..]));
+        assert_eq!(witness.nth(0), Some(&w0[..]));
+        assert_eq!(witness.nth(1), Some(&w1[..]));
+        assert_eq!(witness.nth(2), None);
+        assert_eq!(&witness[0], &w0[..]);
+        assert_eq!(&witness[1], &w1[..]);
+
+        let w_into = Witness::from_slice(&witness_vec);
+        assert_eq!(w_into, witness);
+
+        assert_eq!(witness_serialized, serialize(&witness));
+    }
+
+    #[test]
+    fn test_get_tapscript() {
+        let tapscript = hex!("deadbeef");
+        let control_block = hex!("02");
+        // annex starting with 0x50 causes the branching logic.
+        let annex = hex!("50");
+
+        let witness_vec = vec![tapscript.clone(), control_block.clone()];
+        let witness_vec_annex = vec![tapscript.clone(), control_block, annex];
+
+        let witness_serialized: Vec<u8> = serialize(&witness_vec);
+        let witness_serialized_annex: Vec<u8> = serialize(&witness_vec_annex);
+
+        let witness = Witness {
+            content: append_u32_vec(witness_serialized[1..].to_vec(), &[0, 5]),
+            witness_elements: 2,
+            indices_start: 7,
+        };
+        let witness_annex = Witness {
+            content: append_u32_vec(witness_serialized_annex[1..].to_vec(), &[0, 5, 7]),
+            witness_elements: 3,
+            indices_start: 9,
+        };
+
+        // With or without annex, the tapscript should be returned.
+        assert_eq!(witness.tapscript(), Some(Script::from_bytes(&tapscript[..])));
+        assert_eq!(witness_annex.tapscript(), Some(Script::from_bytes(&tapscript[..])));
+    }
+
+    #[test]
+    fn fuzz_cases() {
+        let bytes = hex!("26ff0000000000c94ce592cf7a4cbb68eb00ce374300000057cd0000000000000026");
+        assert!(deserialize::<Witness>(&bytes).is_err()); // OversizedVectorAllocation
+
+        let bytes = hex!("24000000ffffffffffffffffffffffff");
+        assert!(deserialize::<Witness>(&bytes).is_err()); // OversizedVectorAllocation
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_serde_bincode() {
+        use bincode;
+
+        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);
+
+        let back: Witness = bincode::deserialize(&new).unwrap();
+        assert_eq!(new_witness_format, back);
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_serde_human() {
+        use serde_json;
+
+        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"]"#);
+
+        let back: Witness = serde_json::from_str(&json).unwrap();
+        assert_eq!(witness, back);
+    }
+}
+
+#[cfg(bench)]
+mod benches {
+    use test::{black_box, Bencher};
+
+    use super::Witness;
+
+    #[bench]
+    pub fn bench_big_witness_to_vec(bh: &mut Bencher) {
+        let raw_witness = [[1u8]; 5];
+        let witness = Witness::from_slice(&raw_witness);
+
+        bh.iter(|| {
+            black_box(witness.to_vec());
+        });
+    }
+
+    #[bench]
+    pub fn bench_witness_to_vec(bh: &mut Bencher) {
+        let raw_witness = vec![vec![1u8]; 3];
+        let witness = Witness::from_slice(&raw_witness);
+
+        bh.iter(|| {
+            black_box(witness.to_vec());
+        });
+    }
+}
diff --git a/tapyrus/src/consensus/encode.rs b/tapyrus/src/consensus/encode.rs
new file mode 100644
index 00000000..b3135b39
--- /dev/null
+++ b/tapyrus/src/consensus/encode.rs
@@ -0,0 +1,1318 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin consensus-encodable types.
+//!
+//! This is basically a replacement of the `Encodable` trait which does
+//! normalization of endianness etc., to ensure that the encoding matches
+//! the network consensus encoding.
+//!
+//! Essentially, anything that must go on the _disk_ or _network_ must be
+//! encoded using the `Encodable` trait, since this data must be the same for
+//! all systems. Any data going to the _user_ e.g., over JSONRPC, should use the
+//! ordinary `Encodable` trait. (This should also be the same across systems, of
+//! course, but has some critical differences from the network format e.g.,
+//! scripts come with an opcode decode, hashes are big-endian, numbers are
+//! typically big-endian decimals, etc.)
+//!
+
+use core::convert::{From, TryFrom};
+use core::{fmt, mem};
+
+use hashes::{sha256, sha256d, Hash};
+use internals::write_err;
+
+use crate::bip152::{PrefilledTransaction, ShortId};
+use crate::blockdata::block;
+use crate::blockdata::transaction::{Transaction, TxIn, TxOut};
+use crate::crypto::schnorr;
+use crate::hash_types::{BlockHash, FilterHash, FilterHeader, TxMerkleNode};
+use crate::io::{self, Cursor, Read};
+#[cfg(feature = "std")]
+use crate::p2p::{
+    address::{AddrV2Message, Address},
+    message_blockdata::Inventory,
+};
+use crate::prelude::*;
+use crate::taproot::TapLeafHash;
+
+/// Encoding error.
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum Error {
+    /// And I/O error.
+    Io(io::Error),
+    /// key error
+    Key(crate::crypto::key::Error),
+    /// Tried to allocate an oversized vector.
+    OversizedVectorAllocation {
+        /// The capacity requested.
+        requested: usize,
+        /// The maximum capacity.
+        max: usize,
+    },
+    /// Checksum was invalid.
+    InvalidChecksum {
+        /// The expected checksum.
+        expected: [u8; 4],
+        /// The invalid checksum.
+        actual: [u8; 4],
+    },
+    /// VarInt was encoded in a non-minimal way.
+    NonMinimalVarInt,
+    /// Parsing error.
+    ParseFailed(&'static str),
+    /// Unsupported Segwit flag.
+    UnsupportedSegwitFlag(u8),
+    /// Invalid Xfield
+    UnknownXField(u8),
+    /// XField was None which is unexpected as a hash
+    XFieldNone,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            Io(ref e) => write_err!(f, "IO error"; e),
+            Error::Key(ref e) => write!(f, "Key error: {}", e),
+            OversizedVectorAllocation { requested: ref r, max: ref m } =>
+                write!(f, "allocation of oversized vector: requested {}, maximum {}", r, m),
+            InvalidChecksum { expected: ref e, actual: ref a } =>
+                write!(f, "invalid checksum: expected {:x}, actual {:x}", e.as_hex(), a.as_hex()),
+            NonMinimalVarInt => write!(f, "non-minimal varint"),
+            ParseFailed(ref s) => write!(f, "parse failed: {}", s),
+            UnsupportedSegwitFlag(ref swflag) =>
+                write!(f, "unsupported segwit version: {}", swflag),
+            UnknownXField(ref tp) => write!(f, "Unknown XField. XField type: {}", tp),
+            XFieldNone => write!(f, "XField type None cannot be hashed or signed"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match self {
+            Io(e) => Some(e),
+            Error::Key(ref e) => Some(e),
+            OversizedVectorAllocation { .. }
+            | InvalidChecksum { .. }
+            | NonMinimalVarInt
+            | ParseFailed(_)
+            | UnsupportedSegwitFlag(_)
+            | UnknownXField(_)
+            | XFieldNone => None ,
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(error: io::Error) -> Self { Error::Io(error) }
+}
+
+/// Encodes an object into a vector.
+pub fn serialize<T: Encodable + ?Sized>(data: &T) -> Vec<u8> {
+    let mut encoder = Vec::new();
+    let len = data.consensus_encode(&mut encoder).expect("in-memory writers don't error");
+    debug_assert_eq!(len, encoder.len());
+    encoder
+}
+
+/// Encodes an object into a hex-encoded string.
+pub fn serialize_hex<T: Encodable + ?Sized>(data: &T) -> String {
+    serialize(data).to_lower_hex_string()
+}
+
+/// Deserializes an object from a vector, will error if said deserialization
+/// doesn't consume the entire vector.
+pub fn deserialize<T: Decodable>(data: &[u8]) -> Result<T, Error> {
+    let (rv, consumed) = deserialize_partial(data)?;
+
+    // Fail if data are not consumed entirely.
+    if consumed == data.len() {
+        Ok(rv)
+    } else {
+        Err(Error::ParseFailed("data not consumed entirely when explicitly deserializing"))
+    }
+}
+
+/// Deserializes an object from a vector, but will not report an error if said deserialization
+/// doesn't consume the entire vector.
+pub fn deserialize_partial<T: Decodable>(data: &[u8]) -> Result<(T, usize), Error> {
+    let mut decoder = Cursor::new(data);
+    let rv = Decodable::consensus_decode_from_finite_reader(&mut decoder)?;
+    let consumed = decoder.position() as usize;
+
+    Ok((rv, consumed))
+}
+
+/// 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 boolean.
+    fn emit_bool(&mut self, v: bool) -> Result<(), io::Error>;
+
+    /// Outputs a byte slice.
+    fn emit_slice(&mut self, v: &[u8]) -> Result<(), 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, Error>;
+    /// Reads a 32-bit unsigned integer.
+    fn read_u32(&mut self) -> Result<u32, Error>;
+    /// Reads a 16-bit unsigned integer.
+    fn read_u16(&mut self) -> Result<u16, Error>;
+    /// Reads an 8-bit unsigned integer.
+    fn read_u8(&mut self) -> Result<u8, Error>;
+
+    /// Reads a 64-bit signed integer.
+    fn read_i64(&mut self) -> Result<i64, Error>;
+    /// Reads a 32-bit signed integer.
+    fn read_i32(&mut self) -> Result<i32, Error>;
+    /// Reads a 16-bit signed integer.
+    fn read_i16(&mut self) -> Result<i16, Error>;
+    /// Reads an 8-bit signed integer.
+    fn read_i8(&mut self) -> Result<i8, Error>;
+
+    /// Reads a boolean.
+    fn read_bool(&mut self) -> Result<bool, Error>;
+
+    /// Reads a byte slice.
+    fn read_slice(&mut self, slice: &mut [u8]) -> Result<(), Error>;
+}
+
+macro_rules! encoder_fn {
+    ($name:ident, $val_type:ty) => {
+        #[inline]
+        fn $name(&mut self, v: $val_type) -> 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) -> Result<$val_type, Error> {
+            let mut val = [0; $byte_len];
+            self.read_exact(&mut val[..]).map_err(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(&[v as u8]) }
+    #[inline]
+    fn emit_slice(&mut self, v: &[u8]) -> Result<(), io::Error> { self.write_all(v) }
+}
+
+impl<R: 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, Error> {
+        let mut slice = [0u8; 1];
+        self.read_exact(&mut slice)?;
+        Ok(slice[0])
+    }
+    #[inline]
+    fn read_i8(&mut self) -> Result<i8, Error> {
+        let mut slice = [0u8; 1];
+        self.read_exact(&mut slice)?;
+        Ok(slice[0] as i8)
+    }
+    #[inline]
+    fn read_bool(&mut self) -> Result<bool, Error> { ReadExt::read_i8(self).map(|bit| bit != 0) }
+    #[inline]
+    fn read_slice(&mut self, slice: &mut [u8]) -> Result<(), Error> {
+        self.read_exact(slice).map_err(Error::Io)
+    }
+}
+
+/// Maximum size, in bytes, of a vector we are allowed to decode.
+pub const MAX_VEC_SIZE: usize = 4_000_000;
+
+/// Data which can be encoded in a consensus-consistent way.
+pub trait Encodable {
+    /// Encodes an object with a well-defined format.
+    ///
+    /// # Returns
+    ///
+    /// The number of bytes written on success. The only errors returned are errors propagated from
+    /// the writer.
+    fn consensus_encode<W: io::Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error>;
+}
+
+/// Data which can be encoded in a consensus-consistent way.
+pub trait Decodable: Sized {
+    /// Decode `Self` from a size-limited reader.
+    ///
+    /// Like `consensus_decode` but relies on the reader being limited in the amount of data it
+    /// returns, e.g. by being wrapped in [`std::io::Take`].
+    ///
+    /// Failing to abide to this requirement might lead to memory exhaustion caused by malicious
+    /// inputs.
+    ///
+    /// Users should default to `consensus_decode`, but when data to be decoded is already in a byte
+    /// vector of a limited size, calling this function directly might be marginally faster (due to
+    /// avoiding extra checks).
+    ///
+    /// ### Rules for trait implementations
+    ///
+    /// * Simple types that that have a fixed size (own and member fields), don't have to overwrite
+    ///   this method, or be concern with it.
+    /// * Types that deserialize using externally provided length should implement it:
+    ///   * Make `consensus_decode` forward to `consensus_decode_bytes_from_finite_reader` with the
+    ///     reader wrapped by `Take`. Failure to do so, without other forms of memory exhaustion
+    ///     protection might lead to resource exhaustion vulnerability.
+    ///   * Put a max cap on things like `Vec::with_capacity` to avoid oversized allocations, and
+    ///     rely on the reader running out of data, and collections reallocating on a legitimately
+    ///     oversized input data, instead of trying to enforce arbitrary length limits.
+    /// * Types that contain other types that implement custom
+    ///   `consensus_decode_from_finite_reader`, should also implement it applying same rules, and
+    ///   in addition make sure to call `consensus_decode_from_finite_reader` on all members, to
+    ///   avoid creating redundant `Take` wrappers. Failure to do so might result only in a tiny
+    ///   performance hit.
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(
+        reader: &mut R,
+    ) -> Result<Self, Error> {
+        // This method is always strictly less general than, `consensus_decode`, so it's safe and
+        // make sense to default to just calling it. This way most types, that don't care about
+        // protecting against resource exhaustion due to malicious input, can just ignore it.
+        Self::consensus_decode(reader)
+    }
+
+    /// Decode an object with a well-defined format.
+    ///
+    /// This is the method that should be implemented for a typical, fixed sized type
+    /// implementing this trait. Default implementation is wrapping the reader
+    /// in [`crate::io::Take`] to limit the input size to [`MAX_VEC_SIZE`], and forwards the call to
+    /// [`Self::consensus_decode_from_finite_reader`], which is convenient
+    /// for types that override [`Self::consensus_decode_from_finite_reader`]
+    /// instead.
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(reader: &mut R) -> Result<Self, Error> {
+        Self::consensus_decode_from_finite_reader(reader.take(MAX_VEC_SIZE as u64).by_ref())
+    }
+}
+
+/// A variable-length unsigned integer.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
+pub struct VarInt(pub u64);
+
+/// Data and a 4-byte checksum.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct CheckedData {
+    data: Vec<u8>,
+    checksum: [u8; 4],
+}
+
+impl CheckedData {
+    /// Creates a new `CheckedData` computing the checksum of given data.
+    pub fn new(data: Vec<u8>) -> Self {
+        let checksum = sha2_checksum(&data);
+        Self { data, checksum }
+    }
+
+    /// Returns a reference to the raw data without the checksum.
+    pub fn data(&self) -> &[u8] { &self.data }
+
+    /// Returns the raw data without the checksum.
+    pub fn into_data(self) -> Vec<u8> { self.data }
+
+    /// Returns the checksum of the data.
+    pub fn checksum(&self) -> [u8; 4] { self.checksum }
+}
+
+// Primitive types
+macro_rules! impl_int_encodable {
+    ($ty:ident, $meth_dec:ident, $meth_enc:ident) => {
+        impl Decodable for $ty {
+            #[inline]
+            fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+                ReadExt::$meth_dec(r)
+            }
+        }
+        impl Encodable for $ty {
+            #[inline]
+            fn consensus_encode<W: io::Write + ?Sized>(
+                &self,
+                w: &mut W,
+            ) -> Result<usize, io::Error> {
+                w.$meth_enc(*self)?;
+                Ok(mem::size_of::<$ty>())
+            }
+        }
+    };
+}
+
+impl_int_encodable!(u8, read_u8, emit_u8);
+impl_int_encodable!(u16, read_u16, emit_u16);
+impl_int_encodable!(u32, read_u32, emit_u32);
+impl_int_encodable!(u64, read_u64, emit_u64);
+impl_int_encodable!(i8, read_i8, emit_i8);
+impl_int_encodable!(i16, read_i16, emit_i16);
+impl_int_encodable!(i32, read_i32, emit_i32);
+impl_int_encodable!(i64, read_i64, emit_i64);
+
+#[allow(clippy::len_without_is_empty)] // VarInt has on concept of 'is_empty'.
+impl VarInt {
+    /// Gets the length of this VarInt when encoded.
+    #[inline]
+    #[deprecated(since = "0.31.0", note = "use size instead")]
+    pub const fn len(&self) -> usize { self.size() }
+
+    /// Returns the number of bytes this varint contributes to a transaction size.
+    ///
+    /// Returns 1 for 0..=0xFC, 3 for 0xFD..=(2^16-1), 5 for 0x10000..=(2^32-1), and 9 otherwise.
+    #[inline]
+    pub const fn size(&self) -> usize {
+        match self.0 {
+            0..=0xFC => 1,
+            0xFD..=0xFFFF => 3,
+            0x10000..=0xFFFFFFFF => 5,
+            _ => 9,
+        }
+    }
+}
+
+/// Implements `From<T> for VarInt`.
+///
+/// `VarInt`s are consensus encoded as `u64`s so we store them as such. Casting from any integer size smaller than or equal to `u64` is always safe and the cast value is correctly handled by `consensus_encode`.
+macro_rules! impl_var_int_from {
+    ($($ty:tt),*) => {
+        $(
+            /// Creates a `VarInt` from a `usize` by casting the to a `u64`.
+            impl From<$ty> for VarInt {
+                fn from(x: $ty) -> Self { VarInt(x as u64) }
+            }
+        )*
+    }
+}
+impl_var_int_from!(u8, u16, u32, u64, usize);
+
+impl Encodable for VarInt {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        match self.0 {
+            0..=0xFC => {
+                (self.0 as u8).consensus_encode(w)?;
+                Ok(1)
+            }
+            0xFD..=0xFFFF => {
+                w.emit_u8(0xFD)?;
+                (self.0 as u16).consensus_encode(w)?;
+                Ok(3)
+            }
+            0x10000..=0xFFFFFFFF => {
+                w.emit_u8(0xFE)?;
+                (self.0 as u32).consensus_encode(w)?;
+                Ok(5)
+            }
+            _ => {
+                w.emit_u8(0xFF)?;
+                self.0.consensus_encode(w)?;
+                Ok(9)
+            }
+        }
+    }
+}
+
+impl Decodable for VarInt {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        let n = ReadExt::read_u8(r)?;
+        match n {
+            0xFF => {
+                let x = ReadExt::read_u64(r)?;
+                if x < 0x100000000 {
+                    Err(self::Error::NonMinimalVarInt)
+                } else {
+                    Ok(VarInt::from(x))
+                }
+            }
+            0xFE => {
+                let x = ReadExt::read_u32(r)?;
+                if x < 0x10000 {
+                    Err(self::Error::NonMinimalVarInt)
+                } else {
+                    Ok(VarInt::from(x))
+                }
+            }
+            0xFD => {
+                let x = ReadExt::read_u16(r)?;
+                if x < 0xFD {
+                    Err(self::Error::NonMinimalVarInt)
+                } else {
+                    Ok(VarInt::from(x))
+                }
+            }
+            n => Ok(VarInt::from(n)),
+        }
+    }
+}
+
+impl Encodable for bool {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        w.emit_bool(*self)?;
+        Ok(1)
+    }
+}
+
+impl Decodable for bool {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<bool, Error> {
+        ReadExt::read_bool(r)
+    }
+}
+
+impl Encodable for String {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let b = self.as_bytes();
+        let vi_len = VarInt(b.len() as u64).consensus_encode(w)?;
+        w.emit_slice(b)?;
+        Ok(vi_len + b.len())
+    }
+}
+
+impl Decodable for String {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<String, Error> {
+        String::from_utf8(Decodable::consensus_decode(r)?)
+            .map_err(|_| self::Error::ParseFailed("String was not valid UTF8"))
+    }
+}
+
+impl Encodable for Cow<'static, str> {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let b = self.as_bytes();
+        let vi_len = VarInt(b.len() as u64).consensus_encode(w)?;
+        w.emit_slice(b)?;
+        Ok(vi_len + b.len())
+    }
+}
+
+impl Decodable for Cow<'static, str> {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Cow<'static, str>, Error> {
+        String::from_utf8(Decodable::consensus_decode(r)?)
+            .map_err(|_| self::Error::ParseFailed("String was not valid UTF8"))
+            .map(Cow::Owned)
+    }
+}
+
+macro_rules! impl_array {
+    ( $size:literal ) => {
+        impl Encodable for [u8; $size] {
+            #[inline]
+            fn consensus_encode<W: WriteExt + ?Sized>(
+                &self,
+                w: &mut W,
+            ) -> Result<usize, io::Error> {
+                w.emit_slice(&self[..])?;
+                Ok(self.len())
+            }
+        }
+
+        impl Decodable for [u8; $size] {
+            #[inline]
+            fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+                let mut ret = [0; $size];
+                r.read_slice(&mut ret)?;
+                Ok(ret)
+            }
+        }
+    };
+}
+
+impl_array!(2);
+impl_array!(4);
+impl_array!(6);
+impl_array!(8);
+impl_array!(10);
+impl_array!(12);
+impl_array!(16);
+impl_array!(32);
+impl_array!(33);
+
+impl Decodable for [u16; 8] {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        let mut res = [0; 8];
+        for item in &mut res {
+            *item = Decodable::consensus_decode(r)?;
+        }
+        Ok(res)
+    }
+}
+
+impl Encodable for [u16; 8] {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        for c in self.iter() {
+            c.consensus_encode(w)?;
+        }
+        Ok(16)
+    }
+}
+
+macro_rules! impl_vec {
+    ($type: ty) => {
+        impl Encodable for Vec<$type> {
+            #[inline]
+            fn consensus_encode<W: io::Write + ?Sized>(
+                &self,
+                w: &mut W,
+            ) -> Result<usize, io::Error> {
+                let mut len = 0;
+                len += VarInt(self.len() as u64).consensus_encode(w)?;
+                for c in self.iter() {
+                    len += c.consensus_encode(w)?;
+                }
+                Ok(len)
+            }
+        }
+
+        impl Decodable for Vec<$type> {
+            #[inline]
+            fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(
+                r: &mut R,
+            ) -> Result<Self, Error> {
+                let len = VarInt::consensus_decode_from_finite_reader(r)?.0;
+                // Do not allocate upfront more items than if the sequence of type
+                // occupied roughly quarter a block. This should never be the case
+                // for normal data, but even if that's not true - `push` will just
+                // reallocate.
+                // Note: OOM protection relies on reader eventually running out of
+                // data to feed us.
+                let max_capacity = MAX_VEC_SIZE / 4 / mem::size_of::<$type>();
+                let mut ret = Vec::with_capacity(core::cmp::min(len as usize, max_capacity));
+                for _ in 0..len {
+                    ret.push(Decodable::consensus_decode_from_finite_reader(r)?);
+                }
+                Ok(ret)
+            }
+        }
+    };
+}
+impl_vec!(BlockHash);
+impl_vec!(block::Header);
+impl_vec!(FilterHash);
+impl_vec!(FilterHeader);
+impl_vec!(TxMerkleNode);
+impl_vec!(Transaction);
+impl_vec!(TxOut);
+impl_vec!(TxIn);
+impl_vec!(Vec<u8>);
+impl_vec!(u64);
+impl_vec!(TapLeafHash);
+impl_vec!(VarInt);
+impl_vec!(ShortId);
+impl_vec!(PrefilledTransaction);
+
+#[cfg(feature = "std")]
+impl_vec!(Inventory);
+#[cfg(feature = "std")]
+impl_vec!((u32, Address));
+#[cfg(feature = "std")]
+impl_vec!(AddrV2Message);
+
+pub(crate) fn consensus_encode_with_size<W: io::Write>(
+    data: &[u8],
+    mut w: W,
+) -> Result<usize, io::Error> {
+    let vi_len = VarInt(data.len() as u64).consensus_encode(&mut w)?;
+    w.emit_slice(data)?;
+    Ok(vi_len + data.len())
+}
+
+struct ReadBytesFromFiniteReaderOpts {
+    len: usize,
+    chunk_size: usize,
+}
+
+/// Read `opts.len` bytes from reader, where `opts.len` could potentially be malicious.
+///
+/// This function relies on reader being bound in amount of data
+/// it returns for OOM protection. See [`Decodable::consensus_decode_from_finite_reader`].
+#[inline]
+fn read_bytes_from_finite_reader<D: io::Read>(
+    mut d: D,
+    mut opts: ReadBytesFromFiniteReaderOpts,
+) -> Result<Vec<u8>, Error> {
+    let mut ret = vec![];
+
+    assert_ne!(opts.chunk_size, 0);
+
+    while opts.len > 0 {
+        let chunk_start = ret.len();
+        let chunk_size = core::cmp::min(opts.len, opts.chunk_size);
+        let chunk_end = chunk_start + chunk_size;
+        ret.resize(chunk_end, 0u8);
+        d.read_slice(&mut ret[chunk_start..chunk_end])?;
+        opts.len -= chunk_size;
+    }
+
+    Ok(ret)
+}
+
+impl Encodable for Vec<u8> {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        consensus_encode_with_size(self, w)
+    }
+}
+
+impl Decodable for Vec<u8> {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        let len = VarInt::consensus_decode(r)?.0 as usize;
+        // most real-world vec of bytes data, wouldn't be larger than 128KiB
+        let opts = ReadBytesFromFiniteReaderOpts { len, chunk_size: 128 * 1024 };
+        read_bytes_from_finite_reader(r, opts)
+    }
+}
+
+impl Encodable for Box<[u8]> {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        consensus_encode_with_size(self, w)
+    }
+}
+
+impl Decodable for Box<[u8]> {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        <Vec<u8>>::consensus_decode_from_finite_reader(r).map(From::from)
+    }
+}
+
+/// Does a double-SHA256 on `data` and returns the first 4 bytes.
+fn sha2_checksum(data: &[u8]) -> [u8; 4] {
+    let checksum = <sha256d::Hash as Hash>::hash(data);
+    [checksum[0], checksum[1], checksum[2], checksum[3]]
+}
+
+impl Encodable for CheckedData {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        u32::try_from(self.data.len())
+            .expect("network message use u32 as length")
+            .consensus_encode(w)?;
+        self.checksum().consensus_encode(w)?;
+        w.emit_slice(&self.data)?;
+        Ok(8 + self.data.len())
+    }
+}
+
+impl Decodable for CheckedData {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        let len = u32::consensus_decode_from_finite_reader(r)? as usize;
+
+        let checksum = <[u8; 4]>::consensus_decode_from_finite_reader(r)?;
+        let opts = ReadBytesFromFiniteReaderOpts { len, chunk_size: MAX_VEC_SIZE };
+        let data = read_bytes_from_finite_reader(r, opts)?;
+        let expected_checksum = sha2_checksum(&data);
+        if expected_checksum != checksum {
+            Err(self::Error::InvalidChecksum { expected: expected_checksum, actual: checksum })
+        } else {
+            Ok(CheckedData { data, checksum })
+        }
+    }
+}
+
+impl<'a, T: Encodable> Encodable for &'a T {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        (**self).consensus_encode(w)
+    }
+}
+
+impl<'a, T: Encodable> Encodable for &'a mut T {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        (**self).consensus_encode(w)
+    }
+}
+
+impl<T: Encodable> Encodable for rc::Rc<T> {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        (**self).consensus_encode(w)
+    }
+}
+
+/// Note: This will fail to compile on old Rust for targets that don't support atomics
+#[cfg(any(not(rust_v_1_60), target_has_atomic = "ptr"))]
+impl<T: Encodable> Encodable for sync::Arc<T> {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        (**self).consensus_encode(w)
+    }
+}
+
+macro_rules! tuple_encode {
+    ($($x:ident),*) => {
+        impl <$($x: Encodable),*> Encodable for ($($x),*) {
+            #[inline]
+            #[allow(non_snake_case)]
+            fn consensus_encode<W: io::Write + ?Sized>(
+                &self,
+                w: &mut W,
+            ) -> Result<usize, io::Error> {
+                let &($(ref $x),*) = self;
+                let mut len = 0;
+                $(len += $x.consensus_encode(w)?;)*
+                Ok(len)
+            }
+        }
+
+        impl<$($x: Decodable),*> Decodable for ($($x),*) {
+            #[inline]
+            #[allow(non_snake_case)]
+            fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+                Ok(($({let $x = Decodable::consensus_decode(r)?; $x }),*))
+            }
+        }
+    };
+}
+
+tuple_encode!(T0, T1);
+tuple_encode!(T0, T1, T2);
+tuple_encode!(T0, T1, T2, T3);
+tuple_encode!(T0, T1, T2, T3, T4);
+tuple_encode!(T0, T1, T2, T3, T4, T5);
+tuple_encode!(T0, T1, T2, T3, T4, T5, T6);
+tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
+
+impl Encodable for sha256d::Hash {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.as_byte_array().consensus_encode(w)
+    }
+}
+
+impl Decodable for sha256d::Hash {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        Ok(Self::from_byte_array(<<Self as Hash>::Bytes>::consensus_decode(r)?))
+    }
+}
+
+impl Encodable for sha256::Hash {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.as_byte_array().consensus_encode(w)
+    }
+}
+
+impl Decodable for sha256::Hash {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        Ok(Self::from_byte_array(<<Self as Hash>::Bytes>::consensus_decode(r)?))
+    }
+}
+
+impl Encodable for TapLeafHash {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.as_byte_array().consensus_encode(w)
+    }
+}
+
+impl Decodable for TapLeafHash {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        Ok(Self::from_byte_array(<<Self as Hash>::Bytes>::consensus_decode(r)?))
+    }
+}
+
+// option
+macro_rules! impl_option {
+    ($type: ty) => {
+        impl Encodable for Option<$type> {
+            #[inline]
+            fn consensus_encode<W: io::Write + ?Sized>(
+                &self,
+                w: &mut W,
+            ) -> Result<usize, io::Error> {
+                let mut len = 0;
+                match self {
+                    Some(c) => {
+                        len += VarInt(serialize(c).len() as u64).consensus_encode(w)?;
+                        len += c.consensus_encode(w)?;
+                    }
+                    None => {
+                        len += VarInt(0).consensus_encode(w)?;
+                    }
+                }
+                Ok(len)
+            }
+        }
+
+        impl Decodable for Option<$type> {
+            #[inline]
+            fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+                let len = VarInt::consensus_decode(r)?.0;
+                if len == 0 {
+                    return Ok(None);
+                }
+                let ret = Decodable::consensus_decode(r)?;
+                if len != serialize(&ret).len() as u64 {
+                    return Err(Error::ParseFailed("Invalid length"));
+                }
+                Ok(Some(ret))
+            }
+        }
+    };
+}
+impl_option!(schnorr::Signature);
+
+#[cfg(test)]
+mod tests {
+    use core::fmt;
+    use core::mem::{self, discriminant};
+
+    use super::*;
+    use crate::consensus::{deserialize_partial, Decodable, Encodable};
+    #[cfg(feature = "std")]
+    use crate::p2p::{message_blockdata::Inventory, Address};
+
+    #[test]
+    fn serialize_int_test() {
+        // bool
+        assert_eq!(serialize(&false), vec![0u8]);
+        assert_eq!(serialize(&true), vec![1u8]);
+        // u8
+        assert_eq!(serialize(&1u8), vec![1u8]);
+        assert_eq!(serialize(&0u8), vec![0u8]);
+        assert_eq!(serialize(&255u8), vec![255u8]);
+        // u16
+        assert_eq!(serialize(&1u16), vec![1u8, 0]);
+        assert_eq!(serialize(&256u16), vec![0u8, 1]);
+        assert_eq!(serialize(&5000u16), vec![136u8, 19]);
+        // u32
+        assert_eq!(serialize(&1u32), vec![1u8, 0, 0, 0]);
+        assert_eq!(serialize(&256u32), vec![0u8, 1, 0, 0]);
+        assert_eq!(serialize(&5000u32), vec![136u8, 19, 0, 0]);
+        assert_eq!(serialize(&500000u32), vec![32u8, 161, 7, 0]);
+        assert_eq!(serialize(&168430090u32), vec![10u8, 10, 10, 10]);
+        // i32
+        assert_eq!(serialize(&-1i32), vec![255u8, 255, 255, 255]);
+        assert_eq!(serialize(&-256i32), vec![0u8, 255, 255, 255]);
+        assert_eq!(serialize(&-5000i32), vec![120u8, 236, 255, 255]);
+        assert_eq!(serialize(&-500000i32), vec![224u8, 94, 248, 255]);
+        assert_eq!(serialize(&-168430090i32), vec![246u8, 245, 245, 245]);
+        assert_eq!(serialize(&1i32), vec![1u8, 0, 0, 0]);
+        assert_eq!(serialize(&256i32), vec![0u8, 1, 0, 0]);
+        assert_eq!(serialize(&5000i32), vec![136u8, 19, 0, 0]);
+        assert_eq!(serialize(&500000i32), vec![32u8, 161, 7, 0]);
+        assert_eq!(serialize(&168430090i32), vec![10u8, 10, 10, 10]);
+        // u64
+        assert_eq!(serialize(&1u64), vec![1u8, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq!(serialize(&256u64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
+        assert_eq!(serialize(&5000u64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
+        assert_eq!(serialize(&500000u64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
+        assert_eq!(serialize(&723401728380766730u64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
+        // i64
+        assert_eq!(serialize(&-1i64), vec![255u8, 255, 255, 255, 255, 255, 255, 255]);
+        assert_eq!(serialize(&-256i64), vec![0u8, 255, 255, 255, 255, 255, 255, 255]);
+        assert_eq!(serialize(&-5000i64), vec![120u8, 236, 255, 255, 255, 255, 255, 255]);
+        assert_eq!(serialize(&-500000i64), vec![224u8, 94, 248, 255, 255, 255, 255, 255]);
+        assert_eq!(
+            serialize(&-723401728380766730i64),
+            vec![246u8, 245, 245, 245, 245, 245, 245, 245]
+        );
+        assert_eq!(serialize(&1i64), vec![1u8, 0, 0, 0, 0, 0, 0, 0]);
+        assert_eq!(serialize(&256i64), vec![0u8, 1, 0, 0, 0, 0, 0, 0]);
+        assert_eq!(serialize(&5000i64), vec![136u8, 19, 0, 0, 0, 0, 0, 0]);
+        assert_eq!(serialize(&500000i64), vec![32u8, 161, 7, 0, 0, 0, 0, 0]);
+        assert_eq!(serialize(&723401728380766730i64), vec![10u8, 10, 10, 10, 10, 10, 10, 10]);
+    }
+
+    #[test]
+    fn serialize_varint_test() {
+        assert_eq!(serialize(&VarInt(10)), vec![10u8]);
+        assert_eq!(serialize(&VarInt(0xFC)), vec![0xFCu8]);
+        assert_eq!(serialize(&VarInt(0xFD)), vec![0xFDu8, 0xFD, 0]);
+        assert_eq!(serialize(&VarInt(0xFFF)), vec![0xFDu8, 0xFF, 0xF]);
+        assert_eq!(serialize(&VarInt(0xF0F0F0F)), vec![0xFEu8, 0xF, 0xF, 0xF, 0xF]);
+        assert_eq!(
+            serialize(&VarInt(0xF0F0F0F0F0E0)),
+            vec![0xFFu8, 0xE0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0, 0]
+        );
+        assert_eq!(
+            test_varint_encode(0xFF, &0x100000000_u64.to_le_bytes()).unwrap(),
+            VarInt(0x100000000)
+        );
+        assert_eq!(test_varint_encode(0xFE, &0x10000_u64.to_le_bytes()).unwrap(), VarInt(0x10000));
+        assert_eq!(test_varint_encode(0xFD, &0xFD_u64.to_le_bytes()).unwrap(), VarInt(0xFD));
+
+        // Test that length calc is working correctly
+        test_varint_len(VarInt(0), 1);
+        test_varint_len(VarInt(0xFC), 1);
+        test_varint_len(VarInt(0xFD), 3);
+        test_varint_len(VarInt(0xFFFF), 3);
+        test_varint_len(VarInt(0x10000), 5);
+        test_varint_len(VarInt(0xFFFFFFFF), 5);
+        test_varint_len(VarInt(0xFFFFFFFF + 1), 9);
+        test_varint_len(VarInt(u64::MAX), 9);
+    }
+
+    fn test_varint_len(varint: VarInt, expected: usize) {
+        let mut encoder = vec![];
+        assert_eq!(varint.consensus_encode(&mut encoder).unwrap(), expected);
+        assert_eq!(varint.size(), expected);
+    }
+
+    fn test_varint_encode(n: u8, x: &[u8]) -> Result<VarInt, Error> {
+        let mut input = [0u8; 9];
+        input[0] = n;
+        input[1..x.len() + 1].copy_from_slice(x);
+        deserialize_partial::<VarInt>(&input).map(|t| t.0)
+    }
+
+    #[test]
+    fn deserialize_nonminimal_vec() {
+        // Check the edges for variant int
+        assert_eq!(
+            discriminant(
+                &test_varint_encode(0xFF, &(0x100000000_u64 - 1).to_le_bytes()).unwrap_err()
+            ),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+        assert_eq!(
+            discriminant(&test_varint_encode(0xFE, &(0x10000_u64 - 1).to_le_bytes()).unwrap_err()),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+        assert_eq!(
+            discriminant(&test_varint_encode(0xFD, &(0xFD_u64 - 1).to_le_bytes()).unwrap_err()),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+
+        assert_eq!(
+            discriminant(&deserialize::<Vec<u8>>(&[0xfd, 0x00, 0x00]).unwrap_err()),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+        assert_eq!(
+            discriminant(&deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]).unwrap_err()),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+        assert_eq!(
+            discriminant(&deserialize::<Vec<u8>>(&[0xfd, 0xfc, 0x00]).unwrap_err()),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+        assert_eq!(
+            discriminant(&deserialize::<Vec<u8>>(&[0xfe, 0xff, 0x00, 0x00, 0x00]).unwrap_err()),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+        assert_eq!(
+            discriminant(&deserialize::<Vec<u8>>(&[0xfe, 0xff, 0xff, 0x00, 0x00]).unwrap_err()),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+        assert_eq!(
+            discriminant(
+                &deserialize::<Vec<u8>>(&[0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+                    .unwrap_err()
+            ),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+        assert_eq!(
+            discriminant(
+                &deserialize::<Vec<u8>>(&[0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00])
+                    .unwrap_err()
+            ),
+            discriminant(&Error::NonMinimalVarInt)
+        );
+
+        let mut vec_256 = vec![0; 259];
+        vec_256[0] = 0xfd;
+        vec_256[1] = 0x00;
+        vec_256[2] = 0x01;
+        assert!(deserialize::<Vec<u8>>(&vec_256).is_ok());
+
+        let mut vec_253 = vec![0; 256];
+        vec_253[0] = 0xfd;
+        vec_253[1] = 0xfd;
+        vec_253[2] = 0x00;
+        assert!(deserialize::<Vec<u8>>(&vec_253).is_ok());
+    }
+
+    #[test]
+    fn serialize_checkeddata_test() {
+        let cd = CheckedData::new(vec![1u8, 2, 3, 4, 5]);
+        assert_eq!(serialize(&cd), vec![5, 0, 0, 0, 162, 107, 175, 90, 1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn serialize_vector_test() {
+        assert_eq!(serialize(&vec![1u8, 2, 3]), vec![3u8, 1, 2, 3]);
+        // TODO: test vectors of more interesting objects
+    }
+
+    #[test]
+    fn serialize_strbuf_test() {
+        assert_eq!(serialize(&"Andrew".to_string()), vec![6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]);
+    }
+
+    #[test]
+    fn deserialize_int_test() {
+        // bool
+        assert!((deserialize(&[58u8, 0]) as Result<bool, _>).is_err());
+        assert_eq!(deserialize(&[58u8]).ok(), Some(true));
+        assert_eq!(deserialize(&[1u8]).ok(), Some(true));
+        assert_eq!(deserialize(&[0u8]).ok(), Some(false));
+        assert!((deserialize(&[0u8, 1]) as Result<bool, _>).is_err());
+
+        // u8
+        assert_eq!(deserialize(&[58u8]).ok(), Some(58u8));
+
+        // u16
+        assert_eq!(deserialize(&[0x01u8, 0x02]).ok(), Some(0x0201u16));
+        assert_eq!(deserialize(&[0xABu8, 0xCD]).ok(), Some(0xCDABu16));
+        assert_eq!(deserialize(&[0xA0u8, 0x0D]).ok(), Some(0xDA0u16));
+        let failure16: Result<u16, _> = deserialize(&[1u8]);
+        assert!(failure16.is_err());
+
+        // i16
+        assert_eq!(deserialize(&[0x32_u8, 0xF4]).ok(), Some(-0x0bce_i16));
+        assert_eq!(deserialize(&[0xFF_u8, 0xFE]).ok(), Some(-0x0101_i16));
+        assert_eq!(deserialize(&[0x00_u8, 0x00]).ok(), Some(-0_i16));
+        assert_eq!(deserialize(&[0xFF_u8, 0xFA]).ok(), Some(-0x0501_i16));
+
+        // u32
+        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABu32));
+        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD]).ok(), Some(0xCDAB0DA0u32));
+
+        let failure32: Result<u32, _> = deserialize(&[1u8, 2, 3]);
+        assert!(failure32.is_err());
+
+        // i32
+        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0]).ok(), Some(0xCDABi32));
+        assert_eq!(deserialize(&[0xA0u8, 0x0D, 0xAB, 0x2D]).ok(), Some(0x2DAB0DA0i32));
+
+        assert_eq!(deserialize(&[0, 0, 0, 0]).ok(), Some(-0_i32));
+        assert_eq!(deserialize(&[0, 0, 0, 0]).ok(), Some(0_i32));
+
+        assert_eq!(deserialize(&[0xFF, 0xFF, 0xFF, 0xFF]).ok(), Some(-1_i32));
+        assert_eq!(deserialize(&[0xFE, 0xFF, 0xFF, 0xFF]).ok(), Some(-2_i32));
+        assert_eq!(deserialize(&[0x01, 0xFF, 0xFF, 0xFF]).ok(), Some(-255_i32));
+        assert_eq!(deserialize(&[0x02, 0xFF, 0xFF, 0xFF]).ok(), Some(-254_i32));
+
+        let failurei32: Result<i32, _> = deserialize(&[1u8, 2, 3]);
+        assert!(failurei32.is_err());
+
+        // u64
+        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABu64));
+        assert_eq!(
+            deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(),
+            Some(0x99000099CDAB0DA0u64)
+        );
+        let failure64: Result<u64, _> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
+        assert!(failure64.is_err());
+
+        // i64
+        assert_eq!(deserialize(&[0xABu8, 0xCD, 0, 0, 0, 0, 0, 0]).ok(), Some(0xCDABi64));
+        assert_eq!(
+            deserialize(&[0xA0u8, 0x0D, 0xAB, 0xCD, 0x99, 0, 0, 0x99]).ok(),
+            Some(-0x66ffff663254f260i64)
+        );
+        assert_eq!(
+            deserialize(&[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]).ok(),
+            Some(-1_i64)
+        );
+        assert_eq!(
+            deserialize(&[0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]).ok(),
+            Some(-2_i64)
+        );
+        assert_eq!(
+            deserialize(&[0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]).ok(),
+            Some(-255_i64)
+        );
+        assert_eq!(
+            deserialize(&[0x02, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]).ok(),
+            Some(-254_i64)
+        );
+
+        let failurei64: Result<i64, _> = deserialize(&[1u8, 2, 3, 4, 5, 6, 7]);
+        assert!(failurei64.is_err());
+    }
+
+    #[test]
+    fn deserialize_vec_test() {
+        assert_eq!(deserialize(&[3u8, 2, 3, 4]).ok(), Some(vec![2u8, 3, 4]));
+        assert!((deserialize(&[4u8, 2, 3, 4, 5, 6]) as Result<Vec<u8>, _>).is_err());
+        // found by cargo fuzz
+        assert!(deserialize::<Vec<u64>>(&[
+            0xff, 0xff, 0xff, 0xff, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b,
+            0x6b, 0x6b, 0xa, 0xa, 0x3a
+        ])
+        .is_err());
+
+        let rand_io_err = Error::Io(io::Error::new(io::ErrorKind::Other, ""));
+
+        // Check serialization that `if len > MAX_VEC_SIZE {return err}` isn't inclusive,
+        // by making sure it fails with IO Error and not an `OversizedVectorAllocation` Error.
+        let err =
+            deserialize::<CheckedData>(&serialize(&(super::MAX_VEC_SIZE as u32))).unwrap_err();
+        assert_eq!(discriminant(&err), discriminant(&rand_io_err));
+
+        test_len_is_max_vec::<u8>();
+        test_len_is_max_vec::<BlockHash>();
+        test_len_is_max_vec::<FilterHash>();
+        test_len_is_max_vec::<TxMerkleNode>();
+        test_len_is_max_vec::<Transaction>();
+        test_len_is_max_vec::<TxOut>();
+        test_len_is_max_vec::<TxIn>();
+        test_len_is_max_vec::<Vec<u8>>();
+        test_len_is_max_vec::<u64>();
+        #[cfg(feature = "std")]
+        test_len_is_max_vec::<(u32, Address)>();
+        #[cfg(feature = "std")]
+        test_len_is_max_vec::<Inventory>();
+    }
+
+    fn test_len_is_max_vec<T>()
+    where
+        Vec<T>: Decodable,
+        T: fmt::Debug,
+    {
+        let rand_io_err = Error::Io(io::Error::new(io::ErrorKind::Other, ""));
+        let varint = VarInt((super::MAX_VEC_SIZE / mem::size_of::<T>()) as u64);
+        let err = deserialize::<Vec<T>>(&serialize(&varint)).unwrap_err();
+        assert_eq!(discriminant(&err), discriminant(&rand_io_err));
+    }
+
+    #[test]
+    fn deserialize_strbuf_test() {
+        assert_eq!(
+            deserialize(&[6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]).ok(),
+            Some("Andrew".to_string())
+        );
+        assert_eq!(
+            deserialize(&[6u8, 0x41, 0x6e, 0x64, 0x72, 0x65, 0x77]).ok(),
+            Some(Cow::Borrowed("Andrew"))
+        );
+    }
+
+    #[test]
+    fn deserialize_checkeddata_test() {
+        let cd: Result<CheckedData, _> =
+            deserialize(&[5u8, 0, 0, 0, 162, 107, 175, 90, 1, 2, 3, 4, 5]);
+        assert_eq!(cd.ok(), Some(CheckedData::new(vec![1u8, 2, 3, 4, 5])));
+    }
+
+    #[test]
+    fn limit_read_test() {
+        let witness = vec![vec![0u8; 3_999_999]; 2];
+        let ser = serialize(&witness);
+        let mut reader = io::Cursor::new(ser);
+        let err = Vec::<Vec<u8>>::consensus_decode(&mut reader);
+        assert!(err.is_err());
+    }
+
+    #[test]
+    #[cfg(feature = "rand-std")]
+    fn serialization_round_trips() {
+        use secp256k1::rand::{thread_rng, Rng};
+
+        macro_rules! round_trip {
+            ($($val_type:ty),*) => {
+                $(
+                    let r: $val_type = thread_rng().gen();
+                    assert_eq!(deserialize::<$val_type>(&serialize(&r)).unwrap(), r);
+                )*
+            };
+        }
+        macro_rules! round_trip_bytes {
+            ($(($val_type:ty, $data:expr)),*) => {
+                $(
+                    thread_rng().fill(&mut $data[..]);
+                    assert_eq!(deserialize::<$val_type>(&serialize(&$data)).unwrap()[..], $data[..]);
+                )*
+            };
+        }
+
+        let mut data = Vec::with_capacity(256);
+        let mut data64 = Vec::with_capacity(256);
+        for _ in 0..10 {
+            round_trip! {bool, i8, u8, i16, u16, i32, u32, i64, u64,
+            (bool, i8, u16, i32), (u64, i64, u32, i32, u16, i16), (i8, u8, i16, u16, i32, u32, i64, u64),
+            [u8; 2], [u8; 4], [u8; 8], [u8; 12], [u8; 16], [u8; 32]};
+
+            data.clear();
+            data64.clear();
+            let len = thread_rng().gen_range(1..256);
+            data.resize(len, 0u8);
+            data64.resize(len, 0u64);
+            let mut arr33 = [0u8; 33];
+            let mut arr16 = [0u16; 8];
+            round_trip_bytes! {(Vec<u8>, data), ([u8; 33], arr33), ([u16; 8], arr16), (Vec<u64>, data64)};
+        }
+    }
+
+    #[test]
+    fn test_read_bytes_from_finite_reader() {
+        let data: Vec<u8> = (0..10).collect();
+
+        for chunk_size in 1..20 {
+            assert_eq!(
+                read_bytes_from_finite_reader(
+                    io::Cursor::new(&data),
+                    ReadBytesFromFiniteReaderOpts { len: data.len(), chunk_size }
+                )
+                .unwrap(),
+                data
+            );
+        }
+    }
+
+    #[test]
+    fn serialize_option_test() {
+        let none: Option<schnorr::Signature> = None;
+        assert_eq!(vec![0], serialize(&none));
+
+        let some: Option<schnorr::Signature> = Some(Default::default());
+        let expected = vec![
+            64, 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, 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,
+        ];
+        assert_eq!(expected, serialize(&some));
+    }
+}
diff --git a/tapyrus/src/consensus/mod.rs b/tapyrus/src/consensus/mod.rs
new file mode 100644
index 00000000..454ac924
--- /dev/null
+++ b/tapyrus/src/consensus/mod.rs
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin consensus.
+//!
+//! This module defines structures, functions, and traits that are needed to
+//! conform to Bitcoin consensus.
+//!
+
+pub mod encode;
+pub mod params;
+#[cfg(feature = "bitcoinconsensus")]
+pub mod validation;
+
+pub use self::encode::{
+    deserialize, deserialize_partial, serialize, Decodable, Encodable, ReadExt, WriteExt,
+};
+pub use self::params::Params;
+#[cfg(feature = "bitcoinconsensus")]
+pub use self::validation::{
+    verify_script, verify_script_with_flags, verify_transaction, verify_transaction_with_flags,
+};
+
+#[cfg(feature = "serde")]
+pub mod serde;
diff --git a/tapyrus/src/consensus/params.rs b/tapyrus/src/consensus/params.rs
new file mode 100644
index 00000000..9e231c47
--- /dev/null
+++ b/tapyrus/src/consensus/params.rs
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin consensus parameters.
+//!
+//! This module provides a predefined set of parameters for different Bitcoin
+//! chains (such as mainnet, testnet).
+//!
+
+use crate::network::Network;
+
+/// Parameters that influence chain consensus.
+#[non_exhaustive]
+#[derive(Debug, Clone)]
+pub struct Params {
+    /// Network for which parameters are valid.
+    pub network: Network,
+}
+
+impl Params {
+    /// Creates parameters set for the given network.
+    pub fn new(network: Network) -> Self { Params { network } }
+}
diff --git a/tapyrus/src/consensus/serde.rs b/tapyrus/src/consensus/serde.rs
new file mode 100644
index 00000000..387238e6
--- /dev/null
+++ b/tapyrus/src/consensus/serde.rs
@@ -0,0 +1,573 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Serde serialization via consensus encoding
+//!
+//! This provides functions for (de)serializing any type as consensus-encoded bytes.
+//! For human-readable formats it serializes as a string with a consumer-supplied encoding, for
+//! binary formats it serializes as a sequence of bytes (not `serialize_bytes` to avoid allocations).
+//!
+//! The string encoding has to be specified using a marker type implementing the encoding strategy.
+//! This crate provides hex encoding via `Hex<Upper>` and `Hex<Lower>`
+
+use core::fmt;
+use core::marker::PhantomData;
+
+use serde::de::{SeqAccess, Unexpected, Visitor};
+use serde::ser::SerializeSeq;
+use serde::{Deserializer, Serializer};
+
+use super::encode::Error as ConsensusError;
+use super::{Decodable, Encodable};
+use crate::io;
+
+/// Hex-encoding strategy
+pub struct Hex<Case = hex::Lower>(PhantomData<Case>)
+where
+    Case: hex::Case;
+
+impl<C: hex::Case> Default for Hex<C> {
+    fn default() -> Self { Hex(Default::default()) }
+}
+
+impl<C: hex::Case> ByteEncoder for Hex<C> {
+    type Encoder = hex::Encoder<C>;
+}
+
+/// Implements hex encoding.
+pub mod hex {
+    use core::fmt;
+    use core::marker::PhantomData;
+
+    use hex::buf_encoder::BufEncoder;
+
+    /// Marker for upper/lower case type-level flags ("type-level enum").
+    ///
+    /// You may use this trait in bounds only.
+    pub trait Case: sealed::Case {}
+    impl<T: sealed::Case> Case for T {}
+
+    /// Marker for using lower-case hex encoding.
+    pub enum Lower {}
+    /// Marker for using upper-case hex encoding.
+    pub enum Upper {}
+
+    mod sealed {
+        pub trait Case {
+            /// Internal detail, don't depend on it!!!
+            const INTERNAL_CASE: hex::Case;
+        }
+
+        impl Case for super::Lower {
+            const INTERNAL_CASE: hex::Case = hex::Case::Lower;
+        }
+
+        impl Case for super::Upper {
+            const INTERNAL_CASE: hex::Case = hex::Case::Upper;
+        }
+    }
+
+    // TODO measure various sizes and determine the best value
+    const HEX_BUF_SIZE: usize = 512;
+
+    /// Hex byte encoder.
+    // We wrap `BufEncoder` to not leak internal representation.
+    pub struct Encoder<C: Case>(BufEncoder<[u8; HEX_BUF_SIZE]>, PhantomData<C>);
+
+    impl<C: Case> From<super::Hex<C>> for Encoder<C> {
+        fn from(_: super::Hex<C>) -> Self {
+            Encoder(BufEncoder::new([0; HEX_BUF_SIZE]), Default::default())
+        }
+    }
+
+    impl<C: Case> super::EncodeBytes for Encoder<C> {
+        fn encode_chunk<W: fmt::Write>(&mut self, writer: &mut W, mut bytes: &[u8]) -> fmt::Result {
+            while !bytes.is_empty() {
+                if self.0.is_full() {
+                    self.flush(writer)?;
+                }
+                bytes = self.0.put_bytes_min(bytes, C::INTERNAL_CASE);
+            }
+            Ok(())
+        }
+
+        fn flush<W: fmt::Write>(&mut self, writer: &mut W) -> fmt::Result {
+            writer.write_str(self.0.as_str())?;
+            self.0.clear();
+            Ok(())
+        }
+    }
+
+    // Newtypes to hide internal details.
+    // TODO: statically prove impossible cases
+
+    /// Error returned when a hex string decoder can't be created.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub struct DecodeInitError(hex::HexToBytesError);
+
+    /// Error returned when a hex string contains invalid characters.
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub struct DecodeError(hex::HexToBytesError);
+
+    /// Hex decoder state.
+    pub struct Decoder<'a>(hex::HexToBytesIter<'a>);
+
+    impl<'a> Decoder<'a> {
+        fn new(s: &'a str) -> Result<Self, DecodeInitError> {
+            match hex::HexToBytesIter::new(s) {
+                Ok(iter) => Ok(Decoder(iter)),
+                Err(error) => Err(DecodeInitError(error)),
+            }
+        }
+    }
+
+    impl<'a> Iterator for Decoder<'a> {
+        type Item = Result<u8, DecodeError>;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.0.next().map(|result| result.map_err(DecodeError))
+        }
+    }
+
+    impl<'a, C: Case> super::ByteDecoder<'a> for super::Hex<C> {
+        type InitError = DecodeInitError;
+        type DecodeError = DecodeError;
+        type Decoder = Decoder<'a>;
+
+        fn from_str(s: &'a str) -> Result<Self::Decoder, Self::InitError> { Decoder::new(s) }
+    }
+
+    impl super::IntoDeError for DecodeInitError {
+        fn into_de_error<E: serde::de::Error>(self) -> E {
+            use hex::HexToBytesError;
+
+            match self.0 {
+                HexToBytesError::OddLengthString(len) =>
+                    E::invalid_length(len, &"an even number of ASCII-encoded hex digits"),
+                error => panic!("unexpected error: {:?}", error),
+            }
+        }
+    }
+
+    impl super::IntoDeError for DecodeError {
+        fn into_de_error<E: serde::de::Error>(self) -> E {
+            use hex::HexToBytesError;
+            use serde::de::Unexpected;
+
+            const EXPECTED_CHAR: &str = "an ASCII-encoded hex digit";
+
+            match self.0 {
+                HexToBytesError::InvalidChar(c) if c.is_ascii() =>
+                    E::invalid_value(Unexpected::Char(c as _), &EXPECTED_CHAR),
+                HexToBytesError::InvalidChar(c) =>
+                    E::invalid_value(Unexpected::Unsigned(c.into()), &EXPECTED_CHAR),
+                error => panic!("unexpected error: {:?}", error),
+            }
+        }
+    }
+}
+
+struct DisplayWrapper<'a, T: 'a + Encodable, E>(&'a T, PhantomData<E>);
+
+impl<'a, T: 'a + Encodable, E: ByteEncoder> fmt::Display for DisplayWrapper<'a, T, E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut writer = IoWrapper::<'_, _, E::Encoder>::new(f, E::default().into());
+        self.0.consensus_encode(&mut writer).map_err(|error| {
+            #[cfg(debug_assertions)]
+            {
+                use crate::StdError;
+
+                if error.kind() != io::ErrorKind::Other
+                    || error.source().is_some()
+                    || !writer.writer.was_error
+                {
+                    panic!(
+                        "{} returned an unexpected error: {:?}",
+                        core::any::type_name::<T>(),
+                        error
+                    );
+                }
+            }
+            fmt::Error
+        })?;
+        let result = writer.actually_flush();
+        if result.is_err() {
+            writer.writer.assert_was_error::<E>();
+        }
+        result
+    }
+}
+
+struct ErrorTrackingWriter<W: fmt::Write> {
+    writer: W,
+    #[cfg(debug_assertions)]
+    was_error: bool,
+}
+
+impl<W: fmt::Write> ErrorTrackingWriter<W> {
+    fn new(writer: W) -> Self {
+        ErrorTrackingWriter {
+            writer,
+            #[cfg(debug_assertions)]
+            was_error: false,
+        }
+    }
+
+    #[track_caller]
+    fn assert_no_error(&self, fun: &str) {
+        #[cfg(debug_assertions)]
+        {
+            if self.was_error {
+                panic!("`{}` called on errored writer", fun);
+            }
+        }
+    }
+
+    fn assert_was_error<Offender>(&self) {
+        #[cfg(debug_assertions)]
+        {
+            if !self.was_error {
+                panic!("{} returned an error unexpectedly", core::any::type_name::<Offender>());
+            }
+        }
+    }
+
+    fn set_error(&mut self, was: bool) {
+        #[cfg(debug_assertions)]
+        {
+            self.was_error |= was;
+        }
+    }
+
+    fn check_err<T, E>(&mut self, result: Result<T, E>) -> Result<T, E> {
+        self.set_error(result.is_err());
+        result
+    }
+}
+
+impl<W: fmt::Write> fmt::Write for ErrorTrackingWriter<W> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.assert_no_error("write_str");
+        let result = self.writer.write_str(s);
+        self.check_err(result)
+    }
+
+    fn write_char(&mut self, c: char) -> fmt::Result {
+        self.assert_no_error("write_char");
+        let result = self.writer.write_char(c);
+        self.check_err(result)
+    }
+}
+
+struct IoWrapper<'a, W: fmt::Write, E: EncodeBytes> {
+    writer: ErrorTrackingWriter<&'a mut W>,
+    encoder: E,
+}
+
+impl<'a, W: fmt::Write, E: EncodeBytes> IoWrapper<'a, W, E> {
+    fn new(writer: &'a mut W, encoder: E) -> Self {
+        IoWrapper { writer: ErrorTrackingWriter::new(writer), encoder }
+    }
+
+    fn actually_flush(&mut self) -> fmt::Result { self.encoder.flush(&mut self.writer) }
+}
+
+impl<'a, W: fmt::Write, E: EncodeBytes> io::Write for IoWrapper<'a, W, E> {
+    fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
+        match self.encoder.encode_chunk(&mut self.writer, bytes) {
+            Ok(()) => Ok(bytes.len()),
+            Err(fmt::Error) => {
+                self.writer.assert_was_error::<E>();
+                Err(io::Error::from(io::ErrorKind::Other))
+            }
+        }
+    }
+    // we intentionally ignore flushes because we will do a single flush at the end.
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
+
+/// Provides an instance of byte-to-string encoder.
+///
+/// This is basically a type constructor used in places where value arguments are not accepted.
+/// Such as the generic `serialize`.
+pub trait ByteEncoder: Default {
+    /// The encoder state.
+    type Encoder: EncodeBytes + From<Self>;
+}
+
+/// Transforms given bytes and writes to the writer.
+///
+/// The encoder is allowed to be buffered (and probably should be).
+/// The design passing writer each time bypasses the need for GAT.
+pub trait EncodeBytes {
+    /// Transform the provided slice and write to the writer.
+    ///
+    /// This is similar to the `write_all` method on `io::Write`.
+    fn encode_chunk<W: fmt::Write>(&mut self, writer: &mut W, bytes: &[u8]) -> fmt::Result;
+
+    /// Write data in buffer (if any) to the writer.
+    fn flush<W: fmt::Write>(&mut self, writer: &mut W) -> fmt::Result;
+}
+
+/// Provides an instance of string-to-byte decoder.
+///
+/// This is basically a type constructor used in places where value arguments are not accepted.
+/// Such as the generic `serialize`.
+pub trait ByteDecoder<'a> {
+    /// Error returned when decoder can't be created.
+    ///
+    /// This is typically returned when string length is invalid.
+    type InitError: IntoDeError + fmt::Debug;
+
+    /// Error returned when decoding fails.
+    ///
+    /// This is typically returned when the input string contains malformed chars.
+    type DecodeError: IntoDeError + fmt::Debug;
+
+    /// The decoder state.
+    type Decoder: Iterator<Item = Result<u8, Self::DecodeError>>;
+
+    /// Constructs the decoder from string.
+    fn from_str(s: &'a str) -> Result<Self::Decoder, Self::InitError>;
+}
+
+/// Converts error into a type implementing `serde::de::Error`
+pub trait IntoDeError {
+    /// Performs the conversion.
+    fn into_de_error<E: serde::de::Error>(self) -> E;
+}
+
+struct BinWriter<S: SerializeSeq> {
+    serializer: S,
+    error: Option<S::Error>,
+}
+
+impl<S: SerializeSeq> io::Write for BinWriter<S> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.write_all(buf).map(|_| buf.len()) }
+
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        for byte in buf {
+            if let Err(error) = self.serializer.serialize_element(byte) {
+                self.error = Some(error);
+                return Err(io::ErrorKind::Other.into());
+            }
+        }
+        Ok(())
+    }
+
+    fn flush(&mut self) -> io::Result<()> { Ok(()) }
+}
+
+struct DisplayExpected<D: fmt::Display>(D);
+
+impl<D: fmt::Display> serde::de::Expected for DisplayExpected<D> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, formatter)
+    }
+}
+
+enum DecodeError<E> {
+    TooManyBytes,
+    Consensus(ConsensusError),
+    Other(E),
+}
+
+// not a trait impl because we panic on some variants
+fn consensus_error_into_serde<E: serde::de::Error>(error: ConsensusError) -> E {
+    match error {
+        ConsensusError::Io(error) => panic!("unexpected IO error {:?}", error),
+        ConsensusError::Key(error) => E::custom(format_args!("unexpected Key error: {}", error)),
+        ConsensusError::OversizedVectorAllocation { requested, max } => E::custom(format_args!(
+            "the requested allocation of {} items exceeds maximum of {}",
+            requested, max
+        )),
+        ConsensusError::InvalidChecksum { expected, actual } => E::invalid_value(
+            Unexpected::Bytes(&actual),
+            &DisplayExpected(format_args!(
+                "checksum {:02x}{:02x}{:02x}{:02x}",
+                expected[0], expected[1], expected[2], expected[3]
+            )),
+        ),
+        ConsensusError::NonMinimalVarInt =>
+            E::custom(format_args!("compact size was not encoded minimally")),
+        ConsensusError::ParseFailed(msg) => E::custom(msg),
+        ConsensusError::UnsupportedSegwitFlag(flag) =>
+            E::invalid_value(Unexpected::Unsigned(flag.into()), &"segwit version 1 flag"),
+        ConsensusError::UnknownXField(xfield_type) => E::custom(format!("unknown xfield type: {}", xfield_type)),
+        ConsensusError::XFieldNone => E::custom("XField type None cannot be hashed or signed"),
+    }
+}
+
+impl<E> DecodeError<E>
+where
+    E: serde::de::Error,
+{
+    fn unify(self) -> E {
+        match self {
+            DecodeError::Other(error) => error,
+            DecodeError::TooManyBytes => E::custom(format_args!("got more bytes than expected")),
+            DecodeError::Consensus(error) => consensus_error_into_serde(error),
+        }
+    }
+}
+
+impl<E> IntoDeError for DecodeError<E>
+where
+    E: IntoDeError,
+{
+    fn into_de_error<DE: serde::de::Error>(self) -> DE {
+        match self {
+            DecodeError::Other(error) => error.into_de_error(),
+            DecodeError::TooManyBytes => DE::custom(format_args!("got more bytes than expected")),
+            DecodeError::Consensus(error) => consensus_error_into_serde(error),
+        }
+    }
+}
+
+struct IterReader<E: fmt::Debug, I: Iterator<Item = Result<u8, E>>> {
+    iterator: core::iter::Fuse<I>,
+    error: Option<E>,
+}
+
+impl<E: fmt::Debug, I: Iterator<Item = Result<u8, E>>> IterReader<E, I> {
+    fn new(iterator: I) -> Self { IterReader { iterator: iterator.fuse(), error: None } }
+
+    fn decode<T: Decodable>(mut self) -> Result<T, DecodeError<E>> {
+        use crate::StdError;
+
+        let result = T::consensus_decode(&mut self);
+        match (result, self.error) {
+            (Ok(_), None) if self.iterator.next().is_some() => {
+                Err(DecodeError::TooManyBytes)
+            },
+            (Ok(value), None) => Ok(value),
+            (Ok(_), Some(error)) => panic!("{} silently ate the error: {:?}", core::any::type_name::<T>(), error),
+            (Err(ConsensusError::Io(io_error)), Some(de_error)) if io_error.kind() == io::ErrorKind::Other && io_error.source().is_none() => Err(DecodeError::Other(de_error)),
+            (Err(consensus_error), None) => Err(DecodeError::Consensus(consensus_error)),
+            (Err(ConsensusError::Io(io_error)), de_error) => panic!("Unexpected IO error {:?} returned from {}::consensus_decode(), deserialization error: {:?}", io_error, core::any::type_name::<T>(), de_error),
+            (Err(consensus_error), Some(de_error)) => panic!("{} should've returned `Other` IO error because of deserialization error {:?} but it returned consensus error {:?} instead", core::any::type_name::<T>(), de_error, consensus_error),
+        }
+    }
+}
+
+impl<E: fmt::Debug, I: Iterator<Item = Result<u8, E>>> io::Read for IterReader<E, I> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let mut count = 0;
+        for (dst, src) in buf.iter_mut().zip(&mut self.iterator) {
+            match src {
+                Ok(byte) => *dst = byte,
+                Err(error) => {
+                    self.error = Some(error);
+                    return Err(io::ErrorKind::Other.into());
+                }
+            }
+            // bounded by the length of buf
+            count += 1;
+        }
+        Ok(count)
+    }
+}
+
+/// Helper for `#[serde(with = "")]`.
+///
+/// To (de)serialize a field using consensus encoding you can write e.g.:
+///
+/// ```
+/// use tapyrus::Transaction;
+/// use tapyrus::consensus;
+/// use serde_derive::{Serialize, Deserialize};
+///
+/// #[derive(Serialize, Deserialize)]
+/// # #[serde(crate = "actual_serde")]
+/// pub struct MyStruct {
+///     #[serde(with = "consensus::serde::With::<consensus::serde::Hex>")]
+///     tx: Transaction,
+/// }
+/// ```
+pub struct With<E>(PhantomData<E>);
+
+impl<E> With<E> {
+    /// Serializes the value as consensus-encoded
+    pub fn serialize<T: Encodable, S: Serializer>(
+        value: &T,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        E: ByteEncoder,
+    {
+        if serializer.is_human_readable() {
+            serializer.collect_str(&DisplayWrapper::<'_, _, E>(value, Default::default()))
+        } else {
+            use crate::StdError;
+
+            let serializer = serializer.serialize_seq(None)?;
+            let mut writer = BinWriter { serializer, error: None };
+
+            let result = value.consensus_encode(&mut writer);
+            match (result, writer.error) {
+                (Ok(_), None) => writer.serializer.end(),
+                (Ok(_), Some(error)) =>
+                    panic!("{} silently ate an IO error: {:?}", core::any::type_name::<T>(), error),
+                (Err(io_error), Some(ser_error))
+                    if io_error.kind() == io::ErrorKind::Other && io_error.source().is_none() =>
+                    Err(ser_error),
+                (Err(io_error), ser_error) => panic!(
+                    "{} returned an unexpected IO error: {:?} serialization error: {:?}",
+                    core::any::type_name::<T>(),
+                    io_error,
+                    ser_error
+                ),
+            }
+        }
+    }
+
+    /// Deserializes the value as consensus-encoded
+    pub fn deserialize<'d, T: Decodable, D: Deserializer<'d>>(
+        deserializer: D,
+    ) -> Result<T, D::Error>
+    where
+        for<'a> E: ByteDecoder<'a>,
+    {
+        if deserializer.is_human_readable() {
+            deserializer.deserialize_str(HRVisitor::<_, E>(Default::default()))
+        } else {
+            deserializer.deserialize_seq(BinVisitor(Default::default()))
+        }
+    }
+}
+
+struct HRVisitor<T: Decodable, D: for<'a> ByteDecoder<'a>>(PhantomData<fn() -> (T, D)>);
+
+impl<'de, T: Decodable, D: for<'a> ByteDecoder<'a>> Visitor<'de> for HRVisitor<T, D> {
+    type Value = T;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("bytes encoded as a hex string")
+    }
+
+    fn visit_str<E: serde::de::Error>(self, s: &str) -> Result<T, E> {
+        let decoder = D::from_str(s).map_err(IntoDeError::into_de_error)?;
+        IterReader::new(decoder).decode().map_err(IntoDeError::into_de_error)
+    }
+}
+
+struct BinVisitor<T: Decodable>(PhantomData<fn() -> T>);
+
+impl<'de, T: Decodable> Visitor<'de> for BinVisitor<T> {
+    type Value = T;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str("a sequence of bytes")
+    }
+
+    fn visit_seq<S: SeqAccess<'de>>(self, s: S) -> Result<T, S::Error> {
+        IterReader::new(SeqIterator(s, Default::default())).decode().map_err(DecodeError::unify)
+    }
+}
+
+struct SeqIterator<'a, S: serde::de::SeqAccess<'a>>(S, PhantomData<&'a ()>);
+
+impl<'a, S: serde::de::SeqAccess<'a>> Iterator for SeqIterator<'a, S> {
+    type Item = Result<u8, S::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> { self.0.next_element::<u8>().transpose() }
+}
diff --git a/tapyrus/src/consensus/validation.rs b/tapyrus/src/consensus/validation.rs
new file mode 100644
index 00000000..a2a0326c
--- /dev/null
+++ b/tapyrus/src/consensus/validation.rs
@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Transaction and script validation.
+//!
+//! Relies on the `bitcoinconsensus` crate that uses Bitcoin Core libconsensus to perform validation.
+
+use core::fmt;
+
+use internals::write_err;
+
+use crate::amount::Amount;
+use crate::blockdata::script::Script;
+use crate::blockdata::transaction::{OutPoint, Transaction, TxOut};
+#[cfg(doc)]
+use crate::consensus;
+use crate::consensus::encode;
+
+/// Verifies spend of an input script.
+///
+/// Shorthand for [`consensus::verify_script_with_flags`] with flag
+/// [`bitcoinconsensus::VERIFY_ALL`].
+///
+/// # Parameters
+///  * `index` - The input index in spending which is spending this transaction.
+///  * `amount` - The amount this script guards.
+///  * `spending_tx` - The transaction that attempts to spend the output holding this script.
+///
+/// [`bitcoinconsensus::VERIFY_ALL`]: https://docs.rs/bitcoinconsensus/0.20.2-0.5.0/bitcoinconsensus/constant.VERIFY_ALL.html
+pub fn verify_script(
+    script: &Script,
+    index: usize,
+    amount: Amount,
+    spending_tx: &[u8],
+) -> Result<(), BitcoinconsensusError> {
+    verify_script_with_flags(script, index, amount, spending_tx, bitcoinconsensus::VERIFY_ALL)
+}
+
+/// Verifies spend of an input script.
+///
+/// # Parameters
+///  * `index` - The input index in spending which is spending this transaction.
+///  * `amount` - The amount this script guards.
+///  * `spending_tx` - The transaction that attempts to spend the output holding this script.
+///  * `flags` - Verification flags, see [`bitcoinconsensus::VERIFY_ALL`] and similar.
+///
+/// [`bitcoinconsensus::VERIFY_ALL`]: https://docs.rs/bitcoinconsensus/0.20.2-0.5.0/bitcoinconsensus/constant.VERIFY_ALL.html
+pub fn verify_script_with_flags<F: Into<u32>>(
+    script: &Script,
+    index: usize,
+    amount: Amount,
+    spending_tx: &[u8],
+    flags: F,
+) -> Result<(), BitcoinconsensusError> {
+    Ok(bitcoinconsensus::verify_with_flags(
+        script.as_bytes(),
+        amount.to_tap(),
+        spending_tx,
+        index,
+        flags.into(),
+    )?)
+}
+
+/// Verifies that this transaction is able to spend its inputs.
+///
+/// Shorthand for [`consensus::verify_transaction_with_flags`] with flag
+/// [`bitcoinconsensus::VERIFY_ALL`].
+///
+/// The `spent` closure should not return the same [`TxOut`] twice!
+///
+/// [`bitcoinconsensus::VERIFY_ALL`]: https://docs.rs/bitcoinconsensus/0.20.2-0.5.0/bitcoinconsensus/constant.VERIFY_ALL.html
+pub fn verify_transaction<S>(tx: &Transaction, spent: S) -> Result<(), TxVerifyError>
+where
+    S: FnMut(&OutPoint) -> Option<TxOut>,
+{
+    verify_transaction_with_flags(tx, spent, bitcoinconsensus::VERIFY_ALL)
+}
+
+/// Verifies that this transaction is able to spend its inputs.
+///
+/// The `spent` closure should not return the same [`TxOut`] twice!
+pub fn verify_transaction_with_flags<S, F>(
+    tx: &Transaction,
+    mut spent: S,
+    flags: F,
+) -> Result<(), TxVerifyError>
+where
+    S: FnMut(&OutPoint) -> Option<TxOut>,
+    F: Into<u32>,
+{
+    let serialized_tx = encode::serialize(tx);
+    let flags: u32 = flags.into();
+    for (idx, input) in tx.input.iter().enumerate() {
+        if let Some(output) = spent(&input.previous_output) {
+            verify_script_with_flags(
+                &output.script_pubkey,
+                idx,
+                output.value,
+                serialized_tx.as_slice(),
+                flags,
+            )?;
+        } else {
+            return Err(TxVerifyError::UnknownSpentOutput(input.previous_output));
+        }
+    }
+    Ok(())
+}
+
+impl Script {
+    /// Verifies spend of an input script.
+    ///
+    /// Shorthand for [`Self::verify_with_flags`] with flag [`bitcoinconsensus::VERIFY_ALL`].
+    ///
+    /// # Parameters
+    ///  * `index` - The input index in spending which is spending this transaction.
+    ///  * `amount` - The amount this script guards.
+    ///  * `spending_tx` - The transaction that attempts to spend the output holding this script.
+    ///
+    /// [`bitcoinconsensus::VERIFY_ALL`]: https://docs.rs/bitcoinconsensus/0.20.2-0.5.0/bitcoinconsensus/constant.VERIFY_ALL.html
+    pub fn verify(
+        &self,
+        index: usize,
+        amount: crate::Amount,
+        spending_tx: &[u8],
+    ) -> Result<(), BitcoinconsensusError> {
+        verify_script(self, index, amount, spending_tx)
+    }
+
+    /// Verifies spend of an input script.
+    ///
+    /// # Parameters
+    ///  * `index` - The input index in spending which is spending this transaction.
+    ///  * `amount` - The amount this script guards.
+    ///  * `spending_tx` - The transaction that attempts to spend the output holding this script.
+    ///  * `flags` - Verification flags, see [`bitcoinconsensus::VERIFY_ALL`] and similar.
+    ///
+    /// [`bitcoinconsensus::VERIFY_ALL`]: https://docs.rs/bitcoinconsensus/0.20.2-0.5.0/bitcoinconsensus/constant.VERIFY_ALL.html
+    pub fn verify_with_flags<F: Into<u32>>(
+        &self,
+        index: usize,
+        amount: crate::Amount,
+        spending_tx: &[u8],
+        flags: F,
+    ) -> Result<(), BitcoinconsensusError> {
+        verify_script_with_flags(self, index, amount, spending_tx, flags)
+    }
+}
+
+impl Transaction {
+    /// Verifies that this transaction is able to spend its inputs.
+    ///
+    /// Shorthand for [`Self::verify_with_flags`] with flag [`bitcoinconsensus::VERIFY_ALL`].
+    ///
+    /// The `spent` closure should not return the same [`TxOut`] twice!
+    ///
+    /// [`bitcoinconsensus::VERIFY_ALL`]: https://docs.rs/bitcoinconsensus/0.20.2-0.5.0/bitcoinconsensus/constant.VERIFY_ALL.html
+    pub fn verify<S>(&self, spent: S) -> Result<(), TxVerifyError>
+    where
+        S: FnMut(&OutPoint) -> Option<TxOut>,
+    {
+        verify_transaction(self, spent)
+    }
+
+    /// Verifies that this transaction is able to spend its inputs.
+    ///
+    /// The `spent` closure should not return the same [`TxOut`] twice!
+    pub fn verify_with_flags<S, F>(&self, spent: S, flags: F) -> Result<(), TxVerifyError>
+    where
+        S: FnMut(&OutPoint) -> Option<TxOut>,
+        F: Into<u32>,
+    {
+        verify_transaction_with_flags(self, spent, flags)
+    }
+}
+
+/// Wrapped error from `bitcoinconsensus`.
+// We do this for two reasons:
+// 1. We don't want the error to be part of the public API because we do not want to expose the
+//    unusual versioning used in `bitcoinconsensus` to users of `rust-tapyrus`.
+// 2. We want to implement `std::error::Error` if the "std" feature is enabled in `rust-tapyrus` but
+//    not in `bitcoinconsensus`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct BitcoinconsensusError(bitcoinconsensus::Error);
+
+impl fmt::Display for BitcoinconsensusError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write_err!(f, "bitcoinconsensus error"; &self.0)
+    }
+}
+
+#[cfg(all(feature = "std", feature = "bitcoinconsensus-std"))]
+impl std::error::Error for BitcoinconsensusError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
+#[cfg(all(feature = "std", not(feature = "bitcoinconsensus-std")))]
+impl std::error::Error for BitcoinconsensusError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+impl From<bitcoinconsensus::Error> for BitcoinconsensusError {
+    fn from(e: bitcoinconsensus::Error) -> Self { Self(e) }
+}
+
+/// An error during transaction validation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum TxVerifyError {
+    /// Error validating the script with bitcoinconsensus library.
+    ScriptVerification(BitcoinconsensusError),
+    /// Can not find the spent output.
+    UnknownSpentOutput(OutPoint),
+}
+
+impl fmt::Display for TxVerifyError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use TxVerifyError::*;
+
+        match *self {
+            ScriptVerification(ref e) => write_err!(f, "bitcoinconsensus verification failed"; e),
+            UnknownSpentOutput(ref p) => write!(f, "unknown spent output: {}", p),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TxVerifyError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TxVerifyError::*;
+
+        match *self {
+            ScriptVerification(ref e) => Some(e),
+            UnknownSpentOutput(_) => None,
+        }
+    }
+}
+
+impl From<BitcoinconsensusError> for TxVerifyError {
+    fn from(e: BitcoinconsensusError) -> Self { TxVerifyError::ScriptVerification(e) }
+}
diff --git a/tapyrus/src/crypto/ecdsa.rs b/tapyrus/src/crypto/ecdsa.rs
new file mode 100644
index 00000000..fa8b27b4
--- /dev/null
+++ b/tapyrus/src/crypto/ecdsa.rs
@@ -0,0 +1,236 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! ECDSA Bitcoin signatures.
+//!
+//! This module provides ECDSA signatures used Bitcoin that can be roundtrip (de)serialized.
+
+use core::str::FromStr;
+use core::{fmt, iter};
+
+use hex::FromHex;
+use internals::write_err;
+use secp256k1;
+
+use crate::prelude::*;
+use crate::script::PushBytes;
+use crate::sighash::{EcdsaSighashType, NonStandardSighashTypeError};
+
+const MAX_SIG_LEN: usize = 73;
+
+/// An ECDSA signature with the corresponding hash type.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Signature {
+    /// The underlying ECDSA Signature
+    pub sig: secp256k1::ecdsa::Signature,
+    /// The corresponding hash type
+    pub hash_ty: EcdsaSighashType,
+}
+
+impl Signature {
+    /// Constructs an ECDSA tapyrus signature for [`EcdsaSighashType::All`].
+    pub fn sighash_all(sig: secp256k1::ecdsa::Signature) -> Signature {
+        Signature { sig, hash_ty: EcdsaSighashType::All }
+    }
+
+    /// Deserializes from slice following the standardness rules for [`EcdsaSighashType`].
+    pub fn from_slice(sl: &[u8]) -> Result<Self, Error> {
+        let (hash_ty, sig) = sl.split_last().ok_or(Error::EmptySignature)?;
+        let hash_ty = EcdsaSighashType::from_standard(*hash_ty as u32)?;
+        let sig = secp256k1::ecdsa::Signature::from_der(sig).map_err(Error::Secp256k1)?;
+        Ok(Signature { sig, hash_ty })
+    }
+
+    /// Serializes an ECDSA signature (inner secp256k1 signature in DER format).
+    ///
+    /// This does **not** perform extra heap allocation.
+    pub fn serialize(&self) -> SerializedSignature {
+        let mut buf = [0u8; MAX_SIG_LEN];
+        let signature = self.sig.serialize_der();
+        buf[..signature.len()].copy_from_slice(&signature);
+        buf[signature.len()] = self.hash_ty as u8;
+        SerializedSignature { data: buf, len: signature.len() + 1 }
+    }
+
+    /// Serializes an ECDSA signature (inner secp256k1 signature in DER format) into `Vec`.
+    ///
+    /// Note: this performs an extra heap allocation, you might prefer the
+    /// [`serialize`](Self::serialize) method instead.
+    pub fn to_vec(self) -> Vec<u8> {
+        // TODO: add support to serialize to a writer to SerializedSig
+        self.sig.serialize_der().iter().copied().chain(iter::once(self.hash_ty as u8)).collect()
+    }
+}
+
+impl fmt::Display for Signature {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::LowerHex::fmt(&self.sig.serialize_der().as_hex(), f)?;
+        fmt::LowerHex::fmt(&[self.hash_ty as u8].as_hex(), f)
+    }
+}
+
+impl FromStr for Signature {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let bytes = Vec::from_hex(s)?;
+        let (sighash_byte, signature) = bytes.split_last().ok_or(Error::EmptySignature)?;
+        Ok(Signature {
+            sig: secp256k1::ecdsa::Signature::from_der(signature)?,
+            hash_ty: EcdsaSighashType::from_standard(*sighash_byte as u32)?,
+        })
+    }
+}
+
+/// Holds signature serialized in-line (not in `Vec`).
+///
+/// This avoids allocation and allows proving maximum size of the signature (73 bytes).
+/// The type can be used largely as a byte slice. It implements all standard traits one would
+/// expect and has familiar methods.
+/// However, the usual use case is to push it into a script. This can be done directly passing it
+/// into [`push_slice`](crate::script::ScriptBuf::push_slice).
+#[derive(Copy, Clone)]
+pub struct SerializedSignature {
+    data: [u8; MAX_SIG_LEN],
+    len: usize,
+}
+
+impl SerializedSignature {
+    /// Returns an iterator over bytes of the signature.
+    #[inline]
+    pub fn iter(&self) -> core::slice::Iter<'_, u8> { self.into_iter() }
+}
+
+impl core::ops::Deref for SerializedSignature {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target { &self.data[..self.len] }
+}
+
+impl core::ops::DerefMut for SerializedSignature {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.data[..self.len] }
+}
+
+impl AsRef<[u8]> for SerializedSignature {
+    #[inline]
+    fn as_ref(&self) -> &[u8] { self }
+}
+
+impl AsMut<[u8]> for SerializedSignature {
+    #[inline]
+    fn as_mut(&mut self) -> &mut [u8] { self }
+}
+
+impl AsRef<PushBytes> for SerializedSignature {
+    #[inline]
+    fn as_ref(&self) -> &PushBytes { &<&PushBytes>::from(&self.data)[..self.len()] }
+}
+
+impl core::borrow::Borrow<[u8]> for SerializedSignature {
+    #[inline]
+    fn borrow(&self) -> &[u8] { self }
+}
+
+impl core::borrow::BorrowMut<[u8]> for SerializedSignature {
+    #[inline]
+    fn borrow_mut(&mut self) -> &mut [u8] { self }
+}
+
+impl fmt::Debug for SerializedSignature {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(self, f) }
+}
+
+impl fmt::Display for SerializedSignature {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(self, f) }
+}
+
+impl fmt::LowerHex for SerializedSignature {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(&(**self).as_hex(), f)
+    }
+}
+
+impl fmt::UpperHex for SerializedSignature {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::UpperHex::fmt(&(**self).as_hex(), f)
+    }
+}
+
+impl PartialEq for SerializedSignature {
+    #[inline]
+    fn eq(&self, other: &SerializedSignature) -> bool { **self == **other }
+}
+
+impl Eq for SerializedSignature {}
+
+impl core::hash::Hash for SerializedSignature {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) { core::hash::Hash::hash(&**self, state) }
+}
+
+impl<'a> IntoIterator for &'a SerializedSignature {
+    type IntoIter = core::slice::Iter<'a, u8>;
+    type Item = &'a u8;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter { (*self).iter() }
+}
+
+/// An ECDSA signature-related error.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// Hex decoding error.
+    Hex(hex::HexToBytesError),
+    /// Non-standard sighash type.
+    SighashType(NonStandardSighashTypeError),
+    /// Signature was empty.
+    EmptySignature,
+    /// A secp256k1 error.
+    Secp256k1(secp256k1::Error),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            Hex(ref e) => write_err!(f, "signature hex decoding error"; e),
+            SighashType(ref e) => write_err!(f, "non-standard signature hash type"; e),
+            EmptySignature => write!(f, "empty ECDSA signature"),
+            Secp256k1(ref e) => write_err!(f, "secp256k1"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            Hex(ref e) => Some(e),
+            Secp256k1(ref e) => Some(e),
+            SighashType(ref e) => Some(e),
+            EmptySignature => None,
+        }
+    }
+}
+
+impl From<secp256k1::Error> for Error {
+    fn from(e: secp256k1::Error) -> Error { Error::Secp256k1(e) }
+}
+
+impl From<NonStandardSighashTypeError> for Error {
+    fn from(err: NonStandardSighashTypeError) -> Self { Error::SighashType(err) }
+}
+
+impl From<hex::HexToBytesError> for Error {
+    fn from(err: hex::HexToBytesError) -> Self { Error::Hex(err) }
+}
diff --git a/tapyrus/src/crypto/key.rs b/tapyrus/src/crypto/key.rs
new file mode 100644
index 00000000..671927d7
--- /dev/null
+++ b/tapyrus/src/crypto/key.rs
@@ -0,0 +1,1155 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin keys.
+//!
+//! This module provides keys used in Bitcoin that can be roundtrip
+//! (de)serialized.
+
+use core::fmt::{self, Write};
+use core::ops;
+use core::str::FromStr;
+
+use hashes::{hash160, Hash};
+use hex::FromHex;
+use internals::write_err;
+#[cfg(feature = "rand-std")]
+pub use secp256k1::rand;
+pub use secp256k1::{self, constants, Keypair, Parity, Secp256k1, Verification, XOnlyPublicKey};
+
+use crate::consensus::{encode, Decodable, Encodable};
+use crate::crypto::ecdsa;
+use crate::network::Network;
+use crate::prelude::*;
+use crate::taproot::{TapNodeHash, TapTweakHash};
+use crate::{base58, io};
+
+/// A Bitcoin ECDSA public key
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PublicKey {
+    /// Whether this public key should be serialized as compressed
+    pub compressed: bool,
+    /// The actual ECDSA key
+    pub inner: secp256k1::PublicKey,
+}
+
+impl PublicKey {
+    /// Constructs compressed ECDSA public key from the provided generic Secp256k1 public key
+    pub fn new(key: impl Into<secp256k1::PublicKey>) -> PublicKey {
+        PublicKey { compressed: true, inner: key.into() }
+    }
+
+    /// Constructs uncompressed (legacy) ECDSA public key from the provided generic Secp256k1
+    /// public key
+    pub fn new_uncompressed(key: impl Into<secp256k1::PublicKey>) -> PublicKey {
+        PublicKey { compressed: false, inner: key.into() }
+    }
+
+    fn with_serialized<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+        if self.compressed {
+            f(&self.inner.serialize())
+        } else {
+            f(&self.inner.serialize_uncompressed())
+        }
+    }
+
+    /// Returns tapyrus 160-bit hash of the public key
+    pub fn pubkey_hash(&self) -> PubkeyHash { self.with_serialized(PubkeyHash::hash) }
+
+    /// Returns tapyrus 160-bit hash of the public key for witness program
+    pub fn wpubkey_hash(&self) -> Option<WPubkeyHash> {
+        if self.compressed {
+            Some(WPubkeyHash::from_byte_array(
+                hash160::Hash::hash(&self.inner.serialize()).to_byte_array(),
+            ))
+        } else {
+            // We can't create witness pubkey hashes for an uncompressed
+            // public keys
+            None
+        }
+    }
+
+    /// Write the public key into a writer
+    pub fn write_into<W: io::Write>(&self, mut writer: W) -> Result<(), io::Error> {
+        self.with_serialized(|bytes| writer.write_all(bytes))
+    }
+
+    /// Read the public key from a reader
+    ///
+    /// This internally reads the first byte before reading the rest, so
+    /// use of a `BufReader` is recommended.
+    pub fn read_from<R: io::Read>(mut reader: R) -> Result<Self, io::Error> {
+        let mut bytes = [0; 65];
+
+        reader.read_exact(&mut bytes[0..1])?;
+        let bytes = if bytes[0] < 4 { &mut bytes[..33] } else { &mut bytes[..65] };
+
+        reader.read_exact(&mut bytes[1..])?;
+        Self::from_slice(bytes).map_err(|e| {
+            // Need a static string for core2
+            #[cfg(feature = "std")]
+            let reason = e;
+            #[cfg(not(feature = "std"))]
+            let reason = match e {
+                Error::Base58(_) => "base58 error",
+                Error::Secp256k1(_) => "secp256k1 error",
+                Error::InvalidKeyPrefix(_) => "invalid key prefix",
+                Error::Hex(_) => "hex decoding error",
+                Error::InvalidHexLength(_) => "invalid hex string length",
+            };
+            io::Error::new(io::ErrorKind::InvalidData, reason)
+        })
+    }
+
+    /// Serialize the public key to bytes
+    pub fn to_bytes(self) -> Vec<u8> {
+        let mut buf = Vec::new();
+        self.write_into(&mut buf).expect("vecs don't error");
+        buf
+    }
+
+    /// Serialize the public key into a `SortKey`.
+    ///
+    /// `SortKey` is not too useful by itself, but it can be used to sort a
+    /// `[PublicKey]` slice using `sort_unstable_by_key`, `sort_by_cached_key`,
+    /// `sort_by_key`, or any of the other `*_by_key` methods on slice.
+    /// Pass the method into the sort method directly. (ie. `PublicKey::to_sort_key`)
+    ///
+    /// This method of sorting is in line with Bitcoin Core's implementation of
+    /// sorting keys for output descriptors such as `sortedmulti()`.
+    ///
+    /// If every `PublicKey` in the slice is `compressed == true` then this will sort
+    /// the keys in a
+    /// [BIP67](https://github.com/bitcoin/bips/blob/master/bip-0067.mediawiki)
+    /// compliant way.
+    ///
+    /// # Example: Using with `sort_unstable_by_key`
+    ///
+    /// ```rust
+    /// use std::str::FromStr;
+    /// use tapyrus::PublicKey;
+    ///
+    /// let pk = |s| PublicKey::from_str(s).unwrap();
+    ///
+    /// let mut unsorted = [
+    ///     pk("04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc38e98ac269ffe028345c31ac8d0a365f29c8f7e7cfccac72f84e1acd02bc554f35"),
+    ///     pk("038f47dcd43ba6d97fc9ed2e3bba09b175a45fac55f0683e8cf771e8ced4572354"),
+    ///     pk("028bde91b10013e08949a318018fedbd896534a549a278e220169ee2a36517c7aa"),
+    ///     pk("04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc3816753d96001fd7cba3ce5372f5c9a0d63708183033538d07b1e532fc43aaacfa"),
+    ///     pk("032b8324c93575034047a52e9bca05a46d8347046b91a032eff07d5de8d3f2730b"),
+    ///     pk("045d753414fa292ea5b8f56e39cfb6a0287b2546231a5cb05c4b14ab4b463d171f5128148985b23eccb1e2905374873b1f09b9487f47afa6b1f2b0083ac8b4f7e8"),
+    ///     pk("0234dd69c56c36a41230d573d68adeae0030c9bc0bf26f24d3e1b64c604d293c68"),
+    /// ];
+    /// let sorted = [
+    ///     // These first 4 keys are in a BIP67 compatible sorted order
+    ///     // (since they are compressed)
+    ///     pk("0234dd69c56c36a41230d573d68adeae0030c9bc0bf26f24d3e1b64c604d293c68"),
+    ///     pk("028bde91b10013e08949a318018fedbd896534a549a278e220169ee2a36517c7aa"),
+    ///     pk("032b8324c93575034047a52e9bca05a46d8347046b91a032eff07d5de8d3f2730b"),
+    ///     pk("038f47dcd43ba6d97fc9ed2e3bba09b175a45fac55f0683e8cf771e8ced4572354"),
+    ///     // Uncompressed keys are not BIP67 compliant, but are sorted
+    ///     // after compressed keys in Bitcoin Core using `sortedmulti()`
+    ///     pk("045d753414fa292ea5b8f56e39cfb6a0287b2546231a5cb05c4b14ab4b463d171f5128148985b23eccb1e2905374873b1f09b9487f47afa6b1f2b0083ac8b4f7e8"),
+    ///     pk("04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc3816753d96001fd7cba3ce5372f5c9a0d63708183033538d07b1e532fc43aaacfa"),
+    ///     pk("04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc38e98ac269ffe028345c31ac8d0a365f29c8f7e7cfccac72f84e1acd02bc554f35"),
+    /// ];
+    ///
+    /// unsorted.sort_unstable_by_key(|k| PublicKey::to_sort_key(*k));
+    ///
+    /// assert_eq!(unsorted, sorted);
+    /// ```
+    pub fn to_sort_key(self) -> SortKey {
+        if self.compressed {
+            let bytes = self.inner.serialize();
+            let mut res = [0; 32];
+            res[..].copy_from_slice(&bytes[1..33]);
+            SortKey(bytes[0], res, [0; 32])
+        } else {
+            let bytes = self.inner.serialize_uncompressed();
+            let mut res_left = [0; 32];
+            let mut res_right = [0; 32];
+            res_left[..].copy_from_slice(&bytes[1..33]);
+            res_right[..].copy_from_slice(&bytes[33..65]);
+            SortKey(bytes[0], res_left, res_right)
+        }
+    }
+
+    /// Deserialize a public key from a slice
+    pub fn from_slice(data: &[u8]) -> Result<PublicKey, Error> {
+        let compressed = match data.len() {
+            33 => true,
+            65 => false,
+            len => {
+                return Err(base58::Error::InvalidLength(len).into());
+            }
+        };
+
+        if !compressed && data[0] != 0x04 {
+            return Err(Error::InvalidKeyPrefix(data[0]));
+        }
+
+        Ok(PublicKey { compressed, inner: secp256k1::PublicKey::from_slice(data)? })
+    }
+
+    /// Computes the public key as supposed to be used with this secret
+    pub fn from_private_key<C: secp256k1::Signing>(
+        secp: &Secp256k1<C>,
+        sk: &PrivateKey,
+    ) -> PublicKey {
+        sk.public_key(secp)
+    }
+
+    /// Checks that `sig` is a valid ECDSA signature for `msg` using this public key.
+    pub fn verify<C: secp256k1::Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+        msg: &secp256k1::Message,
+        sig: &ecdsa::Signature,
+    ) -> Result<(), Error> {
+        Ok(secp.verify_ecdsa(msg, &sig.sig, &self.inner)?)
+    }
+
+    /// Returns generator point of secp256k1 as PublicKey
+    pub fn generator() -> PublicKey {
+        let mut combined = vec![0x04];
+        combined.extend_from_slice(&secp256k1::constants::GENERATOR_X);
+        combined.extend_from_slice(&secp256k1::constants::GENERATOR_Y);
+        PublicKey::from_slice(&combined).unwrap()
+    }
+}
+
+impl From<secp256k1::PublicKey> for PublicKey {
+    fn from(pk: secp256k1::PublicKey) -> PublicKey { PublicKey::new(pk) }
+}
+
+impl From<PublicKey> for XOnlyPublicKey {
+    fn from(pk: PublicKey) -> XOnlyPublicKey { pk.inner.into() }
+}
+
+/// An opaque return type for PublicKey::to_sort_key
+#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub struct SortKey(u8, [u8; 32], [u8; 32]);
+
+impl fmt::Display for PublicKey {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // TODO: fast hex encoding
+        self.with_serialized(|bytes| {
+            for ch in bytes {
+                write!(f, "{:02x}", ch)?;
+            }
+            Ok(())
+        })
+    }
+}
+
+impl FromStr for PublicKey {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<PublicKey, Error> {
+        match s.len() {
+            66 => PublicKey::from_slice(&<[u8; 33]>::from_hex(s)?),
+            130 => PublicKey::from_slice(&<[u8; 65]>::from_hex(s)?),
+            len => Err(Error::InvalidHexLength(len)),
+        }
+    }
+}
+
+hashes::hash_newtype! {
+    /// A hash of a public key.
+    pub struct PubkeyHash(hash160::Hash);
+    /// SegWit version of a public key hash.
+    pub struct WPubkeyHash(hash160::Hash);
+}
+crate::hash_types::impl_asref_push_bytes!(PubkeyHash, WPubkeyHash);
+
+impl From<PublicKey> for PubkeyHash {
+    fn from(key: PublicKey) -> PubkeyHash { key.pubkey_hash() }
+}
+
+impl From<&PublicKey> for PubkeyHash {
+    fn from(key: &PublicKey) -> PubkeyHash { key.pubkey_hash() }
+}
+
+/// A Bitcoin ECDSA private key
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Debug))]
+pub struct PrivateKey {
+    /// Whether this private key should be serialized as compressed
+    pub compressed: bool,
+    /// The network on which this key should be used
+    pub network: Network,
+    /// The actual ECDSA key
+    pub inner: secp256k1::SecretKey,
+}
+
+impl PrivateKey {
+    /// Constructs new compressed ECDSA private key using the secp256k1 algorithm and
+    /// a secure random number generator.
+    #[cfg(feature = "rand-std")]
+    pub fn generate(network: Network) -> PrivateKey {
+        let secret_key = secp256k1::SecretKey::new(&mut rand::thread_rng());
+        PrivateKey::new(secret_key, network)
+    }
+    /// Constructs compressed ECDSA private key from the provided generic Secp256k1 private key
+    /// and the specified network
+    pub fn new(key: secp256k1::SecretKey, network: Network) -> PrivateKey {
+        PrivateKey { compressed: true, network, inner: key }
+    }
+
+    /// Constructs uncompressed (legacy) ECDSA private key from the provided generic Secp256k1
+    /// private key and the specified network
+    pub fn new_uncompressed(key: secp256k1::SecretKey, network: Network) -> PrivateKey {
+        PrivateKey { compressed: false, network, inner: key }
+    }
+
+    /// Creates a public key from this private key
+    pub fn public_key<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> PublicKey {
+        PublicKey {
+            compressed: self.compressed,
+            inner: secp256k1::PublicKey::from_secret_key(secp, &self.inner),
+        }
+    }
+
+    /// Serialize the private key to bytes
+    pub fn to_bytes(self) -> Vec<u8> { self.inner[..].to_vec() }
+
+    /// Deserialize a private key from a slice
+    pub fn from_slice(data: &[u8], network: Network) -> Result<PrivateKey, Error> {
+        Ok(PrivateKey::new(secp256k1::SecretKey::from_slice(data)?, network))
+    }
+
+    /// Format the private key to WIF format.
+    pub fn fmt_wif(&self, fmt: &mut dyn fmt::Write) -> fmt::Result {
+        let mut ret = [0; 34];
+        ret[0] = match self.network {
+            Network::Prod => 128,
+            Network::Dev => 239,
+        };
+        ret[1..33].copy_from_slice(&self.inner[..]);
+        let privkey = if self.compressed {
+            ret[33] = 1;
+            base58::encode_check(&ret[..])
+        } else {
+            base58::encode_check(&ret[..33])
+        };
+        fmt.write_str(&privkey)
+    }
+
+    /// Get WIF encoding of this private key.
+    pub fn to_wif(self) -> String {
+        let mut buf = String::new();
+        buf.write_fmt(format_args!("{}", self)).unwrap();
+        buf.shrink_to_fit();
+        buf
+    }
+
+    /// Parse WIF encoded private key.
+    pub fn from_wif(wif: &str) -> Result<PrivateKey, Error> {
+        let data = base58::decode_check(wif)?;
+
+        let compressed = match data.len() {
+            33 => false,
+            34 => true,
+            _ => {
+                return Err(Error::Base58(base58::Error::InvalidLength(data.len())));
+            }
+        };
+
+        let network = match data[0] {
+            128 => Network::Prod,
+            239 => Network::Dev,
+            x => {
+                return Err(Error::Base58(base58::Error::InvalidAddressVersion(x)));
+            }
+        };
+
+        Ok(PrivateKey {
+            compressed,
+            network,
+            inner: secp256k1::SecretKey::from_slice(&data[1..33])?,
+        })
+    }
+}
+
+impl fmt::Display for PrivateKey {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.fmt_wif(f) }
+}
+
+#[cfg(not(feature = "std"))]
+impl fmt::Debug for PrivateKey {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "[private key data]") }
+}
+
+impl FromStr for PrivateKey {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<PrivateKey, Error> { PrivateKey::from_wif(s) }
+}
+
+impl ops::Index<ops::RangeFull> for PrivateKey {
+    type Output = [u8];
+    fn index(&self, _: ops::RangeFull) -> &[u8] { &self.inner[..] }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for PrivateKey {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        s.collect_str(self)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PrivateKey {
+    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<PrivateKey, D::Error> {
+        struct WifVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for WifVisitor {
+            type Value = PrivateKey;
+
+            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
+                formatter.write_str("an ASCII WIF string")
+            }
+
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                if let Ok(s) = core::str::from_utf8(v) {
+                    PrivateKey::from_str(s).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,
+            {
+                PrivateKey::from_str(v).map_err(E::custom)
+            }
+        }
+
+        d.deserialize_str(WifVisitor)
+    }
+}
+
+impl Decodable for PublicKey {
+    #[inline]
+    fn consensus_decode<D: io::Read + ?Sized>(d: &mut D) -> Result<Self, encode::Error> {
+        let s: Vec<u8> = Decodable::consensus_decode(d)?;
+        PublicKey::from_slice(&s[..]).map_err(encode::Error::Key)
+    }
+}
+
+impl Encodable for PublicKey {
+    #[inline]
+    fn consensus_encode<S: io::Write + ?Sized>(&self, mut s: &mut S) -> Result<usize, io::Error> {
+        self.to_bytes().consensus_encode(&mut s)
+    }
+}
+
+#[cfg(feature = "serde")]
+#[allow(clippy::collapsible_else_if)] // Aids readability.
+impl serde::Serialize for PublicKey {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        if s.is_human_readable() {
+            s.collect_str(self)
+        } else {
+            self.with_serialized(|bytes| s.serialize_bytes(bytes))
+        }
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PublicKey {
+    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<PublicKey, D::Error> {
+        if d.is_human_readable() {
+            struct HexVisitor;
+
+            impl<'de> serde::de::Visitor<'de> for HexVisitor {
+                type Value = PublicKey;
+
+                fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
+                    formatter.write_str("an ASCII hex string")
+                }
+
+                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: serde::de::Error,
+                {
+                    if let Ok(hex) = core::str::from_utf8(v) {
+                        PublicKey::from_str(hex).map_err(E::custom)
+                    } else {
+                        Err(E::invalid_value(::serde::de::Unexpected::Bytes(v), &self))
+                    }
+                }
+
+                fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                where
+                    E: serde::de::Error,
+                {
+                    PublicKey::from_str(v).map_err(E::custom)
+                }
+            }
+            d.deserialize_str(HexVisitor)
+        } else {
+            struct BytesVisitor;
+
+            impl<'de> serde::de::Visitor<'de> for BytesVisitor {
+                type Value = PublicKey;
+
+                fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
+                    formatter.write_str("a bytestring")
+                }
+
+                fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: serde::de::Error,
+                {
+                    PublicKey::from_slice(v).map_err(E::custom)
+                }
+            }
+
+            d.deserialize_bytes(BytesVisitor)
+        }
+    }
+}
+
+/// Untweaked BIP-340 X-coord-only public key
+pub type UntweakedPublicKey = XOnlyPublicKey;
+
+/// Tweaked BIP-340 X-coord-only public key
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+pub struct TweakedPublicKey(XOnlyPublicKey);
+
+impl fmt::LowerHex for TweakedPublicKey {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
+}
+
+impl fmt::Display for TweakedPublicKey {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+/// Untweaked BIP-340 key pair
+#[deprecated(since = "0.31.0", note = "use UntweakedKeypair instead")]
+#[allow(deprecated)]
+pub type UntweakedKeyPair = UntweakedKeypair;
+
+/// Untweaked BIP-340 key pair
+pub type UntweakedKeypair = Keypair;
+
+/// Tweaked BIP-340 key pair
+#[deprecated(since = "0.31.0", note = "use TweakedKeypair instead")]
+#[allow(deprecated)]
+pub type TweakedKeyPair = TweakedKeypair;
+
+/// Tweaked BIP-340 key pair
+///
+/// # Examples
+/// ```
+/// # #[cfg(feature = "rand-std")] {
+/// # use tapyrus::key::{Keypair, TweakedKeypair, TweakedPublicKey};
+/// # use tapyrus::secp256k1::{rand, Secp256k1};
+/// # let secp = Secp256k1::new();
+/// # let keypair = TweakedKeypair::dangerous_assume_tweaked(Keypair::new(&secp, &mut rand::thread_rng()));
+/// // There are various conversion methods available to get a tweaked pubkey from a tweaked keypair.
+/// let (_pk, _parity) = keypair.public_parts();
+/// let _pk  = TweakedPublicKey::from_keypair(keypair);
+/// let _pk = TweakedPublicKey::from(keypair);
+/// # }
+/// ```
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+pub struct TweakedKeypair(Keypair);
+
+/// A trait for tweaking BIP340 key types (x-only public keys and key pairs).
+pub trait TapTweak {
+    /// 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 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>,
+    ) -> Self::TweakedAux;
+
+    /// Directly converts an [`UntweakedPublicKey`] to a [`TweakedPublicKey`]
+    ///
+    /// This method is dangerous and can lead to loss of funds if used incorrectly.
+    /// Specifically, in multi-party protocols a peer can provide a value that allows them to steal.
+    fn dangerous_assume_tweaked(self) -> Self::TweakedKey;
+}
+
+impl TapTweak for UntweakedPublicKey {
+    type TweakedAux = (TweakedPublicKey, 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, 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)
+    }
+
+    fn dangerous_assume_tweaked(self) -> TweakedPublicKey { TweakedPublicKey(self) }
+}
+
+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 {
+    /// Returns the [`TweakedPublicKey`] for `keypair`.
+    #[inline]
+    pub fn from_keypair(keypair: TweakedKeypair) -> Self {
+        let (xonly, _parity) = keypair.0.x_only_public_key();
+        TweakedPublicKey(xonly)
+    }
+
+    /// Creates a new [`TweakedPublicKey`] from a [`XOnlyPublicKey`]. No tweak is applied, consider
+    /// calling `tap_tweak` on an [`UntweakedPublicKey`] 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(key: XOnlyPublicKey) -> TweakedPublicKey {
+        TweakedPublicKey(key)
+    }
+
+    /// Returns the underlying public key.
+    pub fn to_inner(self) -> XOnlyPublicKey { self.0 }
+
+    /// Serialize the key as a byte-encoded pair of values. In compressed form
+    /// the y-coordinate is represented by only a single bit, as x determines
+    /// it up to one bit.
+    #[inline]
+    pub fn serialize(&self) -> [u8; constants::SCHNORR_PUBLIC_KEY_SIZE] { self.0.serialize() }
+}
+
+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 [`Parity`] for this [`TweakedKeypair`].
+    #[inline]
+    pub fn public_parts(&self) -> (TweakedPublicKey, 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 key-related error.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// A base58 error.
+    Base58(base58::Error),
+    /// A secp256k1 error.
+    Secp256k1(secp256k1::Error),
+    /// Invalid key prefix error.
+    InvalidKeyPrefix(u8),
+    /// Hex decoding error.
+    Hex(hex::HexToArrayError),
+    /// `PublicKey` hex should be 66 or 130 digits long.
+    InvalidHexLength(usize),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            Base58(ref e) => write_err!(f, "base58"; e),
+            Secp256k1(ref e) => write_err!(f, "secp256k1"; e),
+            InvalidKeyPrefix(ref b) => write!(f, "key prefix invalid: {}", b),
+            Hex(ref e) => write_err!(f, "hex"; e),
+            InvalidHexLength(got) =>
+                write!(f, "pubkey hex should be 66 or 130 digits long, got: {}", got),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            Base58(ref e) => Some(e),
+            Secp256k1(ref e) => Some(e),
+            Hex(ref e) => Some(e),
+            InvalidKeyPrefix(_) | InvalidHexLength(_) => None,
+        }
+    }
+}
+
+impl From<base58::Error> for Error {
+    fn from(e: base58::Error) -> Error { Error::Base58(e) }
+}
+
+impl From<secp256k1::Error> for Error {
+    fn from(e: secp256k1::Error) -> Error { Error::Secp256k1(e) }
+}
+
+impl From<hex::HexToArrayError> for Error {
+    fn from(e: hex::HexToArrayError) -> Self { Error::Hex(e) }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use hex::FromHex;
+    use secp256k1::Secp256k1;
+
+    use super::*;
+    use crate::address::Address;
+    use crate::io;
+    use crate::network::Network::{Dev, Prod};
+
+    #[test]
+    fn test_key_derivation() {
+        // testnet compressed
+        let sk =
+            PrivateKey::from_wif("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
+        assert_eq!(sk.network, Dev);
+        assert!(sk.compressed);
+        assert_eq!(&sk.to_wif(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
+
+        let secp = Secp256k1::new();
+        let pk = Address::p2pkh(&sk.public_key(&secp), sk.network);
+        assert_eq!(&pk.to_string(), "mqwpxxvfv3QbM8PU8uBx2jaNt9btQqvQNx");
+
+        // test string conversion
+        assert_eq!(&sk.to_string(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
+        let sk_str =
+            PrivateKey::from_str("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
+        assert_eq!(&sk.to_wif(), &sk_str.to_wif());
+
+        // mainnet uncompressed
+        let sk =
+            PrivateKey::from_wif("5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM9Z2PT2R3").unwrap();
+        assert_eq!(sk.network, Prod);
+        assert!(!sk.compressed);
+        assert_eq!(&sk.to_wif(), "5JYkZjmN7PVMjJUfJWfRFwtuXTGB439XV6faajeHPAM9Z2PT2R3");
+
+        let secp = Secp256k1::new();
+        let mut pk = sk.public_key(&secp);
+        assert!(!pk.compressed);
+        assert_eq!(&pk.to_string(), "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133");
+        assert_eq!(pk, PublicKey::from_str("042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133").unwrap());
+        let addr = Address::p2pkh(&pk, sk.network);
+        assert_eq!(&addr.to_string(), "1GhQvF6dL8xa6wBxLnWmHcQsurx9RxiMc8");
+        pk.compressed = true;
+        assert_eq!(
+            &pk.to_string(),
+            "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"
+        );
+        assert_eq!(
+            pk,
+            PublicKey::from_str(
+                "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"
+            )
+            .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_pubkey_hash() {
+        let pk = PublicKey::from_str(
+            "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af",
+        )
+        .unwrap();
+        let upk = PublicKey::from_str("042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133").unwrap();
+        assert_eq!(pk.pubkey_hash().to_string(), "9511aa27ef39bbfa4e4f3dd15f4d66ea57f475b4");
+        assert_eq!(upk.pubkey_hash().to_string(), "ac2e7daf42d2c97418fd9f78af2de552bb9c6a7a");
+    }
+
+    #[test]
+    fn test_wpubkey_hash() {
+        let pk = PublicKey::from_str(
+            "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af",
+        )
+        .unwrap();
+        let upk = PublicKey::from_str("042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133").unwrap();
+        assert_eq!(
+            pk.wpubkey_hash().unwrap().to_string(),
+            "9511aa27ef39bbfa4e4f3dd15f4d66ea57f475b4"
+        );
+        assert_eq!(upk.wpubkey_hash(), None);
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_key_serde() {
+        use serde_test::{assert_tokens, Configure, Token};
+
+        static KEY_WIF: &str = "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy";
+        static PK_STR: &str = "039b6347398505f5ec93826dc61c19f47c66c0283ee9be980e29ce325a0f4679ef";
+        static PK_STR_U: &str = "\
+            04\
+            9b6347398505f5ec93826dc61c19f47c66c0283ee9be980e29ce325a0f4679ef\
+            87288ed73ce47fc4f5c79d19ebfa57da7cff3aff6e819e4ee971d86b5e61875d\
+        ";
+        #[rustfmt::skip]
+        static PK_BYTES: [u8; 33] = [
+            0x03,
+            0x9b, 0x63, 0x47, 0x39, 0x85, 0x05, 0xf5, 0xec,
+            0x93, 0x82, 0x6d, 0xc6, 0x1c, 0x19, 0xf4, 0x7c,
+            0x66, 0xc0, 0x28, 0x3e, 0xe9, 0xbe, 0x98, 0x0e,
+            0x29, 0xce, 0x32, 0x5a, 0x0f, 0x46, 0x79, 0xef,
+        ];
+        #[rustfmt::skip]
+        static PK_BYTES_U: [u8; 65] = [
+            0x04,
+            0x9b, 0x63, 0x47, 0x39, 0x85, 0x05, 0xf5, 0xec,
+            0x93, 0x82, 0x6d, 0xc6, 0x1c, 0x19, 0xf4, 0x7c,
+            0x66, 0xc0, 0x28, 0x3e, 0xe9, 0xbe, 0x98, 0x0e,
+            0x29, 0xce, 0x32, 0x5a, 0x0f, 0x46, 0x79, 0xef,
+            0x87, 0x28, 0x8e, 0xd7, 0x3c, 0xe4, 0x7f, 0xc4,
+            0xf5, 0xc7, 0x9d, 0x19, 0xeb, 0xfa, 0x57, 0xda,
+            0x7c, 0xff, 0x3a, 0xff, 0x6e, 0x81, 0x9e, 0x4e,
+            0xe9, 0x71, 0xd8, 0x6b, 0x5e, 0x61, 0x87, 0x5d,
+        ];
+
+        let s = Secp256k1::new();
+        let sk = PrivateKey::from_str(KEY_WIF).unwrap();
+        let pk = PublicKey::from_private_key(&s, &sk);
+        let pk_u = PublicKey { inner: pk.inner, compressed: false };
+
+        assert_tokens(&sk, &[Token::BorrowedStr(KEY_WIF)]);
+        assert_tokens(&pk.compact(), &[Token::BorrowedBytes(&PK_BYTES[..])]);
+        assert_tokens(&pk.readable(), &[Token::BorrowedStr(PK_STR)]);
+        assert_tokens(&pk_u.compact(), &[Token::BorrowedBytes(&PK_BYTES_U[..])]);
+        assert_tokens(&pk_u.readable(), &[Token::BorrowedStr(PK_STR_U)]);
+    }
+
+    fn random_key(mut seed: u8) -> PublicKey {
+        loop {
+            let mut data = [0; 65];
+            for byte in &mut data[..] {
+                *byte = seed;
+                // totally a rng
+                seed = seed.wrapping_mul(41).wrapping_add(43);
+            }
+            if data[0] % 2 == 0 {
+                data[0] = 4;
+                if let Ok(key) = PublicKey::from_slice(&data[..]) {
+                    return key;
+                }
+            } else {
+                data[0] = 2 + (data[0] >> 7);
+                if let Ok(key) = PublicKey::from_slice(&data[..33]) {
+                    return key;
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn pubkey_read_write() {
+        const N_KEYS: usize = 20;
+        let keys: Vec<_> = (0..N_KEYS).map(|i| random_key(i as u8)).collect();
+
+        let mut v = vec![];
+        for k in &keys {
+            k.write_into(&mut v).expect("writing into vec");
+        }
+
+        let mut dec_keys = vec![];
+        let mut cursor = io::Cursor::new(&v);
+        for _ in 0..N_KEYS {
+            dec_keys.push(PublicKey::read_from(&mut cursor).expect("reading from vec"));
+        }
+
+        assert_eq!(keys, dec_keys);
+
+        // sanity checks
+        assert!(PublicKey::read_from(&mut cursor).is_err());
+        assert!(PublicKey::read_from(io::Cursor::new(&[])).is_err());
+        assert!(PublicKey::read_from(io::Cursor::new(&[0; 33][..])).is_err());
+        assert!(PublicKey::read_from(io::Cursor::new(&[2; 32][..])).is_err());
+        assert!(PublicKey::read_from(io::Cursor::new(&[0; 65][..])).is_err());
+        assert!(PublicKey::read_from(io::Cursor::new(&[4; 64][..])).is_err());
+    }
+
+    #[test]
+    fn pubkey_to_sort_key() {
+        let key1 = PublicKey::from_str(
+            "02ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3b2763ed605f8",
+        )
+        .unwrap();
+        let key2 = PublicKey { inner: key1.inner, compressed: false };
+        let expected1 = SortKey(
+            2,
+            <[u8; 32]>::from_hex(
+                "ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3b2763ed605f8",
+            )
+            .unwrap(),
+            [0_u8; 32],
+        );
+        let expected2 = SortKey(
+            4,
+            <[u8; 32]>::from_hex(
+                "ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3b2763ed605f8",
+            )
+            .unwrap(),
+            <[u8; 32]>::from_hex(
+                "1794e7f3d5e420641a3bc690067df5541470c966cbca8c694bf39aa16d836918",
+            )
+            .unwrap(),
+        );
+        assert_eq!(key1.to_sort_key(), expected1);
+        assert_eq!(key2.to_sort_key(), expected2);
+    }
+
+    #[test]
+    fn pubkey_sort() {
+        struct Vector {
+            input: Vec<PublicKey>,
+            expect: Vec<PublicKey>,
+        }
+        let fmt =
+            |v: Vec<_>| v.into_iter().map(|s| PublicKey::from_str(s).unwrap()).collect::<Vec<_>>();
+        let vectors = vec![
+            // Start BIP67 vectors
+            // Vector 1
+            Vector {
+                input: fmt(vec![
+                    "02ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3b2763ed605f8",
+                    "02fe6f0a5a297eb38c391581c4413e084773ea23954d93f7753db7dc0adc188b2f",
+                ]),
+                expect: fmt(vec![
+                    "02fe6f0a5a297eb38c391581c4413e084773ea23954d93f7753db7dc0adc188b2f",
+                    "02ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3b2763ed605f8",
+                ]),
+            },
+            // Vector 2 (Already sorted, no action required)
+            Vector {
+                input: fmt(vec![
+                    "02632b12f4ac5b1d1b72b2a3b508c19172de44f6f46bcee50ba33f3f9291e47ed0",
+                    "027735a29bae7780a9755fae7a1c4374c656ac6a69ea9f3697fda61bb99a4f3e77",
+                    "02e2cc6bd5f45edd43bebe7cb9b675f0ce9ed3efe613b177588290ad188d11b404",
+                ]),
+                expect: fmt(vec![
+                    "02632b12f4ac5b1d1b72b2a3b508c19172de44f6f46bcee50ba33f3f9291e47ed0",
+                    "027735a29bae7780a9755fae7a1c4374c656ac6a69ea9f3697fda61bb99a4f3e77",
+                    "02e2cc6bd5f45edd43bebe7cb9b675f0ce9ed3efe613b177588290ad188d11b404",
+                ]),
+            },
+            // Vector 3
+            Vector {
+                input: fmt(vec![
+                    "030000000000000000000000000000000000004141414141414141414141414141",
+                    "020000000000000000000000000000000000004141414141414141414141414141",
+                    "020000000000000000000000000000000000004141414141414141414141414140",
+                    "030000000000000000000000000000000000004141414141414141414141414140",
+                ]),
+                expect: fmt(vec![
+                    "020000000000000000000000000000000000004141414141414141414141414140",
+                    "020000000000000000000000000000000000004141414141414141414141414141",
+                    "030000000000000000000000000000000000004141414141414141414141414140",
+                    "030000000000000000000000000000000000004141414141414141414141414141",
+                ]),
+            },
+            // Vector 4: (from bitcore)
+            Vector {
+                input: fmt(vec![
+                    "022df8750480ad5b26950b25c7ba79d3e37d75f640f8e5d9bcd5b150a0f85014da",
+                    "03e3818b65bcc73a7d64064106a859cc1a5a728c4345ff0b641209fba0d90de6e9",
+                    "021f2f6e1e50cb6a953935c3601284925decd3fd21bc445712576873fb8c6ebc18",
+                ]),
+                expect: fmt(vec![
+                    "021f2f6e1e50cb6a953935c3601284925decd3fd21bc445712576873fb8c6ebc18",
+                    "022df8750480ad5b26950b25c7ba79d3e37d75f640f8e5d9bcd5b150a0f85014da",
+                    "03e3818b65bcc73a7d64064106a859cc1a5a728c4345ff0b641209fba0d90de6e9",
+                ]),
+            },
+            // Non-BIP67 vectors
+            Vector {
+                input: fmt(vec![
+                    "02c690d642c1310f3a1ababad94e3930e4023c930ea472e7f37f660fe485263b88",
+                    "0234dd69c56c36a41230d573d68adeae0030c9bc0bf26f24d3e1b64c604d293c68",
+                    "041a181bd0e79974bd7ca552e09fc42ba9c3d5dbb3753741d6f0ab3015dbfd9a22d6b001a32f5f51ac6f2c0f35e73a6a62f59e848fa854d3d21f3f231594eeaa46",
+                    "032b8324c93575034047a52e9bca05a46d8347046b91a032eff07d5de8d3f2730b",
+                    "04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc3816753d96001fd7cba3ce5372f5c9a0d63708183033538d07b1e532fc43aaacfa",
+                    "028e1c947c8c0b8ed021088b8e981491ac7af2b8fabebea1abdb448424c8ed75b7",
+                    "045d753414fa292ea5b8f56e39cfb6a0287b2546231a5cb05c4b14ab4b463d171f5128148985b23eccb1e2905374873b1f09b9487f47afa6b1f2b0083ac8b4f7e8",
+                    "03004a8a3d242d7957c0b60fb7208d386fa6a0193aabd1f3f095ffd0ac097e447b",
+                    "04eb0db2d71ccbb0edd8fb35092cbcae2f7fa1f06d4c170804bf52007924b569a8d2d6f6bc8fd2b3caa3253fa1bb674443743bf7fb9f94f9c0b0831a252894cfa8",
+                    "04516cde23e14f2319423b7a4a7ae48b1dadceb5e9c123198d417d10895684c42eb05e210f90ccbc72448803a22312e3f122ff2939956ccef4f7316f836295ddd5",
+                    "038f47dcd43ba6d97fc9ed2e3bba09b175a45fac55f0683e8cf771e8ced4572354",
+                    "04c6bec3b07586a4b085a78cbb97e9bab6f1d3c9ebf299b65dec85213c5eacd44487de86017183120bb7ea3b6c6660c5037615fe1add2a73f800cbeeae22c60438",
+                    "03e1a1cfa9eaff604ae237b7af31ffe4c01be22eb96f3da0e62c5850dd4b4386c1",
+                    "028d3a2d9f1b1c5c75845944f93bc183ba23aecde53f1978b8aa1b77661be6114f",
+                    "028bde91b10013e08949a318018fedbd896534a549a278e220169ee2a36517c7aa",
+                    "04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc38e98ac269ffe028345c31ac8d0a365f29c8f7e7cfccac72f84e1acd02bc554f35",
+                ]),
+                expect: fmt(vec![
+                    "0234dd69c56c36a41230d573d68adeae0030c9bc0bf26f24d3e1b64c604d293c68",
+                    "028bde91b10013e08949a318018fedbd896534a549a278e220169ee2a36517c7aa",
+                    "028d3a2d9f1b1c5c75845944f93bc183ba23aecde53f1978b8aa1b77661be6114f",
+                    "028e1c947c8c0b8ed021088b8e981491ac7af2b8fabebea1abdb448424c8ed75b7",
+                    "02c690d642c1310f3a1ababad94e3930e4023c930ea472e7f37f660fe485263b88",
+                    "03004a8a3d242d7957c0b60fb7208d386fa6a0193aabd1f3f095ffd0ac097e447b",
+                    "032b8324c93575034047a52e9bca05a46d8347046b91a032eff07d5de8d3f2730b",
+                    "038f47dcd43ba6d97fc9ed2e3bba09b175a45fac55f0683e8cf771e8ced4572354",
+                    "03e1a1cfa9eaff604ae237b7af31ffe4c01be22eb96f3da0e62c5850dd4b4386c1",
+                    "041a181bd0e79974bd7ca552e09fc42ba9c3d5dbb3753741d6f0ab3015dbfd9a22d6b001a32f5f51ac6f2c0f35e73a6a62f59e848fa854d3d21f3f231594eeaa46",
+                    "04516cde23e14f2319423b7a4a7ae48b1dadceb5e9c123198d417d10895684c42eb05e210f90ccbc72448803a22312e3f122ff2939956ccef4f7316f836295ddd5",
+                    "045d753414fa292ea5b8f56e39cfb6a0287b2546231a5cb05c4b14ab4b463d171f5128148985b23eccb1e2905374873b1f09b9487f47afa6b1f2b0083ac8b4f7e8",
+                    // These two pubkeys are mirrored. This helps verify the sort past the x value.
+                    "04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc3816753d96001fd7cba3ce5372f5c9a0d63708183033538d07b1e532fc43aaacfa",
+                    "04c4b0bbb339aa236bff38dbe6a451e111972a7909a126bc424013cba2ec33bc38e98ac269ffe028345c31ac8d0a365f29c8f7e7cfccac72f84e1acd02bc554f35",
+                    "04c6bec3b07586a4b085a78cbb97e9bab6f1d3c9ebf299b65dec85213c5eacd44487de86017183120bb7ea3b6c6660c5037615fe1add2a73f800cbeeae22c60438",
+                    "04eb0db2d71ccbb0edd8fb35092cbcae2f7fa1f06d4c170804bf52007924b569a8d2d6f6bc8fd2b3caa3253fa1bb674443743bf7fb9f94f9c0b0831a252894cfa8",
+                ]),
+            },
+        ];
+        for mut vector in vectors {
+            vector.input.sort_by_cached_key(|k| PublicKey::to_sort_key(*k));
+            assert_eq!(vector.input, vector.expect);
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "rand-std")]
+    fn public_key_constructors() {
+        use secp256k1::rand;
+
+        let secp = Secp256k1::new();
+        let kp = Keypair::new(&secp, &mut rand::thread_rng());
+
+        let _ = PublicKey::new(kp);
+        let _ = PublicKey::new_uncompressed(kp);
+    }
+
+    #[test]
+    fn public_key_from_str_wrong_length() {
+        // Sanity checks, we accept string length 130 digits.
+        let s = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133";
+        assert_eq!(s.len(), 130);
+        assert!(PublicKey::from_str(s).is_ok());
+        // And 66 digits.
+        let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af";
+        assert_eq!(s.len(), 66);
+        assert!(PublicKey::from_str(s).is_ok());
+
+        let s = "aoeusthb";
+        assert_eq!(s.len(), 8);
+        let res = PublicKey::from_str(s);
+        assert!(res.is_err());
+        assert_eq!(res.unwrap_err(), Error::InvalidHexLength(8));
+    }
+
+    #[test]
+    fn test_generator() {
+        let g = PublicKey::generator();
+
+        let mut expected: Vec<u8> = Vec::with_capacity(65);
+        expected.extend(&[4]);
+        expected.extend(&secp256k1::constants::GENERATOR_X);
+        expected.extend(&secp256k1::constants::GENERATOR_Y);
+        assert_eq!(&expected[..], &g.inner.serialize_uncompressed()[..]);
+    }
+
+    #[test]
+    fn test_encode() {
+        use crate::consensus::encode::{Decodable, Encodable};
+
+        let pk = PublicKey::from_str(
+            "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af",
+        )
+        .unwrap();
+        let mut s = Vec::new();
+        let _ = pk.consensus_encode(&mut s);
+        let encoded = s.iter().map(|x| format!("{:02x}", x)).collect::<Vec<String>>().join("");
+        assert_eq!("21032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af", encoded);
+
+        let decoded = PublicKey::consensus_decode(&mut &s[..]).unwrap();
+        assert_eq!(decoded, pk);
+    }
+}
diff --git a/tapyrus/src/crypto/mod.rs b/tapyrus/src/crypto/mod.rs
new file mode 100644
index 00000000..8c197ca9
--- /dev/null
+++ b/tapyrus/src/crypto/mod.rs
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Cryptography
+//!
+//! Cryptography related functionality: keys and signatures.
+//!
+
+pub mod ecdsa;
+pub mod key;
+pub mod sighash;
+// Contents re-exported in `tapyrus::taproot`.
+mod prime;
+mod rfc6979;
+pub mod schnorr;
+pub(crate) mod taproot;
+
+#[cfg(test)]
+mod test_helpers;
diff --git a/tapyrus/src/crypto/prime.rs b/tapyrus/src/crypto/prime.rs
new file mode 100644
index 00000000..5b9a5fe7
--- /dev/null
+++ b/tapyrus/src/crypto/prime.rs
@@ -0,0 +1,88 @@
+// Copyright (c) 2024 Chaintope Inc.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+//! Utility for prime number
+//!
+//!
+
+use num_bigint::BigUint;
+use num_integer::Integer;
+use num_traits::{One, FromPrimitive, Zero};
+
+/// Prime number for secp256k1 field element.
+pub const P: [u8; 32] = [
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfc, 0x2f,
+];
+
+/// Calculate jacobi symbol
+pub fn jacobi(a: &[u8]) -> i8 {
+    
+    let a = BigUint::from_bytes_be(a);
+    let p = BigUint::from_bytes_be(&P[..]);
+    jacobi_inner(&a, &p)
+}
+
+fn jacobi_inner(a: &BigUint, n: &BigUint) -> i8 {
+    let three: BigUint = BigUint::from_u64(3).unwrap();
+    let five: BigUint = BigUint::from_u64(5).unwrap();
+    let seven: BigUint = BigUint::from_u64(7).unwrap();
+
+    assert!(*n >= three);
+    let a = a % n;
+    if a.is_zero() {
+        return 0;
+    }
+
+    if a.is_one() {
+        return 1;
+    }
+    let mut a: BigUint = a.clone();
+    let mut e = 0;
+    while a.is_even() {
+        a >>= 1;
+        e += 1;
+    }
+
+    let n_mod_8 = n % 8u32;
+    let mut s: i8 = if e % 2 == 0 || n_mod_8 == BigUint::one() || n_mod_8 == seven {
+        1
+    } else if n_mod_8 == three || n_mod_8 == five {
+        -1
+    } else {
+        0
+    };
+
+    if n % 4u32 == three && &a % 4u32 == three {
+        s = -s
+    }
+
+    if a.is_one() {
+        s
+    } else {
+        let n_mod_a = n % &a;
+        s * jacobi_inner(&n_mod_a, &a)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use hex::FromHex;
+
+    use super::*;
+
+    #[test]
+    fn test_jacobi() {
+        assert_eq!(1, jacobi_inner(&BigUint::from_u64(1).unwrap(), &BigUint::from_u64(3).unwrap()));
+        assert_eq!(-1, jacobi_inner(&BigUint::from_u64(2).unwrap(), &BigUint::from_u64(3).unwrap()));
+        assert_eq!(0, jacobi_inner(&BigUint::from_u64(3).unwrap(), &BigUint::from_u64(3).unwrap()));
+
+        let a = <[u8; 32]>::from_hex(
+            "388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672",
+        )
+        .unwrap();
+
+        assert_eq!(-1, jacobi(&a[..]));
+    }
+}
diff --git a/tapyrus/src/crypto/rfc6979.rs b/tapyrus/src/crypto/rfc6979.rs
new file mode 100644
index 00000000..0627467c
--- /dev/null
+++ b/tapyrus/src/crypto/rfc6979.rs
@@ -0,0 +1,124 @@
+// Copyright (c) 2024 Chaintope Inc.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+//! RFC6979
+//!
+
+use secp256k1::SecretKey;
+
+use crate::hashes::sha256::Hash as SHA256;
+use crate::hashes::{Hash, HashEngine, Hmac, HmacEngine};
+use crate::prelude::*;
+
+/// Generate nonce
+pub fn nonce_rfc6979(
+    message: &[u8; 32],
+    key: &SecretKey,
+    algo16: &[u8; 16],
+    data: Option<&[u8; 32]>,
+    counter: u32,
+) -> [u8; 32] {
+    let mut keydata: Vec<u8> = Vec::new();
+
+    keydata.extend(&key[..]);
+    keydata.extend(message);
+    if let Some(d) = data {
+        keydata.extend(d);
+    }
+    keydata.extend(algo16);
+    let mut rng = RFC6979::new(&keydata[..]);
+    let mut ret: [u8; 32] = [0u8; 32];
+    for _ in 0..=counter {
+        ret = rng.generate();
+    }
+
+    ret
+}
+
+struct RFC6979 {
+    v: [u8; 32],
+    k: [u8; 32],
+    retry: bool,
+}
+
+impl RFC6979 {
+    pub fn new(keydata: &[u8]) -> Self {
+        let mut rng = Self {
+            v: [1u8; 32], // RFC6979 3.2.b.
+            k: [0u8; 32], // RFC6979 3.2.c.
+            retry: false,
+        };
+
+        let zero = [0u8; 1];
+        let one = [1u8; 1];
+
+        // RFC6979 3.2.d.
+        let mut hmac = HmacEngine::<SHA256>::new(&rng.k[..]);
+        hmac.input(&rng.v[..]);
+        hmac.input(&zero[..]);
+        hmac.input(keydata);
+        rng.k = Hmac::from_engine(hmac).to_byte_array();
+        let mut hmac = HmacEngine::<SHA256>::new(&rng.k[..]);
+        hmac.input(&rng.v[..]);
+        rng.v = Hmac::from_engine(hmac).to_byte_array();
+
+        // RFC6979 2.3.f.
+        let mut hmac = HmacEngine::<SHA256>::new(&rng.k[..]);
+        hmac.input(&rng.v[..]);
+        hmac.input(&one[..]);
+        hmac.input(keydata);
+        rng.k = Hmac::from_engine(hmac).to_byte_array();
+        let mut hmac = HmacEngine::<SHA256>::new(&rng.k[..]);
+        hmac.input(&rng.v[..]);
+        rng.v = Hmac::from_engine(hmac).to_byte_array();
+
+        rng
+    }
+
+    pub fn generate(&mut self) -> [u8; 32] {
+        // RFC6979 3.2.h.
+        let zero = [0u8; 1];
+        if self.retry {
+            let mut hmac = HmacEngine::<SHA256>::new(&self.k[..]);
+            hmac.input(&self.v[..]);
+            hmac.input(&zero[..]);
+            self.k = Hmac::from_engine(hmac).to_byte_array();
+            let mut hmac = HmacEngine::<SHA256>::new(&self.k[..]);
+            hmac.input(&self.v[..]);
+            self.v = Hmac::from_engine(hmac).to_byte_array();
+        }
+
+        let mut hmac = HmacEngine::<SHA256>::new(&self.k[..]);
+        hmac.input(&self.v[..]);
+        self.v = Hmac::from_engine(hmac).to_byte_array();
+
+        self.retry = true;
+
+        self.v
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use hex::FromHex;
+
+    use super::*;
+    use crate::crypto::test_helpers::{decode_message, decode_sk};
+
+    #[test]
+    fn test() {
+        let message =
+            decode_message("0000000000000000000000000000000000000000000000000000000000000000");
+        let sk = decode_sk("0000000000000000000000000000000000000000000000000000000000000001");
+
+        // "SCHNORR + SHA256"
+        static ALGO16: [u8; 16] = [83, 67, 72, 78, 79, 82, 82, 32, 43, 32, 83, 72, 65, 50, 53, 54];
+
+        assert_eq!(
+            nonce_rfc6979(&message, &sk, &ALGO16, None, 0),
+            &Vec::from_hex("e9766e06045ef351d82f09d5d8707fd9a3f1f10cd5c596ce34b88b1aa19c7aea")
+                .unwrap()[..]
+        );
+    }
+}
diff --git a/tapyrus/src/crypto/schnorr.rs b/tapyrus/src/crypto/schnorr.rs
new file mode 100644
index 00000000..b9c2e94e
--- /dev/null
+++ b/tapyrus/src/crypto/schnorr.rs
@@ -0,0 +1,353 @@
+// Copyright (c) 2024 Chaintope Inc.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+//! Signature for block proof
+//!
+//! Implementation for Schnorr signature which is used as block proof.
+//!
+
+use core::fmt;
+
+use hashes::{sha256, Hash, HashEngine};
+use secp256k1::{Scalar, SecretKey};
+
+use crate::crypto::prime::jacobi;
+use crate::crypto::rfc6979::nonce_rfc6979;
+use crate::internal_macros::impl_consensus_encoding;
+use crate::{PrivateKey, PublicKey};
+
+/// The size of scalar value on secp256k1 curve
+pub const SECP256K1_SCALAR_SIZE: usize = 32;
+
+/// "SCHNORR + SHA256"
+pub const ALGO16: [u8; 16] = [83, 67, 72, 78, 79, 82, 82, 32, 43, 32, 83, 72, 65, 50, 53, 54];
+
+/// Schnorr signature struct
+#[derive(Eq, PartialEq, Copy, Clone, Debug, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Signature {
+    /// R.x
+    pub r_x: [u8; SECP256K1_SCALAR_SIZE],
+    /// sigma
+    pub sigma: [u8; SECP256K1_SCALAR_SIZE],
+}
+
+impl Signature {
+    /// signing to message
+    pub fn sign(privkey: &PrivateKey, message: &[u8; 32]) -> Result<Self, Error> {
+        Self::sign_inner(&privkey.inner, message)
+    }
+
+    fn sign_inner(sk: &SecretKey, message: &[u8; 32]) -> Result<Self, Error> {
+        let ctx = secp256k1::Secp256k1::signing_only();
+
+        let pk = secp256k1::PublicKey::from_secret_key(&ctx, sk);
+
+        // Generate k
+        let mut k = Self::generate_k(sk, message);
+
+        // Compute R = k * G
+        let r = secp256k1::PublicKey::from_secret_key(&ctx, &k);
+
+        // Negate k if value of jacobi(R.y) is not 1
+        if jacobi(&r.serialize_uncompressed()[33..]) != 1 {
+            k = k.negate();
+        }
+
+        // Compute e = sha256(R.x, pk, message)
+        let e = Self::compute_e(&r.serialize()[1..33], &pk, message)?;
+
+        // Compute s = k + ep
+        let sigma = {
+            let mut result = e;
+            result = result.mul_tweak(&Scalar::from(*sk))?;
+            result = result.add_tweak(&Scalar::from(k))?;
+            result
+        };
+
+        let mut r_x = [0u8; 32];
+        r_x.clone_from_slice(&r.serialize()[1..33]);
+
+        Ok(Signature { r_x, sigma: to_bytes(&sigma) })
+    }
+
+    /// Verify signature
+    pub fn verify(&self, message: &[u8; 32], pk: &PublicKey) -> Result<(), Error> {
+        self.verify_inner(message, &pk.inner)
+    }
+
+    fn verify_inner(&self, message: &[u8; 32], pk: &secp256k1::PublicKey) -> Result<(), Error> {
+        let ctx = secp256k1::Secp256k1::verification_only();
+
+        // Extract s
+        let s = secp256k1::SecretKey::from_slice(&self.sigma[..])?;
+
+        // Compute e
+        let mut e = Self::compute_e(&self.r_x[..], pk, message)?;
+
+        // Compute R = sG - eP
+        let r = {
+            e = e.negate();
+            let minus_ep = {
+                let mut result = *pk;
+                result = result.mul_tweak(&ctx, &Scalar::from(e))?;
+                result
+            };
+
+            let sg = {
+                let mut result = PublicKey::generator().inner;
+                result = result.mul_tweak(&ctx, &Scalar::from(s))?;
+                result
+            };
+
+            sg.combine(&minus_ep)?
+        };
+
+        // Check that R.x is what we expect
+        if r.serialize()[1..33] != self.r_x {
+            return Err(Error::InvalidSignature);
+        }
+
+        // Check that jacobi(R.y) is 1
+        if jacobi(&r.serialize_uncompressed()[33..]) != 1 {
+            return Err(Error::InvalidSignature);
+        }
+
+        Ok(())
+    }
+
+    /// Compute e
+    fn compute_e(
+        r_x: &[u8],
+        pk: &secp256k1::PublicKey,
+        message: &[u8; 32],
+    ) -> Result<SecretKey, secp256k1::Error> {
+        let mut engine = sha256::Hash::engine();
+        engine.input(r_x);
+        engine.input(&pk.serialize()[..]);
+        engine.input(message);
+        let hash = sha256::Hash::from_engine(engine);
+
+        Ok(SecretKey::from_slice(&hash[..])?)
+    }
+
+    fn generate_k(sk: &SecretKey, message: &[u8; 32]) -> SecretKey {
+        let mut count: u32 = 0;
+
+        loop {
+            let nonce = nonce_rfc6979(message, sk, &ALGO16, None, count);
+            count += 1;
+
+            if let Ok(k) = SecretKey::from_slice(&nonce[..]) {
+                return k;
+            }
+        }
+    }
+}
+
+fn to_bytes(sk: &secp256k1::SecretKey) -> [u8; 32] {
+    let mut r = [0u8; 32];
+    r.clone_from_slice(&sk[..]);
+    r
+}
+
+impl Default for Signature {
+    fn default() -> Self {
+        Signature { sigma: [0u8; SECP256K1_SCALAR_SIZE], r_x: [0u8; SECP256K1_SCALAR_SIZE] }
+    }
+}
+
+impl_consensus_encoding!(Signature, r_x, sigma);
+
+/// Signature error
+#[derive(Debug)]
+pub enum Error {
+    /// Invalid Signature Error
+    InvalidSignature,
+    /// secp256k1 error
+    Secp256k1Error(secp256k1::Error),
+}
+
+#[doc(hidden)]
+impl From<secp256k1::Error> for Error {
+    fn from(e: secp256k1::Error) -> Error { Error::Secp256k1Error(e) }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Error::Secp256k1Error(ref e) => fmt::Display::fmt(e, f),
+            Error::InvalidSignature => f.write_str("Invalid signature"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Error::Secp256k1Error(ref e) => Some(e),
+            Error::InvalidSignature => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use hex::{DisplayHex, FromHex};
+
+    use super::*;
+    use crate::consensus::encode::{deserialize, serialize};
+    use crate::crypto::test_helpers::{
+        decode_message, decode_pk, decode_signature, decode_sk, pk_from,
+    };
+    use crate::hashes::Hash;
+
+    #[test]
+    fn test_p2p_sign_and_verify() {
+        for n in 0..16 {
+            let msg = {
+                let m = format!("Very secret message {}: 11", n);
+                let hash = crate::hashes::sha256::Hash::hash(m.as_bytes());
+                hash.to_byte_array()
+            };
+
+            let key = PrivateKey::from_wif("5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj")
+                .unwrap();
+
+            let sign = Signature::sign(&key, &msg).unwrap();
+
+            let ctx = secp256k1::Secp256k1::signing_only();
+            assert!(sign.verify(&msg, &key.public_key(&ctx)).is_ok());
+        }
+    }
+
+    /// these test vectors from here https://github.com/chaintope/tapyrus-schnorr-signature-test-vectors
+    #[test]
+    fn test_signing_and_verification() {
+        let default_message =
+            decode_message("243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89");
+        let default_pk =
+            decode_pk("02DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659");
+
+        // test vector 0
+        let sk = decode_sk("0000000000000000000000000000000000000000000000000000000000000001");
+        let pk = pk_from(&sk);
+        let message =
+            decode_message("0000000000000000000000000000000000000000000000000000000000000000");
+        let sign = Signature::sign_inner(&sk, &message).unwrap();
+
+        assert_eq!("06705D6B7FD5A7A34EA47B6A8D0CE8372A83D2129A65458E2BEF6F45892E7D5DBB13B346C6937CB76D25EFB18979B6523C72B56DD13B8F9D2F180893D20ECF45",
+                   serialize(&sign).to_upper_hex_string());
+        assert!(sign.verify_inner(&message, &pk).is_ok());
+
+        // test vector 1
+        let sk = decode_sk("B7E151628AED2A6ABF7158809CF4F3C762E7160F38B4DA56A784D9045190CFEF");
+        let pk = pk_from(&sk);
+        let message =
+            decode_message("243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89");
+        let sign = Signature::sign_inner(&sk, &message).unwrap();
+
+        assert_eq!("28C528B8E405F81CE9B396755849E24A316A12A0B7BC77CEBCB8C01DAD63AB53C79B5363B04C1046F021F5E28A20D2506C38B1598F3BE79235C5421AC98400B9",
+                   serialize(&sign).to_upper_hex_string());
+        assert!(sign.verify_inner(&message, &pk).is_ok());
+
+        // test vector 2
+        let sk = decode_sk("C90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B14E5C9");
+        let pk = pk_from(&sk);
+        let message =
+            decode_message("5E2D58D8B3BCDF1ABADEC7829054F90DDA9805AAB56C77333024B9D0A508B75C");
+        let sign = Signature::sign_inner(&sk, &message).unwrap();
+
+        assert_eq!("028CD7B45D8C265C9EA76A3633F09E48A3594558EBA0E2A10186ED1BFA1C8E0702B1EE67112B6CE4F5DD1CDFB4709B7628D71C6C74E8EA65B793A5267CA667F7",
+                   serialize(&sign).to_upper_hex_string());
+        assert!(sign.verify_inner(&message, &pk).is_ok());
+
+        // test vector 3, test fails if msg is reduced modulo p or n
+        let sk = decode_sk("0B432B2677937381AEF05BB02A66ECD012773062CF3FA2549E44F58ED2401710");
+        let pk = pk_from(&sk);
+        let message =
+            decode_message("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
+        let sign = Signature::sign_inner(&sk, &message).unwrap();
+
+        assert_eq!("E56D33673C16E2FCB1C8ABFE1065D1058109C1B051BBC0E7450DC6DE9A3C78B5ADCAFC135086D9DED95E3794E3B24F81E01ED232C9F0C59161E1930939FB05D7",
+                   serialize(&sign).to_upper_hex_string());
+        assert!(sign.verify_inner(&message, &pk).is_ok());
+
+        // test vector 4
+        let pk = decode_pk("03D69C3509BB99E412E68B0FE8544E72837DFA30746D8BE2AA65975F29D22DC7B9");
+        let message =
+            decode_message("4DF3C3F68FCC83B27E9D42C90431A72499F17875C81A599B566C9889B9696703");
+        let sign = decode_signature("00000000000000000000003B78CE563F89A0ED9414F5AA28AD0D96D6795F9C63BAFC1D697AADBEB208CB8249CC7D9725A0FF8DA59AE04F68349A1EA06D072266");
+        assert!(sign.verify_inner(&message, &pk).is_ok());
+
+        // test vector 5, public key not on the curve
+        let pk =
+            &Vec::from_hex("02EEFDEA4CDB677750A420FEE807EACF21EB9898AE79B9768766E4FAA04A2D4A34")
+                .unwrap();
+        assert!(secp256k1::PublicKey::from_slice(&pk[..]).is_err());
+
+        // test vector 6, has_square_y(R) is false
+        let sign = decode_signature("F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F91DB49FABFB32B7EAD6D52CF16E38918D26F5C08E3B42D34EF90C29523D5BCA92");
+        assert!(sign.verify_inner(&default_message, &default_pk).is_err());
+
+        // test vector 7, negated message
+        let sign = decode_signature("9A44BCAB38B9EAB28608F673740BC3353BC8C188E949A02E0EFE09B9B1927406FD7546CAAFC5B703FD0A452E4FF3C257E49344885727CBE0F20491D561CD0852");
+        assert!(sign.verify_inner(&default_message, &default_pk).is_err());
+
+        // test vector 8, negated s value
+        let sign = decode_signature("28C528B8E405F81CE9B396755849E24A316A12A0B7BC77CEBCB8C01DAD63AB533864AC9C4FB3EFB90FDE0A1D75DF2DAE4E762B8D200CB8A98A0D1C7206B24088");
+        assert!(sign.verify_inner(&default_message, &default_pk).is_err());
+
+        // test vector 9, sG - eP is infinite. Test fails in single verification if has_square_y(inf) is defined as true and x(inf) as 0
+        let sign = decode_signature("00000000000000000000000000000000000000000000000000000000000000009E9D01AF988B5CEDCE47221BFA9B222721F3FA408915444A4B489021DB55775F");
+        assert!(sign.verify_inner(&default_message, &default_pk).is_err());
+
+        // test vector 10, sG - eP is infinite. Test fails in single verification if has_square_y(inf) is defined as true and x(inf) as 1
+        let sign = decode_signature("0000000000000000000000000000000000000000000000000000000000000000DDE56901145852D60EE498A24C6B6B74370CBBE91F671E945956829EB8B62F90");
+        assert!(sign.verify_inner(&default_message, &default_pk).is_err());
+
+        // test vector 11, sig[0:32] is not an X coordinate on the curve
+        let sign = decode_signature("4A298DACAE57395A15D0795DDBFD1DCB564DA82B0F269BC70A74F8220429BA1DC79B5363B04C1046F021F5E28A20D2506C38B1598F3BE79235C5421AC98400B9");
+        assert!(sign.verify_inner(&default_message, &default_pk).is_err());
+
+        // test vector 12, sig[0:32] is equal to field size
+        let sign = decode_signature("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2FC79B5363B04C1046F021F5E28A20D2506C38B1598F3BE79235C5421AC98400B9");
+        assert!(sign.verify_inner(&default_message, &default_pk).is_err());
+
+        // test vector 13, sig[32:64] is equal to curve order
+        let sign = decode_signature("28C528B8E405F81CE9B396755849E24A316A12A0B7BC77CEBCB8C01DAD63AB53FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
+        assert!(sign.verify_inner(&default_message, &default_pk).is_err());
+
+        // test vector 14, public key is not a valid X coordinate because it exceeds the field size
+        let pk =
+            &Vec::from_hex("02FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC30")
+                .unwrap();
+        assert!(secp256k1::PublicKey::from_slice(&pk[..]).is_err());
+    }
+
+    #[test]
+    fn test_decode() {
+        let sig_data =
+            Vec::from_hex("6ba8aee2e8cee077cb4a799c770e417fb750586ee5dd9f61db65f5158a596e77aaa87e4fec16c70b102bbe99a6c4fe77be424a44a2f5cfdc5fe04d5b4bca799c").unwrap();
+
+        let r_x = <[u8; 32]>::from_hex(
+            "6ba8aee2e8cee077cb4a799c770e417fb750586ee5dd9f61db65f5158a596e77",
+        )
+        .unwrap();
+        let sigma = <[u8; 32]>::from_hex(
+            "aaa87e4fec16c70b102bbe99a6c4fe77be424a44a2f5cfdc5fe04d5b4bca799c",
+        )
+        .unwrap();
+
+        let decode: Result<Signature, _> = deserialize(&sig_data);
+        assert!(decode.is_ok());
+
+        let real_decode = decode.unwrap();
+        assert_eq!(real_decode.sigma, sigma);
+        assert_eq!(real_decode.r_x, r_x);
+        assert_eq!(serialize(&real_decode), sig_data);
+    }
+}
diff --git a/tapyrus/src/crypto/sighash.rs b/tapyrus/src/crypto/sighash.rs
new file mode 100644
index 00000000..d04fa6d0
--- /dev/null
+++ b/tapyrus/src/crypto/sighash.rs
@@ -0,0 +1,1987 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Signature hash implementation (used in transaction signing).
+//!
+//! Efficient implementation of the algorithm to compute the message to be signed according to
+//! [Bip341](https://github.com/bitcoin/bips/blob/150ab6f5c3aca9da05fccc5b435e9667853407f4/bip-0341.mediawiki),
+//! [Bip143](https://github.com/bitcoin/bips/blob/99701f68a88ce33b2d0838eb84e115cef505b4c2/bip-0143.mediawiki)
+//! and legacy (before Bip143).
+//!
+//! Computing signature hashes is required to sign a transaction and this module is designed to
+//! handle its complexity efficiently. Computing these hashes is as simple as creating
+//! [`SighashCache`] and calling its methods.
+
+use core::borrow::{Borrow, BorrowMut};
+use core::{fmt, str};
+
+use hashes::{hash_newtype, sha256, sha256d, sha256t_hash_newtype, Hash};
+
+use crate::blockdata::witness::Witness;
+use crate::consensus::{encode, Encodable};
+use crate::prelude::*;
+use crate::taproot::{LeafVersion, TapLeafHash, TAPROOT_ANNEX_PREFIX};
+use crate::{io, Amount, Script, ScriptBuf, Sequence, Transaction, TxIn, TxOut};
+
+/// Used for signature hash for invalid use of SIGHASH_SINGLE.
+#[rustfmt::skip]
+pub(crate) const UINT256_ONE: [u8; 32] = [
+    1, 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
+];
+
+macro_rules! impl_thirty_two_byte_hash {
+    ($ty:ident) => {
+        impl secp256k1::ThirtyTwoByteHash for $ty {
+            fn into_32(self) -> [u8; 32] { self.to_byte_array() }
+        }
+    };
+}
+
+hash_newtype! {
+    /// Hash of a transaction according to the legacy signature algorithm.
+    #[hash_newtype(forward)]
+    pub struct LegacySighash(sha256d::Hash);
+
+    /// Hash of a transaction according to the segwit version 0 signature algorithm.
+    #[hash_newtype(forward)]
+    pub struct SegwitV0Sighash(sha256d::Hash);
+}
+
+impl_thirty_two_byte_hash!(LegacySighash);
+impl_thirty_two_byte_hash!(SegwitV0Sighash);
+
+sha256t_hash_newtype! {
+    pub struct TapSighashTag = hash_str("TapSighash");
+
+    /// Taproot-tagged hash with tag \"TapSighash\".
+    ///
+    /// This hash type is used for computing taproot signature hash."
+    #[hash_newtype(forward)]
+    pub struct TapSighash(_);
+}
+
+impl_thirty_two_byte_hash!(TapSighash);
+
+/// Efficiently calculates signature hash message for legacy, segwit and taproot inputs.
+#[derive(Debug)]
+pub struct SighashCache<T: Borrow<Transaction>> {
+    /// Access to transaction required for transaction introspection. Moreover, type
+    /// `T: Borrow<Transaction>` allows us to use borrowed and mutable borrowed types,
+    /// the latter in particular is necessary for [`SighashCache::witness_mut`].
+    tx: T,
+
+    /// Common cache for taproot and segwit inputs, `None` for legacy inputs.
+    common_cache: Option<CommonCache>,
+
+    /// Cache for segwit v0 inputs (the result of another round of sha256 on `common_cache`).
+    segwit_cache: Option<SegwitCache>,
+
+    /// Cache for taproot v1 inputs.
+    taproot_cache: Option<TaprootCache>,
+}
+
+/// Common values cached between segwit and taproot inputs.
+#[derive(Debug)]
+struct CommonCache {
+    prevouts: sha256::Hash,
+    sequences: sha256::Hash,
+
+    /// In theory `outputs` could be an `Option` since `SIGHASH_NONE` and `SIGHASH_SINGLE` do not
+    /// need it, but since `SIGHASH_ALL` is by far the most used variant we don't bother.
+    outputs: sha256::Hash,
+}
+
+/// Values cached for segwit inputs, equivalent to [`CommonCache`] plus another round of `sha256`.
+#[derive(Debug)]
+struct SegwitCache {
+    prevouts: sha256d::Hash,
+    sequences: sha256d::Hash,
+    outputs: sha256d::Hash,
+}
+
+/// Values cached for taproot inputs.
+#[derive(Debug)]
+struct TaprootCache {
+    amounts: sha256::Hash,
+    script_pubkeys: sha256::Hash,
+}
+
+/// Contains outputs of previous transactions. In the case [`TapSighashType`] variant is
+/// `SIGHASH_ANYONECANPAY`, [`Prevouts::One`] may be used.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum Prevouts<'u, T>
+where
+    T: 'u + Borrow<TxOut>,
+{
+    /// `One` variant allows provision of the single prevout needed. It's useful, for example, when
+    /// modifier `SIGHASH_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, T),
+    /// When `SIGHASH_ANYONECANPAY` is not provided, or when the caller is giving all prevouts so
+    /// the same variable can be used for multiple inputs.
+    All(&'u [T]),
+}
+
+const KEY_VERSION_0: u8 = 0u8;
+
+/// Information related to the script path spending.
+///
+/// This can be hashed into a [`TapLeafHash`].
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub struct ScriptPath<'s> {
+    script: &'s Script,
+    leaf_version: LeafVersion,
+}
+
+/// Hashtype of an input's signature, encoded in the last byte of the signature.
+/// Fixed values so they can be cast as integer types for encoding.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum TapSighashType {
+    /// 0x0: Used when not explicitly specified, defaults to [`TapSighashType::All`]
+    Default = 0x00,
+    /// 0x1: Sign all outputs.
+    All = 0x01,
+    /// 0x2: Sign no outputs --- anyone can choose the destination.
+    None = 0x02,
+    /// 0x3: Sign the output whose index matches this input's index. If none exists,
+    /// sign the hash `0000000000000000000000000000000000000000000000000000000000000001`.
+    /// (This rule is probably an unintentional C++ism, but it's consensus so we have
+    /// to follow it.)
+    Single = 0x03,
+    /// 0x81: Sign all outputs but only this input.
+    AllPlusAnyoneCanPay = 0x81,
+    /// 0x82: Sign no outputs and only this input.
+    NonePlusAnyoneCanPay = 0x82,
+    /// 0x83: Sign one output and only this input (see `Single` for what "one output" means).
+    SinglePlusAnyoneCanPay = 0x83,
+}
+#[cfg(feature = "serde")]
+crate::serde_utils::serde_string_impl!(TapSighashType, "a TapSighashType data");
+
+impl fmt::Display for TapSighashType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use TapSighashType::*;
+
+        let s = match self {
+            Default => "SIGHASH_DEFAULT",
+            All => "SIGHASH_ALL",
+            None => "SIGHASH_NONE",
+            Single => "SIGHASH_SINGLE",
+            AllPlusAnyoneCanPay => "SIGHASH_ALL|SIGHASH_ANYONECANPAY",
+            NonePlusAnyoneCanPay => "SIGHASH_NONE|SIGHASH_ANYONECANPAY",
+            SinglePlusAnyoneCanPay => "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY",
+        };
+        f.write_str(s)
+    }
+}
+
+impl str::FromStr for TapSighashType {
+    type Err = SighashTypeParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use TapSighashType::*;
+
+        match s {
+            "SIGHASH_DEFAULT" => Ok(Default),
+            "SIGHASH_ALL" => Ok(All),
+            "SIGHASH_NONE" => Ok(None),
+            "SIGHASH_SINGLE" => Ok(Single),
+            "SIGHASH_ALL|SIGHASH_ANYONECANPAY" => Ok(AllPlusAnyoneCanPay),
+            "SIGHASH_NONE|SIGHASH_ANYONECANPAY" => Ok(NonePlusAnyoneCanPay),
+            "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY" => Ok(SinglePlusAnyoneCanPay),
+            _ => Err(SighashTypeParseError { unrecognized: s.to_owned() }),
+        }
+    }
+}
+
+/// Possible errors in computing the signature message.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    /// Could happen only by using `*_encode_signing_*` methods with custom writers, engines writers
+    /// like the ones used in methods `*_signature_hash` do not error.
+    Io(io::ErrorKind),
+
+    /// Requested index is greater or equal than the number of inputs in the transaction.
+    IndexOutOfInputsBounds {
+        /// Requested index.
+        index: usize,
+        /// Number of transaction inputs.
+        inputs_size: usize,
+    },
+
+    /// 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.
+        index: usize,
+        /// Number of transaction outputs.
+        outputs_size: usize,
+    },
+
+    /// There are mismatches in the number of prevouts provided compared to the number of inputs in
+    /// the transaction.
+    PrevoutsSize,
+
+    /// Requested a prevout index which is greater than the number of prevouts provided or a
+    /// [`Prevouts::One`] with different index.
+    PrevoutIndex,
+
+    /// A single prevout has been provided but all prevouts are needed unless using
+    /// `SIGHASH_ANYONECANPAY`.
+    PrevoutKind,
+
+    /// Annex must be at least one byte long and the first bytes must be `0x50`.
+    WrongAnnex,
+
+    /// Invalid Sighash type.
+    InvalidSighashType(u32),
+
+    /// Script is not a witness program for a p2wpkh output.
+    NotP2wpkhScript,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            Io(error_kind) => write!(f, "writer errored: {:?}", error_kind),
+            IndexOutOfInputsBounds { index, inputs_size } => write!(f, "requested index ({}) is greater or equal than the number of transaction inputs ({})", index, inputs_size),
+            SingleWithoutCorrespondingOutput { index, outputs_size } => write!(f, "SIGHASH_SINGLE for input ({}) haven't a corresponding output (#outputs:{})", index, outputs_size),
+            PrevoutsSize => write!(f, "number of supplied prevouts differs from the number of inputs in transaction"),
+            PrevoutIndex => write!(f, "the index requested is greater than available prevouts or different from the provided [Provided::Anyone] index"),
+            PrevoutKind => write!(f, "a single prevout has been provided but all prevouts are needed without `ANYONECANPAY`"),
+            WrongAnnex => write!(f, "annex must be at least one byte long and the first bytes must be `0x50`"),
+            InvalidSighashType(hash_ty) => write!(f, "Invalid taproot signature hash type : {} ", hash_ty),
+            NotP2wpkhScript => write!(f, "script is not a script pubkey for a p2wpkh output"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            Io(_)
+            | IndexOutOfInputsBounds { .. }
+            | SingleWithoutCorrespondingOutput { .. }
+            | PrevoutsSize
+            | PrevoutIndex
+            | PrevoutKind
+            | WrongAnnex
+            | InvalidSighashType(_)
+            | NotP2wpkhScript => None,
+        }
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self { Error::Io(e.kind()) }
+}
+
+impl<'u, T> Prevouts<'u, 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() {
+                return Err(Error::PrevoutsSize);
+            }
+        }
+        Ok(())
+    }
+
+    fn get_all(&self) -> Result<&[T], Error> {
+        match self {
+            Prevouts::All(prevouts) => Ok(*prevouts),
+            _ => Err(Error::PrevoutKind),
+        }
+    }
+
+    fn get(&self, input_index: usize) -> Result<&TxOut, Error> {
+        match self {
+            Prevouts::One(index, prevout) =>
+                if input_index == *index {
+                    Ok(prevout.borrow())
+                } else {
+                    Err(Error::PrevoutIndex)
+                },
+            Prevouts::All(prevouts) =>
+                prevouts.get(input_index).map(|x| x.borrow()).ok_or(Error::PrevoutIndex),
+        }
+    }
+}
+
+impl<'s> ScriptPath<'s> {
+    /// Creates a new `ScriptPath` structure.
+    pub fn new(script: &'s Script, leaf_version: LeafVersion) -> Self {
+        ScriptPath { script, leaf_version }
+    }
+    /// Creates a new `ScriptPath` structure using default leaf version value.
+    pub fn with_defaults(script: &'s Script) -> Self { Self::new(script, LeafVersion::TapScript) }
+    /// Computes the leaf hash for this `ScriptPath`.
+    pub fn leaf_hash(&self) -> TapLeafHash {
+        let mut enc = TapLeafHash::engine();
+
+        self.leaf_version
+            .to_consensus()
+            .consensus_encode(&mut enc)
+            .expect("writing to hash enging should never fail");
+        self.script.consensus_encode(&mut enc).expect("writing to hash enging should never fail");
+
+        TapLeafHash::from_engine(enc)
+    }
+}
+
+impl<'s> From<ScriptPath<'s>> for TapLeafHash {
+    fn from(script_path: ScriptPath<'s>) -> TapLeafHash { script_path.leaf_hash() }
+}
+
+/// Hashtype of an input's signature, encoded in the last byte of the signature.
+///
+/// Fixed values so they can be cast as integer types for encoding (see also
+/// [`TapSighashType`]).
+#[derive(PartialEq, Eq, Debug, Copy, Clone, Hash)]
+pub enum EcdsaSighashType {
+    /// 0x1: Sign all outputs.
+    All = 0x01,
+    /// 0x2: Sign no outputs --- anyone can choose the destination.
+    None = 0x02,
+    /// 0x3: Sign the output whose index matches this input's index. If none exists,
+    /// sign the hash `0000000000000000000000000000000000000000000000000000000000000001`.
+    /// (This rule is probably an unintentional C++ism, but it's consensus so we have
+    /// to follow it.)
+    Single = 0x03,
+    /// 0x81: Sign all outputs but only this input.
+    AllPlusAnyoneCanPay = 0x81,
+    /// 0x82: Sign no outputs and only this input.
+    NonePlusAnyoneCanPay = 0x82,
+    /// 0x83: Sign one output and only this input (see `Single` for what "one output" means).
+    SinglePlusAnyoneCanPay = 0x83,
+}
+#[cfg(feature = "serde")]
+crate::serde_utils::serde_string_impl!(EcdsaSighashType, "a EcdsaSighashType data");
+
+impl fmt::Display for EcdsaSighashType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use EcdsaSighashType::*;
+
+        let s = match self {
+            All => "SIGHASH_ALL",
+            None => "SIGHASH_NONE",
+            Single => "SIGHASH_SINGLE",
+            AllPlusAnyoneCanPay => "SIGHASH_ALL|SIGHASH_ANYONECANPAY",
+            NonePlusAnyoneCanPay => "SIGHASH_NONE|SIGHASH_ANYONECANPAY",
+            SinglePlusAnyoneCanPay => "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY",
+        };
+        f.write_str(s)
+    }
+}
+
+impl str::FromStr for EcdsaSighashType {
+    type Err = SighashTypeParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use EcdsaSighashType::*;
+
+        match s {
+            "SIGHASH_ALL" => Ok(All),
+            "SIGHASH_NONE" => Ok(None),
+            "SIGHASH_SINGLE" => Ok(Single),
+            "SIGHASH_ALL|SIGHASH_ANYONECANPAY" => Ok(AllPlusAnyoneCanPay),
+            "SIGHASH_NONE|SIGHASH_ANYONECANPAY" => Ok(NonePlusAnyoneCanPay),
+            "SIGHASH_SINGLE|SIGHASH_ANYONECANPAY" => Ok(SinglePlusAnyoneCanPay),
+            _ => Err(SighashTypeParseError { unrecognized: s.to_owned() }),
+        }
+    }
+}
+
+impl EcdsaSighashType {
+    /// Splits the sighash flag into the "real" sighash flag and the ANYONECANPAY boolean.
+    pub(crate) fn split_anyonecanpay_flag(self) -> (EcdsaSighashType, bool) {
+        use EcdsaSighashType::*;
+
+        match self {
+            All => (All, false),
+            None => (None, false),
+            Single => (Single, false),
+            AllPlusAnyoneCanPay => (All, true),
+            NonePlusAnyoneCanPay => (None, true),
+            SinglePlusAnyoneCanPay => (Single, true),
+        }
+    }
+
+    /// Creates a [`EcdsaSighashType`] from a raw `u32`.
+    ///
+    /// **Note**: this replicates consensus behaviour, for current standardness rules correctness
+    /// you probably want [`Self::from_standard`].
+    ///
+    /// This might cause unexpected behavior because it does not roundtrip. That is,
+    /// `EcdsaSighashType::from_consensus(n) as u32 != n` for non-standard values of `n`. While
+    /// verifying signatures, the user should retain the `n` and use it compute the signature hash
+    /// message.
+    pub fn from_consensus(n: u32) -> EcdsaSighashType {
+        use EcdsaSighashType::*;
+
+        // In Bitcoin Core, the SignatureHash function will mask the (int32) value with
+        // 0x1f to (apparently) deactivate ACP when checking for SINGLE and NONE bits.
+        // We however want to be matching also against on ACP-masked ALL, SINGLE, and NONE.
+        // So here we re-activate ACP.
+        let mask = 0x1f | 0x80;
+        match n & mask {
+            // "real" sighashes
+            0x01 => All,
+            0x02 => None,
+            0x03 => Single,
+            0x81 => AllPlusAnyoneCanPay,
+            0x82 => NonePlusAnyoneCanPay,
+            0x83 => SinglePlusAnyoneCanPay,
+            // catchalls
+            x if x & 0x80 == 0x80 => AllPlusAnyoneCanPay,
+            _ => All,
+        }
+    }
+
+    /// Creates a [`EcdsaSighashType`] from a raw `u32`.
+    ///
+    /// # Errors
+    ///
+    /// If `n` is a non-standard sighash value.
+    pub fn from_standard(n: u32) -> Result<EcdsaSighashType, NonStandardSighashTypeError> {
+        use EcdsaSighashType::*;
+
+        match n {
+            // Standard sighashes, see https://github.com/bitcoin/bitcoin/blob/b805dbb0b9c90dadef0424e5b3bf86ac308e103e/src/script/interpreter.cpp#L189-L198
+            0x01 => Ok(All),
+            0x02 => Ok(None),
+            0x03 => Ok(Single),
+            0x81 => Ok(AllPlusAnyoneCanPay),
+            0x82 => Ok(NonePlusAnyoneCanPay),
+            0x83 => Ok(SinglePlusAnyoneCanPay),
+            non_standard => Err(NonStandardSighashTypeError(non_standard)),
+        }
+    }
+
+    /// Converts [`EcdsaSighashType`] to a `u32` sighash flag.
+    ///
+    /// The returned value is guaranteed to be a valid according to standardness rules.
+    pub fn to_u32(self) -> u32 { self as u32 }
+}
+
+impl From<EcdsaSighashType> for TapSighashType {
+    fn from(s: EcdsaSighashType) -> Self {
+        use TapSighashType::*;
+
+        match s {
+            EcdsaSighashType::All => All,
+            EcdsaSighashType::None => None,
+            EcdsaSighashType::Single => Single,
+            EcdsaSighashType::AllPlusAnyoneCanPay => AllPlusAnyoneCanPay,
+            EcdsaSighashType::NonePlusAnyoneCanPay => NonePlusAnyoneCanPay,
+            EcdsaSighashType::SinglePlusAnyoneCanPay => SinglePlusAnyoneCanPay,
+        }
+    }
+}
+
+impl TapSighashType {
+    /// Breaks the sighash flag into the "real" sighash flag and the `SIGHASH_ANYONECANPAY` boolean.
+    pub(crate) fn split_anyonecanpay_flag(self) -> (TapSighashType, bool) {
+        use TapSighashType::*;
+
+        match self {
+            Default => (Default, false),
+            All => (All, false),
+            None => (None, false),
+            Single => (Single, false),
+            AllPlusAnyoneCanPay => (All, true),
+            NonePlusAnyoneCanPay => (None, true),
+            SinglePlusAnyoneCanPay => (Single, true),
+        }
+    }
+
+    /// Constructs a [`TapSighashType`] from a raw `u8`.
+    pub fn from_consensus_u8(hash_ty: u8) -> Result<Self, InvalidSighashTypeError> {
+        use TapSighashType::*;
+
+        Ok(match hash_ty {
+            0x00 => Default,
+            0x01 => All,
+            0x02 => None,
+            0x03 => Single,
+            0x81 => AllPlusAnyoneCanPay,
+            0x82 => NonePlusAnyoneCanPay,
+            0x83 => SinglePlusAnyoneCanPay,
+            x => return Err(InvalidSighashTypeError(x.into())),
+        })
+    }
+}
+
+/// Integer is not a consensus valid sighash type.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct InvalidSighashTypeError(pub u32);
+
+impl fmt::Display for InvalidSighashTypeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "invalid sighash type {}", self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for InvalidSighashTypeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// This type is consensus valid but an input including it would prevent the transaction from
+/// being relayed on today's Bitcoin network.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct NonStandardSighashTypeError(pub u32);
+
+impl fmt::Display for NonStandardSighashTypeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "non-standard sighash type {}", self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for NonStandardSighashTypeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// Error returned for failure during parsing one of the sighash types.
+///
+/// This is currently returned for unrecognized sighash strings.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct SighashTypeParseError {
+    /// The unrecognized string we attempted to parse.
+    pub unrecognized: String,
+}
+
+impl fmt::Display for SighashTypeParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "unrecognized SIGHASH string '{}'", self.unrecognized)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SighashTypeParseError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+impl<R: Borrow<Transaction>> SighashCache<R> {
+    /// Constructs a new `SighashCache` from an unsigned transaction.
+    ///
+    /// The sighash components are computed 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
+    /// witness.
+    pub fn new(tx: R) -> Self {
+        SighashCache { tx, common_cache: None, taproot_cache: None, segwit_cache: None }
+    }
+
+    /// Returns the reference to the cached transaction.
+    pub fn transaction(&self) -> &Transaction { self.tx.borrow() }
+
+    /// Destroys the cache and recovers the stored transaction.
+    pub fn into_transaction(self) -> R { self.tx }
+
+    /// Encodes the BIP341 signing data for any flag type into a given object implementing a
+    /// [`io::Write`] trait.
+    pub fn taproot_encode_signing_data_to<Write: io::Write, T: Borrow<TxOut>>(
+        &mut self,
+        mut writer: Write,
+        input_index: usize,
+        prevouts: &Prevouts<T>,
+        annex: Option<Annex>,
+        leaf_hash_code_separator: Option<(TapLeafHash, u32)>,
+        sighash_type: TapSighashType,
+    ) -> Result<(), Error> {
+        prevouts.check_all(self.tx.borrow())?;
+
+        let (sighash, anyone_can_pay) = sighash_type.split_anyonecanpay_flag();
+
+        // epoch
+        0u8.consensus_encode(&mut writer)?;
+
+        // * Control:
+        // hash_type (1).
+        (sighash_type as u8).consensus_encode(&mut writer)?;
+
+        // * Transaction Data:
+        // nVersion (4): the nVersion of the transaction.
+        self.tx.borrow().version.consensus_encode(&mut writer)?;
+
+        // nLockTime (4): the nLockTime of the transaction.
+        self.tx.borrow().lock_time.consensus_encode(&mut writer)?;
+
+        // If the hash_type & 0x80 does not equal SIGHASH_ANYONECANPAY:
+        //     sha_prevouts (32): the SHA256 of the serialization of all input outpoints.
+        //     sha_amounts (32): the SHA256 of the serialization of all spent output amounts.
+        //     sha_scriptpubkeys (32): the SHA256 of the serialization of all spent output scriptPubKeys.
+        //     sha_sequences (32): the SHA256 of the serialization of all input nSequence.
+        if !anyone_can_pay {
+            self.common_cache().prevouts.consensus_encode(&mut writer)?;
+            self.taproot_cache(prevouts.get_all()?).amounts.consensus_encode(&mut writer)?;
+            self.taproot_cache(prevouts.get_all()?).script_pubkeys.consensus_encode(&mut writer)?;
+            self.common_cache().sequences.consensus_encode(&mut writer)?;
+        }
+
+        // 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.
+        if sighash != TapSighashType::None && sighash != TapSighashType::Single {
+            self.common_cache().outputs.consensus_encode(&mut writer)?;
+        }
+
+        // * Data about this input:
+        // spend_type (1): equal to (ext_flag * 2) + annex_present, where annex_present is 0
+        // if no annex is present, or 1 otherwise
+        let mut spend_type = 0u8;
+        if annex.is_some() {
+            spend_type |= 1u8;
+        }
+        if leaf_hash_code_separator.is_some() {
+            spend_type |= 2u8;
+        }
+        spend_type.consensus_encode(&mut writer)?;
+
+        // If hash_type & 0x80 equals SIGHASH_ANYONECANPAY:
+        //      outpoint (36): the COutPoint of this input (32-byte hash + 4-byte little-endian).
+        //      amount (8): value of the previous output spent by this input.
+        //      scriptPubKey (35): scriptPubKey of the previous output spent by this input, serialized as script inside CTxOut. Its size is always 35 bytes.
+        //      nSequence (4): nSequence of this input.
+        if anyone_can_pay {
+            let txin =
+                &self.tx.borrow().input.get(input_index).ok_or(Error::IndexOutOfInputsBounds {
+                    index: input_index,
+                    inputs_size: self.tx.borrow().input.len(),
+                })?;
+            let previous_output = prevouts.get(input_index)?;
+            txin.previous_output.consensus_encode(&mut writer)?;
+            previous_output.value.consensus_encode(&mut writer)?;
+            previous_output.script_pubkey.consensus_encode(&mut writer)?;
+            txin.sequence.consensus_encode(&mut writer)?;
+        } else {
+            (input_index as u32).consensus_encode(&mut writer)?;
+        }
+
+        // If an annex is present (the lowest bit of spend_type is set):
+        //      sha_annex (32): the SHA256 of (compact_size(size of annex) || annex), where annex
+        //      includes the mandatory 0x50 prefix.
+        if let Some(annex) = annex {
+            let mut enc = sha256::Hash::engine();
+            annex.consensus_encode(&mut enc)?;
+            let hash = sha256::Hash::from_engine(enc);
+            hash.consensus_encode(&mut writer)?;
+        }
+
+        // * Data about this output:
+        // If hash_type & 3 equals SIGHASH_SINGLE:
+        //      sha_single_output (32): the SHA256 of the corresponding output in CTxOut format.
+        if sighash == TapSighashType::Single {
+            let mut enc = sha256::Hash::engine();
+            self.tx
+                .borrow()
+                .output
+                .get(input_index)
+                .ok_or(Error::SingleWithoutCorrespondingOutput {
+                    index: input_index,
+                    outputs_size: self.tx.borrow().output.len(),
+                })?
+                .consensus_encode(&mut enc)?;
+            let hash = sha256::Hash::from_engine(enc);
+            hash.consensus_encode(&mut writer)?;
+        }
+
+        //     if (scriptpath):
+        //         ss += TaggedHash("TapLeaf", bytes([leaf_ver]) + ser_string(script))
+        //         ss += bytes([0])
+        //         ss += struct.pack("<i", codeseparator_pos)
+        if let Some((hash, code_separator_pos)) = leaf_hash_code_separator {
+            hash.as_byte_array().consensus_encode(&mut writer)?;
+            KEY_VERSION_0.consensus_encode(&mut writer)?;
+            code_separator_pos.consensus_encode(&mut writer)?;
+        }
+
+        Ok(())
+    }
+
+    /// Computes the BIP341 sighash for any flag type.
+    pub fn taproot_signature_hash<T: Borrow<TxOut>>(
+        &mut self,
+        input_index: usize,
+        prevouts: &Prevouts<T>,
+        annex: Option<Annex>,
+        leaf_hash_code_separator: Option<(TapLeafHash, u32)>,
+        sighash_type: TapSighashType,
+    ) -> Result<TapSighash, Error> {
+        let mut enc = TapSighash::engine();
+        self.taproot_encode_signing_data_to(
+            &mut enc,
+            input_index,
+            prevouts,
+            annex,
+            leaf_hash_code_separator,
+            sighash_type,
+        )?;
+        Ok(TapSighash::from_engine(enc))
+    }
+
+    /// Computes the BIP341 sighash for a key spend.
+    pub fn taproot_key_spend_signature_hash<T: Borrow<TxOut>>(
+        &mut self,
+        input_index: usize,
+        prevouts: &Prevouts<T>,
+        sighash_type: TapSighashType,
+    ) -> Result<TapSighash, Error> {
+        let mut enc = TapSighash::engine();
+        self.taproot_encode_signing_data_to(
+            &mut enc,
+            input_index,
+            prevouts,
+            None,
+            None,
+            sighash_type,
+        )?;
+        Ok(TapSighash::from_engine(enc))
+    }
+
+    /// Computes 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>, T: Borrow<TxOut>>(
+        &mut self,
+        input_index: usize,
+        prevouts: &Prevouts<T>,
+        leaf_hash: S,
+        sighash_type: TapSighashType,
+    ) -> Result<TapSighash, Error> {
+        let mut enc = TapSighash::engine();
+        self.taproot_encode_signing_data_to(
+            &mut enc,
+            input_index,
+            prevouts,
+            None,
+            Some((leaf_hash.into(), 0xFFFFFFFF)),
+            sighash_type,
+        )?;
+        Ok(TapSighash::from_engine(enc))
+    }
+
+    /// Encodes the BIP143 signing data for any flag type into a given object implementing a
+    /// [`std::io::Write`] trait.
+    #[deprecated(since = "0.31.0", note = "use segwit_v0_encode_signing_data_to instead")]
+    pub fn segwit_encode_signing_data_to<Write: io::Write>(
+        &mut self,
+        writer: Write,
+        input_index: usize,
+        script_code: &Script,
+        value: Amount,
+        sighash_type: EcdsaSighashType,
+    ) -> Result<(), Error> {
+        self.segwit_v0_encode_signing_data_to(writer, input_index, script_code, value, sighash_type)
+    }
+
+    /// Encodes the BIP143 signing data for any flag type into a given object implementing a
+    /// [`std::io::Write`] trait.
+    ///
+    /// `script_code` is dependent on the type of the spend transaction. For p2wpkh use
+    /// [`Script::p2wpkh_script_code`], for p2wsh just pass in the witness script. (Also see
+    /// [`Self::p2wpkh_signature_hash`] and [`SighashCache::p2wsh_signature_hash`].)
+    pub fn segwit_v0_encode_signing_data_to<Write: io::Write>(
+        &mut self,
+        mut writer: Write,
+        input_index: usize,
+        script_code: &Script,
+        value: Amount,
+        sighash_type: EcdsaSighashType,
+    ) -> Result<(), Error> {
+        let zero_hash = sha256d::Hash::all_zeros();
+
+        let (sighash, anyone_can_pay) = sighash_type.split_anyonecanpay_flag();
+
+        self.tx.borrow().version.consensus_encode(&mut writer)?;
+
+        if !anyone_can_pay {
+            self.segwit_cache().prevouts.consensus_encode(&mut writer)?;
+        } else {
+            zero_hash.consensus_encode(&mut writer)?;
+        }
+
+        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)?;
+        }
+
+        {
+            let txin =
+                &self.tx.borrow().input.get(input_index).ok_or(Error::IndexOutOfInputsBounds {
+                    index: input_index,
+                    inputs_size: self.tx.borrow().input.len(),
+                })?;
+
+            txin.previous_output.consensus_encode(&mut writer)?;
+            script_code.consensus_encode(&mut writer)?;
+            value.consensus_encode(&mut writer)?;
+            txin.sequence.consensus_encode(&mut writer)?;
+        }
+
+        if sighash != EcdsaSighashType::Single && sighash != EcdsaSighashType::None {
+            self.segwit_cache().outputs.consensus_encode(&mut writer)?;
+        } else if sighash == EcdsaSighashType::Single && input_index < self.tx.borrow().output.len()
+        {
+            let mut single_enc = LegacySighash::engine();
+            self.tx.borrow().output[input_index].consensus_encode(&mut single_enc)?;
+            let hash = LegacySighash::from_engine(single_enc);
+            writer.write_all(&hash[..])?;
+        } else {
+            writer.write_all(&zero_hash[..])?;
+        }
+
+        self.tx.borrow().lock_time.consensus_encode(&mut writer)?;
+        sighash_type.to_u32().consensus_encode(&mut writer)?;
+        Ok(())
+    }
+
+    /// Computes the BIP143 sighash for any flag type.
+    #[deprecated(since = "0.31.0", note = "use (p2wpkh|p2wsh)_signature_hash instead")]
+    pub fn segwit_signature_hash(
+        &mut self,
+        input_index: usize,
+        script_code: &Script,
+        value: Amount,
+        sighash_type: EcdsaSighashType,
+    ) -> Result<SegwitV0Sighash, Error> {
+        let mut enc = SegwitV0Sighash::engine();
+        self.segwit_v0_encode_signing_data_to(
+            &mut enc,
+            input_index,
+            script_code,
+            value,
+            sighash_type,
+        )?;
+        Ok(SegwitV0Sighash::from_engine(enc))
+    }
+
+    /// Computes the BIP143 sighash to spend a p2wpkh transaction for any flag type.
+    ///
+    /// `script_pubkey` is the `scriptPubkey` (native segwit) of the spend transaction
+    /// ([`TxOut::script_pubkey`]) or the `redeemScript` (wrapped segwit).
+    pub fn p2wpkh_signature_hash(
+        &mut self,
+        input_index: usize,
+        script_pubkey: &Script,
+        value: Amount,
+        sighash_type: EcdsaSighashType,
+    ) -> Result<SegwitV0Sighash, Error> {
+        let script_code = script_pubkey.p2wpkh_script_code().ok_or(Error::NotP2wpkhScript)?;
+
+        let mut enc = SegwitV0Sighash::engine();
+        self.segwit_v0_encode_signing_data_to(
+            &mut enc,
+            input_index,
+            &script_code,
+            value,
+            sighash_type,
+        )?;
+        Ok(SegwitV0Sighash::from_engine(enc))
+    }
+
+    /// Computes the BIP143 sighash to spend a p2wsh transaction for any flag type.
+    pub fn p2wsh_signature_hash(
+        &mut self,
+        input_index: usize,
+        witness_script: &Script,
+        value: Amount,
+        sighash_type: EcdsaSighashType,
+    ) -> Result<SegwitV0Sighash, Error> {
+        let mut enc = SegwitV0Sighash::engine();
+        self.segwit_v0_encode_signing_data_to(
+            &mut enc,
+            input_index,
+            witness_script,
+            value,
+            sighash_type,
+        )?;
+        Ok(SegwitV0Sighash::from_engine(enc))
+    }
+
+    /// Encodes the legacy 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
+    /// [`EcdsaSighashType`] appended to the resulting sig, and a script written around this, but
+    /// this is the general (and hard) part.
+    ///
+    /// The `sighash_type` supports an arbitrary `u32` value, instead of just [`EcdsaSighashType`],
+    /// because internally 4 bytes are being hashed, even though only the lowest byte is appended to
+    /// signature in a transaction.
+    ///
+    /// # Warning
+    ///
+    /// - 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.
+    /// - Does NOT handle the sighash single bug (see "Return type" section)
+    ///
+    /// # Returns
+    ///
+    /// This function can't handle the SIGHASH_SINGLE bug internally, so it returns [`EncodeSigningDataResult`]
+    /// that must be handled by the caller (see [`EncodeSigningDataResult::is_sighash_single_bug`]).
+    pub fn legacy_encode_signing_data_to<Write: io::Write, U: Into<u32>>(
+        &self,
+        writer: Write,
+        input_index: usize,
+        script_pubkey: &Script,
+        sighash_type: U,
+    ) -> EncodeSigningDataResult<Error> {
+        if input_index >= self.tx.borrow().input.len() {
+            return EncodeSigningDataResult::WriteResult(Err(Error::IndexOutOfInputsBounds {
+                index: input_index,
+                inputs_size: self.tx.borrow().input.len(),
+            }));
+        }
+        let sighash_type: u32 = sighash_type.into();
+
+        if is_invalid_use_of_sighash_single(
+            sighash_type,
+            input_index,
+            self.tx.borrow().output.len(),
+        ) {
+            // We cannot correctly handle the SIGHASH_SINGLE bug here because usage of this function
+            // will result in the data written to the writer being hashed, however the correct
+            // handling of the SIGHASH_SINGLE bug is to return the 'one array' - either implement
+            // this behaviour manually or use `signature_hash()`.
+            return EncodeSigningDataResult::SighashSingleBug;
+        }
+
+        fn encode_signing_data_to_inner<Write: io::Write>(
+            self_: &Transaction,
+            mut writer: Write,
+            input_index: usize,
+            script_pubkey: &Script,
+            sighash_type: u32,
+        ) -> Result<(), io::Error> {
+            let (sighash, anyone_can_pay) =
+                EcdsaSighashType::from_consensus(sighash_type).split_anyonecanpay_flag();
+
+            // Build tx to sign
+            let mut tx = Transaction {
+                version: self_.version,
+                lock_time: self_.lock_time,
+                input: vec![],
+                output: vec![],
+            };
+            // Add all inputs necessary..
+            if anyone_can_pay {
+                tx.input = vec![TxIn {
+                    previous_output: self_.input[input_index].previous_output,
+                    script_sig: script_pubkey.to_owned(),
+                    sequence: self_.input[input_index].sequence,
+                    witness: Witness::default(),
+                }];
+            } else {
+                tx.input = Vec::with_capacity(self_.input.len());
+                for (n, input) in self_.input.iter().enumerate() {
+                    tx.input.push(TxIn {
+                        previous_output: input.previous_output,
+                        script_sig: if n == input_index {
+                            script_pubkey.to_owned()
+                        } else {
+                            ScriptBuf::new()
+                        },
+                        sequence: if n != input_index
+                            && (sighash == EcdsaSighashType::Single
+                                || sighash == EcdsaSighashType::None)
+                        {
+                            Sequence::ZERO
+                        } else {
+                            input.sequence
+                        },
+                        witness: Witness::default(),
+                    });
+                }
+            }
+            // ..then all outputs
+            tx.output = match sighash {
+                EcdsaSighashType::All => self_.output.clone(),
+                EcdsaSighashType::Single => {
+                    let output_iter = self_
+                        .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::NULL });
+                    output_iter.collect()
+                }
+                EcdsaSighashType::None => vec![],
+                _ => unreachable!(),
+            };
+            // hash the result
+            tx.consensus_encode(&mut writer)?;
+            sighash_type.to_le_bytes().consensus_encode(&mut writer)?;
+            Ok(())
+        }
+
+        EncodeSigningDataResult::WriteResult(
+            encode_signing_data_to_inner(
+                self.tx.borrow(),
+                writer,
+                input_index,
+                script_pubkey,
+                sighash_type,
+            )
+            .map_err(|e| Error::Io(e.kind())),
+        )
+    }
+
+    /// Computes a legacy 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
+    /// [`EcdsaSighashType`] appended to the resulting sig, and a script written around this, but
+    /// this is the general (and hard) part.
+    ///
+    /// The `sighash_type` supports an arbitrary `u32` value, instead of just [`EcdsaSighashType`],
+    /// because internally 4 bytes are being hashed, even though only the lowest byte is appended to
+    /// signature in a transaction.
+    ///
+    /// This function correctly handles the sighash single bug by returning the 'one array'. The
+    /// sighash single bug becomes exploitable when one tries to sign a transaction with
+    /// `SIGHASH_SINGLE` and there is not a corresponding output with the same index as the input.
+    ///
+    /// # Warning
+    ///
+    /// Does NOT attempt to support OP_CODESEPARATOR. In general this would require evaluating
+    /// `script_pubkey` to determine which separators get evaluated and which don't, which we don't
+    /// have the information to determine.
+    pub fn legacy_signature_hash(
+        &self,
+        input_index: usize,
+        script_pubkey: &Script,
+        sighash_type: u32,
+    ) -> Result<LegacySighash, Error> {
+        let mut enc = LegacySighash::engine();
+        if self
+            .legacy_encode_signing_data_to(&mut enc, input_index, script_pubkey, sighash_type)
+            .is_sighash_single_bug()?
+        {
+            Ok(LegacySighash::from_byte_array(UINT256_ONE))
+        } else {
+            Ok(LegacySighash::from_engine(enc))
+        }
+    }
+
+    #[inline]
+    fn common_cache(&mut self) -> &CommonCache {
+        Self::common_cache_minimal_borrow(&mut self.common_cache, self.tx.borrow())
+    }
+
+    fn common_cache_minimal_borrow<'a>(
+        common_cache: &'a mut Option<CommonCache>,
+        tx: &Transaction,
+    ) -> &'a CommonCache {
+        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() {
+                txin.previous_output.consensus_encode(&mut enc_prevouts).unwrap();
+                txin.sequence.consensus_encode(&mut enc_sequences).unwrap();
+            }
+            CommonCache {
+                prevouts: sha256::Hash::from_engine(enc_prevouts),
+                sequences: sha256::Hash::from_engine(enc_sequences),
+                outputs: {
+                    let mut enc = sha256::Hash::engine();
+                    for txout in tx.output.iter() {
+                        txout.consensus_encode(&mut enc).unwrap();
+                    }
+                    sha256::Hash::from_engine(enc)
+                },
+            }
+        })
+    }
+
+    fn segwit_cache(&mut self) -> &SegwitCache {
+        let common_cache = &mut self.common_cache;
+        let tx = self.tx.borrow();
+        self.segwit_cache.get_or_insert_with(|| {
+            let common_cache = Self::common_cache_minimal_borrow(common_cache, tx);
+            SegwitCache {
+                prevouts: common_cache.prevouts.hash_again(),
+                sequences: common_cache.sequences.hash_again(),
+                outputs: common_cache.outputs.hash_again(),
+            }
+        })
+    }
+
+    fn taproot_cache<T: Borrow<TxOut>>(&mut self, prevouts: &[T]) -> &TaprootCache {
+        self.taproot_cache.get_or_insert_with(|| {
+            let mut enc_amounts = sha256::Hash::engine();
+            let mut enc_script_pubkeys = sha256::Hash::engine();
+            for prevout in prevouts {
+                prevout.borrow().value.consensus_encode(&mut enc_amounts).unwrap();
+                prevout.borrow().script_pubkey.consensus_encode(&mut enc_script_pubkeys).unwrap();
+            }
+            TaprootCache {
+                amounts: sha256::Hash::from_engine(enc_amounts),
+                script_pubkeys: sha256::Hash::from_engine(enc_script_pubkeys),
+            }
+        })
+    }
+}
+
+impl<R: BorrowMut<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 tapyrus::{absolute, transaction, Amount, Transaction, Script};
+    /// use tapyrus::sighash::{EcdsaSighashType, SighashCache};
+    ///
+    /// let mut tx_to_sign = Transaction { version: transaction::Version::TWO, lock_time: absolute::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);
+    /// for inp in 0..input_count {
+    ///     let prevout_script = Script::new();
+    ///     let _sighash = sig_hasher.segwit_signature_hash(inp, prevout_script, Amount::ONE_TAP, 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 Witness> {
+        self.tx.borrow_mut().input.get_mut(input_index).map(|i| &mut i.witness)
+    }
+}
+
+/// The `Annex` struct is a slice wrapper enforcing first byte is `0x50`.
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub struct Annex<'a>(&'a [u8]);
+
+impl<'a> Annex<'a> {
+    /// Creates a new `Annex` struct checking the first byte is `0x50`.
+    pub fn new(annex_bytes: &'a [u8]) -> Result<Self, Error> {
+        if annex_bytes.first() == Some(&TAPROOT_ANNEX_PREFIX) {
+            Ok(Annex(annex_bytes))
+        } else {
+            Err(Error::WrongAnnex)
+        }
+    }
+
+    /// Returns the Annex bytes data (including first byte `0x50`).
+    pub fn as_bytes(&self) -> &[u8] { self.0 }
+}
+
+impl<'a> Encodable for Annex<'a> {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        encode::consensus_encode_with_size(self.0, w)
+    }
+}
+
+fn is_invalid_use_of_sighash_single(sighash: u32, input_index: usize, output_len: usize) -> bool {
+    let ty = EcdsaSighashType::from_consensus(sighash);
+    ty == EcdsaSighashType::Single && input_index >= output_len
+}
+
+/// Result of [`SighashCache::legacy_encode_signing_data_to`].
+///
+/// This type forces the caller to handle SIGHASH_SINGLE bug case.
+///
+/// This corner case can't be expressed using standard `Result`,
+/// in a way that is both convenient and not-prone to accidental
+/// mistakes (like calling `.expect("writer never fails")`).
+#[must_use]
+pub enum EncodeSigningDataResult<E> {
+    /// Input data is an instance of `SIGHASH_SINGLE` bug
+    SighashSingleBug,
+    /// Operation performed normally.
+    WriteResult(Result<(), E>),
+}
+
+impl<E> EncodeSigningDataResult<E> {
+    /// Checks for SIGHASH_SINGLE bug returning error if the writer failed.
+    ///
+    /// This method is provided for easy and correct handling of the result because
+    /// SIGHASH_SINGLE bug is a special case that must not be ignored nor cause panicking.
+    /// Since the data is usually written directly into a hasher which never fails,
+    /// the recommended pattern to handle this is:
+    ///
+    /// ```rust
+    /// # use tapyrus::consensus::deserialize;
+    /// # use tapyrus::hashes::{Hash, hex::FromHex};
+    /// # use tapyrus::sighash::{LegacySighash, SighashCache};
+    /// # use tapyrus::Transaction;
+    /// # let mut writer = LegacySighash::engine();
+    /// # let input_index = 0;
+    /// # let script_pubkey = tapyrus::ScriptBuf::new();
+    /// # let sighash_u32 = 0u32;
+    /// # const SOME_TX: &'static str = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
+    /// # let raw_tx = Vec::from_hex(SOME_TX).unwrap();
+    /// # let tx: Transaction = deserialize(&raw_tx).unwrap();
+    /// let cache = SighashCache::new(&tx);
+    /// if cache.legacy_encode_signing_data_to(&mut writer, input_index, &script_pubkey, sighash_u32)
+    ///         .is_sighash_single_bug()
+    ///         .expect("writer can't fail") {
+    ///     // use a hash value of "1", instead of computing the actual hash due to SIGHASH_SINGLE bug
+    /// }
+    /// ```
+    pub fn is_sighash_single_bug(self) -> Result<bool, E> {
+        match self {
+            EncodeSigningDataResult::SighashSingleBug => Ok(true),
+            EncodeSigningDataResult::WriteResult(Ok(())) => Ok(false),
+            EncodeSigningDataResult::WriteResult(Err(e)) => Err(e),
+        }
+    }
+
+    /// Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
+    /// contained [`Err`] value, leaving an [`Ok`] value untouched.
+    ///
+    /// Like [`Result::map_err`].
+    pub fn map_err<E2, F>(self, f: F) -> EncodeSigningDataResult<E2>
+    where
+        F: FnOnce(E) -> E2,
+    {
+        match self {
+            EncodeSigningDataResult::SighashSingleBug => EncodeSigningDataResult::SighashSingleBug,
+            EncodeSigningDataResult::WriteResult(Err(e)) =>
+                EncodeSigningDataResult::WriteResult(Err(f(e))),
+            EncodeSigningDataResult::WriteResult(Ok(o)) =>
+                EncodeSigningDataResult::WriteResult(Ok(o)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use hashes::HashEngine;
+    use hex::{test_hex_unwrap as hex, FromHex};
+
+    use super::*;
+    use crate::blockdata::locktime::absolute;
+    use crate::blockdata::transaction;
+    use crate::consensus::deserialize;
+    use crate::crypto::sighash::{LegacySighash, TapSighash};
+    use crate::taproot::TapLeafHash;
+
+    extern crate serde_json;
+
+    #[test]
+    fn sighash_single_bug() {
+        const SIGHASH_SINGLE: u32 = 3;
+
+        // We need a tx with more inputs than outputs.
+        let tx = Transaction {
+            version: transaction::Version::ONE,
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![TxIn::default(), TxIn::default()],
+            output: vec![TxOut::NULL],
+        };
+        let script = ScriptBuf::new();
+        let cache = SighashCache::new(&tx);
+
+        let got = cache.legacy_signature_hash(1, &script, SIGHASH_SINGLE).expect("sighash");
+        let want = LegacySighash::from_slice(&UINT256_ONE).unwrap();
+
+        assert_eq!(got, want)
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn legacy_sighash() {
+        use serde_json::Value;
+
+        use crate::sighash::SighashCache;
+
+        fn run_test_sighash(
+            tx: &str,
+            script: &str,
+            input_index: usize,
+            hash_type: i64,
+            expected_result: &str,
+        ) {
+            let tx: Transaction = deserialize(&Vec::from_hex(tx).unwrap()[..]).unwrap();
+            let script = ScriptBuf::from(Vec::from_hex(script).unwrap());
+            let mut raw_expected = Vec::from_hex(expected_result).unwrap();
+            raw_expected.reverse();
+            let want = LegacySighash::from_slice(&raw_expected[..]).unwrap();
+
+            let cache = SighashCache::new(&tx);
+            let got = cache.legacy_signature_hash(input_index, &script, hash_type as u32).unwrap();
+
+            assert_eq!(got, want);
+        }
+
+        // These test vectors were stolen from libbtc, which is Copyright 2014 Jonas Schnelli MIT
+        // They were transformed by replacing {...} with run_test_sighash(...), then the ones containing
+        // OP_CODESEPARATOR in their pubkeys were removed
+        let data = include_str!("../../tests/data/legacy_sighash.json");
+
+        let testdata = serde_json::from_str::<Value>(data).unwrap().as_array().unwrap().clone();
+        for t in testdata.iter().skip(1) {
+            let tx = t.get(0).unwrap().as_str().unwrap();
+            let script = t.get(1).unwrap().as_str().unwrap_or("");
+            let input_index = t.get(2).unwrap().as_u64().unwrap();
+            let hash_type = t.get(3).unwrap().as_i64().unwrap();
+            let expected_sighash = t.get(4).unwrap().as_str().unwrap();
+            run_test_sighash(tx, script, input_index as usize, hash_type, expected_sighash);
+        }
+    }
+
+    #[test]
+    fn test_tap_sighash_hash() {
+        let bytes = hex!("00011b96877db45ffa23b307e9f0ac87b80ef9a80b4c5f0db3fbe734422453e83cc5576f3d542c5d4898fb2b696c15d43332534a7c1d1255fda38993545882df92c3e353ff6d36fbfadc4d168452afd8467f02fe53d71714fcea5dfe2ea759bd00185c4cb02bc76d42620393ca358a1a713f4997f9fc222911890afb3fe56c6a19b202df7bffdcfad08003821294279043746631b00e2dc5e52a111e213bbfe6ef09a19428d418dab0d50000000000");
+        let expected = hex!("04e808aad07a40b3767a1442fead79af6ef7e7c9316d82dec409bb31e77699b0");
+        let mut enc = TapSighash::engine();
+        enc.input(&bytes);
+        let hash = TapSighash::from_engine(enc);
+        assert_eq!(expected, hash.to_byte_array());
+    }
+
+    #[test]
+    fn test_sighashes_keyspending() {
+        // following test case has been taken from Bitcoin Core test framework
+
+        test_taproot_sighash(
+            "020000000164eb050a5e3da0c2a65e4786f26d753b7bc69691fabccafb11f7acef36641f1846010000003101b2b404392a22000000000017a9147f2bde86fe78bf68a0544a4f290e12f0b7e0a08c87580200000000000017a91425d11723074ecfb96a0a83c3956bfaf362ae0c908758020000000000001600147e20f938993641de67bb0cdd71682aa34c4d29ad5802000000000000160014c64984dc8761acfa99418bd6bedc79b9287d652d72000000",
+            "01365724000000000023542156b39dab4f8f3508e0432cfb41fab110170acaa2d4c42539cb90a4dc7c093bc500",
+            0,
+            "33ca0ebfb4a945eeee9569fc0f5040221275f88690b7f8592ada88ce3bdf6703",
+            TapSighashType::Default, None, None, None
+        );
+
+        test_taproot_sighash(
+            "0200000002fff49be59befe7566050737910f6ccdc5e749c7f8860ddc140386463d88c5ad0f3000000002cf68eb4a3d67f9d4c079249f7e4f27b8854815cb1ed13842d4fbf395f9e217fd605ee24090100000065235d9203f458520000000000160014b6d48333bb13b4c644e57c43a9a26df3a44b785e58020000000000001976a914eea9461a9e1e3f765d3af3e726162e0229fe3eb688ac58020000000000001976a9143a8869c9f2b5ea1d4ff3aeeb6a8fb2fffb1ad5fe88ac0ad7125c",
+            "02591f220000000000225120f25ad35583ea31998d968871d7de1abd2a52f6fe4178b54ea158274806ff4ece48fb310000000000225120f25ad35583ea31998d968871d7de1abd2a52f6fe4178b54ea158274806ff4ece",
+            1,
+            "626ab955d58c9a8a600a0c580549d06dc7da4e802eb2a531f62a588e430967a8",
+            TapSighashType::All, None, None, None
+        );
+
+        test_taproot_sighash(
+            "0200000001350005f65aa830ced2079df348e2d8c2bdb4f10e2dde6a161d8a07b40d1ad87dae000000001611d0d603d9dc0e000000000017a914459b6d7d6bbb4d8837b4bf7e9a4556f952da2f5c8758020000000000001976a9141dd70e1299ffc2d5b51f6f87de9dfe9398c33cbb88ac58020000000000001976a9141dd70e1299ffc2d5b51f6f87de9dfe9398c33cbb88aca71c1f4f",
+            "01c4811000000000002251201bf9297d0a2968ae6693aadd0fa514717afefd218087a239afb7418e2d22e65c",
+            0,
+            "dfa9437f9c9a1d1f9af271f79f2f5482f287cdb0d2e03fa92c8a9b216cc6061c",
+            TapSighashType::AllPlusAnyoneCanPay, None, None, None
+        );
+
+        test_taproot_sighash(
+            "020000000185bed1a6da2bffbd60ec681a1bfb71c5111d6395b99b3f8b2bf90167111bcb18f5010000007c83ace802ded24a00000000001600142c4698f9f7a773866879755aa78c516fb332af8e5802000000000000160014d38639dfbac4259323b98a472405db0c461b31fa61073747",
+            "0144c84d0000000000225120e3f2107989c88e67296ab2faca930efa2e3a5bd3ff0904835a11c9e807458621",
+            0,
+            "3129de36a5d05fff97ffca31eb75fcccbbbc27b3147a7a36a9e4b45d8b625067",
+            TapSighashType::None, None, None, None
+        );
+
+        test_taproot_sighash(
+            "eb93dbb901028c8515589dac980b6e7f8e4088b77ed866ca0d6d210a7218b6fd0f6b22dd6d7300000000eb4740a9047efc0e0000000000160014913da2128d8fcf292b3691db0e187414aa1783825802000000000000160014913da2128d8fcf292b3691db0e187414aa178382580200000000000017a9143dd27f01c6f7ef9bb9159937b17f17065ed01a0c875802000000000000160014d7630e19df70ada9905ede1722b800c0005f246641000000",
+            "013fed110000000000225120eb536ae8c33580290630fc495046e998086a64f8f33b93b07967d9029b265c55",
+            0,
+            "2441e8b0e063a2083ee790f14f2045022f07258ddde5ee01de543c9e789d80ae",
+            TapSighashType::NonePlusAnyoneCanPay, None, None, None
+        );
+
+        test_taproot_sighash(
+            "02000000017836b409a5fed32211407e44b971591f2032053f14701fb5b3a30c0ff382f2cc9c0100000061ac55f60288fb5600000000001976a9144ea02f6f182b082fb6ce47e36bbde390b6a41b5088ac58020000000000001976a9144ea02f6f182b082fb6ce47e36bbde390b6a41b5088ace4000000",
+            "01efa558000000000022512007071ea3dc7e331b0687d0193d1e6d6ed10e645ef36f10ef8831d5e522ac9e80",
+            0,
+            "30239345177cadd0e3ea413d49803580abb6cb27971b481b7788a78d35117a88",
+            TapSighashType::Single, None, None, None
+        );
+
+        test_taproot_sighash(
+            "0100000001aa6deae89d5e0aaca58714fc76ef6f3c8284224888089232d4e663843ed3ab3eae010000008b6657a60450cb4c0000000000160014a3d42b5413ef0c0701c4702f3cd7d4df222c147058020000000000001976a91430b4ed8723a4ee8992aa2c8814cfe5c3ad0ab9d988ac5802000000000000160014365b1166a6ed0a5e8e9dff17a6d00bbb43454bc758020000000000001976a914bc98c51a84fe7fad5dc380eb8b39586eff47241688ac4f313247",
+            "0107af4e00000000002251202c36d243dfc06cb56a248e62df27ecba7417307511a81ae61aa41c597a929c69",
+            0,
+            "bf9c83f26c6dd16449e4921f813f551c4218e86f2ec906ca8611175b41b566df",
+            TapSighashType::SinglePlusAnyoneCanPay, None, None, None
+        );
+    }
+
+    #[test]
+    fn test_sighashes_with_annex() {
+        test_taproot_sighash(
+            "0200000001df8123752e8f37d132c4e9f1ff7e4f9b986ade9211267e9ebd5fd22a5e718dec6d01000000ce4023b903cb7b23000000000017a914a18b36ea7a094db2f4940fc09edf154e86de7bd787580200000000000017a914afd0d512a2c5c2b40e25669e9cc460303c325b8b87580200000000000017a914a18b36ea7a094db2f4940fc09edf154e86de7bd787f6020000",
+            "01ea49260000000000225120ab5e9800806bf18cb246edcf5fe63441208fe955a4b5a35bbff65f5db622a010",
+            0,
+            "3b003000add359a364a156e73e02846782a59d0d95ca8c4638aaad99f2ef915c",
+            TapSighashType::SinglePlusAnyoneCanPay,
+            Some("507b979802e62d397acb29f56743a791894b99372872fc5af06a4f6e8d242d0615cda53062bb20e6ec79756fe39183f0c128adfe85559a8fa042b042c018aa8010143799e44f0893c40e1e"),
+            None,
+            None,
+        );
+    }
+
+    #[test]
+    fn test_sighashes_with_script_path() {
+        test_taproot_sighash(
+            "020000000189fc651483f9296b906455dd939813bf086b1bbe7c77635e157c8e14ae29062195010000004445b5c7044561320000000000160014331414dbdada7fb578f700f38fb69995fc9b5ab958020000000000001976a914268db0a8104cc6d8afd91233cc8b3d1ace8ac3ef88ac580200000000000017a914ec00dcb368d6a693e11986d265f659d2f59e8be2875802000000000000160014c715799a49a0bae3956df9c17cb4440a673ac0df6f010000",
+            "011bec34000000000022512028055142ea437db73382e991861446040b61dd2185c4891d7daf6893d79f7182",
+            0,
+            "d66de5274a60400c7b08c86ba6b7f198f40660079edf53aca89d2a9501317f2e",
+            TapSighashType::All,
+            None,
+            Some("20cc4e1107aea1d170c5ff5b6817e1303010049724fb3caa7941792ea9d29b3e2bacab"),
+            None,
+        );
+    }
+
+    #[test]
+    fn test_sighashes_with_script_path_raw_hash() {
+        test_taproot_sighash(
+            "020000000189fc651483f9296b906455dd939813bf086b1bbe7c77635e157c8e14ae29062195010000004445b5c7044561320000000000160014331414dbdada7fb578f700f38fb69995fc9b5ab958020000000000001976a914268db0a8104cc6d8afd91233cc8b3d1ace8ac3ef88ac580200000000000017a914ec00dcb368d6a693e11986d265f659d2f59e8be2875802000000000000160014c715799a49a0bae3956df9c17cb4440a673ac0df6f010000",
+            "011bec34000000000022512028055142ea437db73382e991861446040b61dd2185c4891d7daf6893d79f7182",
+            0,
+            "d66de5274a60400c7b08c86ba6b7f198f40660079edf53aca89d2a9501317f2e",
+            TapSighashType::All,
+            None,
+            None,
+            Some("15a2530514e399f8b5cf0b3d3112cf5b289eaa3e308ba2071b58392fdc6da68a"),
+        );
+    }
+
+    #[test]
+    fn test_sighashes_with_annex_and_script() {
+        test_taproot_sighash(
+            "020000000132fb72cb8fba496755f027a9743e2d698c831fdb8304e4d1a346ac92cbf51acba50100000026bdc7df044aad34000000000017a9144fa2554ed6174586854fa3bc01de58dcf33567d0875802000000000000160014950367e1e62cdf240b35b883fc2f5e39f0eb9ab95802000000000000160014950367e1e62cdf240b35b883fc2f5e39f0eb9ab958020000000000001600141b31217d48ccc8760dcc0710fade5866d628e733a02d5122",
+            "011458360000000000225120a7baec3fb9f84614e3899fcc010c638f80f13539344120e1f4d8b68a9a011a13",
+            0,
+            "a0042aa434f9a75904b64043f2a283f8b4c143c7f4f7f49a6cbe5b9f745f4c15",
+            TapSighashType::All,
+            Some("50a6272b470e1460e3332ade7bb14b81671c564fb6245761bd5bd531394b28860e0b3808ab229fb51791fb6ae6fa82d915b2efb8f6df83ae1f5ab3db13e30928875e2a22b749d89358de481f19286cd4caa792ce27f9559082d227a731c5486882cc707f83da361c51b7aadd9a0cf68fe7480c410fa137b454482d9a1ebf0f96d760b4d61426fc109c6e8e99a508372c45caa7b000a41f8251305da3f206c1849985ba03f3d9592832b4053afbd23ab25d0465df0bc25a36c223aacf8e04ec736a418c72dc319e4da3e972e349713ca600965e7c665f2090d5a70e241ac164115a1f5639f28b1773327715ca307ace64a2de7f0e3df70a2ffee3857689f909c0dad46d8a20fa373a4cc6eed6d4c9806bf146f0d76baae1"),
+            Some("7520ab9160dd8299dc1367659be3e8f66781fe440d52940c7f8d314a89b9f2698d406ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6eadac"),
+            None,
+        );
+    }
+
+    #[test]
+    #[rustfmt::skip] // Allow long function call `taproot_signature_hash`.
+    fn test_sighash_errors() {
+        let dumb_tx = Transaction {
+            version: transaction::Version::TWO,
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![TxIn::default()],
+            output: vec![],
+        };
+        let mut c = SighashCache::new(&dumb_tx);
+
+        // 1.29 fixes
+        let empty_vec = vec![];
+        let empty_prevouts : Prevouts<TxOut> = Prevouts::All(&empty_vec);
+        assert_eq!(
+            c.taproot_signature_hash(0, &empty_prevouts, None, None, TapSighashType::All),
+            Err(Error::PrevoutsSize)
+        );
+        let two = vec![TxOut::NULL, TxOut::NULL];
+        let too_many_prevouts = Prevouts::All(&two);
+        assert_eq!(
+            c.taproot_signature_hash(0, &too_many_prevouts, None, None, TapSighashType::All),
+            Err(Error::PrevoutsSize)
+        );
+        let tx_out = TxOut::NULL;
+        let prevout = Prevouts::One(1, &tx_out);
+        assert_eq!(
+            c.taproot_signature_hash(0, &prevout, None, None, TapSighashType::All),
+            Err(Error::PrevoutKind)
+        );
+        assert_eq!(
+            c.taproot_signature_hash(0, &prevout, None, None, TapSighashType::AllPlusAnyoneCanPay),
+            Err(Error::PrevoutIndex)
+        );
+        assert_eq!(
+            c.taproot_signature_hash(10, &prevout, None, None, TapSighashType::AllPlusAnyoneCanPay),
+            Err(Error::IndexOutOfInputsBounds {
+                index: 10,
+                inputs_size: 1
+            })
+        );
+        let prevout = Prevouts::One(0, &tx_out);
+        assert_eq!(
+            c.taproot_signature_hash(0, &prevout, None, None, TapSighashType::SinglePlusAnyoneCanPay),
+            Err(Error::SingleWithoutCorrespondingOutput {
+                index: 0,
+                outputs_size: 0
+            })
+        );
+        assert_eq!(
+            c.legacy_signature_hash(10, Script::new(), 0u32),
+            Err(Error::IndexOutOfInputsBounds {
+                index: 10,
+                inputs_size: 1
+            })
+        );
+    }
+
+    #[test]
+    fn test_annex_errors() {
+        assert_eq!(Annex::new(&[]), Err(Error::WrongAnnex));
+        assert_eq!(Annex::new(&[0x51]), Err(Error::WrongAnnex));
+        assert_eq!(Annex::new(&[0x51, 0x50]), Err(Error::WrongAnnex));
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn test_taproot_sighash(
+        tx_hex: &str,
+        prevout_hex: &str,
+        input_index: usize,
+        expected_hash: &str,
+        sighash_type: TapSighashType,
+        annex_hex: Option<&str>,
+        script_hex: Option<&str>,
+        script_leaf_hash: Option<&str>,
+    ) {
+        let tx_bytes = Vec::from_hex(tx_hex).unwrap();
+        let tx: Transaction = deserialize(&tx_bytes).unwrap();
+        let prevout_bytes = Vec::from_hex(prevout_hex).unwrap();
+        let prevouts: Vec<TxOut> = deserialize(&prevout_bytes).unwrap();
+        let annex_inner;
+        let annex = match annex_hex {
+            Some(annex_hex) => {
+                annex_inner = Vec::from_hex(annex_hex).unwrap();
+                Some(Annex::new(&annex_inner).unwrap())
+            }
+            None => None,
+        };
+
+        let leaf_hash = match (script_hex, script_leaf_hash) {
+            (Some(script_hex), _) => {
+                let script_inner = ScriptBuf::from_hex(script_hex).unwrap();
+                Some(ScriptPath::with_defaults(&script_inner).leaf_hash())
+            }
+            (_, Some(script_leaf_hash)) => Some(script_leaf_hash.parse::<TapLeafHash>().unwrap()),
+            _ => None,
+        };
+        // All our tests use the default `0xFFFFFFFF` codeseparator value
+        let leaf_hash = leaf_hash.map(|lh| (lh, 0xFFFFFFFF));
+
+        let prevouts = if sighash_type.split_anyonecanpay_flag().1 && tx_bytes[0] % 2 == 0 {
+            // for anyonecanpay the `Prevouts::All` variant is good anyway, but sometimes we want to
+            // test other codepaths
+            Prevouts::One(input_index, prevouts[input_index].clone())
+        } else {
+            Prevouts::All(&prevouts)
+        };
+
+        let mut sighash_cache = SighashCache::new(&tx);
+
+        let hash = sighash_cache
+            .taproot_signature_hash(input_index, &prevouts, annex, leaf_hash, sighash_type)
+            .unwrap();
+        let expected = Vec::from_hex(expected_hash).unwrap();
+        assert_eq!(expected, hash.to_byte_array());
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn bip_341_sighash_tests() {
+        fn sighash_deser_numeric<'de, D>(deserializer: D) -> Result<TapSighashType, D::Error>
+        where
+            D: actual_serde::Deserializer<'de>,
+        {
+            use actual_serde::de::{Deserialize, Error, Unexpected};
+
+            let raw = u8::deserialize(deserializer)?;
+            TapSighashType::from_consensus_u8(raw).map_err(|_| {
+                D::Error::invalid_value(
+                    Unexpected::Unsigned(raw.into()),
+                    &"number in range 0-3 or 0x81-0x83",
+                )
+            })
+        }
+
+        use secp256k1::{self, SecretKey, XOnlyPublicKey};
+
+        use crate::consensus::serde as con_serde;
+        use crate::taproot::{TapNodeHash, TapTweakHash};
+
+        #[derive(serde::Deserialize)]
+        #[serde(crate = "actual_serde")]
+        struct UtxoSpent {
+            #[serde(rename = "scriptPubKey")]
+            script_pubkey: ScriptBuf,
+            #[serde(rename = "amountSats")]
+            value: Amount,
+        }
+
+        #[derive(serde::Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        #[serde(crate = "actual_serde")]
+        struct KpsGiven {
+            #[serde(with = "con_serde::With::<con_serde::Hex>")]
+            raw_unsigned_tx: Transaction,
+            utxos_spent: Vec<UtxoSpent>,
+        }
+
+        #[derive(serde::Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        #[serde(crate = "actual_serde")]
+        struct KpsIntermediary {
+            hash_prevouts: sha256::Hash,
+            hash_outputs: sha256::Hash,
+            hash_sequences: sha256::Hash,
+            hash_amounts: sha256::Hash,
+            hash_script_pubkeys: sha256::Hash,
+        }
+
+        #[derive(serde::Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        #[serde(crate = "actual_serde")]
+        struct KpsInputSpendingGiven {
+            txin_index: usize,
+            internal_privkey: SecretKey,
+            merkle_root: Option<TapNodeHash>,
+            #[serde(deserialize_with = "sighash_deser_numeric")]
+            hash_type: TapSighashType,
+        }
+
+        #[derive(serde::Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        #[serde(crate = "actual_serde")]
+        struct KpsInputSpendingIntermediary {
+            internal_pubkey: XOnlyPublicKey,
+            tweak: TapTweakHash,
+            tweaked_privkey: SecretKey,
+            sig_msg: String,
+            //precomputed_used: Vec<String>, // unused
+            sig_hash: TapSighash,
+        }
+
+        #[derive(serde::Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        #[serde(crate = "actual_serde")]
+        struct KpsInputSpendingExpected {
+            witness: Vec<String>,
+        }
+
+        #[derive(serde::Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        #[serde(crate = "actual_serde")]
+        struct KpsInputSpending {
+            given: KpsInputSpendingGiven,
+            intermediary: KpsInputSpendingIntermediary,
+            expected: KpsInputSpendingExpected,
+            // auxiliary: KpsAuxiliary, //unused
+        }
+
+        #[derive(serde::Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        #[serde(crate = "actual_serde")]
+        struct KeyPathSpending {
+            given: KpsGiven,
+            intermediary: KpsIntermediary,
+            input_spending: Vec<KpsInputSpending>,
+        }
+
+        #[derive(serde::Deserialize)]
+        #[serde(rename_all = "camelCase")]
+        #[serde(crate = "actual_serde")]
+        struct TestData {
+            version: u64,
+            key_path_spending: Vec<KeyPathSpending>,
+            //script_pubkey: Vec<ScriptPubKey>, // unused
+        }
+
+        let json_str = include_str!("../../tests/data/bip341_tests.json");
+        let mut data =
+            serde_json::from_str::<TestData>(json_str).expect("JSON was not well-formatted");
+
+        assert_eq!(data.version, 1u64);
+        let secp = &secp256k1::Secp256k1::new();
+        let key_path = data.key_path_spending.remove(0);
+
+        let raw_unsigned_tx = key_path.given.raw_unsigned_tx;
+        let utxos = key_path
+            .given
+            .utxos_spent
+            .into_iter()
+            .map(|txo| TxOut { value: txo.value, script_pubkey: txo.script_pubkey })
+            .collect::<Vec<_>>();
+
+        // Test intermediary
+        let mut cache = SighashCache::new(&raw_unsigned_tx);
+
+        let expected = key_path.intermediary;
+        // Compute all caches
+        assert_eq!(expected.hash_amounts, cache.taproot_cache(&utxos).amounts);
+        assert_eq!(expected.hash_outputs, cache.common_cache().outputs);
+        assert_eq!(expected.hash_prevouts, cache.common_cache().prevouts);
+        assert_eq!(expected.hash_script_pubkeys, cache.taproot_cache(&utxos).script_pubkeys);
+        assert_eq!(expected.hash_sequences, cache.common_cache().sequences);
+
+        for mut inp in key_path.input_spending {
+            let tx_ind = inp.given.txin_index;
+            let internal_priv_key = inp.given.internal_privkey;
+            let merkle_root = inp.given.merkle_root;
+            let hash_ty = inp.given.hash_type;
+
+            let expected = inp.intermediary;
+            let sig_str = inp.expected.witness.remove(0);
+            let (expected_key_spend_sig, expected_hash_ty) = if sig_str.len() == 128 {
+                (
+                    secp256k1::schnorr::Signature::from_str(&sig_str).unwrap(),
+                    TapSighashType::Default,
+                )
+            } else {
+                let hash_ty = u8::from_str_radix(&sig_str[128..130], 16).unwrap();
+                let hash_ty = TapSighashType::from_consensus_u8(hash_ty).unwrap();
+                (secp256k1::schnorr::Signature::from_str(&sig_str[..128]).unwrap(), hash_ty)
+            };
+
+            // tests
+            let keypair = secp256k1::Keypair::from_secret_key(secp, &internal_priv_key);
+            let (internal_key, _parity) = XOnlyPublicKey::from_keypair(&keypair);
+            let tweak = TapTweakHash::from_key_and_tweak(internal_key, merkle_root);
+            let tweaked_keypair = keypair.add_xonly_tweak(secp, &tweak.to_scalar()).unwrap();
+            let mut sig_msg = Vec::new();
+            cache
+                .taproot_encode_signing_data_to(
+                    &mut sig_msg,
+                    tx_ind,
+                    &Prevouts::All(&utxos),
+                    None,
+                    None,
+                    hash_ty,
+                )
+                .unwrap();
+            let sighash = cache
+                .taproot_signature_hash(tx_ind, &Prevouts::All(&utxos), None, None, hash_ty)
+                .unwrap();
+
+            let msg = secp256k1::Message::from_digest(sighash.to_byte_array());
+            let key_spend_sig = secp.sign_schnorr_with_aux_rand(&msg, &tweaked_keypair, &[0u8; 32]);
+
+            assert_eq!(expected.internal_pubkey, internal_key);
+            assert_eq!(expected.tweak, tweak);
+            assert_eq!(expected.sig_msg, sig_msg.to_lower_hex_string());
+            assert_eq!(expected.sig_hash, sighash);
+            assert_eq!(expected_hash_ty, hash_ty);
+            assert_eq!(expected_key_spend_sig, key_spend_sig);
+
+            let tweaked_priv_key = SecretKey::from_keypair(&tweaked_keypair);
+            assert_eq!(expected.tweaked_privkey, tweaked_priv_key);
+        }
+    }
+
+    #[test]
+    fn sighashtype_fromstr_display() {
+        let sighashtypes = vec![
+            ("SIGHASH_DEFAULT", TapSighashType::Default),
+            ("SIGHASH_ALL", TapSighashType::All),
+            ("SIGHASH_NONE", TapSighashType::None),
+            ("SIGHASH_SINGLE", TapSighashType::Single),
+            ("SIGHASH_ALL|SIGHASH_ANYONECANPAY", TapSighashType::AllPlusAnyoneCanPay),
+            ("SIGHASH_NONE|SIGHASH_ANYONECANPAY", TapSighashType::NonePlusAnyoneCanPay),
+            ("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY", TapSighashType::SinglePlusAnyoneCanPay),
+        ];
+        for (s, sht) in sighashtypes {
+            assert_eq!(sht.to_string(), s);
+            assert_eq!(TapSighashType::from_str(s).unwrap(), sht);
+        }
+        let sht_mistakes = vec![
+            "SIGHASH_ALL | SIGHASH_ANYONECANPAY",
+            "SIGHASH_NONE |SIGHASH_ANYONECANPAY",
+            "SIGHASH_SINGLE| SIGHASH_ANYONECANPAY",
+            "SIGHASH_ALL SIGHASH_ANYONECANPAY",
+            "SIGHASH_NONE |",
+            "SIGHASH_SIGNLE",
+            "DEFAULT",
+            "ALL",
+            "sighash_none",
+            "Sighash_none",
+            "SigHash_None",
+            "SigHash_NONE",
+        ];
+        for s in sht_mistakes {
+            assert_eq!(
+                TapSighashType::from_str(s).unwrap_err().to_string(),
+                format!("unrecognized SIGHASH string '{}'", s)
+            );
+        }
+    }
+
+    #[test]
+    fn bip143_p2wpkh() {
+        let tx = deserialize::<Transaction>(
+            &hex!(
+                "0100000002fff7f7881a8099afa6940d42d1e7f6362bec38171ea3edf433541db4e4ad969f000000\
+                0000eeffffffef51e1b804cc89d182d279655c3aa89e815b1b309fe287d9b2b55d57b90ec68a01000000\
+                00ffffffff02202cb206000000001976a9148280b37df378db99f66f85c95a783a76ac7a6d5988ac9093\
+                510d000000001976a9143bde42dbee7e4dbe6a21b2d50ce2f0167faa815988ac11000000"
+            ),
+        ).unwrap();
+
+        let spk = ScriptBuf::from_hex("00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1").unwrap();
+        let value = Amount::from_tap(600_000_000);
+
+        let mut cache = SighashCache::new(&tx);
+        assert_eq!(
+            cache.p2wpkh_signature_hash(1, &spk, value, EcdsaSighashType::All).unwrap(),
+            "c37af31116d1b27caf68aae9e3ac82f1477929014d5b917657d0eb49478cb670"
+                .parse::<SegwitV0Sighash>()
+                .unwrap(),
+        );
+
+        let cache = cache.segwit_cache();
+        // Parse hex into Vec because BIP143 test vector displays forwards but our sha256d::Hash displays backwards.
+        assert_eq!(
+            cache.prevouts.as_byte_array(),
+            &Vec::from_hex("96b827c8483d4e9b96712b6713a7b68d6e8003a781feba36c31143470b4efd37")
+                .unwrap()[..],
+        );
+        assert_eq!(
+            cache.sequences.as_byte_array(),
+            &Vec::from_hex("52b0a642eea2fb7ae638c36f6252b6750293dbe574a806984b8e4d8548339a3b")
+                .unwrap()[..],
+        );
+        assert_eq!(
+            cache.outputs.as_byte_array(),
+            &Vec::from_hex("863ef3e1a92afbfdb97f31ad0fc7683ee943e9abcf2501590ff8f6551f47e5e5")
+                .unwrap()[..],
+        );
+    }
+
+    #[test]
+    fn bip143_p2wpkh_nested_in_p2sh() {
+        let tx = deserialize::<Transaction>(
+            &hex!(
+                "0100000001db6b1b20aa0fd7b23880be2ecbd4a98130974cf4748fb66092ac4d3ceb1a5477010000\
+                0000feffffff02b8b4eb0b000000001976a914a457b684d7f0d539a46a45bbc043f35b59d0d96388ac00\
+                08af2f000000001976a914fd270b1ee6abcaea97fea7ad0402e8bd8ad6d77c88ac92040000"
+            ),
+        ).unwrap();
+
+        let redeem_script =
+            ScriptBuf::from_hex("001479091972186c449eb1ded22b78e40d009bdf0089").unwrap();
+        let value = Amount::from_tap(1_000_000_000);
+
+        let mut cache = SighashCache::new(&tx);
+        assert_eq!(
+            cache.p2wpkh_signature_hash(0, &redeem_script, value, EcdsaSighashType::All).unwrap(),
+            "64f3b0f4dd2bb3aa1ce8566d220cc74dda9df97d8490cc81d89d735c92e59fb6"
+                .parse::<SegwitV0Sighash>()
+                .unwrap(),
+        );
+
+        let cache = cache.segwit_cache();
+        // Parse hex into Vec because BIP143 test vector displays forwards but our sha256d::Hash displays backwards.
+        assert_eq!(
+            cache.prevouts.as_byte_array(),
+            &Vec::from_hex("b0287b4a252ac05af83d2dcef00ba313af78a3e9c329afa216eb3aa2a7b4613a")
+                .unwrap()[..],
+        );
+        assert_eq!(
+            cache.sequences.as_byte_array(),
+            &Vec::from_hex("18606b350cd8bf565266bc352f0caddcf01e8fa789dd8a15386327cf8cabe198")
+                .unwrap()[..],
+        );
+        assert_eq!(
+            cache.outputs.as_byte_array(),
+            &Vec::from_hex("de984f44532e2173ca0d64314fcefe6d30da6f8cf27bafa706da61df8a226c83")
+                .unwrap()[..],
+        );
+    }
+
+    // Note, if you are looking at the test vectors in BIP-143 and wondering why there is a `cf`
+    // prepended to all the script_code hex it is the length byte, it gets added when we consensus
+    // encode a script.
+    fn bip143_p2wsh_nested_in_p2sh_data() -> (Transaction, ScriptBuf, Amount) {
+        let tx = deserialize::<Transaction>(&hex!(
+            "010000000136641869ca081e70f394c6948e8af409e18b619df2ed74aa106c1ca29787b96e0100000000\
+             ffffffff0200e9a435000000001976a914389ffce9cd9ae88dcc0631e88a821ffdbe9bfe2688acc0832f\
+             05000000001976a9147480a33f950689af511e6e84c138dbbd3c3ee41588ac00000000"
+        ))
+        .unwrap();
+
+        let witness_script = ScriptBuf::from_hex(
+            "56210307b8ae49ac90a048e9b53357a2354b3334e9c8bee813ecb98e99a7e07e8c3ba32103b28f0c28\
+             bfab54554ae8c658ac5c3e0ce6e79ad336331f78c428dd43eea8449b21034b8113d703413d57761b8b\
+             9781957b8c0ac1dfe69f492580ca4195f50376ba4a21033400f6afecb833092a9a21cfdf1ed1376e58\
+             c5d1f47de74683123987e967a8f42103a6d48b1131e94ba04d9737d61acdaa1322008af9602b3b1486\
+             2c07a1789aac162102d8b661b0b3302ee2f162b09e07a55ad5dfbe673a9f01d9f0c19617681024306b\
+             56ae",
+        )
+        .unwrap();
+
+        let value = Amount::from_tap(987_654_321);
+        (tx, witness_script, value)
+    }
+
+    #[test]
+    fn bip143_p2wsh_nested_in_p2sh_sighash_type_all() {
+        let (tx, witness_script, value) = bip143_p2wsh_nested_in_p2sh_data();
+        let mut cache = SighashCache::new(&tx);
+        assert_eq!(
+            cache.p2wsh_signature_hash(0, &witness_script, value, EcdsaSighashType::All).unwrap(),
+            "185c0be5263dce5b4bb50a047973c1b6272bfbd0103a89444597dc40b248ee7c"
+                .parse::<SegwitV0Sighash>()
+                .unwrap(),
+        );
+
+        // We only test the cache intermediate values for `EcdsaSighashType::All` because they are
+        // not the same as the BIP test vectors for all the rest of the sighash types. These fields
+        // are private so it does not effect sighash cache usage, we do test against the produced
+        // sighash for all sighash types.
+
+        let cache = cache.segwit_cache();
+        // Parse hex into Vec because BIP143 test vector displays forwards but our sha256d::Hash displays backwards.
+        assert_eq!(
+            cache.prevouts.as_byte_array(),
+            &Vec::from_hex("74afdc312af5183c4198a40ca3c1a275b485496dd3929bca388c4b5e31f7aaa0")
+                .unwrap()[..],
+        );
+        assert_eq!(
+            cache.sequences.as_byte_array(),
+            &Vec::from_hex("3bb13029ce7b1f559ef5e747fcac439f1455a2ec7c5f09b72290795e70665044")
+                .unwrap()[..],
+        );
+        assert_eq!(
+            cache.outputs.as_byte_array(),
+            &Vec::from_hex("bc4d309071414bed932f98832b27b4d76dad7e6c1346f487a8fdbb8eb90307cc")
+                .unwrap()[..],
+        );
+    }
+
+    macro_rules! check_bip143_p2wsh_nested_in_p2sh {
+        ($($test_name:ident, $sighash_type:ident, $sighash:literal);* $(;)?) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    use EcdsaSighashType::*;
+
+                    let (tx, witness_script, value) = bip143_p2wsh_nested_in_p2sh_data();
+                    let mut cache = SighashCache::new(&tx);
+                    assert_eq!(
+                        cache
+                            .p2wsh_signature_hash(0, &witness_script, value, $sighash_type)
+                            .unwrap(),
+                        $sighash
+                            .parse::<SegwitV0Sighash>()
+                            .unwrap(),
+                    );
+                }
+            )*
+        }
+    }
+    check_bip143_p2wsh_nested_in_p2sh! {
+        // EcdsaSighashType::All tested above.
+        bip143_p2wsh_nested_in_p2sh_sighash_none, None, "e9733bc60ea13c95c6527066bb975a2ff29a925e80aa14c213f686cbae5d2f36";
+        bip143_p2wsh_nested_in_p2sh_sighash_single, Single, "1e1f1c303dc025bd664acb72e583e933fae4cff9148bf78c157d1e8f78530aea";
+        bip143_p2wsh_nested_in_p2sh_sighash_all_plus_anyonecanpay, AllPlusAnyoneCanPay, "2a67f03e63a6a422125878b40b82da593be8d4efaafe88ee528af6e5a9955c6e";
+        bip143_p2wsh_nested_in_p2sh_sighash_none_plus_anyonecanpay, NonePlusAnyoneCanPay, "781ba15f3779d5542ce8ecb5c18716733a5ee42a6f51488ec96154934e2c890a";
+        bip143_p2wsh_nested_in_p2sh_sighash_single_plus_anyonecanpay, SinglePlusAnyoneCanPay, "511e8e52ed574121fc1b654970395502128263f62662e076dc6baf05c2e6a99b";
+    }
+}
diff --git a/tapyrus/src/crypto/taproot.rs b/tapyrus/src/crypto/taproot.rs
new file mode 100644
index 00000000..d7cc880a
--- /dev/null
+++ b/tapyrus/src/crypto/taproot.rs
@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin taproot keys.
+//!
+//! This module provides taproot keys used in Bitcoin (including reexporting secp256k1 keys).
+//!
+
+use core::fmt;
+
+use internals::write_err;
+
+use crate::prelude::*;
+use crate::sighash::{InvalidSighashTypeError, TapSighashType};
+
+/// A BIP340-341 serialized taproot signature with the corresponding hash type.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Signature {
+    /// The underlying schnorr signature
+    pub sig: secp256k1::schnorr::Signature,
+    /// The corresponding hash type
+    pub hash_ty: TapSighashType,
+}
+
+impl Signature {
+    /// Deserialize from slice
+    pub fn from_slice(sl: &[u8]) -> Result<Self, SigFromSliceError> {
+        match sl.len() {
+            64 => {
+                // default type
+                let sig = secp256k1::schnorr::Signature::from_slice(sl)?;
+                Ok(Signature { sig, hash_ty: TapSighashType::Default })
+            }
+            65 => {
+                let (hash_ty, sig) = sl.split_last().expect("Slice len checked == 65");
+                let hash_ty = TapSighashType::from_consensus_u8(*hash_ty)?;
+                let sig = secp256k1::schnorr::Signature::from_slice(sig)?;
+                Ok(Signature { sig, hash_ty })
+            }
+            len => Err(SigFromSliceError::InvalidSignatureSize(len)),
+        }
+    }
+
+    /// Serialize Signature
+    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 self.hash_ty == TapSighashType::Default {
+            // default sighash type, don't add extra sighash byte
+        } else {
+            ser_sig.push(self.hash_ty as u8);
+        }
+        ser_sig
+    }
+}
+
+/// An error constructing a [`taproot::Signature`] from a byte slice.
+///
+/// [`taproot::Signature`]: crate::crypto::taproot::Signature
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum SigFromSliceError {
+    /// Invalid signature hash type.
+    SighashType(InvalidSighashTypeError),
+    /// A secp256k1 error.
+    Secp256k1(secp256k1::Error),
+    /// Invalid taproot signature size
+    InvalidSignatureSize(usize),
+}
+
+impl fmt::Display for SigFromSliceError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use SigFromSliceError::*;
+
+        match *self {
+            SighashType(ref e) => write_err!(f, "sighash"; e),
+            Secp256k1(ref e) => write_err!(f, "secp256k1"; e),
+            InvalidSignatureSize(sz) => write!(f, "invalid taproot signature size: {}", sz),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SigFromSliceError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use SigFromSliceError::*;
+
+        match *self {
+            Secp256k1(ref e) => Some(e),
+            SighashType(ref e) => Some(e),
+            InvalidSignatureSize(_) => None,
+        }
+    }
+}
+
+impl From<secp256k1::Error> for SigFromSliceError {
+    fn from(e: secp256k1::Error) -> Self { Self::Secp256k1(e) }
+}
+
+impl From<InvalidSighashTypeError> for SigFromSliceError {
+    fn from(err: InvalidSighashTypeError) -> Self { Self::SighashType(err) }
+}
diff --git a/tapyrus/src/crypto/test_helpers.rs b/tapyrus/src/crypto/test_helpers.rs
new file mode 100644
index 00000000..497b5e28
--- /dev/null
+++ b/tapyrus/src/crypto/test_helpers.rs
@@ -0,0 +1,40 @@
+// Copyright (c) 2024 Chaintope Inc.
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+//! Internal helper functions for unit tests
+//!
+//!
+
+use hex::FromHex;
+use secp256k1::SecretKey;
+
+use crate::consensus::encode::deserialize;
+use crate::crypto::schnorr::Signature;
+
+pub fn decode_sk(sk_hex: &str) -> SecretKey {
+    let sk = <[u8; 32]>::from_hex(sk_hex).unwrap();
+    SecretKey::from_slice(&sk[..]).unwrap()
+}
+
+pub fn decode_message(message_hex: &str) -> [u8; 32] {
+    let vec = <[u8; 32]>::from_hex(message_hex).unwrap();
+    let mut r = [0u8; 32];
+    r.clone_from_slice(&vec[..]);
+    r
+}
+
+pub fn decode_pk(pk_hex: &str) -> secp256k1::PublicKey {
+    let pk = <[u8; 33]>::from_hex(pk_hex).unwrap();
+    secp256k1::PublicKey::from_slice(&pk[..]).unwrap()
+}
+
+pub fn pk_from(sk: &SecretKey) -> secp256k1::PublicKey {
+    let secp = secp256k1::Secp256k1::signing_only();
+    secp256k1::PublicKey::from_secret_key(&secp, sk)
+}
+
+pub fn decode_signature(sig_hex: &str) -> Signature {
+    let sig = Vec::from_hex(sig_hex).unwrap();
+    deserialize(&sig[..]).unwrap()
+}
diff --git a/tapyrus/src/error.rs b/tapyrus/src/error.rs
new file mode 100644
index 00000000..f5ea45c3
--- /dev/null
+++ b/tapyrus/src/error.rs
@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Contains error types and other error handling tools.
+
+pub use crate::parse::ParseIntError;
diff --git a/tapyrus/src/hash_types.rs b/tapyrus/src/hash_types.rs
new file mode 100644
index 00000000..70700a5a
--- /dev/null
+++ b/tapyrus/src/hash_types.rs
@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin hash types.
+//!
+//! This module defines types for hashes used throughout the library. These
+//! types are needed in order to avoid mixing data of the same hash format
+//! (e.g. `SHA256d`) but of different meaning (such as transaction id, block
+//! hash).
+//!
+
+#[rustfmt::skip]
+macro_rules! impl_hashencode {
+    ($hashtype:ident) => {
+        impl $crate::consensus::Encodable for $hashtype {
+            fn consensus_encode<W: $crate::io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, $crate::io::Error> {
+                self.0.consensus_encode(w)
+            }
+        }
+
+        impl $crate::consensus::Decodable for $hashtype {
+            fn consensus_decode<R: $crate::io::Read + ?Sized>(r: &mut R) -> Result<Self, $crate::consensus::encode::Error> {
+                use $crate::hashes::Hash;
+                Ok(Self::from_byte_array(<<$hashtype as $crate::hashes::Hash>::Bytes>::consensus_decode(r)?))
+            }
+        }
+    };
+}
+pub(crate) use impl_hashencode;
+
+#[rustfmt::skip]
+macro_rules! impl_asref_push_bytes {
+    ($($hashtype:ident),*) => {
+        $(
+            impl AsRef<$crate::blockdata::script::PushBytes> for $hashtype {
+                fn as_ref(&self) -> &$crate::blockdata::script::PushBytes {
+                    use $crate::hashes::Hash;
+                    self.as_byte_array().into()
+                }
+            }
+
+            impl From<$hashtype> for $crate::blockdata::script::PushBytesBuf {
+                fn from(hash: $hashtype) -> Self {
+                    use $crate::hashes::Hash;
+                    hash.as_byte_array().into()
+                }
+            }
+        )*
+    };
+}
+pub(crate) use impl_asref_push_bytes;
+// newtypes module is solely here so we can rustfmt::skip.
+pub use newtypes::*;
+
+#[rustfmt::skip]
+mod newtypes {
+    use hashes::{sha256d, hash_newtype};
+
+    hash_newtype! {
+        /// A tapyrus transaction hash/transaction ID.
+        ///
+        /// For compatibility with the existing Bitcoin infrastructure and historical
+        /// and current versions of the Bitcoin Core software itself, this and
+        /// other [`sha256d::Hash`] types, are serialized in reverse
+        /// byte order when converted to a hex string via [`std::fmt::Display`] trait operations.
+        /// See [`hashes::Hash::DISPLAY_BACKWARD`] for more details.
+        pub struct Txid(sha256d::Hash); 
+
+        /// A Bitcoin witness transaction ID.
+        pub struct Wtxid(sha256d::Hash);
+        /// A Tapyrus transaction ID with transactions malleability fix.
+        /// see: [Transaction Malleability](https://github.com/chaintope/tapyrus-core/blob/master/doc/tapyrus/fix_transaction_malleability.md)
+        pub struct MalFixTxid(sha256d::Hash);
+        /// A tapyrus block hash.
+        pub struct BlockHash(sha256d::Hash);
+        /// A hash of the block for sigining.
+        pub struct BlockSigHash(sha256d::Hash);
+        /// A hash of the xfield for signing
+        pub struct XFieldHash(sha256d::Hash);
+
+        /// A hash of the Merkle tree branch or root for transactions
+        pub struct TxMerkleNode(sha256d::Hash);
+        /// A hash corresponding to the Merkle tree root for witness data
+        pub struct WitnessMerkleNode(sha256d::Hash);
+        /// A hash corresponding to the witness structure commitment in the coinbase transaction
+        pub struct WitnessCommitment(sha256d::Hash);
+
+        /// Filter hash, as defined in BIP-157
+        pub struct FilterHash(sha256d::Hash);
+        /// Filter header, as defined in BIP-157
+        pub struct FilterHeader(sha256d::Hash);
+    }
+
+    impl_hashencode!(Txid);
+    impl_hashencode!(Wtxid);
+    impl_hashencode!(MalFixTxid);
+    impl_hashencode!(BlockHash);
+    impl_hashencode!(BlockSigHash);
+    impl_hashencode!(XFieldHash);
+    impl_hashencode!(TxMerkleNode);
+    impl_hashencode!(WitnessMerkleNode);
+
+    impl_hashencode!(FilterHash);
+    impl_hashencode!(FilterHeader);
+}
diff --git a/tapyrus/src/internal_macros.rs b/tapyrus/src/internal_macros.rs
new file mode 100644
index 00000000..cf95940f
--- /dev/null
+++ b/tapyrus/src/internal_macros.rs
@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Internal macros.
+//!
+//! Macros meant to be used inside the Rust Bitcoin library.
+//!
+
+macro_rules! impl_consensus_encoding {
+    ($thing:ident, $($field:ident),+) => (
+        impl $crate::consensus::Encodable for $thing {
+            #[inline]
+            fn consensus_encode<R: $crate::io::Write + ?Sized>(
+                &self,
+                r: &mut R,
+            ) -> Result<usize, $crate::io::Error> {
+                let mut len = 0;
+                $(len += self.$field.consensus_encode(r)?;)+
+                Ok(len)
+            }
+        }
+
+        impl $crate::consensus::Decodable for $thing {
+
+            #[inline]
+            fn consensus_decode_from_finite_reader<R: $crate::io::Read + ?Sized>(
+                r: &mut R,
+            ) -> Result<$thing, $crate::consensus::encode::Error> {
+                Ok($thing {
+                    $($field: $crate::consensus::Decodable::consensus_decode_from_finite_reader(r)?),+
+                })
+            }
+
+            #[inline]
+            fn consensus_decode<R: $crate::io::Read + ?Sized>(
+                r: &mut R,
+            ) -> Result<$thing, $crate::consensus::encode::Error> {
+                use crate::io::Read as _;
+                let mut r = r.take($crate::consensus::encode::MAX_VEC_SIZE as u64);
+                Ok($thing {
+                    $($field: $crate::consensus::Decodable::consensus_decode(r.by_ref())?),+
+                })
+            }
+        }
+    );
+}
+pub(crate) use impl_consensus_encoding;
+
+/// Implements several traits for byte-based newtypes.
+/// Implements:
+/// - core::fmt::LowerHex
+/// - core::fmt::UpperHex
+/// - core::fmt::Display
+/// - core::str::FromStr
+/// - hex::FromHex
+macro_rules! impl_bytes_newtype {
+    ($t:ident, $len:literal) => {
+        impl $t {
+            /// Returns a reference the underlying bytes.
+            #[inline]
+            pub fn as_bytes(&self) -> &[u8; $len] { &self.0 }
+
+            /// Returns the underlying bytes.
+            #[inline]
+            pub fn to_bytes(self) -> [u8; $len] {
+                // We rely on `Copy` being implemented for $t so conversion
+                // methods use the correct Rust naming conventions.
+                fn check_copy<T: Copy>() {}
+                check_copy::<$t>();
+
+                self.0
+            }
+        }
+
+        impl core::fmt::LowerHex for $t {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                use $crate::hex::{display, Case};
+                display::fmt_hex_exact!(f, $len, &self.0, Case::Lower)
+            }
+        }
+
+        impl core::fmt::UpperHex for $t {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                use $crate::hex::{display, Case};
+                display::fmt_hex_exact!(f, $len, &self.0, Case::Upper)
+            }
+        }
+
+        impl core::fmt::Display for $t {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                core::fmt::LowerHex::fmt(self, f)
+            }
+        }
+
+        impl core::fmt::Debug for $t {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                core::fmt::LowerHex::fmt(self, f)
+            }
+        }
+
+        impl $crate::hex::FromHex for $t {
+            type Err = $crate::hex::HexToArrayError;
+
+            fn from_byte_iter<I>(iter: I) -> Result<Self, $crate::hex::HexToArrayError>
+            where
+                I: core::iter::Iterator<Item = Result<u8, $crate::hex::HexToBytesError>>
+                    + core::iter::ExactSizeIterator
+                    + core::iter::DoubleEndedIterator,
+            {
+                Ok($t($crate::hex::FromHex::from_byte_iter(iter)?))
+            }
+        }
+
+        impl core::str::FromStr for $t {
+            type Err = $crate::hex::HexToArrayError;
+            fn from_str(s: &str) -> Result<Self, Self::Err> { $crate::hex::FromHex::from_hex(s) }
+        }
+
+        #[cfg(feature = "serde")]
+        impl $crate::serde::Serialize for $t {
+            fn serialize<S: $crate::serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+                if s.is_human_readable() {
+                    s.collect_str(self)
+                } else {
+                    s.serialize_bytes(&self[..])
+                }
+            }
+        }
+
+        #[cfg(feature = "serde")]
+        impl<'de> $crate::serde::Deserialize<'de> for $t {
+            fn deserialize<D: $crate::serde::Deserializer<'de>>(d: D) -> Result<$t, D::Error> {
+                if d.is_human_readable() {
+                    struct HexVisitor;
+
+                    impl<'de> $crate::serde::de::Visitor<'de> for HexVisitor {
+                        type Value = $t;
+
+                        fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                            f.write_str("an ASCII hex string")
+                        }
+
+                        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                        where
+                            E: $crate::serde::de::Error,
+                        {
+                            use $crate::serde::de::Unexpected;
+
+                            if let Ok(hex) = core::str::from_utf8(v) {
+                                $crate::hex::FromHex::from_hex(hex).map_err(E::custom)
+                            } else {
+                                return Err(E::invalid_value(Unexpected::Bytes(v), &self));
+                            }
+                        }
+
+                        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                        where
+                            E: $crate::serde::de::Error,
+                        {
+                            $crate::hex::FromHex::from_hex(v).map_err(E::custom)
+                        }
+                    }
+
+                    d.deserialize_str(HexVisitor)
+                } else {
+                    struct BytesVisitor;
+
+                    impl<'de> $crate::serde::de::Visitor<'de> for BytesVisitor {
+                        type Value = $t;
+
+                        fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                            f.write_str("a bytestring")
+                        }
+
+                        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                        where
+                            E: $crate::serde::de::Error,
+                        {
+                            if v.len() != $len {
+                                Err(E::invalid_length(v.len(), &stringify!($len)))
+                            } else {
+                                let mut ret = [0; $len];
+                                ret.copy_from_slice(v);
+                                Ok($t(ret))
+                            }
+                        }
+                    }
+
+                    d.deserialize_bytes(BytesVisitor)
+                }
+            }
+        }
+    };
+}
+pub(crate) use impl_bytes_newtype;
diff --git a/tapyrus/src/lib.rs b/tapyrus/src/lib.rs
new file mode 100644
index 00000000..8ff7a33e
--- /dev/null
+++ b/tapyrus/src/lib.rs
@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! # Rust Bitcoin Library
+//!
+//! This is a library that supports the Bitcoin network protocol and associated
+//! primitives. It is designed for Rust programs built to work with the Bitcoin
+//! network.
+//!
+//! Except for its dependency on libsecp256k1 (and optionally libbitcoinconsensus),
+//! this library is written entirely in Rust. It illustrates the benefits of
+//! strong type safety, including ownership and lifetime, for financial and/or cryptographic software.
+//!
+//! See README.md for detailed documentation about development and supported
+//! environments.
+//!
+//! ## Available feature flags
+//!
+//! * `std` - the usual dependency on `std` (default).
+//! * `secp-recovery` - enables calculating public key from a signature and message.
+//! * `base64` - (dependency), enables encoding of PSBTs and message signatures.
+//! * `rand` - (dependency), makes it more convenient to generate random values.
+//! * `serde` - (dependency), implements `serde`-based serialization and
+//!                 deserialization.
+//! * `secp-lowmemory` - optimizations for low-memory devices.
+//! * `no-std` - enables additional features required for this crate to be usable
+//!              without std. Does **not** disable `std`. Depends on `core2`.
+//! * `bitcoinconsensus-std` - enables `std` in `bitcoinconsensus` and communicates it
+//!                            to this crate so it knows how to implement
+//!                            `std::error::Error`. At this time there's a hack to
+//!                            achieve the same without this feature but it could
+//!                            happen the implementations diverge one day.
+
+#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]
+// Experimental features we need.
+#![cfg_attr(bench, feature(test))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+// Coding conventions
+#![warn(missing_docs)]
+// Instead of littering the codebase for non-fuzzing code just globally allow.
+#![cfg_attr(fuzzing, allow(dead_code, unused_imports))]
+// Exclude clippy lints we don't think are valuable
+#![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
+
+#[cfg(not(any(feature = "std", feature = "no-std")))]
+compile_error!("at least one of the `std` or `no-std` features must be enabled");
+
+// Disable 16-bit support at least for now as we can't guarantee it yet.
+#[cfg(target_pointer_width = "16")]
+compile_error!(
+    "rust-tapyrus currently only supports architectures with pointers wider than 16 bits, let us
+    know if you want 16-bit support. Note that we do NOT guarantee that we will implement it!"
+);
+
+#[cfg(bench)]
+extern crate test;
+
+#[macro_use]
+extern crate alloc;
+
+#[cfg(feature = "base64")]
+/// Encodes and decodes base64 as bytes or utf8.
+pub extern crate base64;
+
+/// Encodes and decodes the Bech32 forrmat.
+pub extern crate bech32;
+
+#[cfg(feature = "bitcoinconsensus")]
+/// Bitcoin's libbitcoinconsensus with Rust binding.
+pub extern crate bitcoinconsensus;
+
+#[cfg(not(feature = "std"))]
+extern crate core2;
+
+/// Rust implementation of cryptographic hash function algorithems.
+pub extern crate hashes;
+
+/// Re-export the `hex-conservative` crate.
+pub extern crate hex;
+
+/// Rust wrapper library for Pieter Wuille's libsecp256k1.  Implements ECDSA and BIP 340 signatures
+/// for the SECG elliptic curve group secp256k1 and related utilities.
+pub extern crate secp256k1;
+
+#[cfg(feature = "serde")]
+#[macro_use]
+extern crate actual_serde as serde;
+
+extern crate core;
+
+#[cfg(test)]
+#[macro_use]
+mod test_macros;
+mod internal_macros;
+mod parse;
+#[cfg(feature = "serde")]
+mod serde_utils;
+
+#[macro_use]
+pub mod p2p;
+pub mod address;
+pub mod amount;
+pub mod base58;
+pub mod bip152;
+pub mod bip158;
+pub mod bip32;
+pub mod blockdata;
+pub mod consensus;
+// Private until we either make this a crate or flatten it - still to be decided.
+pub(crate) mod crypto;
+pub mod error;
+pub mod hash_types;
+pub mod merkle_tree;
+pub mod network;
+pub mod policy;
+pub mod psbt;
+pub mod sign_message;
+pub mod string;
+pub mod taproot;
+
+// May depend on crate features and we don't want to bother with it
+#[allow(unused)]
+#[cfg(feature = "std")]
+use std::error::Error as StdError;
+#[cfg(feature = "std")]
+use std::io;
+
+#[allow(unused)]
+#[cfg(not(feature = "std"))]
+use core2::error::Error as StdError;
+#[cfg(not(feature = "std"))]
+use core2::io;
+
+pub use crate::address::{Address, AddressType};
+pub use crate::amount::{Amount, Denomination, SignedAmount};
+pub use crate::bip32::XKeyIdentifier;
+pub use crate::blockdata::block::{self, Block};
+pub use crate::blockdata::constants;
+pub use crate::blockdata::fee_rate::FeeRate;
+pub use crate::blockdata::locktime::{self, absolute, relative};
+pub use crate::blockdata::opcodes::{self, Opcode};
+pub use crate::blockdata::script::witness_program::{self, WitnessProgram};
+pub use crate::blockdata::script::witness_version::{self, WitnessVersion};
+pub use crate::blockdata::script::{self, Script, ScriptBuf, ScriptHash, WScriptHash};
+pub use crate::blockdata::transaction::{self, OutPoint, Sequence, Transaction, TxIn, TxOut};
+pub use crate::blockdata::weight::Weight;
+pub use crate::blockdata::witness::{self, Witness};
+pub use crate::consensus::encode::VarInt;
+pub use crate::crypto::ecdsa;
+pub use crate::crypto::key::{
+    self, PrivateKey, PubkeyHash, PublicKey, WPubkeyHash, XOnlyPublicKey,
+};
+pub use crate::crypto::sighash::{self, LegacySighash, SegwitV0Sighash, TapSighash, TapSighashTag};
+pub use crate::hash_types::{
+    BlockHash, FilterHash, FilterHeader, TxMerkleNode, Txid, WitnessCommitment, Wtxid, MalFixTxid,
+};
+pub use crate::merkle_tree::MerkleBlock;
+pub use crate::network::Network;
+pub use crate::psbt::Psbt;
+pub use crate::sighash::{EcdsaSighashType, TapSighashType};
+pub use crate::taproot::{
+    TapBranchTag, TapLeafHash, TapLeafTag, TapNodeHash, TapTweakHash, TapTweakTag,
+};
+
+#[cfg(not(feature = "std"))]
+mod io_extras {
+    /// A writer which will move data into the void.
+    pub struct Sink {
+        _priv: (),
+    }
+
+    /// Creates an instance of a writer which will successfully consume all data.
+    pub const fn sink() -> Sink { Sink { _priv: () } }
+
+    impl core2::io::Write for Sink {
+        #[inline]
+        fn write(&mut self, buf: &[u8]) -> core2::io::Result<usize> { Ok(buf.len()) }
+
+        #[inline]
+        fn flush(&mut self) -> core2::io::Result<()> { Ok(()) }
+    }
+}
+
+#[rustfmt::skip]
+mod prelude {
+    #[cfg(all(not(feature = "std"), not(test)))]
+    pub use alloc::{string::{String, ToString}, vec::Vec, boxed::Box, borrow::{Borrow, BorrowMut, Cow, ToOwned}, rc};
+
+    #[cfg(all(not(feature = "std"), not(test), any(not(rust_v_1_60), target_has_atomic = "ptr")))]
+    pub use alloc::sync;
+
+    #[cfg(any(feature = "std", test))]
+    pub use std::{string::{String, ToString}, vec::Vec, boxed::Box, borrow::{Borrow, BorrowMut, Cow, ToOwned}, rc, sync};
+
+    #[cfg(all(not(feature = "std"), not(test)))]
+    pub use alloc::collections::{BTreeMap, BTreeSet, btree_map, BinaryHeap};
+
+    #[cfg(any(feature = "std", test))]
+    pub use std::collections::{BTreeMap, BTreeSet, btree_map, BinaryHeap};
+
+    #[cfg(feature = "std")]
+    pub use std::io::sink;
+
+    #[cfg(not(feature = "std"))]
+    pub use crate::io_extras::sink;
+
+    pub use hex::DisplayHex;
+}
+
+#[cfg(bench)]
+use bench::EmptyWrite;
+
+#[cfg(bench)]
+mod bench {
+    use core::fmt::Arguments;
+
+    use crate::io::{IoSlice, Result, Write};
+
+    #[derive(Default, Clone, Debug, PartialEq, Eq)]
+    pub struct EmptyWrite;
+
+    impl Write for EmptyWrite {
+        fn write(&mut self, buf: &[u8]) -> Result<usize> { Ok(buf.len()) }
+        fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize> {
+            Ok(bufs.iter().map(|s| s.len()).sum())
+        }
+        fn flush(&mut self) -> Result<()> { Ok(()) }
+
+        fn write_all(&mut self, _: &[u8]) -> Result<()> { Ok(()) }
+        fn write_fmt(&mut self, _: Arguments) -> Result<()> { Ok(()) }
+    }
+}
diff --git a/tapyrus/src/merkle_tree/block.rs b/tapyrus/src/merkle_tree/block.rs
new file mode 100644
index 00000000..5e5c82e1
--- /dev/null
+++ b/tapyrus/src/merkle_tree/block.rs
@@ -0,0 +1,848 @@
+// SPDX-License-Identifier: CC0-1.0
+//
+// This code was translated from merkleblock.h, merkleblock.cpp and pmt_tests.cpp
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2018 The Bitcoin Core developers
+// SPDX-License-Identifier: MIT
+
+//! Merkle Block and Partial Merkle Tree.
+//!
+//! Support proofs that transaction(s) belong to a block.
+//!
+//! # Examples
+//!
+//! ```rust
+//! use tapyrus::hash_types::Txid;
+//! use tapyrus::hex::FromHex;
+//! use tapyrus::{Block, MerkleBlock};
+//!
+//! // Get the proof from a bitcoind by running in the terminal:
+//! // $ TXID="57e1df6a71dcf4fc9535f4d23b15fef372613dfa0ad9b80b6fcd00bf50ce123c"
+//! // $ tapyrus-cli gettxoutproof [\"$TXID\"]
+//! let mb_bytes = Vec::from_hex("0100000096574bdcf9fca26560e5ddf07812c8e64841cb56e6453bf689277e\
+//!     47e0de40d4acd63fe13a8e957e37396beb969a3c54169ba154085ac6933d92c048b8ac01d139b453897c252f\
+//!     18b1258327ff99e923acabe1ce5c8340d19e1098445c1b8cb7a7b57c62004020fd9cd7dc16bedcba8925e358\
+//!     485db06b915c97b3ebfffde128ff5739a01955d21db9f1f4a92f94c77433f01d4b94247902724d70a342a90b\
+//!     5f44d7d0ee70880900000005b5c5945cc9908afb0a0cb2910b6623857e46d04df470e5a1ab482d2b7a119bc9\
+//!     02bff69aa3707c3317d35beb0f9bbfbca793bdf57869ec16b142880489fa025b431bbc09b76450aa05184574\
+//!     7dafb19876528d23814abef113fd032765be4d721ba6f4b8499fec71f8950a0e4fd22c9b623fb8c14106fec0\
+//!     37f498f3f628bc04f541d68b460a5247b1e1ecacff7b66aaa11b66c0ede3d0c58a835d6ca100c4d6022f0f").unwrap();
+//! let mb: MerkleBlock = tapyrus::consensus::deserialize(&mb_bytes).unwrap();
+//!
+//! // Authenticate and extract matched transaction ids
+//! let mut matches: Vec<Txid> = vec![];
+//! let mut index: Vec<u32> = vec![];
+//! assert!(mb.extract_matches(&mut matches, &mut index).is_ok());
+//! assert_eq!(2, matches.len());
+//! assert_eq!(
+//!     "5b02fa89048842b116ec6978f5bd93a7bcbf9b0feb5bd317337c70a39af6bf02".parse::<Txid>().unwrap(),
+//!     matches[0]
+//! );
+//! assert_eq!(2, index.len());
+//! assert_eq!(1, index[0]);
+//! ```
+
+use core::fmt;
+
+use hashes::Hash;
+
+use self::MerkleBlockError::*;
+use crate::blockdata::block::{self, Block};
+use crate::blockdata::transaction::Transaction;
+use crate::blockdata::weight::Weight;
+use crate::consensus::encode::{self, Decodable, Encodable, MAX_VEC_SIZE};
+use crate::hash_types::{TxMerkleNode, Txid};
+use crate::io;
+use crate::prelude::*;
+
+/// Data structure that represents a block header paired to a partial merkle tree.
+///
+/// NOTE: This assumes that the given Block has *at least* 1 transaction. If the Block has 0 txs,
+/// it will hit an assertion.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct MerkleBlock {
+    /// The block header
+    pub header: block::Header,
+    /// Transactions making up a partial merkle tree
+    pub txn: PartialMerkleTree,
+}
+
+impl MerkleBlock {
+    /// Create a MerkleBlock from a block, that contains proofs for specific txids.
+    ///
+    /// The `block` is a full block containing the header and transactions and `match_txids` is a
+    /// function that returns true for the ids that should be included in the partial merkle tree.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use tapyrus::hash_types::Txid;
+    /// use tapyrus::hex::FromHex;
+    /// use tapyrus::{Block, MerkleBlock};
+    ///
+    /// // Block 80000
+    /// let block_bytes = Vec::from_hex("01000000ba8b9cda965dd8e536670f9ddec10e53aab14b20bacad2\
+    ///     7b9137190000000000190760b278fe7b8565fda3b968b918d5fd997f993b23674c0af3b6fde300b38fa3\
+    ///     23afa6d43f364667ed377d3b500c1622d911c3a5b0ab10ca0e2ac89c9460cb33a5914c00000201000000\
+    ///     010000000000000000000000000000000000000000000000000000000000000000ffffffff0704e6ed5b\
+    ///     1b014effffffff0100f2052a01000000434104b68a50eaa0287eff855189f949c1c6e5f58b37c8823137\
+    ///     3d8a59809cbae83059cc6469d65c665ccfd1cfeb75c6e8e19413bba7fbff9bc762419a76d87b16086eac\
+    ///     000000000100000001a6b97044d03da79c005b20ea9c0e1a6d9dc12d9f7b91a5911c9030a439eed8f500\
+    ///     0000004948304502206e21798a42fae0e854281abd38bacd1aeed3ee3738d9e1446618c4571d1090db02\
+    ///     2100e2ac980643b0b82c0e88ffdfec6b64e3e6ba35e7ba5fdd7d5d6cc8d25c6b241501ffffffff0100f2\
+    ///     052a010000001976a914404371705fa9bd789a2fcd52d2c580b65d35549d88ac00000000").unwrap();
+    /// let block: Block = tapyrus::consensus::deserialize(&block_bytes).unwrap();
+    ///
+    /// // Create a merkle block containing a single transaction
+    /// let txid = "5a4ebf66822b0b2d56bd9dc64ece0bc38ee7844a23ff1d7320a88c5fdb2ad3e2".parse::<Txid>().unwrap();
+    /// let match_txids: Vec<Txid> = vec![txid].into_iter().collect();
+    /// let mb = MerkleBlock::from_block_with_predicate(&block, |t| match_txids.contains(t));
+    ///
+    /// // Authenticate and extract matched transaction ids
+    /// let mut matches: Vec<Txid> = vec![];
+    /// let mut index: Vec<u32> = vec![];
+    /// assert!(mb.extract_matches(&mut matches, &mut index).is_ok());
+    /// assert_eq!(txid, matches[0]);
+    /// ```
+    pub fn from_block_with_predicate<F>(block: &Block, match_txids: F) -> Self
+    where
+        F: Fn(&Txid) -> bool,
+    {
+        let block_txids: Vec<_> = block.txdata.iter().map(Transaction::txid).collect();
+        Self::from_header_txids_with_predicate(&block.header, &block_txids, match_txids)
+    }
+
+    /// Create a MerkleBlock from the block's header and txids, that contain proofs for specific txids.
+    ///
+    /// The `header` is the block header, `block_txids` is the full list of txids included in the block and
+    /// `match_txids` is a function that returns true for the ids that should be included in the partial merkle tree.
+    pub fn from_header_txids_with_predicate<F>(
+        header: &block::Header,
+        block_txids: &[Txid],
+        match_txids: F,
+    ) -> Self
+    where
+        F: Fn(&Txid) -> bool,
+    {
+        let matches: Vec<bool> = block_txids.iter().map(match_txids).collect();
+
+        let pmt = PartialMerkleTree::from_txids(block_txids, &matches);
+        MerkleBlock { header: header.clone(), txn: pmt }
+    }
+
+    /// Extract the matching txid's represented by this partial merkle tree
+    /// and their respective indices within the partial tree.
+    /// returns Ok(()) on success, or error in case of failure
+    pub fn extract_matches(
+        &self,
+        matches: &mut Vec<Txid>,
+        indexes: &mut Vec<u32>,
+    ) -> Result<(), MerkleBlockError> {
+        let merkle_root = self.txn.extract_matches(matches, indexes)?;
+
+        if merkle_root.eq(&self.header.merkle_root) {
+            Ok(())
+        } else {
+            Err(MerkleRootMismatch)
+        }
+    }
+}
+
+impl Encodable for MerkleBlock {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let len = self.header.consensus_encode(w)? + self.txn.consensus_encode(w)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for MerkleBlock {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(MerkleBlock {
+            header: Decodable::consensus_decode(r)?,
+            txn: Decodable::consensus_decode(r)?,
+        })
+    }
+}
+
+/// Data structure that represents a partial merkle tree.
+///
+/// It represents a subset of the txid's of a known block, in a way that
+/// allows recovery of the list of txid's and the merkle root, in an
+/// authenticated way.
+///
+/// The encoding works as follows: we traverse the tree in depth-first order,
+/// storing a bit for each traversed node, signifying whether the node is the
+/// parent of at least one matched leaf txid (or a matched txid itself). In
+/// case we are at the leaf level, or this bit is 0, its merkle node hash is
+/// stored, and its children are not explored further. Otherwise, no hash is
+/// stored, but we recurse into both (or the only) child branch. During
+/// decoding, the same depth-first traversal is performed, consuming bits and
+/// hashes as they written during encoding.
+///
+/// The serialization is fixed and provides a hard guarantee about the
+/// encoded size:
+///
+///   SIZE <= 10 + ceil(32.25*N)
+///
+/// Where N represents the number of leaf nodes of the partial tree. N itself
+/// is bounded by:
+///
+///   N <= total_transactions
+///   N <= 1 + matched_transactions*tree_height
+///
+/// The serialization format:
+///  - uint32     total_transactions (4 bytes)
+///  - varint     number of hashes   (1-3 bytes)
+///  - uint256[]  hashes in depth-first order (<= 32*N bytes)
+///  - varint     number of bytes of flag bits (1-3 bytes)
+///  - byte[]     flag bits, packed per 8 in a byte, least significant bit first (<= 2*N-1 bits)
+///
+/// The size constraints follow from this.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct PartialMerkleTree {
+    /// The total number of transactions in the block
+    num_transactions: u32,
+    /// node-is-parent-of-matched-txid bits
+    bits: Vec<bool>,
+    /// Transaction ids and internal hashes
+    hashes: Vec<TxMerkleNode>,
+}
+
+impl PartialMerkleTree {
+    /// Returns the total number of transactions in the block.
+    pub fn num_transactions(&self) -> u32 { self.num_transactions }
+
+    /// Returns the node-is-parent-of-matched-txid bits of the partial merkle tree.
+    pub fn bits(&self) -> &Vec<bool> { &self.bits }
+
+    /// Returns the transaction ids and internal hashes of the partial merkle tree.
+    pub fn hashes(&self) -> &Vec<TxMerkleNode> { &self.hashes }
+
+    /// Construct a partial merkle tree
+    /// The `txids` are the transaction hashes of the block and the `matches` is the contains flags
+    /// wherever a tx hash should be included in the proof.
+    ///
+    /// Panics when `txids` is empty or when `matches` has a different length
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use tapyrus::hash_types::Txid;
+    /// use tapyrus::hex::FromHex;
+    /// use tapyrus::merkle_tree::{MerkleBlock, PartialMerkleTree};
+    ///
+    /// // Block 80000
+    /// let txids: Vec<Txid> = [
+    ///     "c06fbab289f723c6261d3030ddb6be121f7d2508d77862bb1e484f5cd7f92b25",
+    ///     "5a4ebf66822b0b2d56bd9dc64ece0bc38ee7844a23ff1d7320a88c5fdb2ad3e2",
+    /// ]
+    /// .iter()
+    /// .map(|hex| hex.parse::<Txid>().unwrap())
+    /// .collect();
+    ///
+    /// // Select the second transaction
+    /// let matches = vec![false, true];
+    /// let tree = PartialMerkleTree::from_txids(&txids, &matches);
+    /// assert!(tree.extract_matches(&mut vec![], &mut vec![]).is_ok());
+    /// ```
+    pub fn from_txids(txids: &[Txid], matches: &[bool]) -> Self {
+        // We can never have zero txs in a merkle block, we always need the coinbase tx
+        assert_ne!(txids.len(), 0);
+        assert_eq!(txids.len(), matches.len());
+
+        let mut pmt = PartialMerkleTree {
+            num_transactions: txids.len() as u32,
+            bits: Vec::with_capacity(txids.len()),
+            hashes: vec![],
+        };
+        let height = pmt.calc_tree_height();
+
+        // traverse the partial tree
+        pmt.traverse_and_build(height, 0, txids, matches);
+        pmt
+    }
+
+    /// Extract the matching txid's represented by this partial merkle tree
+    /// and their respective indices within the partial tree.
+    /// returns the merkle root, or error in case of failure
+    pub fn extract_matches(
+        &self,
+        matches: &mut Vec<Txid>,
+        indexes: &mut Vec<u32>,
+    ) -> Result<TxMerkleNode, MerkleBlockError> {
+        matches.clear();
+        indexes.clear();
+        // An empty set will not work
+        if self.num_transactions == 0 {
+            return Err(NoTransactions);
+        };
+        // check for excessively high numbers of transactions
+        if self.num_transactions as u64 > Weight::MAX_BLOCK / Weight::MIN_TRANSACTION {
+            return Err(TooManyTransactions);
+        }
+        // there can never be more hashes provided than one for every txid
+        if self.hashes.len() as u32 > self.num_transactions {
+            return Err(TooManyHashes);
+        };
+        // there must be at least one bit per node in the partial tree, and at least one node per hash
+        if self.bits.len() < self.hashes.len() {
+            return Err(NotEnoughBits);
+        };
+
+        let height = self.calc_tree_height();
+
+        // traverse the partial tree
+        let mut bits_used = 0u32;
+        let mut hash_used = 0u32;
+        let hash_merkle_root =
+            self.traverse_and_extract(height, 0, &mut bits_used, &mut hash_used, matches, indexes)?;
+        // Verify that all bits were consumed (except for the padding caused by
+        // serializing it as a byte sequence)
+        if (bits_used + 7) / 8 != (self.bits.len() as u32 + 7) / 8 {
+            return Err(NotAllBitsConsumed);
+        }
+        // Verify that all hashes were consumed
+        if hash_used != self.hashes.len() as u32 {
+            return Err(NotAllHashesConsumed);
+        }
+        Ok(TxMerkleNode::from_byte_array(hash_merkle_root.to_byte_array()))
+    }
+
+    /// Calculates the height of the tree.
+    fn calc_tree_height(&self) -> u32 {
+        let mut height = 0;
+        while self.calc_tree_width(height) > 1 {
+            height += 1;
+        }
+        height
+    }
+
+    /// Helper function to efficiently calculate the number of nodes at given height
+    /// in the merkle tree
+    #[inline]
+    fn calc_tree_width(&self, height: u32) -> u32 {
+        (self.num_transactions + (1 << height) - 1) >> height
+    }
+
+    /// Calculate the hash of a node in the merkle tree (at leaf level: the txid's themselves)
+    fn calc_hash(&self, height: u32, pos: u32, txids: &[Txid]) -> TxMerkleNode {
+        if height == 0 {
+            // Hash at height 0 is the txid itself
+            TxMerkleNode::from_byte_array(txids[pos as usize].to_byte_array())
+        } else {
+            // Calculate left hash
+            let left = self.calc_hash(height - 1, pos * 2, txids);
+            // Calculate right hash if not beyond the end of the array - copy left hash otherwise
+            let right = if pos * 2 + 1 < self.calc_tree_width(height - 1) {
+                self.calc_hash(height - 1, pos * 2 + 1, txids)
+            } else {
+                left
+            };
+            // Combine subhashes
+            PartialMerkleTree::parent_hash(left, right)
+        }
+    }
+
+    /// Recursive function that traverses tree nodes, storing the data as bits and hashes
+    fn traverse_and_build(&mut self, height: u32, pos: u32, txids: &[Txid], matches: &[bool]) {
+        // Determine whether this node is the parent of at least one matched txid
+        let mut parent_of_match = false;
+        let mut p = pos << height;
+        while p < (pos + 1) << height && p < self.num_transactions {
+            parent_of_match |= matches[p as usize];
+            p += 1;
+        }
+        // Store as flag bit
+        self.bits.push(parent_of_match);
+
+        if height == 0 || !parent_of_match {
+            // If at height 0, or nothing interesting below, store hash and stop
+            let hash = self.calc_hash(height, pos, txids);
+            self.hashes.push(hash);
+        } else {
+            // Otherwise, don't store any hash, but descend into the subtrees
+            self.traverse_and_build(height - 1, pos * 2, txids, matches);
+            if pos * 2 + 1 < self.calc_tree_width(height - 1) {
+                self.traverse_and_build(height - 1, pos * 2 + 1, txids, matches);
+            }
+        }
+    }
+
+    /// Recursive function that traverses tree nodes, consuming the bits and hashes produced by
+    /// TraverseAndBuild. It returns the hash of the respective node and its respective index.
+    fn traverse_and_extract(
+        &self,
+        height: u32,
+        pos: u32,
+        bits_used: &mut u32,
+        hash_used: &mut u32,
+        matches: &mut Vec<Txid>,
+        indexes: &mut Vec<u32>,
+    ) -> Result<TxMerkleNode, MerkleBlockError> {
+        if *bits_used as usize >= self.bits.len() {
+            return Err(BitsArrayOverflow);
+        }
+        let parent_of_match = self.bits[*bits_used as usize];
+        *bits_used += 1;
+        if height == 0 || !parent_of_match {
+            // If at height 0, or nothing interesting below, use stored hash and do not descend
+            if *hash_used as usize >= self.hashes.len() {
+                return Err(HashesArrayOverflow);
+            }
+            let hash = self.hashes[*hash_used as usize];
+            *hash_used += 1;
+            if height == 0 && parent_of_match {
+                // in case of height 0, we have a matched txid
+                matches.push(Txid::from_byte_array(hash.to_byte_array()));
+                indexes.push(pos);
+            }
+            Ok(hash)
+        } else {
+            // otherwise, descend into the subtrees to extract matched txids and hashes
+            let left = self.traverse_and_extract(
+                height - 1,
+                pos * 2,
+                bits_used,
+                hash_used,
+                matches,
+                indexes,
+            )?;
+            let right;
+            if pos * 2 + 1 < self.calc_tree_width(height - 1) {
+                right = self.traverse_and_extract(
+                    height - 1,
+                    pos * 2 + 1,
+                    bits_used,
+                    hash_used,
+                    matches,
+                    indexes,
+                )?;
+                if right == left {
+                    // The left and right branches should never be identical, as the transaction
+                    // hashes covered by them must each be unique.
+                    return Err(IdenticalHashesFound);
+                }
+            } else {
+                right = left;
+            }
+            // and combine them before returning
+            Ok(PartialMerkleTree::parent_hash(left, right))
+        }
+    }
+
+    /// Helper method to produce SHA256D(left + right)
+    fn parent_hash(left: TxMerkleNode, right: TxMerkleNode) -> TxMerkleNode {
+        let mut encoder = TxMerkleNode::engine();
+        left.consensus_encode(&mut encoder).expect("engines don't error");
+        right.consensus_encode(&mut encoder).expect("engines don't error");
+        TxMerkleNode::from_engine(encoder)
+    }
+}
+
+impl Encodable for PartialMerkleTree {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut ret = self.num_transactions.consensus_encode(w)?;
+        ret += self.hashes.consensus_encode(w)?;
+
+        let nb_bytes_for_bits = (self.bits.len() + 7) / 8;
+        ret += encode::VarInt::from(nb_bytes_for_bits).consensus_encode(w)?;
+        for chunk in self.bits.chunks(8) {
+            let mut byte = 0u8;
+            for (i, bit) in chunk.iter().enumerate() {
+                byte |= (*bit as u8) << i;
+            }
+            ret += byte.consensus_encode(w)?;
+        }
+        Ok(ret)
+    }
+}
+
+impl Decodable for PartialMerkleTree {
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        let num_transactions: u32 = Decodable::consensus_decode(r)?;
+        let hashes: Vec<TxMerkleNode> = Decodable::consensus_decode(r)?;
+
+        let nb_bytes_for_bits = encode::VarInt::consensus_decode(r)?.0 as usize;
+        if nb_bytes_for_bits > MAX_VEC_SIZE {
+            return Err(encode::Error::OversizedVectorAllocation {
+                requested: nb_bytes_for_bits,
+                max: MAX_VEC_SIZE,
+            });
+        }
+        let mut bits = vec![false; nb_bytes_for_bits * 8];
+        for chunk in bits.chunks_mut(8) {
+            let byte = u8::consensus_decode(r)?;
+            for (i, bit) in chunk.iter_mut().enumerate() {
+                *bit = (byte & (1 << i)) != 0;
+            }
+        }
+
+        Ok(PartialMerkleTree { num_transactions, hashes, bits })
+    }
+}
+
+/// An error when verifying the merkle block.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum MerkleBlockError {
+    /// Merkle root in the header doesn't match to the root calculated from partial merkle tree.
+    MerkleRootMismatch,
+    /// Partial merkle tree contains no transactions.
+    NoTransactions,
+    /// There are too many transactions.
+    TooManyTransactions,
+    /// There are too many hashes
+    TooManyHashes,
+    /// There must be at least one bit per node in the partial tree,
+    /// and at least one node per hash
+    NotEnoughBits,
+    /// Not all bits were consumed
+    NotAllBitsConsumed,
+    /// Not all hashes were consumed
+    NotAllHashesConsumed,
+    /// Overflowed the bits array
+    BitsArrayOverflow,
+    /// Overflowed the hashes array
+    HashesArrayOverflow,
+    /// The left and right branches should never be identical
+    IdenticalHashesFound,
+}
+
+impl fmt::Display for MerkleBlockError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use MerkleBlockError::*;
+
+        match *self {
+            MerkleRootMismatch => write!(f, "merkle header root doesn't match to the root calculated from the partial merkle tree"),
+            NoTransactions => write!(f, "partial merkle tree contains no transactions"),
+            TooManyTransactions => write!(f, "too many transactions"),
+            TooManyHashes => write!(f, "proof contains more hashes than transactions"),
+            NotEnoughBits => write!(f, "proof contains less bits than hashes"),
+            NotAllBitsConsumed => write!(f, "not all bit were consumed"),
+            NotAllHashesConsumed => write!(f, "not all hashes were consumed"),
+            BitsArrayOverflow => write!(f, "overflowed the bits array"),
+            HashesArrayOverflow => write!(f, "overflowed the hashes array"),
+            IdenticalHashesFound => write!(f, "found identical transaction hashes"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for MerkleBlockError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use MerkleBlockError::*;
+
+        match *self {
+            MerkleRootMismatch | NoTransactions | TooManyTransactions | TooManyHashes
+            | NotEnoughBits | NotAllBitsConsumed | NotAllHashesConsumed | BitsArrayOverflow
+            | HashesArrayOverflow | IdenticalHashesFound => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "rand-std")]
+    use hashes::Hash;
+    use hex::test_hex_unwrap as hex;
+    #[cfg(feature = "rand-std")]
+    use secp256k1::rand::prelude::*;
+
+    use super::*;
+    use crate::consensus::encode::{deserialize, serialize};
+    #[cfg(feature = "rand-std")]
+    use crate::hash_types::TxMerkleNode;
+    use crate::{Block, Txid};
+
+    #[cfg(feature = "rand-std")]
+    macro_rules! pmt_tests {
+        ($($name:ident),* $(,)?) => {
+            $(
+                #[test]
+                fn $name() {
+                    pmt_test_from_name(stringify!($name));
+                }
+            )*
+        }
+    }
+
+    #[cfg(feature = "rand-std")]
+    pmt_tests!(
+        pmt_test_1,
+        pmt_test_4,
+        pmt_test_7,
+        pmt_test_17,
+        pmt_test_56,
+        pmt_test_100,
+        pmt_test_127,
+        pmt_test_256,
+        pmt_test_312,
+        pmt_test_513,
+        pmt_test_1000,
+        pmt_test_4095
+    );
+
+    /// Parses the transaction count out of `name` with form: `pmt_test_$num`.
+    #[cfg(feature = "rand-std")]
+    fn pmt_test_from_name(name: &str) { pmt_test(name[9..].parse().unwrap()) }
+
+    #[cfg(feature = "rand-std")]
+    fn pmt_test(tx_count: usize) {
+        use core::cmp::min;
+
+        use crate::merkle_tree;
+
+        let mut rng = thread_rng();
+        // Create some fake tx ids
+        let tx_ids = (1..=tx_count)
+            .map(|i| format!("{:064x}", i).parse::<Txid>().unwrap())
+            .collect::<Vec<_>>();
+
+        // Calculate the merkle root and height
+        let hashes = tx_ids.iter().map(|t| t.to_raw_hash());
+        let merkle_root_1: TxMerkleNode =
+            merkle_tree::calculate_root(hashes).expect("hashes is not empty").into();
+        let mut height = 1;
+        let mut ntx = tx_count;
+        while ntx > 1 {
+            ntx = (ntx + 1) / 2;
+            height += 1;
+        }
+
+        // Check with random subsets with inclusion chances 1, 1/2, 1/4, ..., 1/128
+        for att in 1..15 {
+            let mut matches = vec![false; tx_count];
+            let mut match_txid1 = vec![];
+            for j in 0..tx_count {
+                // Generate `att / 2` random bits
+                let rand_bits = match att / 2 {
+                    0 => 0,
+                    bits => rng.gen::<u64>() >> (64 - bits),
+                };
+                let include = rand_bits == 0;
+                matches[j] = include;
+
+                if include {
+                    match_txid1.push(tx_ids[j]);
+                };
+            }
+
+            // Build the partial merkle tree
+            let pmt1 = PartialMerkleTree::from_txids(&tx_ids, &matches);
+            let serialized = serialize(&pmt1);
+
+            // Verify PartialMerkleTree's size guarantees
+            let n = min(tx_count, 1 + match_txid1.len() * height);
+            assert!(serialized.len() <= 10 + (258 * n + 7) / 8);
+
+            // Deserialize into a tester copy
+            let pmt2: PartialMerkleTree =
+                deserialize(&serialized).expect("Could not deserialize own data");
+
+            // Extract merkle root and matched txids from copy
+            let mut match_txid2: Vec<Txid> = vec![];
+            let mut indexes = vec![];
+            let merkle_root_2 = pmt2
+                .extract_matches(&mut match_txid2, &mut indexes)
+                .expect("Could not extract matches");
+
+            // Check that it has the same merkle root as the original, and a valid one
+            assert_eq!(merkle_root_1, merkle_root_2);
+            assert_ne!(merkle_root_2, TxMerkleNode::all_zeros());
+
+            // check that it contains the matched transactions (in the same order!)
+            assert_eq!(match_txid1, match_txid2);
+
+            // check that random bit flips break the authentication
+            for _ in 0..4 {
+                let mut pmt3: PartialMerkleTree = deserialize(&serialized).unwrap();
+                pmt3.damage(&mut rng);
+                let mut match_txid3 = vec![];
+                let merkle_root_3 = pmt3.extract_matches(&mut match_txid3, &mut indexes).unwrap();
+                assert_ne!(merkle_root_3, merkle_root_1);
+            }
+        }
+    }
+
+    #[test]
+    fn pmt_malleability() {
+        // Create some fake tx ids with the last 2 hashes repeating
+        let txids: Vec<Txid> = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 10]
+            .iter()
+            .map(|i| format!("{:064x}", i).parse::<Txid>().unwrap())
+            .collect();
+
+        let matches =
+            vec![false, false, false, false, false, false, false, false, false, true, true, false];
+
+        let tree = PartialMerkleTree::from_txids(&txids, &matches);
+        // Should fail due to duplicate txs found
+        let result = tree.extract_matches(&mut vec![], &mut vec![]);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn merkleblock_serialization() {
+        let mb_hex = include_str!("../../tests/data/merkle_block.hex");
+
+        let mb: MerkleBlock = deserialize(&hex!(mb_hex)).unwrap();
+        assert_eq!(get_block_13b8a().block_hash(), mb.header.block_hash());
+        assert_eq!(
+            mb.header.merkle_root,
+            mb.txn.extract_matches(&mut vec![], &mut vec![]).unwrap()
+        );
+        // Serialize again and check that it matches the original bytes
+        assert_eq!(mb_hex, serialize(&mb).to_lower_hex_string().as_str());
+    }
+
+    /// Create a CMerkleBlock using a list of txids which will be found in the
+    /// given block.
+    #[test]
+    fn merkleblock_construct_from_txids_found() {
+        let block = get_block_13b8a();
+
+        // These txids are not `Immutable Txid`.
+        let txids: Vec<Txid> = [
+            "d6c400a16c5d838ac5d0e3edc0661ba1aa667bffacece1b147520a468bd641f5",
+            "5b02fa89048842b116ec6978f5bd93a7bcbf9b0feb5bd317337c70a39af6bf02",
+        ]
+        .iter()
+        .map(|hex| hex.parse::<Txid>().unwrap())
+        .collect();
+
+        let txid1 = txids[0];
+        let txid2 = txids[1];
+        let txids = [txid1, txid2];
+
+        let merkle_block = MerkleBlock::from_block_with_predicate(&block, |t| txids.contains(t));
+
+        assert_eq!(merkle_block.header.block_hash(), block.block_hash());
+
+        let mut matches: Vec<Txid> = vec![];
+        let mut index: Vec<u32> = vec![];
+        assert_eq!(
+            merkle_block.txn.extract_matches(&mut matches, &mut index).unwrap(),
+            block.header.merkle_root
+        );
+        assert_eq!(matches.len(), 2);
+
+        // Ordered by occurrence in depth-first tree traversal.
+        assert_eq!(matches[0], txid2);
+        assert_eq!(index[0], 1);
+
+        assert_eq!(matches[1], txid1);
+        assert_eq!(index[1], 8);
+    }
+
+    /// Create a CMerkleBlock using a list of txids which will not be found in the given block
+    #[test]
+    fn merkleblock_construct_from_txids_not_found() {
+        let block = get_block_13b8a();
+        let txids: Vec<Txid> = ["c0ffee00003bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"]
+            .iter()
+            .map(|hex| hex.parse::<Txid>().unwrap())
+            .collect();
+
+        let merkle_block = MerkleBlock::from_block_with_predicate(&block, |t| txids.contains(t));
+
+        assert_eq!(merkle_block.header.block_hash(), block.block_hash());
+
+        let mut matches: Vec<Txid> = vec![];
+        let mut index: Vec<u32> = vec![];
+
+        assert_eq!(
+            merkle_block.txn.extract_matches(&mut matches, &mut index).unwrap(),
+            block.header.merkle_root
+        );
+        assert_eq!(matches.len(), 0);
+        assert_eq!(index.len(), 0);
+    }
+
+    #[cfg(feature = "rand-std")]
+    impl PartialMerkleTree {
+        /// Flip one bit in one of the hashes - this should break the authentication
+        fn damage(&mut self, rng: &mut ThreadRng) {
+            let n = rng.gen_range(0..self.hashes.len());
+            let bit = rng.gen::<u8>();
+            let hashes = &mut self.hashes;
+            let mut hash = hashes[n].to_byte_array();
+            hash[(bit >> 3) as usize] ^= 1 << (bit & 7);
+            hashes[n] = TxMerkleNode::from_slice(&hash).unwrap();
+        }
+    }
+
+    /// Returns a real block in Testnet(3ec84be4559f8ada97bd934b9772ad25ecb8c1762df758c324a19f1cf28749be)
+    /// with 9 txs.
+    fn get_block_13b8a() -> Block {
+        use hex::FromHex;
+        let block_hex = include_str!("../../tests/data/block_3ec84b_hex");
+        deserialize(&Vec::from_hex(block_hex).unwrap()).unwrap()
+    }
+
+    macro_rules! check_calc_tree_width {
+        ($($test_name:ident, $num_transactions:literal, $height:literal, $expected_width:literal);* $(;)?) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    let pmt = PartialMerkleTree {
+                        num_transactions: $num_transactions,
+                        bits: vec![],
+                        hashes: vec![],
+                    };
+                    let got = pmt.calc_tree_width($height);
+                    assert_eq!(got, $expected_width)
+                }
+            )*
+        }
+    }
+
+    // tree_width_<id> <num txs> <height> <expected_width>
+    //
+    // height 0 is the bottom of the tree, where the leaves are.
+    check_calc_tree_width! {
+        tree_width_01, 1, 0, 1;
+        //
+        tree_width_02, 2, 0, 2;
+        tree_width_03, 2, 1, 1;
+        //
+        tree_width_04, 3, 0, 3;
+        tree_width_05, 3, 1, 2;
+        tree_width_06, 3, 2, 1;
+        //
+        tree_width_07, 4, 0, 4;
+        tree_width_08, 4, 1, 2;
+        tree_width_09, 4, 2, 1;
+        //
+        tree_width_10, 5, 0, 5;
+        tree_width_11, 5, 1, 3;
+        tree_width_12, 5, 2, 2;
+        tree_width_13, 5, 3, 1;
+        //
+        tree_width_14, 6, 0, 6;
+        tree_width_15, 6, 1, 3;
+        tree_width_16, 6, 2, 2;
+        tree_width_17, 6, 3, 1;
+        //
+        tree_width_18, 7, 0, 7;
+        tree_width_19, 7, 1, 4;
+        tree_width_20, 7, 2, 2;
+        tree_width_21, 7, 3, 1;
+    }
+
+    #[test]
+    fn regression_2606() {
+        // Attempt
+        let bytes = hex!(
+            "000006000000000000000004ee00000004c7f1ccb1000000ffff000000010000\
+             0000ffffffffff1f000000000400000000000002000000000500000000000000\
+             000000000300000000000003000000000200000000ff00000000c7f1ccb10407\
+             00000000000000ccb100c76538b100000004bfa9c251681b1b00040000000025\
+             00000004bfaac251681b1b25\
+         "
+        );
+        let deser = crate::consensus::deserialize::<MerkleBlock>(&bytes);
+        assert!(deser.is_err());
+    }
+}
diff --git a/tapyrus/src/merkle_tree/mod.rs b/tapyrus/src/merkle_tree/mod.rs
new file mode 100644
index 00000000..898a9c76
--- /dev/null
+++ b/tapyrus/src/merkle_tree/mod.rs
@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin merkle tree functions.
+//!
+//! # Examples
+//!
+//! ```
+//! # use tapyrus::{merkle_tree, Txid};
+//! # use tapyrus::hashes::Hash;
+//! # let tx1 = Txid::all_zeros();  // Dummy hash values.
+//! # let tx2 = Txid::all_zeros();
+//! let tx_hashes = vec![tx1, tx2]; // All the hashes we wish to merkelize.
+//! let root = merkle_tree::calculate_root(tx_hashes.into_iter());
+//! ```
+
+mod block;
+
+use core::cmp::min;
+use core::iter;
+
+pub use block::{MerkleBlock, MerkleBlockError, PartialMerkleTree};
+use hashes::Hash;
+
+use crate::consensus::encode::Encodable;
+use crate::io;
+use crate::prelude::*;
+
+/// Calculates the merkle root of a list of *hashes*, inline (in place) in `hashes`.
+///
+/// In most cases, you'll want to use [`calculate_root`] instead. Please note, calling this function
+/// trashes the data in `hashes` (i.e. the `hashes` is left in an undefined state at conclusion of
+/// this method and should not be used again afterwards).
+///
+/// # Returns
+/// - `None` if `hashes` is empty. The merkle root of an empty tree of hashes is undefined.
+/// - `Some(hash)` if `hashes` contains one element. A single hash is by definition the merkle root.
+/// - `Some(merkle_root)` if length of `hashes` is greater than one.
+pub fn calculate_root_inline<T>(hashes: &mut [T]) -> Option<T>
+where
+    T: Hash + Encodable,
+    <T as Hash>::Engine: io::Write,
+{
+    match hashes.len() {
+        0 => None,
+        1 => Some(hashes[0]),
+        _ => Some(merkle_root_r(hashes)),
+    }
+}
+
+/// Calculates the merkle root of an iterator of *hashes*.
+///
+/// # Returns
+/// - `None` if `hashes` is empty. The merkle root of an empty tree of hashes is undefined.
+/// - `Some(hash)` if `hashes` contains one element. A single hash is by definition the merkle root.
+/// - `Some(merkle_root)` if length of `hashes` is greater than one.
+pub fn calculate_root<T, I>(mut hashes: I) -> Option<T>
+where
+    T: Hash + Encodable,
+    <T as Hash>::Engine: io::Write,
+    I: Iterator<Item = T>,
+{
+    let first = hashes.next()?;
+    let second = match hashes.next() {
+        Some(second) => second,
+        None => return Some(first),
+    };
+
+    let mut hashes = iter::once(first).chain(iter::once(second)).chain(hashes);
+
+    // We need a local copy to pass to `merkle_root_r`. It's more efficient to do the first loop of
+    // processing as we make the copy instead of copying the whole iterator.
+    let (min, max) = hashes.size_hint();
+    let mut alloc = Vec::with_capacity(max.unwrap_or(min) / 2 + 1);
+
+    while let Some(hash1) = hashes.next() {
+        // If the size is odd, use the last element twice.
+        let hash2 = hashes.next().unwrap_or(hash1);
+        let mut encoder = T::engine();
+        hash1.consensus_encode(&mut encoder).expect("in-memory writers don't error");
+        hash2.consensus_encode(&mut encoder).expect("in-memory writers don't error");
+        alloc.push(T::from_engine(encoder));
+    }
+
+    Some(merkle_root_r(&mut alloc))
+}
+
+// `hashes` must contain at least one hash.
+fn merkle_root_r<T>(hashes: &mut [T]) -> T
+where
+    T: Hash + Encodable,
+    <T as Hash>::Engine: io::Write,
+{
+    if hashes.len() == 1 {
+        return hashes[0];
+    }
+
+    for idx in 0..((hashes.len() + 1) / 2) {
+        let idx1 = 2 * idx;
+        let idx2 = min(idx1 + 1, hashes.len() - 1);
+        let mut encoder = T::engine();
+        hashes[idx1].consensus_encode(&mut encoder).expect("in-memory writers don't error");
+        hashes[idx2].consensus_encode(&mut encoder).expect("in-memory writers don't error");
+        hashes[idx] = T::from_engine(encoder);
+    }
+    let half_len = hashes.len() / 2 + hashes.len() % 2;
+
+    merkle_root_r(&mut hashes[0..half_len])
+}
+
+#[cfg(test)]
+mod tests {
+    use hashes::sha256d;
+    use hex::test_hex_unwrap as hex;
+
+    use super::*;
+    use crate::blockdata::block::Block;
+    use crate::consensus::encode::deserialize;
+
+    #[test]
+    fn both_merkle_root_functions_return_the_same_result() {
+        // testnet block 3ec84be4559f8ada97bd934b9772ad25ecb8c1762df758c324a19f1cf28749be
+        let block_hex = include_str!("../../tests/data/block_3ec84b_hex");
+        let block: Block = deserialize(&hex!(block_hex)).expect("Failed to deserialize block");
+        assert!(block.check_merkle_root()); // Sanity check.
+
+        let hashes_iter = block.txdata.iter().map(|obj| obj.txid().to_raw_hash());
+
+        let mut hashes_array: [sha256d::Hash; 9] = [Hash::all_zeros(); 9];
+        for (i, hash) in hashes_iter.clone().enumerate() {
+            hashes_array[i] = hash;
+        }
+
+        let from_iter = calculate_root(hashes_iter);
+        let from_array = calculate_root_inline(&mut hashes_array);
+        assert_eq!(from_iter, from_array);
+    }
+}
diff --git a/tapyrus/src/network.rs b/tapyrus/src/network.rs
new file mode 100644
index 00000000..7ccd1619
--- /dev/null
+++ b/tapyrus/src/network.rs
@@ -0,0 +1,393 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin network.
+//!
+//! The term "network" is overloaded, here [`Network`] refers to the specific
+//! Bitcoin network we are operating on e.g., signet, regtest. The terms
+//! "network" and "chain" are often used interchangeably for this concept.
+//!
+//! # Example: encoding a network's magic bytes
+//!
+//! ```rust
+//! use tapyrus::network::NetworkId;
+//! use tapyrus::consensus::encode::serialize;
+//!
+//! let network = NetworkId::PRODUCTION;
+//! let bytes = serialize(&network.magic());
+//!
+//! assert_eq!(&bytes[..], &[0x01, 0xFF, 0xF0, 0x00]);
+//! ```
+
+use core::fmt;
+use core::str::FromStr;
+use core::num::ParseIntError;
+
+use internals::write_err;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use crate::prelude::{String, ToOwned};
+
+/// Network ID is identifier of the Tapyrus network
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct NetworkId(u32);
+
+impl NetworkId {
+    /// Return the network magic bytes, which should be encoded little-endian
+    /// at the start of every message
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use tapyrus::network::NetworkId;
+    ///
+    /// let network = NetworkId::PRODUCTION;
+    /// assert_eq!(network.magic(), 0x00F0FF01);
+    /// ```
+    pub fn magic(&self) -> u32 { (33550335 + self.0).swap_bytes() }
+
+
+    /// for production environment.
+    pub const PRODUCTION: NetworkId = NetworkId(1);
+    /// for paradium environment.
+    pub const PARADIUM: NetworkId = NetworkId(101);
+    /// for public testnet environment.
+    pub const TESTNET: NetworkId = NetworkId(1939510133);
+    /// for regtest environment.
+    pub const REGTEST: NetworkId = NetworkId(1905960821);
+
+}
+
+impl From<u32> for NetworkId {
+    fn from(n: u32) -> Self { NetworkId(n) }
+}
+
+impl FromStr for NetworkId {
+    type Err = ParseIntError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(NetworkId::from(s.parse::<u32>()?))
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for NetworkId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_u32(self.0)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> ::serde::Deserialize<'de> for NetworkId {
+    fn deserialize<D: ::serde::Deserializer<'de>>(d: D) -> Result<NetworkId, D::Error> {
+        struct NetworkIdVisitor;
+
+        impl<'de> ::serde::de::Visitor<'de> for NetworkIdVisitor {
+            type Value = NetworkId;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("an integer u32")
+            }
+
+            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+            where
+                E: ::serde::de::Error,
+            {
+                Ok(NetworkId::from(v as u32))
+            }
+        }
+
+        d.deserialize_u32(NetworkIdVisitor)
+    }
+}
+
+/// The cryptocurrency network to act on.
+#[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Clone, Hash, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
+#[non_exhaustive]
+pub enum Network {
+    /// For production
+    /// #[strum(serialize = "prod")]
+    Prod,
+    /// For development
+    /// #[strum(serialize = "dev")]
+    Dev,
+}
+
+impl Network {
+    /// Converts a `Network` to its equivalent `bitcoind -chain` argument name.
+    ///
+    /// ```bash
+    /// $ tapyrus-23.0/bin/bitcoind --help | grep -C 3 '\-chain=<chain>'
+    /// Chain selection options:
+    ///
+    /// -chain=<chain>
+    /// Use the chain <chain> (default: main). Allowed values: main, test, signet, regtest
+    /// ```
+    pub fn to_core_arg(self) -> &'static str {
+        match self {
+            Network::Prod => "prod",
+            Network::Dev => "dev",
+        }
+    }
+
+    /// Converts a `bitcoind -chain` argument name to its equivalent `Network`.
+    ///
+    /// ```bash
+    /// $ tapyrus-23.0/bin/bitcoind --help | grep -C 3 '\-chain=<chain>'
+    /// Chain selection options:
+    ///
+    /// -chain=<chain>
+    /// Use the chain <chain> (default: main). Allowed values: main, test, signet, regtest
+    /// ```
+    pub fn from_core_arg(core_arg: &str) -> Result<Self, ParseNetworkError> {
+        use Network::*;
+
+        let network = match core_arg {
+            "prod" => Prod,
+            "dev" => Dev,
+            _ => return Err(ParseNetworkError(core_arg.to_owned())),
+        };
+        Ok(network)
+    }
+}
+
+#[cfg(feature = "serde")]
+pub mod as_core_arg {
+    //! Module for serialization/deserialization of network variants into/from Bitcoin Core values
+    #![allow(missing_docs)]
+
+    use serde;
+
+    use crate::Network;
+
+    pub fn serialize<S>(network: &Network, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(network.to_core_arg())
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Network, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct NetworkVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for NetworkVisitor {
+            type Value = Network;
+
+            fn visit_str<E: serde::de::Error>(self, s: &str) -> Result<Self::Value, E> {
+                Network::from_core_arg(s).map_err(|_| {
+                    E::invalid_value(
+                        serde::de::Unexpected::Str(s),
+                        &"tapyrus network encoded as a string (either main, test, signet or regtest)",
+                    )
+                })
+            }
+
+            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(
+                    formatter,
+                    "tapyrus network encoded as a string (either main, test, signet or regtest)"
+                )
+            }
+        }
+
+        deserializer.deserialize_str(NetworkVisitor)
+    }
+}
+
+/// An error in parsing network string.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ParseNetworkError(pub String);
+
+impl fmt::Display for ParseNetworkError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write_err!(f, "failed to parse {} as network", self.0; self)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseNetworkError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+impl FromStr for Network {
+    type Err = ParseNetworkError;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use Network::*;
+
+        let network = match s {
+            "prod" => Prod,
+            "dev" => Dev,
+            _ => return Err(ParseNetworkError(s.to_owned())),
+        };
+        Ok(network)
+    }
+}
+
+impl fmt::Display for Network {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        use Network::*;
+
+        let s = match *self {
+            Prod => "prod",
+            Dev => "dev",
+        };
+        write!(f, "{}", s)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use super::{Network, NetworkId};
+    use crate::consensus::encode::{deserialize, serialize};
+    use crate::p2p::ServiceFlags;
+
+    #[test]
+    fn serialize_test() {
+        // Production
+        assert_eq!(serialize(&NetworkId::PRODUCTION.magic()), &[0x01, 0xff, 0xf0, 0x00]);
+        // Public Testnet
+        assert_eq!(serialize(&NetworkId::TESTNET.magic()), &[0x75, 0x9a, 0x83, 0x74]);
+        // Regtest
+        assert_eq!(serialize(&NetworkId::REGTEST.magic()), &[0x73, 0x9a, 0x97, 0x74]);
+        // Paradium
+        assert_eq!(serialize(&NetworkId::PARADIUM.magic()), &[0x01, 0xff, 0xf0, 0x64]);
+
+        // Production
+        assert_eq!(deserialize(&[0x01, 0xff, 0xf0, 0x00]).ok(), Some(NetworkId::PRODUCTION.magic()));
+        // Public Testnet
+        assert_eq!(
+            deserialize(&[0x75, 0x9a, 0x83, 0x74]).ok(),
+            Some(NetworkId::TESTNET.magic())
+        );
+        // Regtest
+        assert_eq!(
+            deserialize(&[0x73, 0x9a, 0x97, 0x74]).ok(),
+            Some(NetworkId::REGTEST.magic())
+        );
+        // Paradium
+        assert_eq!(deserialize(&[0x01, 0xff, 0xf0, 0x64]).ok(), Some(NetworkId::PARADIUM.magic()));
+    }
+
+    #[test]
+    fn string_test() {
+        assert_eq!(Network::Prod.to_string(), "prod");
+        assert_eq!(Network::Dev.to_string(), "dev");
+
+        assert_eq!("prod".parse::<Network>().unwrap(), Network::Prod);
+        assert_eq!("dev".parse::<Network>().unwrap(), Network::Dev);
+        assert!("fakenet".parse::<Network>().is_err());
+    }
+
+    #[test]
+    fn network_id_from_str_test() {
+        assert_eq!(NetworkId::from_str("1").unwrap(), NetworkId::from(1));
+    }
+
+    #[test]
+    fn service_flags_test() {
+        let all = [
+            ServiceFlags::NETWORK,
+            ServiceFlags::GETUTXO,
+            ServiceFlags::BLOOM,
+            ServiceFlags::WITNESS,
+            ServiceFlags::COMPACT_FILTERS,
+            ServiceFlags::NETWORK_LIMITED,
+        ];
+
+        let mut flags = ServiceFlags::NONE;
+        for f in all.iter() {
+            assert!(!flags.has(*f));
+        }
+
+        flags |= ServiceFlags::WITNESS;
+        assert_eq!(flags, ServiceFlags::WITNESS);
+
+        let mut flags2 = flags | ServiceFlags::GETUTXO;
+        for f in all.iter() {
+            assert_eq!(flags2.has(*f), *f == ServiceFlags::WITNESS || *f == ServiceFlags::GETUTXO);
+        }
+
+        flags2 ^= ServiceFlags::WITNESS;
+        assert_eq!(flags2, ServiceFlags::GETUTXO);
+
+        flags2 |= ServiceFlags::COMPACT_FILTERS;
+        flags2 ^= ServiceFlags::GETUTXO;
+        assert_eq!(flags2, ServiceFlags::COMPACT_FILTERS);
+
+        // Test formatting.
+        assert_eq!("ServiceFlags(NONE)", ServiceFlags::NONE.to_string());
+        assert_eq!("ServiceFlags(WITNESS)", ServiceFlags::WITNESS.to_string());
+        let flag = ServiceFlags::WITNESS | ServiceFlags::BLOOM | ServiceFlags::NETWORK;
+        assert_eq!("ServiceFlags(NETWORK|BLOOM|WITNESS)", flag.to_string());
+        let flag = ServiceFlags::WITNESS | 0xf0.into();
+        assert_eq!("ServiceFlags(WITNESS|COMPACT_FILTERS|0xb0)", flag.to_string());
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_network_id_serialize() {
+        serde_round_trip!(NetworkId::from(1));
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_roundtrip() {
+        use Network::*;
+        let tests = vec![(Prod, "prod"), (Dev, "dev")];
+
+        for tc in tests {
+            let network = tc.0;
+
+            let want = format!("\"{}\"", tc.1);
+            let got = serde_json::to_string(&tc.0).expect("failed to serialize network");
+            assert_eq!(got, want);
+
+            let back: Network = serde_json::from_str(&got).expect("failed to deserialize network");
+            assert_eq!(back, network);
+        }
+    }
+
+    #[test]
+    fn from_to_core_arg() {
+        let expected_pairs = [(Network::Prod, "prod"), (Network::Dev, "dev")];
+
+        for (net, core_arg) in &expected_pairs {
+            assert_eq!(Network::from_core_arg(core_arg), Ok(*net));
+            assert_eq!(net.to_core_arg(), *core_arg);
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn serde_as_core_arg() {
+        #[derive(Serialize, Deserialize, PartialEq, Debug)]
+        #[serde(crate = "actual_serde")]
+        struct T {
+            #[serde(with = "crate::network::as_core_arg")]
+            pub network: Network,
+        }
+
+        serde_test::assert_tokens(
+            &T { network: Network::Prod },
+            &[
+                serde_test::Token::Struct { name: "T", len: 1 },
+                serde_test::Token::Str("network"),
+                serde_test::Token::Str("prod"),
+                serde_test::Token::StructEnd,
+            ],
+        );
+    }
+}
diff --git a/tapyrus/src/p2p/address.rs b/tapyrus/src/p2p/address.rs
new file mode 100644
index 00000000..2ae9bba1
--- /dev/null
+++ b/tapyrus/src/p2p/address.rs
@@ -0,0 +1,560 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin network addresses.
+//!
+//! This module defines the structures and functions needed to encode
+//! network addresses in Bitcoin messages.
+//!
+
+use core::{fmt, iter};
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
+
+use crate::consensus::encode::{self, Decodable, Encodable, ReadExt, VarInt, WriteExt};
+use crate::io;
+use crate::p2p::ServiceFlags;
+use crate::prelude::*;
+
+/// A message which can be sent on the Bitcoin network
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Address {
+    /// Services provided by the peer whose address this is
+    pub services: ServiceFlags,
+    /// Network byte-order ipv6 address, or ipv4-mapped ipv6 address
+    pub address: [u16; 8],
+    /// Network port
+    pub port: u16,
+}
+
+const ONION: [u16; 3] = [0xFD87, 0xD87E, 0xEB43];
+
+impl Address {
+    /// Create an address message for a socket
+    pub fn new(socket: &SocketAddr, services: ServiceFlags) -> Address {
+        let (address, port) = match *socket {
+            SocketAddr::V4(addr) => (addr.ip().to_ipv6_mapped().segments(), addr.port()),
+            SocketAddr::V6(addr) => (addr.ip().segments(), addr.port()),
+        };
+        Address { address, port, services }
+    }
+
+    /// Extract socket address from an [Address] message.
+    /// This will return [io::Error] [io::ErrorKind::AddrNotAvailable]
+    /// if the message contains a Tor address.
+    pub fn socket_addr(&self) -> Result<SocketAddr, io::Error> {
+        let addr = &self.address;
+        if addr[0..3] == ONION {
+            return Err(io::Error::from(io::ErrorKind::AddrNotAvailable));
+        }
+        let ipv6 =
+            Ipv6Addr::new(addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]);
+        if let Some(ipv4) = ipv6.to_ipv4() {
+            Ok(SocketAddr::V4(SocketAddrV4::new(ipv4, self.port)))
+        } else {
+            Ok(SocketAddr::V6(SocketAddrV6::new(ipv6, self.port, 0, 0)))
+        }
+    }
+}
+
+impl Encodable for Address {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = self.services.consensus_encode(w)?;
+
+        for word in &self.address {
+            w.write_all(&word.to_be_bytes())?;
+            len += 2;
+        }
+
+        w.write_all(&self.port.to_be_bytes())?;
+        len += 2;
+
+        Ok(len)
+    }
+}
+
+impl Decodable for Address {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(Address {
+            services: Decodable::consensus_decode(r)?,
+            address: read_be_address(r)?,
+            port: u16::swap_bytes(Decodable::consensus_decode(r)?),
+        })
+    }
+}
+
+/// Read a big-endian address from reader.
+fn read_be_address<R: io::Read + ?Sized>(r: &mut R) -> Result<[u16; 8], encode::Error> {
+    let mut address = [0u16; 8];
+    let mut buf = [0u8; 2];
+
+    for word in &mut address {
+        io::Read::read_exact(r, &mut buf)?;
+        *word = u16::from_be_bytes(buf)
+    }
+    Ok(address)
+}
+
+impl fmt::Debug for Address {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let ipv6 = Ipv6Addr::from(self.address);
+
+        match ipv6.to_ipv4() {
+            Some(addr) => write!(
+                f,
+                "Address {{services: {}, address: {}, port: {}}}",
+                self.services, addr, self.port
+            ),
+            None => write!(
+                f,
+                "Address {{services: {}, address: {}, port: {}}}",
+                self.services, ipv6, self.port
+            ),
+        }
+    }
+}
+
+impl ToSocketAddrs for Address {
+    type Iter = iter::Once<SocketAddr>;
+    fn to_socket_addrs(&self) -> Result<Self::Iter, io::Error> {
+        Ok(iter::once(self.socket_addr()?))
+    }
+}
+
+/// Supported networks for use in BIP155 addrv2 message
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub enum AddrV2 {
+    /// IPV4
+    Ipv4(Ipv4Addr),
+    /// IPV6
+    Ipv6(Ipv6Addr),
+    /// TORV2
+    TorV2([u8; 10]),
+    /// TORV3
+    TorV3([u8; 32]),
+    /// I2P
+    I2p([u8; 32]),
+    /// CJDNS
+    Cjdns(Ipv6Addr),
+    /// Unknown
+    Unknown(u8, Vec<u8>),
+}
+
+impl Encodable for AddrV2 {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        fn encode_addr<W: io::Write + ?Sized>(
+            w: &mut W,
+            network: u8,
+            bytes: &[u8],
+        ) -> Result<usize, io::Error> {
+            let len = network.consensus_encode(w)?
+                + VarInt::from(bytes.len()).consensus_encode(w)?
+                + bytes.len();
+            w.emit_slice(bytes)?;
+            Ok(len)
+        }
+        Ok(match *self {
+            AddrV2::Ipv4(ref addr) => encode_addr(w, 1, &addr.octets())?,
+            AddrV2::Ipv6(ref addr) => encode_addr(w, 2, &addr.octets())?,
+            AddrV2::TorV2(ref bytes) => encode_addr(w, 3, bytes)?,
+            AddrV2::TorV3(ref bytes) => encode_addr(w, 4, bytes)?,
+            AddrV2::I2p(ref bytes) => encode_addr(w, 5, bytes)?,
+            AddrV2::Cjdns(ref addr) => encode_addr(w, 6, &addr.octets())?,
+            AddrV2::Unknown(network, ref bytes) => encode_addr(w, network, bytes)?,
+        })
+    }
+}
+
+impl Decodable for AddrV2 {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let network_id = u8::consensus_decode(r)?;
+        let len = VarInt::consensus_decode(r)?.0;
+        if len > 512 {
+            return Err(encode::Error::ParseFailed("IP must be <= 512 bytes"));
+        }
+        Ok(match network_id {
+            1 => {
+                if len != 4 {
+                    return Err(encode::Error::ParseFailed("Invalid IPv4 address"));
+                }
+                let addr: [u8; 4] = Decodable::consensus_decode(r)?;
+                AddrV2::Ipv4(Ipv4Addr::new(addr[0], addr[1], addr[2], addr[3]))
+            }
+            2 => {
+                if len != 16 {
+                    return Err(encode::Error::ParseFailed("Invalid IPv6 address"));
+                }
+                let addr: [u16; 8] = read_be_address(r)?;
+                if addr[0..3] == ONION {
+                    return Err(encode::Error::ParseFailed(
+                        "OnionCat address sent with IPv6 network id",
+                    ));
+                }
+                if addr[0..6] == [0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xFFFF] {
+                    return Err(encode::Error::ParseFailed(
+                        "IPV4 wrapped address sent with IPv6 network id",
+                    ));
+                }
+                AddrV2::Ipv6(Ipv6Addr::new(
+                    addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
+                ))
+            }
+            3 => {
+                if len != 10 {
+                    return Err(encode::Error::ParseFailed("Invalid TorV2 address"));
+                }
+                let id = Decodable::consensus_decode(r)?;
+                AddrV2::TorV2(id)
+            }
+            4 => {
+                if len != 32 {
+                    return Err(encode::Error::ParseFailed("Invalid TorV3 address"));
+                }
+                let pubkey = Decodable::consensus_decode(r)?;
+                AddrV2::TorV3(pubkey)
+            }
+            5 => {
+                if len != 32 {
+                    return Err(encode::Error::ParseFailed("Invalid I2P address"));
+                }
+                let hash = Decodable::consensus_decode(r)?;
+                AddrV2::I2p(hash)
+            }
+            6 => {
+                if len != 16 {
+                    return Err(encode::Error::ParseFailed("Invalid CJDNS address"));
+                }
+                let addr: [u16; 8] = read_be_address(r)?;
+                // check the first byte for the CJDNS marker
+                if addr[0] != u16::from_be_bytes([0xFC, 0x00]) {
+                    return Err(encode::Error::ParseFailed("Invalid CJDNS address"));
+                }
+                AddrV2::Cjdns(Ipv6Addr::new(
+                    addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], addr[6], addr[7],
+                ))
+            }
+            _ => {
+                // len already checked above to be <= 512
+                let mut addr = vec![0u8; len as usize];
+                r.read_slice(&mut addr)?;
+                AddrV2::Unknown(network_id, addr)
+            }
+        })
+    }
+}
+
+/// Address received from BIP155 addrv2 message
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
+pub struct AddrV2Message {
+    /// Time that this node was last seen as connected to the network
+    pub time: u32,
+    /// Service bits
+    pub services: ServiceFlags,
+    /// Network ID + Network Address
+    pub addr: AddrV2,
+    /// Network port, 0 if not applicable
+    pub port: u16,
+}
+
+impl AddrV2Message {
+    /// Extract socket address from an [AddrV2Message] message.
+    /// This will return [io::Error] [io::ErrorKind::AddrNotAvailable]
+    /// if the address type can't be converted into a [SocketAddr].
+    pub fn socket_addr(&self) -> Result<SocketAddr, io::Error> {
+        match self.addr {
+            AddrV2::Ipv4(addr) => Ok(SocketAddr::V4(SocketAddrV4::new(addr, self.port))),
+            AddrV2::Ipv6(addr) => Ok(SocketAddr::V6(SocketAddrV6::new(addr, self.port, 0, 0))),
+            _ => Err(io::Error::from(io::ErrorKind::AddrNotAvailable)),
+        }
+    }
+}
+
+impl Encodable for AddrV2Message {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.time.consensus_encode(w)?;
+        len += VarInt(self.services.to_u64()).consensus_encode(w)?;
+        len += self.addr.consensus_encode(w)?;
+
+        w.write_all(&self.port.to_be_bytes())?;
+        len += 2; // port u16 is two bytes.
+
+        Ok(len)
+    }
+}
+
+impl Decodable for AddrV2Message {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(AddrV2Message {
+            time: Decodable::consensus_decode(r)?,
+            services: ServiceFlags::from(VarInt::consensus_decode(r)?.0),
+            addr: Decodable::consensus_decode(r)?,
+            port: u16::swap_bytes(Decodable::consensus_decode(r)?),
+        })
+    }
+}
+
+impl ToSocketAddrs for AddrV2Message {
+    type Iter = iter::Once<SocketAddr>;
+    fn to_socket_addrs(&self) -> Result<Self::Iter, io::Error> {
+        Ok(iter::once(self.socket_addr()?))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use core::str::FromStr;
+    use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+
+    use hex::{test_hex_unwrap as hex, FromHex};
+
+    use super::{AddrV2, AddrV2Message, Address};
+    use crate::consensus::encode::{deserialize, serialize};
+    use crate::p2p::ServiceFlags;
+
+    #[test]
+    fn serialize_address_test() {
+        assert_eq!(
+            serialize(&Address {
+                services: ServiceFlags::NETWORK,
+                address: [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001],
+                port: 8333
+            }),
+            vec![
+                1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
+                0x20, 0x8d
+            ]
+        );
+    }
+
+    #[test]
+    fn debug_format_test() {
+        let mut flags = ServiceFlags::NETWORK;
+        assert_eq!(
+            format!("The address is: {:?}", Address {
+                services: flags.add(ServiceFlags::WITNESS),
+                address: [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001],
+                port: 8333
+            }),
+            "The address is: Address {services: ServiceFlags(NETWORK|WITNESS), address: 10.0.0.1, port: 8333}"
+        );
+
+        assert_eq!(
+            format!("The address is: {:?}", Address {
+                services: ServiceFlags::NETWORK_LIMITED,
+                address: [0xFD87, 0xD87E, 0xEB43, 0, 0, 0xffff, 0x0a00, 0x0001],
+                port: 8333
+            }),
+            "The address is: Address {services: ServiceFlags(NETWORK_LIMITED), address: fd87:d87e:eb43::ffff:a00:1, port: 8333}"
+        );
+    }
+
+    #[test]
+    fn deserialize_address_test() {
+        let mut addr: Result<Address, _> = deserialize(&[
+            1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
+            0x20, 0x8d,
+        ]);
+        assert!(addr.is_ok());
+        let full = addr.unwrap();
+        assert!(matches!(full.socket_addr().unwrap(), SocketAddr::V4(_)));
+        assert_eq!(full.services, ServiceFlags::NETWORK);
+        assert_eq!(full.address, [0, 0, 0, 0, 0, 0xffff, 0x0a00, 0x0001]);
+        assert_eq!(full.port, 8333);
+
+        addr = deserialize(&[
+            1u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0x0a, 0, 0, 1,
+        ]);
+        assert!(addr.is_err());
+    }
+
+    #[test]
+    fn test_socket_addr() {
+        let s4 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(111, 222, 123, 4)), 5555);
+        let a4 = Address::new(&s4, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
+        assert_eq!(a4.socket_addr().unwrap(), s4);
+        let s6 = SocketAddr::new(
+            IpAddr::V6(Ipv6Addr::new(
+                0x1111, 0x2222, 0x3333, 0x4444, 0x5555, 0x6666, 0x7777, 0x8888,
+            )),
+            9999,
+        );
+        let a6 = Address::new(&s6, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
+        assert_eq!(a6.socket_addr().unwrap(), s6);
+    }
+
+    #[test]
+    fn onion_test() {
+        let onionaddr = SocketAddr::new(
+            IpAddr::V6(Ipv6Addr::from_str("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").unwrap()),
+            1111,
+        );
+        let addr = Address::new(&onionaddr, ServiceFlags::NONE);
+        assert!(addr.socket_addr().is_err());
+    }
+
+    #[test]
+    fn serialize_addrv2_test() {
+        // Taken from https://github.com/bitcoin/bitcoin/blob/12a1c3ad1a43634d2a98717e49e3f02c4acea2fe/src/test/net_tests.cpp#L348
+
+        let ip = AddrV2::Ipv4(Ipv4Addr::new(1, 2, 3, 4));
+        assert_eq!(serialize(&ip), hex!("010401020304"));
+
+        let ip =
+            AddrV2::Ipv6(Ipv6Addr::from_str("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b").unwrap());
+        assert_eq!(serialize(&ip), hex!("02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b"));
+
+        let ip = AddrV2::TorV2(FromHex::from_hex("f1f2f3f4f5f6f7f8f9fa").unwrap());
+        assert_eq!(serialize(&ip), hex!("030af1f2f3f4f5f6f7f8f9fa"));
+
+        let ip = AddrV2::TorV3(
+            FromHex::from_hex("53cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88")
+                .unwrap(),
+        );
+        assert_eq!(
+            serialize(&ip),
+            hex!("042053cd5648488c4707914182655b7664034e09e66f7e8cbf1084e654eb56c5bd88")
+        );
+
+        let ip = AddrV2::I2p(
+            FromHex::from_hex("a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
+                .unwrap(),
+        );
+        assert_eq!(
+            serialize(&ip),
+            hex!("0520a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
+        );
+
+        let ip = AddrV2::Cjdns(Ipv6Addr::from_str("fc00:1:2:3:4:5:6:7").unwrap());
+        assert_eq!(serialize(&ip), hex!("0610fc000001000200030004000500060007"));
+
+        let ip = AddrV2::Unknown(170, hex!("01020304"));
+        assert_eq!(serialize(&ip), hex!("aa0401020304"));
+    }
+
+    #[test]
+    fn deserialize_addrv2_test() {
+        // Taken from https://github.com/bitcoin/bitcoin/blob/12a1c3ad1a43634d2a98717e49e3f02c4acea2fe/src/test/net_tests.cpp#L386
+
+        // Valid IPv4.
+        let ip: AddrV2 = deserialize(&hex!("010401020304")).unwrap();
+        assert_eq!(ip, AddrV2::Ipv4(Ipv4Addr::new(1, 2, 3, 4)));
+
+        // Invalid IPv4, valid length but address itself is shorter.
+        deserialize::<AddrV2>(&hex!("01040102")).unwrap_err();
+
+        // Invalid IPv4, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("010501020304")).is_err());
+
+        // Invalid IPv4, with extreme length.
+        assert!(deserialize::<AddrV2>(&hex!("01fd010201020304")).is_err());
+
+        // Valid IPv6.
+        let ip: AddrV2 = deserialize(&hex!("02100102030405060708090a0b0c0d0e0f10")).unwrap();
+        assert_eq!(
+            ip,
+            AddrV2::Ipv6(Ipv6Addr::from_str("102:304:506:708:90a:b0c:d0e:f10").unwrap())
+        );
+
+        // Invalid IPv6, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("020400")).is_err());
+
+        // Invalid IPv6, contains embedded IPv4.
+        assert!(deserialize::<AddrV2>(&hex!("021000000000000000000000ffff01020304")).is_err());
+
+        // Invalid IPv6, contains embedded TORv2.
+        assert!(deserialize::<AddrV2>(&hex!("0210fd87d87eeb430102030405060708090a")).is_err());
+
+        // Valid TORv2.
+        let ip: AddrV2 = deserialize(&hex!("030af1f2f3f4f5f6f7f8f9fa")).unwrap();
+        assert_eq!(ip, AddrV2::TorV2(FromHex::from_hex("f1f2f3f4f5f6f7f8f9fa").unwrap()));
+
+        // Invalid TORv2, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("030700")).is_err());
+
+        // Valid TORv3.
+        let ip: AddrV2 = deserialize(&hex!(
+            "042079bcc625184b05194975c28b66b66b0469f7f6556fb1ac3189a79b40dda32f1f"
+        ))
+        .unwrap();
+        assert_eq!(
+            ip,
+            AddrV2::TorV3(
+                FromHex::from_hex(
+                    "79bcc625184b05194975c28b66b66b0469f7f6556fb1ac3189a79b40dda32f1f"
+                )
+                .unwrap()
+            )
+        );
+
+        // Invalid TORv3, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("040000")).is_err());
+
+        // Valid I2P.
+        let ip: AddrV2 = deserialize(&hex!(
+            "0520a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87"
+        ))
+        .unwrap();
+        assert_eq!(
+            ip,
+            AddrV2::I2p(
+                FromHex::from_hex(
+                    "a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87"
+                )
+                .unwrap()
+            )
+        );
+
+        // Invalid I2P, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("050300")).is_err());
+
+        // Valid CJDNS.
+        let ip: AddrV2 = deserialize(&hex!("0610fc000001000200030004000500060007")).unwrap();
+        assert_eq!(ip, AddrV2::Cjdns(Ipv6Addr::from_str("fc00:1:2:3:4:5:6:7").unwrap()));
+
+        // Invalid CJDNS, incorrect marker
+        assert!(deserialize::<AddrV2>(&hex!("0610fd000001000200030004000500060007")).is_err());
+
+        // Invalid CJDNS, with bogus length.
+        assert!(deserialize::<AddrV2>(&hex!("060100")).is_err());
+
+        // Unknown, with extreme length.
+        assert!(deserialize::<AddrV2>(&hex!("aafe0000000201020304050607")).is_err());
+
+        // Unknown, with reasonable length.
+        let ip: AddrV2 = deserialize(&hex!("aa0401020304")).unwrap();
+        assert_eq!(ip, AddrV2::Unknown(170, hex!("01020304")));
+
+        // Unknown, with zero length.
+        let ip: AddrV2 = deserialize(&hex!("aa00")).unwrap();
+        assert_eq!(ip, AddrV2::Unknown(170, vec![]));
+    }
+
+    #[test]
+    fn addrv2message_test() {
+        let raw = hex!("0261bc6649019902abab208d79627683fd4804010409090909208d");
+        let addresses: Vec<AddrV2Message> = deserialize(&raw).unwrap();
+
+        assert_eq!(
+            addresses,
+            vec![
+                AddrV2Message {
+                    services: ServiceFlags::NETWORK,
+                    time: 0x4966bc61,
+                    port: 8333,
+                    addr: AddrV2::Unknown(153, hex!("abab"))
+                },
+                AddrV2Message {
+                    services: ServiceFlags::NETWORK_LIMITED
+                        | ServiceFlags::WITNESS
+                        | ServiceFlags::COMPACT_FILTERS,
+                    time: 0x83766279,
+                    port: 8333,
+                    addr: AddrV2::Ipv4(Ipv4Addr::new(9, 9, 9, 9))
+                },
+            ]
+        );
+
+        assert_eq!(serialize(&addresses), raw);
+    }
+}
diff --git a/tapyrus/src/p2p/message.rs b/tapyrus/src/p2p/message.rs
new file mode 100644
index 00000000..19e53127
--- /dev/null
+++ b/tapyrus/src/p2p/message.rs
@@ -0,0 +1,851 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin network messages.
+//!
+//! This module defines the `NetworkMessage` and `RawNetworkMessage` types that
+//! are used for (de)serializing Bitcoin objects for transmission on the network.
+//!
+
+use core::convert::TryFrom;
+use core::{fmt, iter};
+
+use hashes::{sha256d, Hash};
+use io::Read as _;
+
+use crate::blockdata::{block, transaction};
+use crate::consensus::encode::{self, CheckedData, Decodable, Encodable, VarInt};
+use crate::io;
+use crate::merkle_tree::MerkleBlock;
+use crate::p2p::address::{AddrV2Message, Address};
+use crate::p2p::{
+    message_blockdata, message_bloom, message_compact_blocks, message_filter, message_network,
+    Magic,
+};
+use crate::prelude::*;
+
+/// The maximum number of [super::message_blockdata::Inventory] items in an `inv` message.
+///
+/// This limit is not currently enforced by this implementation.
+pub const MAX_INV_SIZE: usize = 50_000;
+
+/// Maximum size, in bytes, of an encoded message
+/// This by neccessity should be larger tham `MAX_VEC_SIZE`
+pub const MAX_MSG_SIZE: usize = 5_000_000;
+
+/// Serializer for command string
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct CommandString(Cow<'static, str>);
+
+impl CommandString {
+    /// Converts `&'static str` to `CommandString`
+    ///
+    /// This is more efficient for string literals than non-static conversions because it avoids
+    /// allocation.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if, and only if, the string is
+    /// larger than 12 characters in length.
+    pub fn try_from_static(s: &'static str) -> Result<CommandString, CommandStringError> {
+        Self::try_from_static_cow(s.into())
+    }
+
+    fn try_from_static_cow(cow: Cow<'static, str>) -> Result<CommandString, CommandStringError> {
+        if cow.len() > 12 {
+            Err(CommandStringError { cow })
+        } else {
+            Ok(CommandString(cow))
+        }
+    }
+}
+
+impl TryFrom<String> for CommandString {
+    type Error = CommandStringError;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        Self::try_from_static_cow(value.into())
+    }
+}
+
+impl TryFrom<Box<str>> for CommandString {
+    type Error = CommandStringError;
+
+    fn try_from(value: Box<str>) -> Result<Self, Self::Error> {
+        Self::try_from_static_cow(String::from(value).into())
+    }
+}
+
+impl<'a> TryFrom<&'a str> for CommandString {
+    type Error = CommandStringError;
+
+    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
+        Self::try_from_static_cow(value.to_owned().into())
+    }
+}
+
+impl core::str::FromStr for CommandString {
+    type Err = CommandStringError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::try_from_static_cow(s.to_owned().into())
+    }
+}
+
+impl fmt::Display for CommandString {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(self.0.as_ref()) }
+}
+
+impl AsRef<str> for CommandString {
+    fn as_ref(&self) -> &str { self.0.as_ref() }
+}
+
+impl Encodable for CommandString {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut rawbytes = [0u8; 12];
+        let strbytes = self.0.as_bytes();
+        debug_assert!(strbytes.len() <= 12);
+        rawbytes[..strbytes.len()].copy_from_slice(strbytes);
+        rawbytes.consensus_encode(w)
+    }
+}
+
+impl Decodable for CommandString {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let rawbytes: [u8; 12] = Decodable::consensus_decode(r)?;
+        let rv = iter::FromIterator::from_iter(rawbytes.iter().filter_map(|&u| {
+            if u > 0 {
+                Some(u as char)
+            } else {
+                None
+            }
+        }));
+        Ok(CommandString(rv))
+    }
+}
+
+/// Error returned when a command string is invalid.
+///
+/// This is currently returned for command strings longer than 12.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct CommandStringError {
+    cow: Cow<'static, str>,
+}
+
+impl fmt::Display for CommandStringError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "the command string '{}' has length {} which is larger than 12",
+            self.cow,
+            self.cow.len()
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for CommandStringError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+/// A Network message
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RawNetworkMessage {
+    magic: Magic,
+    payload: NetworkMessage,
+    payload_len: u32,
+    checksum: [u8; 4],
+}
+
+/// A Network message payload. Proper documentation is available on at
+/// [Bitcoin Wiki: Protocol Specification](https://en.bitcoin.it/wiki/Protocol_specification)
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum NetworkMessage {
+    /// `version`
+    Version(message_network::VersionMessage),
+    /// `verack`
+    Verack,
+    /// `addr`
+    Addr(Vec<(u32, Address)>),
+    /// `inv`
+    Inv(Vec<message_blockdata::Inventory>),
+    /// `getdata`
+    GetData(Vec<message_blockdata::Inventory>),
+    /// `notfound`
+    NotFound(Vec<message_blockdata::Inventory>),
+    /// `getblocks`
+    GetBlocks(message_blockdata::GetBlocksMessage),
+    /// `getheaders`
+    GetHeaders(message_blockdata::GetHeadersMessage),
+    /// `mempool`
+    MemPool,
+    /// tx
+    Tx(transaction::Transaction),
+    /// `block`
+    Block(block::Block),
+    /// `headers`
+    Headers(Vec<block::Header>),
+    /// `sendheaders`
+    SendHeaders,
+    /// `getaddr`
+    GetAddr,
+    // TODO: checkorder,
+    // TODO: submitorder,
+    // TODO: reply,
+    /// `ping`
+    Ping(u64),
+    /// `pong`
+    Pong(u64),
+    /// `merkleblock`
+    MerkleBlock(MerkleBlock),
+    /// BIP 37 `filterload`
+    FilterLoad(message_bloom::FilterLoad),
+    /// BIP 37 `filteradd`
+    FilterAdd(message_bloom::FilterAdd),
+    /// BIP 37 `filterclear`
+    FilterClear,
+    /// BIP157 getcfilters
+    GetCFilters(message_filter::GetCFilters),
+    /// BIP157 cfilter
+    CFilter(message_filter::CFilter),
+    /// BIP157 getcfheaders
+    GetCFHeaders(message_filter::GetCFHeaders),
+    /// BIP157 cfheaders
+    CFHeaders(message_filter::CFHeaders),
+    /// BIP157 getcfcheckpt
+    GetCFCheckpt(message_filter::GetCFCheckpt),
+    /// BIP157 cfcheckpt
+    CFCheckpt(message_filter::CFCheckpt),
+    /// BIP152 sendcmpct
+    SendCmpct(message_compact_blocks::SendCmpct),
+    /// BIP152 cmpctblock
+    CmpctBlock(message_compact_blocks::CmpctBlock),
+    /// BIP152 getblocktxn
+    GetBlockTxn(message_compact_blocks::GetBlockTxn),
+    /// BIP152 blocktxn
+    BlockTxn(message_compact_blocks::BlockTxn),
+    /// `alert`
+    Alert(Vec<u8>),
+    /// `reject`
+    Reject(message_network::Reject),
+    /// `feefilter`
+    FeeFilter(i64),
+    /// `wtxidrelay`
+    WtxidRelay,
+    /// `addrv2`
+    AddrV2(Vec<AddrV2Message>),
+    /// `sendaddrv2`
+    SendAddrV2,
+
+    /// Any other message.
+    Unknown {
+        /// The command of this message.
+        command: CommandString,
+        /// The payload of this message.
+        payload: Vec<u8>,
+    },
+}
+
+impl NetworkMessage {
+    /// Return the message command as a static string reference.
+    ///
+    /// This returns `"unknown"` for [NetworkMessage::Unknown],
+    /// regardless of the actual command in the unknown message.
+    /// Use the [Self::command] method to get the command for unknown messages.
+    pub fn cmd(&self) -> &'static str {
+        match *self {
+            NetworkMessage::Version(_) => "version",
+            NetworkMessage::Verack => "verack",
+            NetworkMessage::Addr(_) => "addr",
+            NetworkMessage::Inv(_) => "inv",
+            NetworkMessage::GetData(_) => "getdata",
+            NetworkMessage::NotFound(_) => "notfound",
+            NetworkMessage::GetBlocks(_) => "getblocks",
+            NetworkMessage::GetHeaders(_) => "getheaders",
+            NetworkMessage::MemPool => "mempool",
+            NetworkMessage::Tx(_) => "tx",
+            NetworkMessage::Block(_) => "block",
+            NetworkMessage::Headers(_) => "headers",
+            NetworkMessage::SendHeaders => "sendheaders",
+            NetworkMessage::GetAddr => "getaddr",
+            NetworkMessage::Ping(_) => "ping",
+            NetworkMessage::Pong(_) => "pong",
+            NetworkMessage::MerkleBlock(_) => "merkleblock",
+            NetworkMessage::FilterLoad(_) => "filterload",
+            NetworkMessage::FilterAdd(_) => "filteradd",
+            NetworkMessage::FilterClear => "filterclear",
+            NetworkMessage::GetCFilters(_) => "getcfilters",
+            NetworkMessage::CFilter(_) => "cfilter",
+            NetworkMessage::GetCFHeaders(_) => "getcfheaders",
+            NetworkMessage::CFHeaders(_) => "cfheaders",
+            NetworkMessage::GetCFCheckpt(_) => "getcfcheckpt",
+            NetworkMessage::CFCheckpt(_) => "cfcheckpt",
+            NetworkMessage::SendCmpct(_) => "sendcmpct",
+            NetworkMessage::CmpctBlock(_) => "cmpctblock",
+            NetworkMessage::GetBlockTxn(_) => "getblocktxn",
+            NetworkMessage::BlockTxn(_) => "blocktxn",
+            NetworkMessage::Alert(_) => "alert",
+            NetworkMessage::Reject(_) => "reject",
+            NetworkMessage::FeeFilter(_) => "feefilter",
+            NetworkMessage::WtxidRelay => "wtxidrelay",
+            NetworkMessage::AddrV2(_) => "addrv2",
+            NetworkMessage::SendAddrV2 => "sendaddrv2",
+            NetworkMessage::Unknown { .. } => "unknown",
+        }
+    }
+
+    /// Return the CommandString for the message command.
+    pub fn command(&self) -> CommandString {
+        match *self {
+            NetworkMessage::Unknown { command: ref c, .. } => c.clone(),
+            _ => CommandString::try_from_static(self.cmd()).expect("cmd returns valid commands"),
+        }
+    }
+}
+
+impl RawNetworkMessage {
+    /// Creates a [RawNetworkMessage]
+    pub fn new(magic: Magic, payload: NetworkMessage) -> Self {
+        let mut engine = sha256d::Hash::engine();
+        let payload_len = payload.consensus_encode(&mut engine).expect("engine doesn't error");
+        let payload_len = u32::try_from(payload_len).expect("network message use u32 as length");
+        let checksum = sha256d::Hash::from_engine(engine);
+        let checksum = [checksum[0], checksum[1], checksum[2], checksum[3]];
+        Self { magic, payload, payload_len, checksum }
+    }
+
+    /// The actual message data
+    pub fn payload(&self) -> &NetworkMessage { &self.payload }
+
+    /// Magic bytes to identify the network these messages are meant for
+    pub fn magic(&self) -> &Magic { &self.magic }
+
+    /// Return the message command as a static string reference.
+    ///
+    /// This returns `"unknown"` for [NetworkMessage::Unknown],
+    /// regardless of the actual command in the unknown message.
+    /// Use the [Self::command] method to get the command for unknown messages.
+    pub fn cmd(&self) -> &'static str { self.payload.cmd() }
+
+    /// Return the CommandString for the message command.
+    pub fn command(&self) -> CommandString { self.payload.command() }
+}
+
+struct HeaderSerializationWrapper<'a>(&'a Vec<block::Header>);
+
+impl<'a> Encodable for HeaderSerializationWrapper<'a> {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = 0;
+        len += VarInt::from(self.0.len()).consensus_encode(w)?;
+        for header in self.0.iter() {
+            len += header.consensus_encode(w)?;
+            len += 0u8.consensus_encode(w)?;
+        }
+        Ok(len)
+    }
+}
+
+impl Encodable for NetworkMessage {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
+        match self {
+            NetworkMessage::Version(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Addr(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Inv(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::GetData(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::NotFound(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::GetBlocks(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::GetHeaders(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Tx(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Block(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Headers(ref dat) =>
+                HeaderSerializationWrapper(dat).consensus_encode(writer),
+            NetworkMessage::Ping(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Pong(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::MerkleBlock(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::FilterLoad(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::FilterAdd(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::GetCFilters(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::CFilter(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::GetCFHeaders(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::CFHeaders(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::GetCFCheckpt(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::CFCheckpt(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::SendCmpct(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::CmpctBlock(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::GetBlockTxn(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::BlockTxn(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Alert(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Reject(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::FeeFilter(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::AddrV2(ref dat) => dat.consensus_encode(writer),
+            NetworkMessage::Verack
+            | NetworkMessage::SendHeaders
+            | NetworkMessage::MemPool
+            | NetworkMessage::GetAddr
+            | NetworkMessage::WtxidRelay
+            | NetworkMessage::FilterClear
+            | NetworkMessage::SendAddrV2 => Ok(0),
+            NetworkMessage::Unknown { payload: ref data, .. } => data.consensus_encode(writer),
+        }
+    }
+}
+
+impl Encodable for RawNetworkMessage {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = 0;
+        len += self.magic.consensus_encode(w)?;
+        len += self.command().consensus_encode(w)?;
+        len += self.payload_len.consensus_encode(w)?;
+        len += self.checksum.consensus_encode(w)?;
+        len += self.payload().consensus_encode(w)?;
+        Ok(len)
+    }
+}
+
+struct HeaderDeserializationWrapper(Vec<block::Header>);
+
+impl Decodable for HeaderDeserializationWrapper {
+    #[inline]
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        let len = VarInt::consensus_decode(r)?.0;
+        // should be above usual number of items to avoid
+        // allocation
+        let mut ret = Vec::with_capacity(core::cmp::min(1024 * 16, len as usize));
+        for _ in 0..len {
+            ret.push(Decodable::consensus_decode(r)?);
+            if u8::consensus_decode(r)? != 0u8 {
+                return Err(encode::Error::ParseFailed(
+                    "Headers message should not contain transactions",
+                ));
+            }
+        }
+        Ok(HeaderDeserializationWrapper(ret))
+    }
+
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Self::consensus_decode_from_finite_reader(r.take(MAX_MSG_SIZE as u64).by_ref())
+    }
+}
+
+impl Decodable for RawNetworkMessage {
+    fn consensus_decode_from_finite_reader<R: io::Read + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        let magic = Decodable::consensus_decode_from_finite_reader(r)?;
+        let cmd = CommandString::consensus_decode_from_finite_reader(r)?;
+        let checked_data = CheckedData::consensus_decode_from_finite_reader(r)?;
+        let checksum = checked_data.checksum();
+        let raw_payload = checked_data.into_data();
+        let payload_len = raw_payload.len() as u32;
+
+        let mut mem_d = io::Cursor::new(raw_payload);
+        let payload = match &cmd.0[..] {
+            "version" =>
+                NetworkMessage::Version(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "verack" => NetworkMessage::Verack,
+            "addr" =>
+                NetworkMessage::Addr(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "inv" =>
+                NetworkMessage::Inv(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "getdata" =>
+                NetworkMessage::GetData(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "notfound" => NetworkMessage::NotFound(Decodable::consensus_decode_from_finite_reader(
+                &mut mem_d,
+            )?),
+            "getblocks" => NetworkMessage::GetBlocks(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "getheaders" => NetworkMessage::GetHeaders(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "mempool" => NetworkMessage::MemPool,
+            "block" =>
+                NetworkMessage::Block(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "headers" => NetworkMessage::Headers(
+                HeaderDeserializationWrapper::consensus_decode_from_finite_reader(&mut mem_d)?.0,
+            ),
+            "sendheaders" => NetworkMessage::SendHeaders,
+            "getaddr" => NetworkMessage::GetAddr,
+            "ping" =>
+                NetworkMessage::Ping(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "pong" =>
+                NetworkMessage::Pong(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "merkleblock" => NetworkMessage::MerkleBlock(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "filterload" => NetworkMessage::FilterLoad(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "filteradd" => NetworkMessage::FilterAdd(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "filterclear" => NetworkMessage::FilterClear,
+            "tx" => NetworkMessage::Tx(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "getcfilters" => NetworkMessage::GetCFilters(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "cfilter" =>
+                NetworkMessage::CFilter(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "getcfheaders" => NetworkMessage::GetCFHeaders(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "cfheaders" => NetworkMessage::CFHeaders(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "getcfcheckpt" => NetworkMessage::GetCFCheckpt(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "cfcheckpt" => NetworkMessage::CFCheckpt(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "reject" =>
+                NetworkMessage::Reject(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "alert" =>
+                NetworkMessage::Alert(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "feefilter" => NetworkMessage::FeeFilter(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "sendcmpct" => NetworkMessage::SendCmpct(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "cmpctblock" => NetworkMessage::CmpctBlock(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "getblocktxn" => NetworkMessage::GetBlockTxn(
+                Decodable::consensus_decode_from_finite_reader(&mut mem_d)?,
+            ),
+            "blocktxn" => NetworkMessage::BlockTxn(Decodable::consensus_decode_from_finite_reader(
+                &mut mem_d,
+            )?),
+            "wtxidrelay" => NetworkMessage::WtxidRelay,
+            "addrv2" =>
+                NetworkMessage::AddrV2(Decodable::consensus_decode_from_finite_reader(&mut mem_d)?),
+            "sendaddrv2" => NetworkMessage::SendAddrV2,
+            _ => NetworkMessage::Unknown { command: cmd, payload: mem_d.into_inner() },
+        };
+        Ok(RawNetworkMessage { magic, payload, payload_len, checksum })
+    }
+
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Self::consensus_decode_from_finite_reader(r.take(MAX_MSG_SIZE as u64).by_ref())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::net::Ipv4Addr;
+
+    use hashes::sha256d::Hash;
+    use hashes::Hash as HashTrait;
+    use hex::test_hex_unwrap as hex;
+
+    use super::message_network::{Reject, RejectReason, VersionMessage};
+    use super::{CommandString, NetworkMessage, RawNetworkMessage, *};
+    use crate::bip152::BlockTransactionsRequest;
+    use crate::block::Header;
+    use crate::blockdata::block::Block;
+    use crate::blockdata::script::ScriptBuf;
+    use crate::blockdata::transaction::Transaction;
+    use crate::consensus::encode::{deserialize, deserialize_partial, serialize};
+    use crate::network::NetworkId;
+    use crate::p2p::address::{AddrV2, AddrV2Message, Address};
+    use crate::p2p::message_blockdata::{GetBlocksMessage, GetHeadersMessage, Inventory};
+    use crate::p2p::message_bloom::{BloomFlags, FilterAdd, FilterLoad};
+    use crate::p2p::message_compact_blocks::{GetBlockTxn, SendCmpct};
+    use crate::p2p::message_filter::{
+        CFCheckpt, CFHeaders, CFilter, GetCFCheckpt, GetCFHeaders, GetCFilters,
+    };
+    use crate::p2p::{Magic, ServiceFlags};
+
+    fn hash(slice: [u8; 32]) -> Hash { Hash::from_slice(&slice).unwrap() }
+
+    #[test]
+    #[ignore]
+    fn full_round_ser_der_raw_network_message_test() {
+        // TODO: Impl Rand traits here to easily generate random values.
+        let version_msg: VersionMessage = deserialize(&hex!("721101000100000000000000e6e0845300000000010000000000000000000000000000000000ffff0000000000000100000000000000fd87d87eeb4364f22cf54dca59412db7208d47d920cffce83ee8102f5361746f7368693a302e392e39392f2c9f040001")).unwrap();
+        let tx: Transaction = deserialize(&hex!("0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000")).unwrap();
+        let block: Block = deserialize(&hex!("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914c364243a74762685f916378ce87c5384ad39b594aca206426d9d244ef51d644d2d74d6e490121032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af000201000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0804ffff001d026e04ffffffff0100f2052a0100000043410446ef0102d1ec5240f0d061a4246c1bdef63fc3dbab7733052fbbf0ecd8f41fc26bf049ebb4f9527f374280259e7cfa99c48b0e3f39c51347a19a5819651503a5ac00000000010000000321f75f3139a013f50f315b23b0c9a2b6eac31e2bec98e5891c924664889942260000000049483045022100cb2c6b346a978ab8c61b18b5e9397755cbd17d6eb2fe0083ef32e067fa6c785a02206ce44e613f31d9a6b0517e46f3db1576e9812cc98d159bfdaf759a5014081b5c01ffffffff79cda0945903627c3da1f85fc95d0b8ee3e76ae0cfdc9a65d09744b1f8fc85430000000049483045022047957cdd957cfd0becd642f6b84d82f49b6cb4c51a91f49246908af7c3cfdf4a022100e96b46621f1bffcf5ea5982f88cef651e9354f5791602369bf5a82a6cd61a62501fffffffffe09f5fe3ffbf5ee97a54eb5e5069e9da6b4856ee86fc52938c2f979b0f38e82000000004847304402204165be9a4cbab8049e1af9723b96199bfd3e85f44c6b4c0177e3962686b26073022028f638da23fc003760861ad481ead4099312c60030d4cb57820ce4d33812a5ce01ffffffff01009d966b01000000434104ea1feff861b51fe3f5f8a3b12d0f4712db80e919548a80839fc47c6a21e66d957e9c5d8cd108c7a2d2324bad71f9904ac0ae7336507d785b17a2c115e427a32fac00000000")).unwrap();
+        let header: Header = deserialize(&hex!("010000004ddccd549d28f385ab457e98d1b11ce80bfea2c5ab93015ade4973e400000000bf4473e53794beae34e64fccc471dace6ae544180816f89591894e0f417a914c364243a74762685f916378ce87c5384ad39b594aca206426d9d244ef51d644d2d74d6e490121032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af00")).unwrap();
+        let script: ScriptBuf =
+            deserialize(&hex!("1976a91431a420903c05a0a7de2de40c9f02ebedbacdc17288ac")).unwrap();
+        let merkle_block: MerkleBlock = deserialize(&hex!("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101")).unwrap();
+        let cmptblock = deserialize(&hex!("00000030d923ad36ff2d955abab07f8a0a6e813bc6e066b973e780c5e36674cad5d1cd1f6e265f2a17a0d35cbe701fe9d06e2c6324cfe135f6233e8b767bfa3fb4479b71115dc562ffff7f2006000000000000000000000000010002000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0302ee00ffffffff0100f9029500000000015100000000")).unwrap();
+        let blocktxn = deserialize(&hex!("2e93c0cff39ff605020072d96bc3a8d20b8447e294d08092351c8583e08d9b5a01020000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0402dc0000ffffffff0200f90295000000001976a9142b4569203694fc997e13f2c0a1383b9e16c77a0d88ac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000")).unwrap();
+
+        let msgs = vec![
+            NetworkMessage::Version(version_msg),
+            NetworkMessage::Verack,
+            NetworkMessage::Addr(vec![(
+                45,
+                Address::new(&([123, 255, 000, 100], 833).into(), ServiceFlags::NETWORK),
+            )]),
+            NetworkMessage::Inv(vec![Inventory::Block(hash([8u8; 32]).into())]),
+            NetworkMessage::GetData(vec![Inventory::Transaction(hash([45u8; 32]).into())]),
+            NetworkMessage::NotFound(vec![Inventory::Error]),
+            NetworkMessage::GetBlocks(GetBlocksMessage::new(
+                vec![hash([1u8; 32]).into(), hash([4u8; 32]).into()],
+                hash([5u8; 32]).into(),
+            )),
+            NetworkMessage::GetHeaders(GetHeadersMessage::new(
+                vec![hash([10u8; 32]).into(), hash([40u8; 32]).into()],
+                hash([50u8; 32]).into(),
+            )),
+            NetworkMessage::MemPool,
+            NetworkMessage::Tx(tx),
+            NetworkMessage::Block(block),
+            NetworkMessage::Headers(vec![header]),
+            NetworkMessage::SendHeaders,
+            NetworkMessage::GetAddr,
+            NetworkMessage::Ping(15),
+            NetworkMessage::Pong(23),
+            NetworkMessage::MerkleBlock(merkle_block),
+            NetworkMessage::FilterLoad(FilterLoad {
+                filter: hex!("03614e9b050000000000000001"),
+                hash_funcs: 1,
+                tweak: 2,
+                flags: BloomFlags::All,
+            }),
+            NetworkMessage::FilterAdd(FilterAdd { data: script.as_bytes().to_vec() }),
+            NetworkMessage::FilterAdd(FilterAdd {
+                data: hash([29u8; 32]).as_byte_array().to_vec(),
+            }),
+            NetworkMessage::FilterClear,
+            NetworkMessage::GetCFilters(GetCFilters {
+                filter_type: 2,
+                start_height: 52,
+                stop_hash: hash([42u8; 32]).into(),
+            }),
+            NetworkMessage::CFilter(CFilter {
+                filter_type: 7,
+                block_hash: hash([25u8; 32]).into(),
+                filter: vec![1, 2, 3],
+            }),
+            NetworkMessage::GetCFHeaders(GetCFHeaders {
+                filter_type: 4,
+                start_height: 102,
+                stop_hash: hash([47u8; 32]).into(),
+            }),
+            NetworkMessage::CFHeaders(CFHeaders {
+                filter_type: 13,
+                stop_hash: hash([53u8; 32]).into(),
+                previous_filter_header: hash([12u8; 32]).into(),
+                filter_hashes: vec![hash([4u8; 32]).into(), hash([12u8; 32]).into()],
+            }),
+            NetworkMessage::GetCFCheckpt(GetCFCheckpt {
+                filter_type: 17,
+                stop_hash: hash([25u8; 32]).into(),
+            }),
+            NetworkMessage::CFCheckpt(CFCheckpt {
+                filter_type: 27,
+                stop_hash: hash([77u8; 32]).into(),
+                filter_headers: vec![hash([3u8; 32]).into(), hash([99u8; 32]).into()],
+            }),
+            NetworkMessage::Alert(vec![45, 66, 3, 2, 6, 8, 9, 12, 3, 130]),
+            NetworkMessage::Reject(Reject {
+                message: "Test reject".into(),
+                ccode: RejectReason::Duplicate,
+                reason: "Cause".into(),
+                hash: hash([255u8; 32]),
+            }),
+            NetworkMessage::FeeFilter(1000),
+            NetworkMessage::WtxidRelay,
+            NetworkMessage::AddrV2(vec![AddrV2Message {
+                addr: AddrV2::Ipv4(Ipv4Addr::new(127, 0, 0, 1)),
+                port: 0,
+                services: ServiceFlags::NONE,
+                time: 0,
+            }]),
+            NetworkMessage::SendAddrV2,
+            NetworkMessage::CmpctBlock(cmptblock),
+            NetworkMessage::GetBlockTxn(GetBlockTxn {
+                txs_request: BlockTransactionsRequest {
+                    block_hash: hash([11u8; 32]).into(),
+                    indexes: vec![0, 1, 2, 3, 10, 3002],
+                },
+            }),
+            NetworkMessage::BlockTxn(blocktxn),
+            NetworkMessage::SendCmpct(SendCmpct { send_compact: true, version: 8333 }),
+        ];
+
+        for msg in msgs {
+            let raw_msg = RawNetworkMessage::new(Magic::from_bytes([57, 0, 0, 0]), msg);
+            assert_eq!(deserialize::<RawNetworkMessage>(&serialize(&raw_msg)).unwrap(), raw_msg);
+        }
+    }
+
+    #[test]
+    fn commandstring_test() {
+        // Test converting.
+        assert_eq!(
+            CommandString::try_from_static("AndrewAndrew").unwrap().as_ref(),
+            "AndrewAndrew"
+        );
+        assert!(CommandString::try_from_static("AndrewAndrewA").is_err());
+
+        // Test serializing.
+        let cs = CommandString("Andrew".into());
+        assert_eq!(serialize(&cs), vec![0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
+
+        // Test deserializing
+        let cs: Result<CommandString, _> =
+            deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0, 0]);
+        assert!(cs.is_ok());
+        assert_eq!(cs.as_ref().unwrap().to_string(), "Andrew".to_owned());
+        assert_eq!(cs.unwrap(), CommandString::try_from_static("Andrew").unwrap());
+
+        let short_cs: Result<CommandString, _> =
+            deserialize(&[0x41u8, 0x6e, 0x64, 0x72, 0x65, 0x77, 0, 0, 0, 0, 0]);
+        assert!(short_cs.is_err());
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_verack_test() {
+        assert_eq!(serialize(&RawNetworkMessage::new(Magic::from(NetworkId::PRODUCTION), NetworkMessage::Verack)),
+                   vec![0x00, 0xf0, 0xff, 0x01, 0x76, 0x65, 0x72, 0x61,
+                        0x63, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_ping_test() {
+        assert_eq!(serialize(&RawNetworkMessage::new(Magic::from(NetworkId::PRODUCTION), NetworkMessage::Ping(100))),
+                   vec![0x00, 0xf0, 0xff, 0x01, 0x70, 0x69, 0x6e, 0x67,
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x08, 0x00, 0x00, 0x00, 0x24, 0x67, 0xf1, 0x1d,
+                        0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_mempool_test() {
+        assert_eq!(serialize(&RawNetworkMessage::new(Magic::from(NetworkId::PRODUCTION), NetworkMessage::MemPool)),
+                   vec![0x00, 0xf0, 0xff, 0x01, 0x6d, 0x65, 0x6d, 0x70,
+                        0x6f, 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn serialize_getaddr_test() {
+        assert_eq!(serialize(&RawNetworkMessage::new(Magic::from(NetworkId::PRODUCTION), NetworkMessage::GetAddr)),
+                   vec![0x00, 0xf0, 0xff, 0x01, 0x67, 0x65, 0x74, 0x61,
+                        0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
+    }
+
+    #[test]
+    fn deserialize_getaddr_test() {
+        #[rustfmt::skip]
+        let msg = deserialize(&[
+            0x00, 0xf0, 0xff, 0x01, 0x67, 0x65, 0x74, 0x61,
+            0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2
+        ]);
+        let preimage =
+            RawNetworkMessage::new(Magic::from(NetworkId::PRODUCTION), NetworkMessage::GetAddr);
+        assert!(msg.is_ok());
+        let msg: RawNetworkMessage = msg.unwrap();
+        assert_eq!(preimage.magic, msg.magic);
+        assert_eq!(preimage.payload, msg.payload);
+    }
+
+    #[test]
+    fn deserialize_version_test() {
+        #[rustfmt::skip]
+        let msg = deserialize::<RawNetworkMessage>(&[
+            0x00, 0xf0, 0xff, 0x01, 0x76, 0x65, 0x72, 0x73,
+            0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
+            0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
+            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
+            0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
+            0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01
+        ]);
+
+        assert!(msg.is_ok());
+        let msg = msg.unwrap();
+        assert_eq!(msg.magic, Magic::from(NetworkId::PRODUCTION));
+        if let NetworkMessage::Version(version_msg) = msg.payload {
+            assert_eq!(version_msg.version, 70015);
+            assert_eq!(
+                version_msg.services,
+                ServiceFlags::NETWORK
+                    | ServiceFlags::BLOOM
+                    | ServiceFlags::WITNESS
+                    | ServiceFlags::NETWORK_LIMITED
+            );
+            assert_eq!(version_msg.timestamp, 1548554224);
+            assert_eq!(version_msg.nonce, 13952548347456104954);
+            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
+            assert_eq!(version_msg.start_height, 560275);
+            assert!(version_msg.relay);
+        } else {
+            panic!("Wrong message type");
+        }
+    }
+
+    #[test]
+    fn deserialize_partial_message_test() {
+        #[rustfmt::skip]
+        let data = [
+            0x00, 0xf0, 0xff, 0x01, 0x76, 0x65, 0x72, 0x73,
+            0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x66, 0x00, 0x00, 0x00, 0xbe, 0x61, 0xb8, 0x27,
+            0x7f, 0x11, 0x01, 0x00, 0x0d, 0x04, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0xf0, 0x0f, 0x4d, 0x5c,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff,
+            0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, 0x0d, 0x04,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1,
+            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68,
+            0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31,
+            0x2f, 0x93, 0x8c, 0x08, 0x00, 0x01, 0x00, 0x00
+        ];
+        let msg = deserialize_partial::<RawNetworkMessage>(&data);
+        assert!(msg.is_ok());
+
+        let (msg, consumed) = msg.unwrap();
+        assert_eq!(consumed, data.to_vec().len() - 2);
+        assert_eq!(msg.magic, Magic::from(NetworkId::PRODUCTION));
+        if let NetworkMessage::Version(version_msg) = msg.payload {
+            assert_eq!(version_msg.version, 70015);
+            assert_eq!(
+                version_msg.services,
+                ServiceFlags::NETWORK
+                    | ServiceFlags::BLOOM
+                    | ServiceFlags::WITNESS
+                    | ServiceFlags::NETWORK_LIMITED
+            );
+            assert_eq!(version_msg.timestamp, 1548554224);
+            assert_eq!(version_msg.nonce, 13952548347456104954);
+            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
+            assert_eq!(version_msg.start_height, 560275);
+            assert!(version_msg.relay);
+        } else {
+            panic!("Wrong message type");
+        }
+    }
+}
diff --git a/tapyrus/src/p2p/message_blockdata.rs b/tapyrus/src/p2p/message_blockdata.rs
new file mode 100644
index 00000000..ead49a8f
--- /dev/null
+++ b/tapyrus/src/p2p/message_blockdata.rs
@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin blockdata network messages.
+//!
+//! This module describes network messages which are used for passing
+//! Bitcoin data (blocks and transactions) around.
+//!
+
+use hashes::{sha256d, Hash as _};
+
+use crate::consensus::encode::{self, Decodable, Encodable};
+use crate::hash_types::{BlockHash, MalFixTxid, Wtxid};
+use crate::internal_macros::impl_consensus_encoding;
+use crate::prelude::*;
+use crate::{io, p2p};
+
+/// An inventory item.
+#[derive(PartialEq, Eq, Clone, Debug, Copy, Hash, PartialOrd, Ord)]
+pub enum Inventory {
+    /// Error --- these inventories can be ignored
+    Error,
+    /// Transaction
+    Transaction(MalFixTxid),
+    /// Block
+    Block(BlockHash),
+    /// Compact Block
+    CompactBlock(BlockHash),
+    /// Witness Transaction by Wtxid
+    WTx(Wtxid),
+    /// Witness Transaction
+    WitnessTransaction(MalFixTxid),
+    /// Witness Block
+    WitnessBlock(BlockHash),
+    /// Unknown inventory type
+    Unknown {
+        /// The inventory item type.
+        inv_type: u32,
+        /// The hash of the inventory item
+        hash: [u8; 32],
+    },
+}
+
+impl Inventory {
+    /// Return the item value represented as a SHA256-d hash.
+    ///
+    /// Returns [None] only for [Inventory::Error].
+    pub fn network_hash(&self) -> Option<[u8; 32]> {
+        match self {
+            Inventory::Error => None,
+            Inventory::Transaction(t) => Some(t.to_byte_array()),
+            Inventory::Block(b) => Some(b.to_byte_array()),
+            Inventory::CompactBlock(b) => Some(b.to_byte_array()),
+            Inventory::WTx(t) => Some(t.to_byte_array()),
+            Inventory::WitnessTransaction(t) => Some(t.to_byte_array()),
+            Inventory::WitnessBlock(b) => Some(b.to_byte_array()),
+            Inventory::Unknown { hash, .. } => Some(*hash),
+        }
+    }
+}
+
+impl Encodable for Inventory {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        macro_rules! encode_inv {
+            ($code:expr, $item:expr) => {
+                u32::consensus_encode(&$code, w)? + $item.consensus_encode(w)?
+            };
+        }
+        Ok(match *self {
+            Inventory::Error => encode_inv!(0, sha256d::Hash::all_zeros()),
+            Inventory::Transaction(ref t) => encode_inv!(1, t),
+            Inventory::Block(ref b) => encode_inv!(2, b),
+            Inventory::CompactBlock(ref b) => encode_inv!(4, b),
+            Inventory::WTx(w) => encode_inv!(5, w),
+            Inventory::WitnessTransaction(ref t) => encode_inv!(0x40000001, t),
+            Inventory::WitnessBlock(ref b) => encode_inv!(0x40000002, b),
+            Inventory::Unknown { inv_type: t, hash: ref d } => encode_inv!(t, d),
+        })
+    }
+}
+
+impl Decodable for Inventory {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let inv_type: u32 = Decodable::consensus_decode(r)?;
+        Ok(match inv_type {
+            0 => Inventory::Error,
+            1 => Inventory::Transaction(Decodable::consensus_decode(r)?),
+            2 => Inventory::Block(Decodable::consensus_decode(r)?),
+            4 => Inventory::CompactBlock(Decodable::consensus_decode(r)?),
+            5 => Inventory::WTx(Decodable::consensus_decode(r)?),
+            0x40000001 => Inventory::WitnessTransaction(Decodable::consensus_decode(r)?),
+            0x40000002 => Inventory::WitnessBlock(Decodable::consensus_decode(r)?),
+            tp => Inventory::Unknown { inv_type: tp, hash: Decodable::consensus_decode(r)? },
+        })
+    }
+}
+
+// Some simple messages
+
+/// The `getblocks` message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct GetBlocksMessage {
+    /// The protocol version
+    pub version: u32,
+    /// Locator hashes --- ordered newest to oldest. The remote peer will
+    /// reply with its longest known chain, starting from a locator hash
+    /// if possible and block 1 otherwise.
+    pub locator_hashes: Vec<BlockHash>,
+    /// References the block to stop at, or zero to just fetch the maximum 500 blocks
+    pub stop_hash: BlockHash,
+}
+
+/// The `getheaders` message
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct GetHeadersMessage {
+    /// The protocol version
+    pub version: u32,
+    /// Locator hashes --- ordered newest to oldest. The remote peer will
+    /// reply with its longest known chain, starting from a locator hash
+    /// if possible and block 1 otherwise.
+    pub locator_hashes: Vec<BlockHash>,
+    /// References the header to stop at, or zero to just fetch the maximum 2000 headers
+    pub stop_hash: BlockHash,
+}
+
+impl GetBlocksMessage {
+    /// Construct a new `getblocks` message
+    pub fn new(locator_hashes: Vec<BlockHash>, stop_hash: BlockHash) -> GetBlocksMessage {
+        GetBlocksMessage { version: p2p::PROTOCOL_VERSION, locator_hashes, stop_hash }
+    }
+}
+
+impl_consensus_encoding!(GetBlocksMessage, version, locator_hashes, stop_hash);
+
+impl GetHeadersMessage {
+    /// Construct a new `getheaders` message
+    pub fn new(locator_hashes: Vec<BlockHash>, stop_hash: BlockHash) -> GetHeadersMessage {
+        GetHeadersMessage { version: p2p::PROTOCOL_VERSION, locator_hashes, stop_hash }
+    }
+}
+
+impl_consensus_encoding!(GetHeadersMessage, version, locator_hashes, stop_hash);
+
+#[cfg(test)]
+mod tests {
+    use hashes::Hash;
+    use hex::test_hex_unwrap as hex;
+
+    use super::{GetBlocksMessage, GetHeadersMessage, Vec};
+    use crate::consensus::encode::{deserialize, serialize};
+
+    #[test]
+    fn getblocks_message_test() {
+        let from_tap = hex!("72110100014a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b0000000000000000000000000000000000000000000000000000000000000000");
+        let genhash = hex!("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b");
+
+        let decode: Result<GetBlocksMessage, _> = deserialize(&from_tap);
+        assert!(decode.is_ok());
+        let real_decode = decode.unwrap();
+        assert_eq!(real_decode.version, 70002);
+        assert_eq!(real_decode.locator_hashes.len(), 1);
+        assert_eq!(serialize(&real_decode.locator_hashes[0]), genhash);
+        assert_eq!(real_decode.stop_hash, Hash::all_zeros());
+
+        assert_eq!(serialize(&real_decode), from_tap);
+    }
+
+    #[test]
+    fn getheaders_message_test() {
+        let from_tap = hex!("72110100014a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b0000000000000000000000000000000000000000000000000000000000000000");
+        let genhash = hex!("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b");
+
+        let decode: Result<GetHeadersMessage, _> = deserialize(&from_tap);
+        assert!(decode.is_ok());
+        let real_decode = decode.unwrap();
+        assert_eq!(real_decode.version, 70002);
+        assert_eq!(real_decode.locator_hashes.len(), 1);
+        assert_eq!(serialize(&real_decode.locator_hashes[0]), genhash);
+        assert_eq!(real_decode.stop_hash, Hash::all_zeros());
+
+        assert_eq!(serialize(&real_decode), from_tap);
+    }
+}
diff --git a/tapyrus/src/p2p/message_bloom.rs b/tapyrus/src/p2p/message_bloom.rs
new file mode 100644
index 00000000..e3dcbe18
--- /dev/null
+++ b/tapyrus/src/p2p/message_bloom.rs
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin Connection Bloom filtering network messages.
+//!
+//! This module describes BIP37 Connection Bloom filtering network messages.
+//!
+
+use std::io;
+
+use crate::consensus::{encode, Decodable, Encodable, ReadExt};
+use crate::internal_macros::impl_consensus_encoding;
+
+/// `filterload` message sets the current bloom filter
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FilterLoad {
+    /// The filter itself
+    pub filter: Vec<u8>,
+    /// The number of hash functions to use
+    pub hash_funcs: u32,
+    /// A random value
+    pub tweak: u32,
+    /// Controls how matched items are added to the filter
+    pub flags: BloomFlags,
+}
+
+impl_consensus_encoding!(FilterLoad, filter, hash_funcs, tweak, flags);
+
+/// Bloom filter update flags
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum BloomFlags {
+    /// Never update the filter with outpoints.
+    None,
+    /// Always update the filter with outpoints.
+    All,
+    /// Only update the filter with outpoints if it is P2PK or P2MS
+    PubkeyOnly,
+}
+
+impl Encodable for BloomFlags {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        w.write_all(&[match self {
+            BloomFlags::None => 0,
+            BloomFlags::All => 1,
+            BloomFlags::PubkeyOnly => 2,
+        }])?;
+        Ok(1)
+    }
+}
+
+impl Decodable for BloomFlags {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(match r.read_u8()? {
+            0 => BloomFlags::None,
+            1 => BloomFlags::All,
+            2 => BloomFlags::PubkeyOnly,
+            _ => return Err(encode::Error::ParseFailed("unknown bloom flag")),
+        })
+    }
+}
+
+/// `filteradd` message updates the current filter with new data
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FilterAdd {
+    /// The data element to add to the current filter.
+    pub data: Vec<u8>,
+}
+
+impl_consensus_encoding!(FilterAdd, data);
diff --git a/tapyrus/src/p2p/message_compact_blocks.rs b/tapyrus/src/p2p/message_compact_blocks.rs
new file mode 100644
index 00000000..66246052
--- /dev/null
+++ b/tapyrus/src/p2p/message_compact_blocks.rs
@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//!
+//! BIP152  Compact Blocks network messages
+//!
+
+use crate::bip152;
+use crate::internal_macros::impl_consensus_encoding;
+
+/// sendcmpct message
+#[derive(PartialEq, Eq, Clone, Debug, Copy, PartialOrd, Ord, Hash)]
+pub struct SendCmpct {
+    /// Request to be send compact blocks.
+    pub send_compact: bool,
+    /// Compact Blocks protocol version number.
+    pub version: u64,
+}
+impl_consensus_encoding!(SendCmpct, send_compact, version);
+
+/// cmpctblock message
+///
+/// Note that the rules for validation before relaying compact blocks is
+/// different from headers and regular block messages. Thus, you shouldn't use
+/// compact blocks when relying on an upstream full node to have validated data
+/// being forwarded to you.
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct CmpctBlock {
+    /// The Compact Block.
+    pub compact_block: bip152::HeaderAndShortIds,
+}
+impl_consensus_encoding!(CmpctBlock, compact_block);
+
+/// getblocktxn message
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct GetBlockTxn {
+    /// The block transactions request.
+    pub txs_request: bip152::BlockTransactionsRequest,
+}
+impl_consensus_encoding!(GetBlockTxn, txs_request);
+
+/// blocktxn message
+#[derive(PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
+pub struct BlockTxn {
+    /// The requested block transactions.
+    pub transactions: bip152::BlockTransactions,
+}
+impl_consensus_encoding!(BlockTxn, transactions);
diff --git a/src/network/message_filter.rs b/tapyrus/src/p2p/message_filter.rs
similarity index 85%
rename from src/network/message_filter.rs
rename to tapyrus/src/p2p/message_filter.rs
index 17d3318c..e2231bca 100644
--- a/src/network/message_filter.rs
+++ b/tapyrus/src/p2p/message_filter.rs
@@ -1,11 +1,15 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin Client Side Block Filtering network messages.
 //!
-//! BIP157  Client Side Block Filtering network messages
+//! This module describes BIP157 Client Side Block Filtering network messages.
 //!
 
-use hash_types::{BlockHash, FilterHash};
+use crate::hash_types::{BlockHash, FilterHash, FilterHeader};
+use crate::internal_macros::impl_consensus_encoding;
 
-#[derive(PartialEq, Eq, Clone, Debug)]
 /// getcfilters message
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct GetCFilters {
     /// Filter type for which headers are requested
     pub filter_type: u8,
@@ -16,8 +20,8 @@ pub struct GetCFilters {
 }
 impl_consensus_encoding!(GetCFilters, filter_type, start_height, stop_hash);
 
-#[derive(PartialEq, Eq, Clone, Debug)]
 /// cfilter message
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct CFilter {
     /// Byte identifying the type of filter being returned
     pub filter_type: u8,
@@ -28,8 +32,8 @@ pub struct CFilter {
 }
 impl_consensus_encoding!(CFilter, filter_type, block_hash, filter);
 
-#[derive(PartialEq, Eq, Clone, Debug)]
 /// getcfheaders message
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct GetCFHeaders {
     /// Byte identifying the type of filter being returned
     pub filter_type: u8,
@@ -40,22 +44,22 @@ pub struct GetCFHeaders {
 }
 impl_consensus_encoding!(GetCFHeaders, filter_type, start_height, stop_hash);
 
-#[derive(PartialEq, Eq, Clone, Debug)]
 /// cfheaders message
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct CFHeaders {
     /// Filter type for which headers are requested
     pub filter_type: u8,
     /// The hash of the last block in the requested range
     pub stop_hash: BlockHash,
     /// The filter header preceding the first block in the requested range
-    pub previous_filter: FilterHash,
+    pub previous_filter_header: FilterHeader,
     /// The filter hashes for each block in the requested range
     pub filter_hashes: Vec<FilterHash>,
 }
-impl_consensus_encoding!(CFHeaders, filter_type, stop_hash, previous_filter, filter_hashes);
+impl_consensus_encoding!(CFHeaders, filter_type, stop_hash, previous_filter_header, filter_hashes);
 
-#[derive(PartialEq, Eq, Clone, Debug)]
 /// getcfcheckpt message
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct GetCFCheckpt {
     /// Filter type for which headers are requested
     pub filter_type: u8,
@@ -64,14 +68,14 @@ pub struct GetCFCheckpt {
 }
 impl_consensus_encoding!(GetCFCheckpt, filter_type, stop_hash);
 
-#[derive(PartialEq, Eq, Clone, Debug)]
 /// cfcheckpt message
+#[derive(PartialEq, Eq, Clone, Debug)]
 pub struct CFCheckpt {
     /// Filter type for which headers are requested
     pub filter_type: u8,
     /// The hash of the last block in the requested range
     pub stop_hash: BlockHash,
     /// The filter headers at intervals of 1,000
-    pub filter_headers: Vec<FilterHash>,
+    pub filter_headers: Vec<FilterHeader>,
 }
 impl_consensus_encoding!(CFCheckpt, filter_type, stop_hash, filter_headers);
diff --git a/src/network/message_network.rs b/tapyrus/src/p2p/message_network.rs
similarity index 52%
rename from src/network/message_network.rs
rename to tapyrus/src/p2p/message_network.rs
index de158e54..75f6e6b0 100644
--- a/src/network/message_network.rs
+++ b/tapyrus/src/p2p/message_network.rs
@@ -1,33 +1,20 @@
-// Rust Bitcoin Library
-// Written in 2014 by
-//     Andrew Poelstra <apoelstra@wpsoftware.net>
-//
-// 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/>.
-//
-
-//! Network-related network messages
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin network-related network messages.
 //!
 //! This module defines network messages which describe peers and their
-//! capabilities
+//! capabilities.
 //!
 
-use std::io;
-use std::borrow::Cow;
-
-use network::address::Address;
-use network::constants::{self, ServiceFlags};
-use consensus::{Encodable, Decodable, ReadExt};
-use consensus::encode;
-use network::message::CommandString;
 use hashes::sha256d;
 
+use crate::consensus::{encode, Decodable, Encodable, ReadExt};
+use crate::internal_macros::impl_consensus_encoding;
+use crate::p2p::address::Address;
+use crate::p2p::ServiceFlags;
+use crate::prelude::*;
+use crate::{io, p2p};
+
 /// Some simple messages
 
 /// The `version` message
@@ -52,7 +39,7 @@ pub struct VersionMessage {
     /// Whether the receiving peer should relay messages to the sender; used
     /// if the sender is bandwidth-limited and would like to support bloom
     /// filtering. Defaults to false.
-    pub relay: bool
+    pub relay: bool,
 }
 
 impl VersionMessage {
@@ -67,25 +54,34 @@ impl VersionMessage {
         start_height: i32,
     ) -> VersionMessage {
         VersionMessage {
-            version: constants::PROTOCOL_VERSION,
-            services: services,
-            timestamp: timestamp,
-            receiver: receiver,
-            sender: sender,
-            nonce: nonce,
-            user_agent: user_agent,
-            start_height: start_height,
+            version: p2p::PROTOCOL_VERSION,
+            services,
+            timestamp,
+            receiver,
+            sender,
+            nonce,
+            user_agent,
+            start_height,
             relay: false,
         }
     }
 }
 
-impl_consensus_encoding!(VersionMessage, version, services, timestamp,
-                         receiver, sender, nonce,
-                         user_agent, start_height, relay);
+impl_consensus_encoding!(
+    VersionMessage,
+    version,
+    services,
+    timestamp,
+    receiver,
+    sender,
+    nonce,
+    user_agent,
+    start_height,
+    relay
+);
 
-#[derive(PartialEq, Eq, Clone, Copy, Debug)]
 /// message rejection reason as a code
+#[derive(PartialEq, Eq, Clone, Copy, Debug)]
 pub enum RejectReason {
     /// malformed message
     Malformed = 0x01,
@@ -102,19 +98,19 @@ pub enum RejectReason {
     /// insufficient fee
     Fee = 0x42,
     /// checkpoint
-    Checkpoint = 0x43
+    Checkpoint = 0x43,
 }
 
 impl Encodable for RejectReason {
-    fn consensus_encode<W: io::Write>(&self, mut e: W) -> Result<usize, encode::Error> {
-        e.write_all(&[*self as u8])?;
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        w.write_all(&[*self as u8])?;
         Ok(1)
     }
 }
 
 impl Decodable for RejectReason {
-    fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
-        Ok(match d.read_u8()? {
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(match r.read_u8()? {
             0x01 => RejectReason::Malformed,
             0x10 => RejectReason::Invalid,
             0x11 => RejectReason::Obsolete,
@@ -123,7 +119,7 @@ impl Decodable for RejectReason {
             0x41 => RejectReason::Dust,
             0x42 => RejectReason::Fee,
             0x43 => RejectReason::Checkpoint,
-            _ => return Err(encode::Error::ParseFailed("unknown reject code"))
+            _ => return Err(encode::Error::ParseFailed("unknown reject code")),
         })
     }
 }
@@ -132,32 +128,32 @@ impl Decodable for RejectReason {
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct Reject {
     /// message type rejected
-    pub message: CommandString,
+    pub message: Cow<'static, str>,
     /// reason of rejection as code
     pub ccode: RejectReason,
     /// reason of rejectection
     pub reason: Cow<'static, str>,
     /// reference to rejected item
-    pub hash: sha256d::Hash
+    pub hash: sha256d::Hash,
 }
 
 impl_consensus_encoding!(Reject, message, ccode, reason, hash);
 
 #[cfg(test)]
 mod tests {
-    use super::VersionMessage;
+    use hashes::sha256d;
+    use hex::test_hex_unwrap as hex;
 
-    use hex::decode as hex_decode;
-    use network::constants::ServiceFlags;
-
-    use consensus::encode::{deserialize, serialize};
+    use super::{Reject, RejectReason, VersionMessage};
+    use crate::consensus::encode::{deserialize, serialize};
+    use crate::p2p::ServiceFlags;
 
     #[test]
     fn version_message_test() {
         // This message is from my satoshi node, morning of May 27 2014
-        let from_sat = hex_decode("721101000100000000000000e6e0845300000000010000000000000000000000000000000000ffff0000000000000100000000000000fd87d87eeb4364f22cf54dca59412db7208d47d920cffce83ee8102f5361746f7368693a302e392e39392f2c9f040001").unwrap();
+        let from_tap = hex!("721101000100000000000000e6e0845300000000010000000000000000000000000000000000ffff0000000000000100000000000000fd87d87eeb4364f22cf54dca59412db7208d47d920cffce83ee8102f5361746f7368693a302e392e39392f2c9f040001");
 
-        let decode: Result<VersionMessage, _> = deserialize(&from_sat);
+        let decode: Result<VersionMessage, _> = deserialize(&from_tap);
         assert!(decode.is_ok());
         let real_decode = decode.unwrap();
         assert_eq!(real_decode.version, 70002);
@@ -167,8 +163,45 @@ mod tests {
         assert_eq!(real_decode.nonce, 16735069437859780935);
         assert_eq!(real_decode.user_agent, "/Satoshi:0.9.99/".to_string());
         assert_eq!(real_decode.start_height, 302892);
-        assert_eq!(real_decode.relay, true);
+        assert!(real_decode.relay);
+
+        assert_eq!(serialize(&real_decode), from_tap);
+    }
 
-        assert_eq!(serialize(&real_decode), from_sat);
+    #[test]
+    fn reject_message_test() {
+        let reject_tx_conflict = hex!("027478121474786e2d6d656d706f6f6c2d636f6e666c69637405df54d3860b3c41806a3546ab48279300affacf4b88591b229141dcf2f47004");
+        let reject_tx_nonfinal = hex!("02747840096e6f6e2d66696e616c259bbe6c83db8bbdfca7ca303b19413dc245d9f2371b344ede5f8b1339a5460b");
+
+        let decode_result_conflict: Result<Reject, _> = deserialize(&reject_tx_conflict);
+        let decode_result_nonfinal: Result<Reject, _> = deserialize(&reject_tx_nonfinal);
+
+        assert!(decode_result_conflict.is_ok());
+        assert!(decode_result_nonfinal.is_ok());
+
+        let conflict = decode_result_conflict.unwrap();
+        assert_eq!("tx", conflict.message);
+        assert_eq!(RejectReason::Duplicate, conflict.ccode);
+        assert_eq!("txn-mempool-conflict", conflict.reason);
+        assert_eq!(
+            "0470f4f2dc4191221b59884bcffaaf00932748ab46356a80413c0b86d354df05"
+                .parse::<sha256d::Hash>()
+                .unwrap(),
+            conflict.hash
+        );
+
+        let nonfinal = decode_result_nonfinal.unwrap();
+        assert_eq!("tx", nonfinal.message);
+        assert_eq!(RejectReason::NonStandard, nonfinal.ccode);
+        assert_eq!("non-final", nonfinal.reason);
+        assert_eq!(
+            "0b46a539138b5fde4e341b37f2d945c23d41193b30caa7fcbd8bdb836cbe9b25"
+                .parse::<sha256d::Hash>()
+                .unwrap(),
+            nonfinal.hash
+        );
+
+        assert_eq!(serialize(&conflict), reject_tx_conflict);
+        assert_eq!(serialize(&nonfinal), reject_tx_nonfinal);
     }
 }
diff --git a/tapyrus/src/p2p/mod.rs b/tapyrus/src/p2p/mod.rs
new file mode 100644
index 00000000..ccb83750
--- /dev/null
+++ b/tapyrus/src/p2p/mod.rs
@@ -0,0 +1,406 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin p2p network types.
+//!
+//! This module defines support for (de)serialization and network transport
+//! of Bitcoin data and Bitcoin p2p network messages.
+
+#[cfg(feature = "std")]
+pub mod address;
+#[cfg(feature = "std")]
+pub use self::address::Address;
+#[cfg(feature = "std")]
+pub mod message;
+#[cfg(feature = "std")]
+pub mod message_blockdata;
+#[cfg(feature = "std")]
+pub mod message_bloom;
+#[cfg(feature = "std")]
+pub mod message_compact_blocks;
+#[cfg(feature = "std")]
+pub mod message_filter;
+#[cfg(feature = "std")]
+pub mod message_network;
+
+use core::convert::TryFrom;
+use core::str::FromStr;
+use core::{fmt, ops};
+
+use hex::FromHex;
+use internals::{debug_from_display, write_err};
+
+use crate::consensus::encode::{self, Decodable, Encodable};
+use crate::io;
+use crate::network::NetworkId;
+use crate::prelude::{Borrow, BorrowMut, String, ToOwned};
+
+/// Version of the protocol as appearing in network message headers.
+///
+/// This constant is used to signal to other peers which features you support. Increasing it implies
+/// that your software also supports every feature prior to this version. Doing so without support
+/// may lead to you incorrectly banning other peers or other peers banning you.
+///
+/// These are the features required for each version:
+/// 70016 - Support receiving `wtxidrelay` message between `version` and `verack` message
+/// 70015 - Support receiving invalid compact blocks from a peer without banning them
+/// 70014 - Support compact block messages `sendcmpct`, `cmpctblock`, `getblocktxn` and `blocktxn`
+/// 70013 - Support `feefilter` message
+/// 70012 - Support `sendheaders` message and announce new blocks via headers rather than inv
+/// 70011 - Support NODE_BLOOM service flag and don't support bloom filter messages if it is not set
+/// 70002 - Support `reject` message
+/// 70001 - Support bloom filter messages `filterload`, `filterclear` `filteradd`, `merkleblock` and FILTERED_BLOCK inventory type
+/// 60002 - Support `mempool` message
+/// 60001 - Support `pong` message and nonce in `ping` message
+pub const PROTOCOL_VERSION: u32 = 10000;
+
+/// Flags to indicate which network services a node supports.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ServiceFlags(u64);
+
+impl ServiceFlags {
+    /// NONE means no services supported.
+    pub const NONE: ServiceFlags = ServiceFlags(0);
+
+    /// NETWORK means that the node is capable of serving the complete block chain. It is currently
+    /// set by all Bitcoin Core non pruned nodes, and is unset by SPV clients or other light
+    /// clients.
+    pub const NETWORK: ServiceFlags = ServiceFlags(1 << 0);
+
+    /// GETUTXO means the node is capable of responding to the getutxo protocol request.  Bitcoin
+    /// Core does not support this but a patch set called Bitcoin XT does.
+    /// See BIP 64 for details on how this is implemented.
+    pub const GETUTXO: ServiceFlags = ServiceFlags(1 << 1);
+
+    /// BLOOM means the node is capable and willing to handle bloom-filtered connections.  Bitcoin
+    /// Core nodes used to support this by default, without advertising this bit, but no longer do
+    /// as of protocol version 70011 (= NO_BLOOM_VERSION)
+    pub const BLOOM: ServiceFlags = ServiceFlags(1 << 2);
+
+    /// WITNESS indicates that a node can be asked for blocks and transactions including witness
+    /// data.
+    pub const WITNESS: ServiceFlags = ServiceFlags(1 << 3);
+
+    /// COMPACT_FILTERS means the node will service basic block filter requests.
+    /// See BIP157 and BIP158 for details on how this is implemented.
+    pub const COMPACT_FILTERS: ServiceFlags = ServiceFlags(1 << 6);
+
+    /// NETWORK_LIMITED means the same as NODE_NETWORK with the limitation of only serving the last
+    /// 288 (2 day) blocks.
+    /// See BIP159 for details on how this is implemented.
+    pub const NETWORK_LIMITED: ServiceFlags = ServiceFlags(1 << 10);
+
+    // NOTE: When adding new flags, remember to update the Display impl accordingly.
+
+    /// Add [ServiceFlags] together.
+    ///
+    /// Returns itself.
+    pub fn add(&mut self, other: ServiceFlags) -> ServiceFlags {
+        self.0 |= other.0;
+        *self
+    }
+
+    /// Remove [ServiceFlags] from this.
+    ///
+    /// Returns itself.
+    pub fn remove(&mut self, other: ServiceFlags) -> ServiceFlags {
+        self.0 ^= other.0;
+        *self
+    }
+
+    /// Check whether [ServiceFlags] are included in this one.
+    pub fn has(self, flags: ServiceFlags) -> bool { (self.0 | flags.0) == self.0 }
+
+    /// Gets the integer representation of this [`ServiceFlags`].
+    pub fn to_u64(self) -> u64 { self.0 }
+}
+
+impl fmt::LowerHex for ServiceFlags {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
+}
+
+impl fmt::UpperHex for ServiceFlags {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::UpperHex::fmt(&self.0, f) }
+}
+
+impl fmt::Display for ServiceFlags {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut flags = *self;
+        if flags == ServiceFlags::NONE {
+            return write!(f, "ServiceFlags(NONE)");
+        }
+        let mut first = true;
+        macro_rules! write_flag {
+            ($f:ident) => {
+                if flags.has(ServiceFlags::$f) {
+                    if !first {
+                        write!(f, "|")?;
+                    }
+                    first = false;
+                    write!(f, stringify!($f))?;
+                    flags.remove(ServiceFlags::$f);
+                }
+            };
+        }
+        write!(f, "ServiceFlags(")?;
+        write_flag!(NETWORK);
+        write_flag!(GETUTXO);
+        write_flag!(BLOOM);
+        write_flag!(WITNESS);
+        write_flag!(COMPACT_FILTERS);
+        write_flag!(NETWORK_LIMITED);
+        // If there are unknown flags left, we append them in hex.
+        if flags != ServiceFlags::NONE {
+            if !first {
+                write!(f, "|")?;
+            }
+            write!(f, "0x{:x}", flags)?;
+        }
+        write!(f, ")")
+    }
+}
+
+impl From<u64> for ServiceFlags {
+    fn from(f: u64) -> Self { ServiceFlags(f) }
+}
+
+impl From<ServiceFlags> for u64 {
+    fn from(flags: ServiceFlags) -> Self { flags.0 }
+}
+
+impl ops::BitOr for ServiceFlags {
+    type Output = Self;
+
+    fn bitor(mut self, rhs: Self) -> Self { self.add(rhs) }
+}
+
+impl ops::BitOrAssign for ServiceFlags {
+    fn bitor_assign(&mut self, rhs: Self) { self.add(rhs); }
+}
+
+impl ops::BitXor for ServiceFlags {
+    type Output = Self;
+
+    fn bitxor(mut self, rhs: Self) -> Self { self.remove(rhs) }
+}
+
+impl ops::BitXorAssign for ServiceFlags {
+    fn bitxor_assign(&mut self, rhs: Self) { self.remove(rhs); }
+}
+
+impl Encodable for ServiceFlags {
+    #[inline]
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(w)
+    }
+}
+
+impl Decodable for ServiceFlags {
+    #[inline]
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Ok(ServiceFlags(Decodable::consensus_decode(r)?))
+    }
+}
+/// Network magic bytes to identify the cryptocurrency network the message was intended for.
+#[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Clone, Hash)]
+pub struct Magic([u8; 4]);
+
+impl Magic {
+    /// Tapyrus prod network magic bytes.
+    pub const PROD: Self = Self([0xF9, 0xBE, 0xB4, 0xD9]);
+    /// Tapyrus dev network magic bytes.
+    pub const DEV: Self = Self([0x0B, 0x11, 0x09, 0x07]);
+
+    /// Create network magic from bytes.
+    pub fn from_bytes(bytes: [u8; 4]) -> Magic { Magic(bytes) }
+
+    /// Get network magic bytes.
+    pub fn to_bytes(self) -> [u8; 4] { self.0 }
+}
+
+impl FromStr for Magic {
+    type Err = ParseMagicError;
+
+    fn from_str(s: &str) -> Result<Magic, Self::Err> {
+        match <[u8; 4]>::from_hex(s) {
+            Ok(magic) => Ok(Magic::from_bytes(magic)),
+            Err(e) => Err(ParseMagicError { error: e, magic: s.to_owned() }),
+        }
+    }
+}
+
+impl From<NetworkId> for Magic {
+    fn from(network_id: NetworkId) -> Magic { Magic::from_bytes(network_id.magic().to_be_bytes()) }
+}
+
+impl TryFrom<Magic> for NetworkId {
+    type Error = UnknownMagicError;
+
+    fn try_from(magic: Magic) -> Result<Self, Self::Error> {
+        let n = u32::from_be_bytes(magic.to_bytes()) - 33550335;
+        Ok(NetworkId::from(n))
+    }
+}
+
+impl fmt::Display for Magic {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        hex::fmt_hex_exact!(f, 4, &self.0, hex::Case::Lower)?;
+        Ok(())
+    }
+}
+debug_from_display!(Magic);
+
+impl fmt::LowerHex for Magic {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        hex::fmt_hex_exact!(f, 4, &self.0, hex::Case::Lower)?;
+        Ok(())
+    }
+}
+
+impl fmt::UpperHex for Magic {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        hex::fmt_hex_exact!(f, 4, &self.0, hex::Case::Upper)?;
+        Ok(())
+    }
+}
+
+impl Encodable for Magic {
+    fn consensus_encode<W: io::Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
+        self.0.consensus_encode(writer)
+    }
+}
+
+impl Decodable for Magic {
+    fn consensus_decode<R: io::Read + ?Sized>(reader: &mut R) -> Result<Self, encode::Error> {
+        Ok(Magic(Decodable::consensus_decode(reader)?))
+    }
+}
+
+impl AsRef<[u8]> for Magic {
+    fn as_ref(&self) -> &[u8] { &self.0 }
+}
+
+impl AsRef<[u8; 4]> for Magic {
+    fn as_ref(&self) -> &[u8; 4] { &self.0 }
+}
+
+impl AsMut<[u8]> for Magic {
+    fn as_mut(&mut self) -> &mut [u8] { &mut self.0 }
+}
+
+impl AsMut<[u8; 4]> for Magic {
+    fn as_mut(&mut self) -> &mut [u8; 4] { &mut self.0 }
+}
+
+impl Borrow<[u8]> for Magic {
+    fn borrow(&self) -> &[u8] { &self.0 }
+}
+
+impl Borrow<[u8; 4]> for Magic {
+    fn borrow(&self) -> &[u8; 4] { &self.0 }
+}
+
+impl BorrowMut<[u8]> for Magic {
+    fn borrow_mut(&mut self) -> &mut [u8] { &mut self.0 }
+}
+
+impl BorrowMut<[u8; 4]> for Magic {
+    fn borrow_mut(&mut self) -> &mut [u8; 4] { &mut self.0 }
+}
+
+/// An error in parsing magic bytes.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ParseMagicError {
+    /// The error that occurred when parsing the string.
+    error: hex::HexToArrayError,
+    /// The byte string that failed to parse.
+    magic: String,
+}
+
+impl fmt::Display for ParseMagicError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write_err!(f, "failed to parse {} as network magic", self.magic; self.error)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseMagicError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.error) }
+}
+
+/// Error in creating a Network from Magic bytes.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct UnknownMagicError(Magic);
+
+impl fmt::Display for UnknownMagicError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        write!(f, "unknown network magic {}", self.0)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnknownMagicError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn service_flags_test() {
+        let all = [
+            ServiceFlags::NETWORK,
+            ServiceFlags::GETUTXO,
+            ServiceFlags::BLOOM,
+            ServiceFlags::WITNESS,
+            ServiceFlags::COMPACT_FILTERS,
+            ServiceFlags::NETWORK_LIMITED,
+        ];
+
+        let mut flags = ServiceFlags::NONE;
+        for f in all.iter() {
+            assert!(!flags.has(*f));
+        }
+
+        flags |= ServiceFlags::WITNESS;
+        assert_eq!(flags, ServiceFlags::WITNESS);
+
+        let mut flags2 = flags | ServiceFlags::GETUTXO;
+        for f in all.iter() {
+            assert_eq!(flags2.has(*f), *f == ServiceFlags::WITNESS || *f == ServiceFlags::GETUTXO);
+        }
+
+        flags2 ^= ServiceFlags::WITNESS;
+        assert_eq!(flags2, ServiceFlags::GETUTXO);
+
+        flags2 |= ServiceFlags::COMPACT_FILTERS;
+        flags2 ^= ServiceFlags::GETUTXO;
+        assert_eq!(flags2, ServiceFlags::COMPACT_FILTERS);
+
+        // Test formatting.
+        assert_eq!("ServiceFlags(NONE)", ServiceFlags::NONE.to_string());
+        assert_eq!("ServiceFlags(WITNESS)", ServiceFlags::WITNESS.to_string());
+        let flag = ServiceFlags::WITNESS | ServiceFlags::BLOOM | ServiceFlags::NETWORK;
+        assert_eq!("ServiceFlags(NETWORK|BLOOM|WITNESS)", flag.to_string());
+        let flag = ServiceFlags::WITNESS | 0xf0.into();
+        assert_eq!("ServiceFlags(WITNESS|COMPACT_FILTERS|0xb0)", flag.to_string());
+    }
+
+    #[test]
+    fn magic_from_str() {
+        let known_network_magic_strs = [
+            ("01fff000", NetworkId::PRODUCTION),
+            ("01fff064", NetworkId::PARADIUM),
+            ("759a8374", NetworkId::TESTNET),
+            ("739a9774", NetworkId::REGTEST),
+        ];
+
+        for (magic_str, network_id) in &known_network_magic_strs {
+            let magic: Magic = Magic::from_str(magic_str).unwrap();
+            assert_eq!(NetworkId::try_from(magic).unwrap(), *network_id);
+            assert_eq!(&magic.to_string(), magic_str);
+        }
+    }
+}
diff --git a/tapyrus/src/parse.rs b/tapyrus/src/parse.rs
new file mode 100644
index 00000000..aebc5f8d
--- /dev/null
+++ b/tapyrus/src/parse.rs
@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::convert::TryFrom;
+use core::fmt;
+use core::str::FromStr;
+
+use internals::write_err;
+
+use crate::prelude::*;
+
+/// Error with rich context returned when a string can't be parsed as an integer.
+///
+/// This is an extension of [`core::num::ParseIntError`], which carries the input that failed to
+/// parse as well as type information. As a result it provides very informative error messages that
+/// make it easier to understand the problem and correct mistakes.
+///
+/// Note that this is larger than the type from `core` so if it's passed through a deep call stack
+/// in a performance-critical application you may want to box it or throw away the context by
+/// converting to `core` type.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct ParseIntError {
+    input: String,
+    // for displaying - see Display impl with nice error message below
+    bits: u8,
+    // We could represent this as a single bit but it wouldn't actually derease the cost of moving
+    // the struct because String contains pointers so there will be padding of bits at least
+    // pointer_size - 1 bytes: min 1B in practice.
+    is_signed: bool,
+    source: core::num::ParseIntError,
+}
+
+impl ParseIntError {
+    /// Returns the input that was attempted to be parsed.
+    pub fn input(&self) -> &str { &self.input }
+}
+
+impl fmt::Display for ParseIntError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let signed = if self.is_signed { "signed" } else { "unsigned" };
+        let n = if self.bits == 8 { "n" } else { "" };
+        write_err!(f, "failed to parse '{}' as a{} {}-bit {} integer", self.input, n, self.bits, signed; self.source)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseIntError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.source) }
+}
+
+impl From<ParseIntError> for core::num::ParseIntError {
+    fn from(value: ParseIntError) -> Self { value.source }
+}
+
+impl AsRef<core::num::ParseIntError> for ParseIntError {
+    fn as_ref(&self) -> &core::num::ParseIntError { &self.source }
+}
+
+/// Not strictly neccessary but serves as a lint - avoids weird behavior if someone accidentally
+/// passes non-integer to the `parse()` function.
+pub(crate) trait Integer:
+    FromStr<Err = core::num::ParseIntError> + TryFrom<i8> + Sized
+{
+}
+
+macro_rules! impl_integer {
+    ($($type:ty),* $(,)?) => {
+        $(
+        impl Integer for $type {}
+        )*
+    }
+}
+
+impl_integer!(u8, i8, u16, i16, u32, i32, u64, i64, u128, i128);
+
+/// Parses the input string as an integer returning an error carrying rich context.
+///
+/// If the caller owns `String` or `Box<str>` which is not used later it's better to pass it as
+/// owned since it avoids allocation in error case.
+pub(crate) fn int<T: Integer, S: AsRef<str> + Into<String>>(s: S) -> Result<T, ParseIntError> {
+    s.as_ref().parse().map_err(|error| {
+        ParseIntError {
+            input: s.into(),
+            bits: u8::try_from(core::mem::size_of::<T>() * 8).expect("max is 128 bits for u128"),
+            // We detect if the type is signed by checking if -1 can be represented by it
+            // this way we don't have to implement special traits and optimizer will get rid of the
+            // computation.
+            is_signed: T::try_from(-1i8).is_ok(),
+            source: error,
+        }
+    })
+}
+
+pub(crate) fn hex_u32<S: AsRef<str> + Into<String>>(s: S) -> Result<u32, ParseIntError> {
+    u32::from_str_radix(s.as_ref(), 16).map_err(|error| ParseIntError {
+        input: s.into(),
+        bits: u8::try_from(core::mem::size_of::<u32>() * 8).expect("max is 32 bits for u32"),
+        is_signed: u32::try_from(-1i8).is_ok(),
+        source: error,
+    })
+}
+
+/// Implements `TryFrom<$from> for $to` using `parse::int`, mapping the output using infallible
+/// conversion function `fn`.
+macro_rules! impl_tryfrom_str_from_int_infallible {
+    ($($from:ty, $to:ident, $inner:ident, $fn:ident);*) => {
+        $(
+        impl core::convert::TryFrom<$from> for $to {
+            type Error = $crate::error::ParseIntError;
+
+            fn try_from(s: $from) -> Result<Self, Self::Error> {
+                $crate::parse::int::<$inner, $from>(s).map($to::$fn)
+            }
+        }
+        )*
+    }
+}
+pub(crate) use impl_tryfrom_str_from_int_infallible;
+
+/// Implements `FromStr` and `TryFrom<{&str, String, Box<str>}> for $to` using `parse::int`, mapping
+/// the output using infallible conversion function `fn`.
+///
+/// The `Error` type is `ParseIntError`
+macro_rules! impl_parse_str_from_int_infallible {
+    ($to:ident, $inner:ident, $fn:ident) => {
+        $crate::parse::impl_tryfrom_str_from_int_infallible!(&str, $to, $inner, $fn; String, $to, $inner, $fn; Box<str>, $to, $inner, $fn);
+
+        impl core::str::FromStr for $to {
+            type Err = $crate::error::ParseIntError;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                $crate::parse::int::<$inner, &str>(s).map($to::$fn)
+            }
+        }
+
+    }
+}
+pub(crate) use impl_parse_str_from_int_infallible;
+
+/// Implements `TryFrom<$from> for $to` using `parse::int`, mapping the output using fallible
+/// conversion function `fn`.
+macro_rules! impl_tryfrom_str_from_int_fallible {
+    ($($from:ty, $to:ident, $inner:ident, $fn:ident, $err:ident);*) => {
+        $(
+        impl core::convert::TryFrom<$from> for $to {
+            type Error = $err;
+
+            fn try_from(s: $from) -> Result<Self, Self::Error> {
+                let u = $crate::parse::int::<$inner, $from>(s)?;
+                $to::$fn(u)
+            }
+        }
+        )*
+    }
+}
+pub(crate) use impl_tryfrom_str_from_int_fallible;
+
+/// Implements `FromStr` and `TryFrom<{&str, String, Box<str>}> for $to` using `parse::int`, mapping
+/// the output using fallible conversion function `fn`.
+///
+/// The `Error` type is `ParseIntError`
+macro_rules! impl_parse_str_from_int_fallible {
+    ($to:ident, $inner:ident, $fn:ident, $err:ident) => {
+        $crate::parse::impl_tryfrom_str_from_int_fallible!(&str, $to, $inner, $fn, $err; String, $to, $inner, $fn, $err; Box<str>, $to, $inner, $fn, $err);
+
+        impl core::str::FromStr for $to {
+            type Err = $err;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                let u = $crate::parse::int::<$inner, &str>(s)?;
+                $to::$fn(u)
+            }
+        }
+
+    }
+}
+pub(crate) use impl_parse_str_from_int_fallible;
diff --git a/tapyrus/src/policy.rs b/tapyrus/src/policy.rs
new file mode 100644
index 00000000..cc5a02de
--- /dev/null
+++ b/tapyrus/src/policy.rs
@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin policy.
+//!
+//! This module exposes some constants and functions used in the reference
+//! implementation and which, as a consequence, define some network rules.
+//!
+//! # *Warning*
+//! While the constants present in this module are very unlikely to change, they do not define
+//! Bitcoin. As such they must not be relied upon as if they were consensus rules.
+//!
+//! These values were taken from bitcoind v0.21.1 (194b9b8792d9b0798fdb570b79fa51f1d1f5ebaf).
+//!
+
+use core::cmp;
+
+use super::blockdata::constants::{MAX_BLOCK_SIGOPS_COST, WITNESS_SCALE_FACTOR};
+
+/// Maximum weight of a transaction for it to be relayed by most nodes on the network
+pub const MAX_STANDARD_TX_WEIGHT: u32 = 400_000;
+
+/// Minimum non-witness size for a standard transaction (1 segwit input + 1 P2WPKH output = 82 bytes)
+pub const MIN_STANDARD_TX_NONWITNESS_SIZE: u32 = 82;
+
+/// Maximum number of sigops in a standard tx.
+pub const MAX_STANDARD_TX_SIGOPS_COST: u32 = MAX_BLOCK_SIGOPS_COST as u32 / 5;
+
+/// The minimum incremental *feerate* (despite the name), in taps per virtual kilobyte for RBF.
+pub const DEFAULT_INCREMENTAL_RELAY_FEE: u32 = 1_000;
+
+/// The number of bytes equivalent per signature operation. Affects transaction relay through the
+/// virtual size computation.
+pub const DEFAULT_BYTES_PER_SIGOP: u32 = 20;
+
+/// The minimum feerate, in taps per kilo-virtualbyte, for defining dust. An output is considered
+/// dust if spending it under this feerate would cost more in fee.
+pub const DUST_RELAY_TX_FEE: u32 = 3_000;
+
+/// Minimum feerate, in taps per virtual kilobyte, for a transaction to be relayed by most nodes on
+/// the network.
+pub const DEFAULT_MIN_RELAY_TX_FEE: u32 = 1_000;
+
+/// Default number of hours for an unconfirmed transaction to expire in most of the network nodes'
+/// mempools.
+pub const DEFAULT_MEMPOOL_EXPIRY: u32 = 336;
+
+/// The virtual transaction size, as computed by default by bitcoind node.
+pub fn get_virtual_tx_size(weight: i64, n_sigops: i64) -> i64 {
+    (cmp::max(weight, n_sigops * DEFAULT_BYTES_PER_SIGOP as i64) + WITNESS_SCALE_FACTOR as i64 - 1)
+        / WITNESS_SCALE_FACTOR as i64
+}
diff --git a/tapyrus/src/psbt/error.rs b/tapyrus/src/psbt/error.rs
new file mode 100644
index 00000000..89793741
--- /dev/null
+++ b/tapyrus/src/psbt/error.rs
@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::fmt;
+
+use internals::write_err;
+
+use crate::bip32::Xpub;
+use crate::blockdata::transaction::Transaction;
+use crate::consensus::encode;
+use crate::prelude::*;
+use crate::psbt::raw;
+use crate::{hashes, io};
+
+/// Enum for marking psbt hash error.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum PsbtHash {
+    Ripemd,
+    Sha256,
+    Hash160,
+    Hash256,
+}
+/// Ways that a Partially Signed Transaction might fail.
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum Error {
+    /// Magic bytes for a PSBT must be the ASCII for "psbt" serialized in most
+    /// significant byte order.
+    InvalidMagic,
+    /// Missing both the witness and non-witness utxo.
+    MissingUtxo,
+    /// The separator for a PSBT must be `0xff`.
+    InvalidSeparator,
+    /// Returned when output index is out of bounds in relation to the output in non-witness UTXO.
+    PsbtUtxoOutOfbounds,
+    /// Known keys must be according to spec.
+    InvalidKey(raw::Key),
+    /// Non-proprietary key type found when proprietary key was expected
+    InvalidProprietaryKey,
+    /// Keys within key-value map should never be duplicated.
+    DuplicateKey(raw::Key),
+    /// The scriptSigs for the unsigned transaction must be empty.
+    UnsignedTxHasScriptSigs,
+    /// The scriptWitnesses for the unsigned transaction must be empty.
+    UnsignedTxHasScriptWitnesses,
+    /// A PSBT must have an unsigned transaction.
+    MustHaveUnsignedTx,
+    /// Signals that there are no more key-value pairs in a key-value map.
+    NoMorePairs,
+    /// Attempting to combine with a PSBT describing a different unsigned
+    /// transaction.
+    UnexpectedUnsignedTx {
+        /// Expected
+        expected: Box<Transaction>,
+        /// Actual
+        actual: Box<Transaction>,
+    },
+    /// Unable to parse as a standard sighash type.
+    NonStandardSighashType(u32),
+    /// Invalid hash when parsing slice.
+    InvalidHash(hashes::FromSliceError),
+    /// The pre-image must hash to the correponding psbt hash
+    InvalidPreimageHashPair {
+        /// Hash-type
+        hash_type: PsbtHash,
+        /// Pre-image
+        preimage: Box<[u8]>,
+        /// Hash value
+        hash: Box<[u8]>,
+    },
+    /// Conflicting data during combine procedure:
+    /// global extended public key has inconsistent key sources
+    CombineInconsistentKeySources(Box<Xpub>),
+    /// Serialization error in tapyrus consensus-encoded structures
+    ConsensusEncoding(encode::Error),
+    /// Negative fee
+    NegativeFee,
+    /// Integer overflow in fee calculation
+    FeeOverflow,
+    /// Parsing error indicating invalid public keys
+    InvalidPublicKey(crate::crypto::key::Error),
+    /// Parsing error indicating invalid secp256k1 public keys
+    InvalidSecp256k1PublicKey(secp256k1::Error),
+    /// Parsing error indicating invalid xonly public keys
+    InvalidXOnlyPublicKey,
+    /// Parsing error indicating invalid ECDSA signatures
+    InvalidEcdsaSignature(crate::crypto::ecdsa::Error),
+    /// Parsing error indicating invalid taproot signatures
+    InvalidTaprootSignature(crate::crypto::taproot::SigFromSliceError),
+    /// Parsing error indicating invalid control block
+    InvalidControlBlock,
+    /// Parsing error indicating invalid leaf version
+    InvalidLeafVersion,
+    /// Parsing error indicating a taproot error
+    Taproot(&'static str),
+    /// Taproot tree deserilaization error
+    TapTree(crate::taproot::IncompleteBuilderError),
+    /// Error related to an xpub key
+    XPubKey(&'static str),
+    /// Error related to PSBT version
+    Version(&'static str),
+    /// PSBT data is not consumed entirely
+    PartialDataConsumption,
+    /// I/O error.
+    Io(io::Error),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use Error::*;
+
+        match *self {
+            InvalidMagic => f.write_str("invalid magic"),
+            MissingUtxo => f.write_str("UTXO information is not present in PSBT"),
+            InvalidSeparator => f.write_str("invalid separator"),
+            PsbtUtxoOutOfbounds =>
+                f.write_str("output index is out of bounds of non witness script output array"),
+            InvalidKey(ref rkey) => write!(f, "invalid key: {}", rkey),
+            InvalidProprietaryKey =>
+                write!(f, "non-proprietary key type found when proprietary key was expected"),
+            DuplicateKey(ref rkey) => write!(f, "duplicate key: {}", rkey),
+            UnsignedTxHasScriptSigs => f.write_str("the unsigned transaction has script sigs"),
+            UnsignedTxHasScriptWitnesses =>
+                f.write_str("the unsigned transaction has script witnesses"),
+            MustHaveUnsignedTx =>
+                f.write_str("partially signed transactions must have an unsigned transaction"),
+            NoMorePairs => f.write_str("no more key-value pairs for this psbt map"),
+            UnexpectedUnsignedTx { expected: ref e, actual: ref a } => write!(
+                f,
+                "different unsigned transaction: expected {}, actual {}",
+                e.txid(),
+                a.txid()
+            ),
+            NonStandardSighashType(ref sht) => write!(f, "non-standard sighash type: {}", sht),
+            InvalidHash(ref e) => write_err!(f, "invalid hash when parsing slice"; e),
+            InvalidPreimageHashPair { ref preimage, ref hash, ref hash_type } => {
+                // directly using debug forms of psbthash enums
+                write!(f, "Preimage {:?} does not match {:?} hash {:?}", preimage, hash_type, hash)
+            }
+            CombineInconsistentKeySources(ref s) => {
+                write!(f, "combine conflict: {}", s)
+            }
+            ConsensusEncoding(ref e) => write_err!(f, "tapyrus consensus encoding error"; e),
+            NegativeFee => f.write_str("PSBT has a negative fee which is not allowed"),
+            FeeOverflow => f.write_str("integer overflow in fee calculation"),
+            InvalidPublicKey(ref e) => write_err!(f, "invalid public key"; e),
+            InvalidSecp256k1PublicKey(ref e) => write_err!(f, "invalid secp256k1 public key"; e),
+            InvalidXOnlyPublicKey => f.write_str("invalid xonly public key"),
+            InvalidEcdsaSignature(ref e) => write_err!(f, "invalid ECDSA signature"; e),
+            InvalidTaprootSignature(ref e) => write_err!(f, "invalid taproot signature"; e),
+            InvalidControlBlock => f.write_str("invalid control block"),
+            InvalidLeafVersion => f.write_str("invalid leaf version"),
+            Taproot(s) => write!(f, "taproot error -  {}", s),
+            TapTree(ref e) => write_err!(f, "taproot tree error"; e),
+            XPubKey(s) => write!(f, "xpub key error -  {}", s),
+            Version(s) => write!(f, "version error {}", s),
+            PartialDataConsumption =>
+                f.write_str("data not consumed entirely when explicitly deserializing"),
+            Io(ref e) => write_err!(f, "I/O error"; e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use Error::*;
+
+        match *self {
+            InvalidHash(ref e) => Some(e),
+            ConsensusEncoding(ref e) => Some(e),
+            Io(ref e) => Some(e),
+            InvalidMagic
+            | MissingUtxo
+            | InvalidSeparator
+            | PsbtUtxoOutOfbounds
+            | InvalidKey(_)
+            | InvalidProprietaryKey
+            | DuplicateKey(_)
+            | UnsignedTxHasScriptSigs
+            | UnsignedTxHasScriptWitnesses
+            | MustHaveUnsignedTx
+            | NoMorePairs
+            | UnexpectedUnsignedTx { .. }
+            | NonStandardSighashType(_)
+            | InvalidPreimageHashPair { .. }
+            | CombineInconsistentKeySources(_)
+            | NegativeFee
+            | FeeOverflow
+            | InvalidPublicKey(_)
+            | InvalidSecp256k1PublicKey(_)
+            | InvalidXOnlyPublicKey
+            | InvalidEcdsaSignature(_)
+            | InvalidTaprootSignature(_)
+            | InvalidControlBlock
+            | InvalidLeafVersion
+            | Taproot(_)
+            | TapTree(_)
+            | XPubKey(_)
+            | Version(_)
+            | PartialDataConsumption => None,
+        }
+    }
+}
+
+impl From<hashes::FromSliceError> for Error {
+    fn from(e: hashes::FromSliceError) -> Error { Error::InvalidHash(e) }
+}
+
+impl From<encode::Error> for Error {
+    fn from(e: encode::Error) -> Self { Error::ConsensusEncoding(e) }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self { Error::Io(e) }
+}
diff --git a/tapyrus/src/psbt/macros.rs b/tapyrus/src/psbt/macros.rs
new file mode 100644
index 00000000..f07e5bbc
--- /dev/null
+++ b/tapyrus/src/psbt/macros.rs
@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: CC0-1.0
+
+#[allow(unused_macros)]
+macro_rules! combine {
+    ($thing:ident, $slf:ident, $other:ident) => {
+        if let (&None, Some($thing)) = (&$slf.$thing, $other.$thing) {
+            $slf.$thing = Some($thing);
+        }
+    };
+}
+
+macro_rules! impl_psbt_de_serialize {
+    ($thing:ty) => {
+        impl_psbt_serialize!($thing);
+        impl_psbt_deserialize!($thing);
+    };
+}
+
+macro_rules! impl_psbt_deserialize {
+    ($thing:ty) => {
+        impl $crate::psbt::serialize::Deserialize for $thing {
+            fn deserialize(bytes: &[u8]) -> Result<Self, $crate::psbt::Error> {
+                $crate::consensus::deserialize(&bytes[..]).map_err(|e| $crate::psbt::Error::from(e))
+            }
+        }
+    };
+}
+
+macro_rules! impl_psbt_serialize {
+    ($thing:ty) => {
+        impl $crate::psbt::serialize::Serialize for $thing {
+            fn serialize(&self) -> $crate::prelude::Vec<u8> { $crate::consensus::serialize(self) }
+        }
+    };
+}
+
+macro_rules! impl_psbtmap_serialize {
+    ($thing:ty) => {
+        impl $crate::psbt::serialize::Serialize for $thing {
+            fn serialize(&self) -> Vec<u8> { self.serialize_map() }
+        }
+    };
+}
+
+macro_rules! impl_psbtmap_deserialize {
+    ($thing:ty) => {
+        impl $crate::psbt::serialize::Deserialize for $thing {
+            fn deserialize(bytes: &[u8]) -> Result<Self, $crate::psbt::Error> {
+                let mut decoder = bytes;
+                Self::decode(&mut decoder)
+            }
+        }
+    };
+}
+
+macro_rules! impl_psbtmap_decoding {
+    ($thing:ty) => {
+        impl $thing {
+            pub(crate) fn decode<R: $crate::io::Read + ?Sized>(
+                r: &mut R,
+            ) -> Result<Self, $crate::psbt::Error> {
+                let mut rv: Self = core::default::Default::default();
+
+                loop {
+                    match $crate::psbt::raw::Pair::decode(r) {
+                        Ok(pair) => rv.insert_pair(pair)?,
+                        Err($crate::psbt::Error::NoMorePairs) => return Ok(rv),
+                        Err(e) => return Err(e),
+                    }
+                }
+            }
+        }
+    };
+}
+
+macro_rules! impl_psbtmap_ser_de_serialize {
+    ($thing:ty) => {
+        impl_psbtmap_decoding!($thing);
+        impl_psbtmap_serialize!($thing);
+        impl_psbtmap_deserialize!($thing);
+    };
+}
+
+#[rustfmt::skip]
+macro_rules! impl_psbt_insert_pair {
+    ($slf:ident.$unkeyed_name:ident <= <$raw_key:ident: _>|<$raw_value:ident: $unkeyed_value_type:ty>) => {
+        if $raw_key.key.is_empty() {
+            if $slf.$unkeyed_name.is_none() {
+                let val: $unkeyed_value_type = $crate::psbt::serialize::Deserialize::deserialize(&$raw_value)?;
+                $slf.$unkeyed_name = Some(val)
+            } else {
+                return Err($crate::psbt::Error::DuplicateKey($raw_key).into());
+            }
+        } else {
+            return Err($crate::psbt::Error::InvalidKey($raw_key).into());
+        }
+    };
+    ($slf:ident.$keyed_name:ident <= <$raw_key:ident: $keyed_key_type:ty>|<$raw_value:ident: $keyed_value_type:ty>) => {
+        if !$raw_key.key.is_empty() {
+            let key_val: $keyed_key_type = $crate::psbt::serialize::Deserialize::deserialize(&$raw_key.key)?;
+            match $slf.$keyed_name.entry(key_val) {
+                $crate::prelude::btree_map::Entry::Vacant(empty_key) => {
+                    let val: $keyed_value_type = $crate::psbt::serialize::Deserialize::deserialize(&$raw_value)?;
+                    empty_key.insert(val);
+                }
+                $crate::prelude::btree_map::Entry::Occupied(_) => return Err($crate::psbt::Error::DuplicateKey($raw_key).into()),
+            }
+        } else {
+            return Err($crate::psbt::Error::InvalidKey($raw_key).into());
+        }
+    };
+}
+
+#[rustfmt::skip]
+macro_rules! impl_psbt_get_pair {
+    ($rv:ident.push($slf:ident.$unkeyed_name:ident, $unkeyed_typeval:ident)) => {
+        if let Some(ref $unkeyed_name) = $slf.$unkeyed_name {
+            $rv.push($crate::psbt::raw::Pair {
+                key: $crate::psbt::raw::Key {
+                    type_value: $unkeyed_typeval,
+                    key: vec![],
+                },
+                value: $crate::psbt::serialize::Serialize::serialize($unkeyed_name),
+            });
+        }
+    };
+    ($rv:ident.push_map($slf:ident.$keyed_name:ident, $keyed_typeval:ident)) => {
+        for (key, val) in &$slf.$keyed_name {
+            $rv.push($crate::psbt::raw::Pair {
+                key: $crate::psbt::raw::Key {
+                    type_value: $keyed_typeval,
+                    key: $crate::psbt::serialize::Serialize::serialize(key),
+                },
+                value: $crate::psbt::serialize::Serialize::serialize(val),
+            });
+        }
+    };
+}
+
+// macros for serde of hashes
+macro_rules! impl_psbt_hash_de_serialize {
+    ($hash_type:ty) => {
+        impl_psbt_hash_serialize!($hash_type);
+        impl_psbt_hash_deserialize!($hash_type);
+    };
+}
+
+macro_rules! impl_psbt_hash_deserialize {
+    ($hash_type:ty) => {
+        impl $crate::psbt::serialize::Deserialize for $hash_type {
+            fn deserialize(bytes: &[u8]) -> Result<Self, $crate::psbt::Error> {
+                <$hash_type>::from_slice(&bytes[..]).map_err(|e| $crate::psbt::Error::from(e))
+            }
+        }
+    };
+}
+
+macro_rules! impl_psbt_hash_serialize {
+    ($hash_type:ty) => {
+        impl $crate::psbt::serialize::Serialize for $hash_type {
+            fn serialize(&self) -> $crate::prelude::Vec<u8> { self.as_byte_array().to_vec() }
+        }
+    };
+}
diff --git a/tapyrus/src/psbt/map/global.rs b/tapyrus/src/psbt/map/global.rs
new file mode 100644
index 00000000..22a25f4e
--- /dev/null
+++ b/tapyrus/src/psbt/map/global.rs
@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::convert::TryFrom;
+
+use crate::bip32::{ChildNumber, DerivationPath, Fingerprint, Xpub};
+use crate::blockdata::transaction::Transaction;
+use crate::consensus::encode::MAX_VEC_SIZE;
+use crate::consensus::{encode, Decodable};
+use crate::io::{self, Cursor, Read};
+use crate::prelude::*;
+use crate::psbt::map::Map;
+use crate::psbt::{raw, Error, Psbt};
+
+/// Type: Unsigned Transaction PSBT_GLOBAL_UNSIGNED_TX = 0x00
+const PSBT_GLOBAL_UNSIGNED_TX: u8 = 0x00;
+/// Type: Extended Public Key PSBT_GLOBAL_XPUB = 0x01
+const PSBT_GLOBAL_XPUB: u8 = 0x01;
+/// Type: Version Number PSBT_GLOBAL_VERSION = 0xFB
+const PSBT_GLOBAL_VERSION: u8 = 0xFB;
+/// Type: Proprietary Use Type PSBT_GLOBAL_PROPRIETARY = 0xFC
+const PSBT_GLOBAL_PROPRIETARY: u8 = 0xFC;
+
+impl Map for Psbt {
+    fn get_pairs(&self) -> Vec<raw::Pair> {
+        let mut rv: Vec<raw::Pair> = Default::default();
+
+        rv.push(raw::Pair {
+            key: raw::Key { type_value: PSBT_GLOBAL_UNSIGNED_TX, key: vec![] },
+            value: {
+                // Manually serialized to ensure 0-input txs are serialized
+                // without witnesses.
+                let mut ret = Vec::new();
+                ret.extend(encode::serialize(&self.unsigned_tx.version));
+                ret.extend(encode::serialize(&self.unsigned_tx.input));
+                ret.extend(encode::serialize(&self.unsigned_tx.output));
+                ret.extend(encode::serialize(&self.unsigned_tx.lock_time));
+                ret
+            },
+        });
+
+        for (xpub, (fingerprint, derivation)) in &self.xpub {
+            rv.push(raw::Pair {
+                key: raw::Key { type_value: PSBT_GLOBAL_XPUB, key: xpub.encode().to_vec() },
+                value: {
+                    let mut ret = Vec::with_capacity(4 + derivation.len() * 4);
+                    ret.extend(fingerprint.as_bytes());
+                    derivation.into_iter().for_each(|n| ret.extend(&u32::from(*n).to_le_bytes()));
+                    ret
+                },
+            });
+        }
+
+        // Serializing version only for non-default value; otherwise test vectors fail
+        if self.version > 0 {
+            rv.push(raw::Pair {
+                key: raw::Key { type_value: PSBT_GLOBAL_VERSION, key: vec![] },
+                value: self.version.to_le_bytes().to_vec(),
+            });
+        }
+
+        for (key, value) in self.proprietary.iter() {
+            rv.push(raw::Pair { key: key.to_key(), value: value.clone() });
+        }
+
+        for (key, value) in self.unknown.iter() {
+            rv.push(raw::Pair { key: key.clone(), value: value.clone() });
+        }
+
+        rv
+    }
+}
+
+impl Psbt {
+    pub(crate) fn decode_global<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        let mut r = r.take(MAX_VEC_SIZE as u64);
+        let mut tx: Option<Transaction> = None;
+        let mut version: Option<u32> = None;
+        let mut unknowns: BTreeMap<raw::Key, Vec<u8>> = Default::default();
+        let mut xpub_map: BTreeMap<Xpub, (Fingerprint, DerivationPath)> = Default::default();
+        let mut proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>> = Default::default();
+
+        loop {
+            match raw::Pair::decode(&mut r) {
+                Ok(pair) => {
+                    match pair.key.type_value {
+                        PSBT_GLOBAL_UNSIGNED_TX => {
+                            // key has to be empty
+                            if pair.key.key.is_empty() {
+                                // there can only be one unsigned transaction
+                                if tx.is_none() {
+                                    let vlen: usize = pair.value.len();
+                                    let mut decoder = Cursor::new(pair.value);
+
+                                    // Manually deserialized to ensure 0-input
+                                    // txs without witnesses are deserialized
+                                    // properly.
+                                    tx = Some(Transaction {
+                                        version: Decodable::consensus_decode(&mut decoder)?,
+                                        input: Decodable::consensus_decode(&mut decoder)?,
+                                        output: Decodable::consensus_decode(&mut decoder)?,
+                                        lock_time: Decodable::consensus_decode(&mut decoder)?,
+                                    });
+
+                                    if decoder.position() != vlen as u64 {
+                                        return Err(Error::PartialDataConsumption);
+                                    }
+                                } else {
+                                    return Err(Error::DuplicateKey(pair.key));
+                                }
+                            } else {
+                                return Err(Error::InvalidKey(pair.key));
+                            }
+                        }
+                        PSBT_GLOBAL_XPUB => {
+                            if !pair.key.key.is_empty() {
+                                let xpub = Xpub::decode(&pair.key.key)
+                                    .map_err(|_| Error::XPubKey(
+                                        "Can't deserialize ExtendedPublicKey from global XPUB key data"
+                                    ))?;
+
+                                if pair.value.is_empty() || pair.value.len() % 4 != 0 {
+                                    return Err(Error::XPubKey(
+                                        "Incorrect length of global xpub derivation data",
+                                    ));
+                                }
+
+                                let child_count = pair.value.len() / 4 - 1;
+                                let mut decoder = Cursor::new(pair.value);
+                                let mut fingerprint = [0u8; 4];
+                                decoder.read_exact(&mut fingerprint[..]).map_err(|_| {
+                                    Error::XPubKey("Can't read global xpub 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(Error::XPubKey("Repeated global xpub key"));
+                                }
+                            } else {
+                                return Err(Error::XPubKey(
+                                    "Xpub global key must contain serialized Xpub data",
+                                ));
+                            }
+                        }
+                        PSBT_GLOBAL_VERSION => {
+                            // key has to be empty
+                            if pair.key.key.is_empty() {
+                                // there can only be one version
+                                if version.is_none() {
+                                    let vlen: usize = pair.value.len();
+                                    let mut decoder = Cursor::new(pair.value);
+                                    if vlen != 4 {
+                                        return Err(Error::Version(
+                                            "invalid global version value length (must be 4 bytes)",
+                                        ));
+                                    }
+                                    version = Some(Decodable::consensus_decode(&mut decoder)?);
+                                    // We only understand version 0 PSBTs. According to BIP-174 we
+                                    // should throw an error if we see anything other than version 0.
+                                    if version != Some(0) {
+                                        return Err(Error::Version(
+                                            "PSBT versions greater than 0 are not supported",
+                                        ));
+                                    }
+                                } else {
+                                    return Err(Error::DuplicateKey(pair.key));
+                                }
+                            } else {
+                                return Err(Error::InvalidKey(pair.key));
+                            }
+                        }
+                        PSBT_GLOBAL_PROPRIETARY => match proprietary
+                            .entry(raw::ProprietaryKey::try_from(pair.key.clone())?)
+                        {
+                            btree_map::Entry::Vacant(empty_key) => {
+                                empty_key.insert(pair.value);
+                            }
+                            btree_map::Entry::Occupied(_) =>
+                                return Err(Error::DuplicateKey(pair.key)),
+                        },
+                        _ => match unknowns.entry(pair.key) {
+                            btree_map::Entry::Vacant(empty_key) => {
+                                empty_key.insert(pair.value);
+                            }
+                            btree_map::Entry::Occupied(k) =>
+                                return Err(Error::DuplicateKey(k.key().clone())),
+                        },
+                    }
+                }
+                Err(crate::psbt::Error::NoMorePairs) => break,
+                Err(e) => return Err(e),
+            }
+        }
+
+        if let Some(tx) = tx {
+            Ok(Psbt {
+                unsigned_tx: tx,
+                version: version.unwrap_or(0),
+                xpub: xpub_map,
+                proprietary,
+                unknown: unknowns,
+                inputs: vec![],
+                outputs: vec![],
+            })
+        } else {
+            Err(Error::MustHaveUnsignedTx)
+        }
+    }
+}
diff --git a/tapyrus/src/psbt/map/input.rs b/tapyrus/src/psbt/map/input.rs
new file mode 100644
index 00000000..f74a4ee5
--- /dev/null
+++ b/tapyrus/src/psbt/map/input.rs
@@ -0,0 +1,582 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::convert::TryFrom;
+use core::fmt;
+use core::str::FromStr;
+
+use hashes::{self, hash160, ripemd160, sha256, sha256d};
+use secp256k1::XOnlyPublicKey;
+
+use crate::bip32::KeySource;
+use crate::blockdata::script::ScriptBuf;
+use crate::blockdata::transaction::{Transaction, TxOut};
+use crate::blockdata::witness::Witness;
+use crate::crypto::key::PublicKey;
+use crate::crypto::{ecdsa, taproot};
+use crate::prelude::*;
+use crate::psbt::map::Map;
+use crate::psbt::serialize::Deserialize;
+use crate::psbt::{self, error, raw, Error};
+use crate::sighash::{
+    EcdsaSighashType, InvalidSighashTypeError, NonStandardSighashTypeError, SighashTypeParseError,
+    TapSighashType,
+};
+use crate::taproot::{ControlBlock, LeafVersion, TapLeafHash, TapNodeHash};
+
+/// Type: Non-Witness UTXO PSBT_IN_NON_WITNESS_UTXO = 0x00
+const PSBT_IN_NON_WITNESS_UTXO: u8 = 0x00;
+/// Type: Witness UTXO PSBT_IN_WITNESS_UTXO = 0x01
+const PSBT_IN_WITNESS_UTXO: u8 = 0x01;
+/// Type: Partial Signature PSBT_IN_PARTIAL_SIG = 0x02
+const PSBT_IN_PARTIAL_SIG: u8 = 0x02;
+/// Type: Sighash Type PSBT_IN_SIGHASH_TYPE = 0x03
+const PSBT_IN_SIGHASH_TYPE: u8 = 0x03;
+/// Type: Redeem Script PSBT_IN_REDEEM_SCRIPT = 0x04
+const PSBT_IN_REDEEM_SCRIPT: u8 = 0x04;
+/// Type: Witness Script PSBT_IN_WITNESS_SCRIPT = 0x05
+const PSBT_IN_WITNESS_SCRIPT: u8 = 0x05;
+/// Type: BIP 32 Derivation Path PSBT_IN_BIP32_DERIVATION = 0x06
+const PSBT_IN_BIP32_DERIVATION: u8 = 0x06;
+/// Type: Finalized scriptSig PSBT_IN_FINAL_SCRIPTSIG = 0x07
+const PSBT_IN_FINAL_SCRIPTSIG: u8 = 0x07;
+/// Type: Finalized scriptWitness PSBT_IN_FINAL_SCRIPTWITNESS = 0x08
+const PSBT_IN_FINAL_SCRIPTWITNESS: u8 = 0x08;
+/// Type: RIPEMD160 preimage PSBT_IN_RIPEMD160 = 0x0a
+const PSBT_IN_RIPEMD160: u8 = 0x0a;
+/// Type: SHA256 preimage PSBT_IN_SHA256 = 0x0b
+const PSBT_IN_SHA256: u8 = 0x0b;
+/// Type: HASH160 preimage PSBT_IN_HASH160 = 0x0c
+const PSBT_IN_HASH160: u8 = 0x0c;
+/// Type: HASH256 preimage PSBT_IN_HASH256 = 0x0d
+const PSBT_IN_HASH256: u8 = 0x0d;
+/// Type: Taproot Signature in Key Spend PSBT_IN_TAP_KEY_SIG = 0x13
+const PSBT_IN_TAP_KEY_SIG: u8 = 0x13;
+/// Type: Taproot 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
+const PSBT_IN_TAP_LEAF_SCRIPT: u8 = 0x15;
+/// 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
+const PSBT_IN_TAP_INTERNAL_KEY: u8 = 0x17;
+/// Type: Taproot Merkle Root PSBT_IN_TAP_MERKLE_ROOT = 0x18
+const PSBT_IN_TAP_MERKLE_ROOT: u8 = 0x18;
+/// Type: Proprietary Use Type PSBT_IN_PROPRIETARY = 0xFC
+const PSBT_IN_PROPRIETARY: u8 = 0xFC;
+
+/// A key-value map for an input of the corresponding index in the unsigned
+/// transaction.
+#[derive(Clone, Default, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Input {
+    /// The non-witness transaction this input spends from. Should only be
+    /// `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
+    /// `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 for a non-taproot inputs.
+    pub partial_sigs: BTreeMap<PublicKey, ecdsa::Signature>,
+    /// The sighash type to be used for this input. Signatures for this input
+    /// must use the sighash type.
+    pub sighash_type: Option<PsbtSighashType>,
+    /// The redeem script for this input.
+    pub redeem_script: Option<ScriptBuf>,
+    /// The witness script for this input.
+    pub witness_script: Option<ScriptBuf>,
+    /// A map from public keys needed to sign this input to their corresponding
+    /// master key fingerprints and derivation paths.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
+    pub bip32_derivation: BTreeMap<secp256k1::PublicKey, KeySource>,
+    /// The finalized, fully-constructed scriptSig with signatures and any other
+    /// scripts necessary for this input to pass validation.
+    pub final_script_sig: Option<ScriptBuf>,
+    /// The finalized, fully-constructed scriptWitness with signatures and any
+    /// other scripts necessary for this input to pass validation.
+    pub final_script_witness: Option<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>>,
+    /// Serialized taproot signature with sighash type for key spend.
+    pub tap_key_sig: Option<taproot::Signature>,
+    /// Map of `<xonlypubkey>|<leafhash>` with signature.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
+    pub tap_script_sigs: BTreeMap<(XOnlyPublicKey, TapLeafHash), taproot::Signature>,
+    /// Map of Control blocks to Script version pair.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
+    pub tap_scripts: BTreeMap<ControlBlock, (ScriptBuf, LeafVersion)>,
+    /// Map of tap root x only keys to origin info and leaf hashes contained in it.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
+    pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
+    /// Taproot Internal key.
+    pub tap_internal_key: Option<XOnlyPublicKey>,
+    /// Taproot Merkle root.
+    pub tap_merkle_root: Option<TapNodeHash>,
+    /// Proprietary key-value pairs for this input.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
+    pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
+    /// Unknown key-value pairs for this input.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
+    pub unknown: BTreeMap<raw::Key, Vec<u8>>,
+}
+
+/// A Signature hash type for the corresponding input. As of taproot upgrade, the signature hash
+/// type can be either [`EcdsaSighashType`] or [`TapSighashType`] 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)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct PsbtSighashType {
+    pub(in crate::psbt) inner: u32,
+}
+
+impl fmt::Display for PsbtSighashType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.taproot_hash_ty() {
+            Err(_) => write!(f, "{:#x}", self.inner),
+            Ok(taproot_hash_ty) => fmt::Display::fmt(&taproot_hash_ty, f),
+        }
+    }
+}
+
+impl FromStr for PsbtSighashType {
+    type Err = SighashTypeParseError;
+
+    #[inline]
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // We accept strings of form: "SIGHASH_ALL" etc.
+        //
+        // NB: some of Taproot 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).
+        if let Ok(ty) = TapSighashType::from_str(s) {
+            return Ok(ty.into());
+        }
+
+        // We accept non-standard sighash values.
+        if let Ok(inner) = u32::from_str_radix(s.trim_start_matches("0x"), 16) {
+            return Ok(PsbtSighashType { inner });
+        }
+
+        Err(SighashTypeParseError { unrecognized: s.to_owned() })
+    }
+}
+impl From<EcdsaSighashType> for PsbtSighashType {
+    fn from(ecdsa_hash_ty: EcdsaSighashType) -> Self {
+        PsbtSighashType { inner: ecdsa_hash_ty as u32 }
+    }
+}
+
+impl From<TapSighashType> for PsbtSighashType {
+    fn from(taproot_hash_ty: TapSighashType) -> Self {
+        PsbtSighashType { inner: taproot_hash_ty as u32 }
+    }
+}
+
+impl PsbtSighashType {
+    /// Returns the [`EcdsaSighashType`] if the [`PsbtSighashType`] can be
+    /// converted to one.
+    pub fn ecdsa_hash_ty(self) -> Result<EcdsaSighashType, NonStandardSighashTypeError> {
+        EcdsaSighashType::from_standard(self.inner)
+    }
+
+    /// Returns the [`TapSighashType`] if the [`PsbtSighashType`] can be
+    /// converted to one.
+    pub fn taproot_hash_ty(self) -> Result<TapSighashType, InvalidSighashTypeError> {
+        if self.inner > 0xffu32 {
+            Err(InvalidSighashTypeError(self.inner))
+        } else {
+            TapSighashType::from_consensus_u8(self.inner as u8)
+        }
+    }
+
+    /// Creates a [`PsbtSighashType`] from a raw `u32`.
+    ///
+    /// Allows construction of a non-standard or non-valid sighash flag
+    /// ([`EcdsaSighashType`], [`TapSighashType`] respectively).
+    pub fn from_u32(n: u32) -> PsbtSighashType { PsbtSighashType { inner: n } }
+
+    /// Converts [`PsbtSighashType`] to a raw `u32` sighash flag.
+    ///
+    /// No guarantees are made as to the standardness or validity of the returned value.
+    pub fn to_u32(self) -> u32 { self.inner }
+}
+
+impl Input {
+    /// 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) -> Result<EcdsaSighashType, NonStandardSighashTypeError> {
+        self.sighash_type
+            .map(|sighash_type| sighash_type.ecdsa_hash_ty())
+            .unwrap_or(Ok(EcdsaSighashType::All))
+    }
+
+    /// Obtains the [`TapSighashType`] for this input if one is specified. If no sighash type is
+    /// specified, returns [`TapSighashType::Default`].
+    ///
+    /// # Errors
+    ///
+    /// If the `sighash_type` field is set to a invalid Taproot sighash value.
+    pub fn taproot_hash_ty(&self) -> Result<TapSighashType, InvalidSighashTypeError> {
+        self.sighash_type
+            .map(|sighash_type| sighash_type.taproot_hash_ty())
+            .unwrap_or(Ok(TapSighashType::Default))
+    }
+
+    pub(super) fn insert_pair(&mut self, pair: raw::Pair) -> Result<(), Error> {
+        let raw::Pair { key: raw_key, value: raw_value } = pair;
+
+        match raw_key.type_value {
+            PSBT_IN_NON_WITNESS_UTXO => {
+                impl_psbt_insert_pair! {
+                    self.non_witness_utxo <= <raw_key: _>|<raw_value: Transaction>
+                }
+            }
+            PSBT_IN_WITNESS_UTXO => {
+                impl_psbt_insert_pair! {
+                    self.witness_utxo <= <raw_key: _>|<raw_value: TxOut>
+                }
+            }
+            PSBT_IN_PARTIAL_SIG => {
+                impl_psbt_insert_pair! {
+                    self.partial_sigs <= <raw_key: PublicKey>|<raw_value: ecdsa::Signature>
+                }
+            }
+            PSBT_IN_SIGHASH_TYPE => {
+                impl_psbt_insert_pair! {
+                    self.sighash_type <= <raw_key: _>|<raw_value: PsbtSighashType>
+                }
+            }
+            PSBT_IN_REDEEM_SCRIPT => {
+                impl_psbt_insert_pair! {
+                    self.redeem_script <= <raw_key: _>|<raw_value: ScriptBuf>
+                }
+            }
+            PSBT_IN_WITNESS_SCRIPT => {
+                impl_psbt_insert_pair! {
+                    self.witness_script <= <raw_key: _>|<raw_value: ScriptBuf>
+                }
+            }
+            PSBT_IN_BIP32_DERIVATION => {
+                impl_psbt_insert_pair! {
+                    self.bip32_derivation <= <raw_key: secp256k1::PublicKey>|<raw_value: KeySource>
+                }
+            }
+            PSBT_IN_FINAL_SCRIPTSIG => {
+                impl_psbt_insert_pair! {
+                    self.final_script_sig <= <raw_key: _>|<raw_value: ScriptBuf>
+                }
+            }
+            PSBT_IN_FINAL_SCRIPTWITNESS => {
+                impl_psbt_insert_pair! {
+                    self.final_script_witness <= <raw_key: _>|<raw_value: Witness>
+                }
+            }
+            PSBT_IN_RIPEMD160 => {
+                psbt_insert_hash_pair(
+                    &mut self.ripemd160_preimages,
+                    raw_key,
+                    raw_value,
+                    error::PsbtHash::Ripemd,
+                )?;
+            }
+            PSBT_IN_SHA256 => {
+                psbt_insert_hash_pair(
+                    &mut self.sha256_preimages,
+                    raw_key,
+                    raw_value,
+                    error::PsbtHash::Sha256,
+                )?;
+            }
+            PSBT_IN_HASH160 => {
+                psbt_insert_hash_pair(
+                    &mut self.hash160_preimages,
+                    raw_key,
+                    raw_value,
+                    error::PsbtHash::Hash160,
+                )?;
+            }
+            PSBT_IN_HASH256 => {
+                psbt_insert_hash_pair(
+                    &mut self.hash256_preimages,
+                    raw_key,
+                    raw_value,
+                    error::PsbtHash::Hash256,
+                )?;
+            }
+            PSBT_IN_TAP_KEY_SIG => {
+                impl_psbt_insert_pair! {
+                    self.tap_key_sig <= <raw_key: _>|<raw_value: taproot::Signature>
+                }
+            }
+            PSBT_IN_TAP_SCRIPT_SIG => {
+                impl_psbt_insert_pair! {
+                    self.tap_script_sigs <= <raw_key: (XOnlyPublicKey, TapLeafHash)>|<raw_value: taproot::Signature>
+                }
+            }
+            PSBT_IN_TAP_LEAF_SCRIPT => {
+                impl_psbt_insert_pair! {
+                    self.tap_scripts <= <raw_key: ControlBlock>|< raw_value: (ScriptBuf, LeafVersion)>
+                }
+            }
+            PSBT_IN_TAP_BIP32_DERIVATION => {
+                impl_psbt_insert_pair! {
+                    self.tap_key_origins <= <raw_key: XOnlyPublicKey>|< raw_value: (Vec<TapLeafHash>, KeySource)>
+                }
+            }
+            PSBT_IN_TAP_INTERNAL_KEY => {
+                impl_psbt_insert_pair! {
+                    self.tap_internal_key <= <raw_key: _>|< raw_value: XOnlyPublicKey>
+                }
+            }
+            PSBT_IN_TAP_MERKLE_ROOT => {
+                impl_psbt_insert_pair! {
+                    self.tap_merkle_root <= <raw_key: _>|< raw_value: TapNodeHash>
+                }
+            }
+            PSBT_IN_PROPRIETARY => {
+                let key = raw::ProprietaryKey::try_from(raw_key.clone())?;
+                match self.proprietary.entry(key) {
+                    btree_map::Entry::Vacant(empty_key) => {
+                        empty_key.insert(raw_value);
+                    }
+                    btree_map::Entry::Occupied(_) => return Err(Error::DuplicateKey(raw_key)),
+                }
+            }
+            _ => match self.unknown.entry(raw_key) {
+                btree_map::Entry::Vacant(empty_key) => {
+                    empty_key.insert(raw_value);
+                }
+                btree_map::Entry::Occupied(k) => return Err(Error::DuplicateKey(k.key().clone())),
+            },
+        }
+
+        Ok(())
+    }
+
+    /// Combines this [`Input`] with `other` `Input` (as described by BIP 174).
+    pub fn combine(&mut self, other: Self) {
+        combine!(non_witness_utxo, self, other);
+
+        if let (&None, Some(witness_utxo)) = (&self.witness_utxo, other.witness_utxo) {
+            self.witness_utxo = Some(witness_utxo);
+            self.non_witness_utxo = None; // Clear out any non-witness UTXO when we set a witness one
+        }
+
+        self.partial_sigs.extend(other.partial_sigs);
+        self.bip32_derivation.extend(other.bip32_derivation);
+        self.ripemd160_preimages.extend(other.ripemd160_preimages);
+        self.sha256_preimages.extend(other.sha256_preimages);
+        self.hash160_preimages.extend(other.hash160_preimages);
+        self.hash256_preimages.extend(other.hash256_preimages);
+        self.tap_script_sigs.extend(other.tap_script_sigs);
+        self.tap_scripts.extend(other.tap_scripts);
+        self.tap_key_origins.extend(other.tap_key_origins);
+        self.proprietary.extend(other.proprietary);
+        self.unknown.extend(other.unknown);
+
+        combine!(redeem_script, self, other);
+        combine!(witness_script, self, other);
+        combine!(final_script_sig, self, other);
+        combine!(final_script_witness, self, other);
+        combine!(tap_key_sig, self, other);
+        combine!(tap_internal_key, self, other);
+        combine!(tap_merkle_root, self, other);
+    }
+}
+
+impl Map for Input {
+    fn get_pairs(&self) -> Vec<raw::Pair> {
+        let mut rv: Vec<raw::Pair> = Default::default();
+
+        impl_psbt_get_pair! {
+            rv.push(self.non_witness_utxo, PSBT_IN_NON_WITNESS_UTXO)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.witness_utxo, PSBT_IN_WITNESS_UTXO)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.partial_sigs, PSBT_IN_PARTIAL_SIG)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.sighash_type, PSBT_IN_SIGHASH_TYPE)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.redeem_script, PSBT_IN_REDEEM_SCRIPT)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.witness_script, PSBT_IN_WITNESS_SCRIPT)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.bip32_derivation, PSBT_IN_BIP32_DERIVATION)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.final_script_sig, PSBT_IN_FINAL_SCRIPTSIG)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.final_script_witness, PSBT_IN_FINAL_SCRIPTWITNESS)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.ripemd160_preimages, PSBT_IN_RIPEMD160)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.sha256_preimages, PSBT_IN_SHA256)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.hash160_preimages, PSBT_IN_HASH160)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.hash256_preimages, PSBT_IN_HASH256)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.tap_key_sig, PSBT_IN_TAP_KEY_SIG)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.tap_script_sigs, PSBT_IN_TAP_SCRIPT_SIG)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.tap_scripts, PSBT_IN_TAP_LEAF_SCRIPT)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.tap_key_origins, PSBT_IN_TAP_BIP32_DERIVATION)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.tap_internal_key, PSBT_IN_TAP_INTERNAL_KEY)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.tap_merkle_root, PSBT_IN_TAP_MERKLE_ROOT)
+        }
+        for (key, value) in self.proprietary.iter() {
+            rv.push(raw::Pair { key: key.to_key(), value: value.clone() });
+        }
+
+        for (key, value) in self.unknown.iter() {
+            rv.push(raw::Pair { key: key.clone(), value: value.clone() });
+        }
+
+        rv
+    }
+}
+
+impl_psbtmap_ser_de_serialize!(Input);
+
+fn psbt_insert_hash_pair<H>(
+    map: &mut BTreeMap<H, Vec<u8>>,
+    raw_key: raw::Key,
+    raw_value: Vec<u8>,
+    hash_type: error::PsbtHash,
+) -> Result<(), Error>
+where
+    H: hashes::Hash + Deserialize,
+{
+    if raw_key.key.is_empty() {
+        return Err(psbt::Error::InvalidKey(raw_key));
+    }
+    let key_val: H = Deserialize::deserialize(&raw_key.key)?;
+    match map.entry(key_val) {
+        btree_map::Entry::Vacant(empty_key) => {
+            let val: Vec<u8> = Deserialize::deserialize(&raw_value)?;
+            if <H as hashes::Hash>::hash(&val) != key_val {
+                return Err(psbt::Error::InvalidPreimageHashPair {
+                    preimage: val.into_boxed_slice(),
+                    hash: Box::from(key_val.borrow()),
+                    hash_type,
+                });
+            }
+            empty_key.insert(val);
+            Ok(())
+        }
+        btree_map::Entry::Occupied(_) => Err(psbt::Error::DuplicateKey(raw_key)),
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn psbt_sighash_type_ecdsa() {
+        for ecdsa in &[
+            EcdsaSighashType::All,
+            EcdsaSighashType::None,
+            EcdsaSighashType::Single,
+            EcdsaSighashType::AllPlusAnyoneCanPay,
+            EcdsaSighashType::NonePlusAnyoneCanPay,
+            EcdsaSighashType::SinglePlusAnyoneCanPay,
+        ] {
+            let sighash = PsbtSighashType::from(*ecdsa);
+            let s = format!("{}", sighash);
+            let back = PsbtSighashType::from_str(&s).unwrap();
+            assert_eq!(back, sighash);
+            assert_eq!(back.ecdsa_hash_ty().unwrap(), *ecdsa);
+        }
+    }
+
+    #[test]
+    fn psbt_sighash_type_taproot() {
+        for tap in &[
+            TapSighashType::Default,
+            TapSighashType::All,
+            TapSighashType::None,
+            TapSighashType::Single,
+            TapSighashType::AllPlusAnyoneCanPay,
+            TapSighashType::NonePlusAnyoneCanPay,
+            TapSighashType::SinglePlusAnyoneCanPay,
+        ] {
+            let sighash = PsbtSighashType::from(*tap);
+            let s = format!("{}", sighash);
+            let back = PsbtSighashType::from_str(&s).unwrap();
+            assert_eq!(back, sighash);
+            assert_eq!(back.taproot_hash_ty().unwrap(), *tap);
+        }
+    }
+
+    #[test]
+    fn psbt_sighash_type_notstd() {
+        let nonstd = 0xdddddddd;
+        let sighash = PsbtSighashType { inner: nonstd };
+        let s = format!("{}", sighash);
+        let back = PsbtSighashType::from_str(&s).unwrap();
+
+        assert_eq!(back, sighash);
+        assert_eq!(back.ecdsa_hash_ty(), Err(NonStandardSighashTypeError(nonstd)));
+        assert_eq!(back.taproot_hash_ty(), Err(InvalidSighashTypeError(nonstd)));
+    }
+}
diff --git a/tapyrus/src/psbt/map/mod.rs b/tapyrus/src/psbt/map/mod.rs
new file mode 100644
index 00000000..91d455e0
--- /dev/null
+++ b/tapyrus/src/psbt/map/mod.rs
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use crate::prelude::*;
+use crate::psbt::raw;
+
+mod global;
+mod input;
+mod output;
+
+pub use self::input::{Input, PsbtSighashType};
+pub use self::output::Output;
+use super::serialize::Serialize;
+
+/// A trait that describes a PSBT key-value map.
+pub(super) trait Map {
+    /// Attempt to get all key-value pairs.
+    fn get_pairs(&self) -> Vec<raw::Pair>;
+
+    /// Serialize Psbt binary map data according to BIP-174 specification.
+    ///
+    /// <map> := <keypair>* 0x00
+    ///
+    /// Why is the separator here 0x00 instead of 0xff? The separator here is used to distinguish between each chunk of data.
+    /// A separator of 0x00 would mean that the unserializer can read it as a key length of 0, which would never occur with
+    /// actual keys. It can thus be used as a separator and allow for easier unserializer implementation.
+    fn serialize_map(&self) -> Vec<u8> {
+        let mut buf = Vec::new();
+        for pair in Map::get_pairs(self) {
+            buf.extend(&pair.serialize());
+        }
+        buf.push(0x00_u8);
+        buf
+    }
+}
diff --git a/tapyrus/src/psbt/map/output.rs b/tapyrus/src/psbt/map/output.rs
new file mode 100644
index 00000000..4f032019
--- /dev/null
+++ b/tapyrus/src/psbt/map/output.rs
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use core::convert::TryFrom;
+
+use secp256k1::XOnlyPublicKey;
+use {core, secp256k1};
+
+use crate::bip32::KeySource;
+use crate::blockdata::script::ScriptBuf;
+use crate::prelude::*;
+use crate::psbt::map::Map;
+use crate::psbt::{raw, Error};
+use crate::taproot::{TapLeafHash, TapTree};
+
+/// Type: Redeem ScriptBuf PSBT_OUT_REDEEM_SCRIPT = 0x00
+const PSBT_OUT_REDEEM_SCRIPT: u8 = 0x00;
+/// Type: Witness ScriptBuf PSBT_OUT_WITNESS_SCRIPT = 0x01
+const PSBT_OUT_WITNESS_SCRIPT: u8 = 0x01;
+/// Type: BIP 32 Derivation Path PSBT_OUT_BIP32_DERIVATION = 0x02
+const PSBT_OUT_BIP32_DERIVATION: u8 = 0x02;
+/// 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
+const PSBT_OUT_TAP_TREE: u8 = 0x06;
+/// 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 PSBT_IN_PROPRIETARY = 0xFC
+const PSBT_OUT_PROPRIETARY: u8 = 0xFC;
+
+/// A key-value map for an output of the corresponding index in the unsigned
+/// transaction.
+#[derive(Clone, Default, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Output {
+    /// The redeem script for this output.
+    pub redeem_script: Option<ScriptBuf>,
+    /// The witness script for this output.
+    pub witness_script: Option<ScriptBuf>,
+    /// A map from public keys needed to spend this output to their
+    /// corresponding master key fingerprints and derivation paths.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
+    pub bip32_derivation: BTreeMap<secp256k1::PublicKey, KeySource>,
+    /// The internal pubkey.
+    pub tap_internal_key: Option<XOnlyPublicKey>,
+    /// Taproot Output tree.
+    pub tap_tree: Option<TapTree>,
+    /// Map of tap root x only keys to origin info and leaf hashes contained in it.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
+    pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
+    /// Proprietary key-value pairs for this output.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
+    pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
+    /// Unknown key-value pairs for this output.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
+    pub unknown: BTreeMap<raw::Key, Vec<u8>>,
+}
+
+impl Output {
+    pub(super) fn insert_pair(&mut self, pair: raw::Pair) -> Result<(), Error> {
+        let raw::Pair { key: raw_key, value: raw_value } = pair;
+
+        match raw_key.type_value {
+            PSBT_OUT_REDEEM_SCRIPT => {
+                impl_psbt_insert_pair! {
+                    self.redeem_script <= <raw_key: _>|<raw_value: ScriptBuf>
+                }
+            }
+            PSBT_OUT_WITNESS_SCRIPT => {
+                impl_psbt_insert_pair! {
+                    self.witness_script <= <raw_key: _>|<raw_value: ScriptBuf>
+                }
+            }
+            PSBT_OUT_BIP32_DERIVATION => {
+                impl_psbt_insert_pair! {
+                    self.bip32_derivation <= <raw_key: secp256k1::PublicKey>|<raw_value: KeySource>
+                }
+            }
+            PSBT_OUT_PROPRIETARY => {
+                let key = raw::ProprietaryKey::try_from(raw_key.clone())?;
+                match self.proprietary.entry(key) {
+                    btree_map::Entry::Vacant(empty_key) => {
+                        empty_key.insert(raw_value);
+                    }
+                    btree_map::Entry::Occupied(_) => return Err(Error::DuplicateKey(raw_key)),
+                }
+            }
+            PSBT_OUT_TAP_INTERNAL_KEY => {
+                impl_psbt_insert_pair! {
+                    self.tap_internal_key <= <raw_key: _>|<raw_value: XOnlyPublicKey>
+                }
+            }
+            PSBT_OUT_TAP_TREE => {
+                impl_psbt_insert_pair! {
+                    self.tap_tree <= <raw_key: _>|<raw_value: TapTree>
+                }
+            }
+            PSBT_OUT_TAP_BIP32_DERIVATION => {
+                impl_psbt_insert_pair! {
+                    self.tap_key_origins <= <raw_key: XOnlyPublicKey>|< raw_value: (Vec<TapLeafHash>, KeySource)>
+                }
+            }
+            _ => match self.unknown.entry(raw_key) {
+                btree_map::Entry::Vacant(empty_key) => {
+                    empty_key.insert(raw_value);
+                }
+                btree_map::Entry::Occupied(k) => return Err(Error::DuplicateKey(k.key().clone())),
+            },
+        }
+
+        Ok(())
+    }
+
+    /// Combines this [`Output`] with `other` `Output` (as described by BIP 174).
+    pub fn combine(&mut self, other: Self) {
+        self.bip32_derivation.extend(other.bip32_derivation);
+        self.proprietary.extend(other.proprietary);
+        self.unknown.extend(other.unknown);
+        self.tap_key_origins.extend(other.tap_key_origins);
+
+        combine!(redeem_script, self, other);
+        combine!(witness_script, self, other);
+        combine!(tap_internal_key, self, other);
+        combine!(tap_tree, self, other);
+    }
+}
+
+impl Map for Output {
+    fn get_pairs(&self) -> Vec<raw::Pair> {
+        let mut rv: Vec<raw::Pair> = Default::default();
+
+        impl_psbt_get_pair! {
+            rv.push(self.redeem_script, PSBT_OUT_REDEEM_SCRIPT)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.witness_script, PSBT_OUT_WITNESS_SCRIPT)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.bip32_derivation, PSBT_OUT_BIP32_DERIVATION)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.tap_internal_key, PSBT_OUT_TAP_INTERNAL_KEY)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push(self.tap_tree, PSBT_OUT_TAP_TREE)
+        }
+
+        impl_psbt_get_pair! {
+            rv.push_map(self.tap_key_origins, PSBT_OUT_TAP_BIP32_DERIVATION)
+        }
+
+        for (key, value) in self.proprietary.iter() {
+            rv.push(raw::Pair { key: key.to_key(), value: value.clone() });
+        }
+
+        for (key, value) in self.unknown.iter() {
+            rv.push(raw::Pair { key: key.clone(), value: value.clone() });
+        }
+
+        rv
+    }
+}
+
+impl_psbtmap_ser_de_serialize!(Output);
diff --git a/tapyrus/src/psbt/mod.rs b/tapyrus/src/psbt/mod.rs
new file mode 100644
index 00000000..8cdf6923
--- /dev/null
+++ b/tapyrus/src/psbt/mod.rs
@@ -0,0 +1,2097 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Partially Signed Bitcoin Transactions.
+//!
+//! Implementation of BIP174 Partially Signed Bitcoin Transaction Format as
+//! defined at <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki>
+//! except we define PSBTs containing non-standard sighash types as invalid.
+//!
+
+use core::{cmp, fmt};
+#[cfg(feature = "std")]
+use std::collections::{HashMap, HashSet};
+
+use hashes::Hash;
+use internals::write_err;
+use secp256k1::{Message, Secp256k1, Signing};
+
+use crate::bip32::{self, KeySource, Xpriv, Xpub};
+use crate::blockdata::transaction::{Transaction, TxOut};
+use crate::crypto::ecdsa;
+use crate::crypto::key::{PrivateKey, PublicKey};
+use crate::prelude::*;
+use crate::sighash::{self, EcdsaSighashType, SighashCache};
+use crate::{Amount, FeeRate};
+
+#[macro_use]
+mod macros;
+pub mod raw;
+pub mod serialize;
+
+mod error;
+pub use self::error::Error;
+
+mod map;
+pub use self::map::{Input, Output, PsbtSighashType};
+
+/// A Partially Signed Transaction.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Psbt {
+    /// The unsigned transaction, scriptSigs and witnesses for each input must be empty.
+    pub unsigned_tx: Transaction,
+    /// The version number of this PSBT. If omitted, the version number is 0.
+    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<Xpub, KeySource>,
+    /// Global proprietary key-value pairs.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
+    pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
+    /// Unknown global key-value pairs.
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
+    pub unknown: BTreeMap<raw::Key, Vec<u8>>,
+
+    /// The corresponding key-value map for each input in the unsigned transaction.
+    pub inputs: Vec<Input>,
+    /// The corresponding key-value map for each output in the unsigned transaction.
+    pub outputs: Vec<Output>,
+}
+
+impl Psbt {
+    /// Returns an iterator for the funding UTXOs of the psbt
+    ///
+    /// For each PSBT input that contains UTXO information `Ok` is returned containing that information.
+    /// The order of returned items is same as the order of inputs.
+    ///
+    /// ## Errors
+    ///
+    /// The function returns error when UTXO information is not present or is invalid.
+    ///
+    /// ## Panics
+    ///
+    /// The function panics if the length of transaction inputs is not equal to the length of PSBT inputs.
+    pub fn iter_funding_utxos(&self) -> impl Iterator<Item = Result<&TxOut, Error>> {
+        assert_eq!(self.inputs.len(), self.unsigned_tx.input.len());
+        self.unsigned_tx.input.iter().zip(&self.inputs).map(|(tx_input, psbt_input)| {
+            match (&psbt_input.witness_utxo, &psbt_input.non_witness_utxo) {
+                (Some(witness_utxo), _) => Ok(witness_utxo),
+                (None, Some(non_witness_utxo)) => {
+                    let vout = tx_input.previous_output.vout as usize;
+                    non_witness_utxo.output.get(vout).ok_or(Error::PsbtUtxoOutOfbounds)
+                }
+                (None, None) => Err(Error::MissingUtxo),
+            }
+        })
+    }
+
+    /// Checks that unsigned transaction does not have scriptSig's or witness data.
+    fn unsigned_tx_checks(&self) -> Result<(), Error> {
+        for txin in &self.unsigned_tx.input {
+            if !txin.script_sig.is_empty() {
+                return Err(Error::UnsignedTxHasScriptSigs);
+            }
+
+            if !txin.witness.is_empty() {
+                return Err(Error::UnsignedTxHasScriptWitnesses);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Creates a PSBT from an unsigned transaction.
+    ///
+    /// # Errors
+    ///
+    /// If transactions is not unsigned.
+    pub fn from_unsigned_tx(tx: Transaction) -> Result<Self, Error> {
+        let psbt = Psbt {
+            inputs: vec![Default::default(); tx.input.len()],
+            outputs: vec![Default::default(); tx.output.len()],
+
+            unsigned_tx: tx,
+            xpub: Default::default(),
+            version: 0,
+            proprietary: Default::default(),
+            unknown: Default::default(),
+        };
+        psbt.unsigned_tx_checks()?;
+        Ok(psbt)
+    }
+
+    /// The default `max_fee_rate` value used for extracting transactions with [`extract_tx`]
+    ///
+    /// As of 2023, even the biggest overpayers during the highest fee markets only paid around
+    /// 1000 taps/vByte. 25k taps/vByte is obviously a mistake at this point.
+    ///
+    /// [`extract_tx`]: Psbt::extract_tx
+    pub const DEFAULT_MAX_FEE_RATE: FeeRate = FeeRate::from_tap_per_vb_unchecked(25_000);
+
+    /// An alias for [`extract_tx_fee_rate_limit`].
+    ///
+    /// [`extract_tx_fee_rate_limit`]: Psbt::extract_tx_fee_rate_limit
+    pub fn extract_tx(self) -> Result<Transaction, ExtractTxError> {
+        self.internal_extract_tx_with_fee_rate_limit(Self::DEFAULT_MAX_FEE_RATE)
+    }
+
+    /// Extracts the [`Transaction`] from a [`Psbt`] by filling in the available signature information.
+    ///
+    /// ## Errors
+    ///
+    /// [`ExtractTxError`] variants will contain either the [`Psbt`] itself or the [`Transaction`]
+    /// that was extracted. These can be extracted from the Errors in order to recover.
+    /// See the error documentation for info on the variants. In general, it covers large fees.
+    pub fn extract_tx_fee_rate_limit(self) -> Result<Transaction, ExtractTxError> {
+        self.internal_extract_tx_with_fee_rate_limit(Self::DEFAULT_MAX_FEE_RATE)
+    }
+
+    /// Extracts the [`Transaction`] from a [`Psbt`] by filling in the available signature information.
+    ///
+    /// ## Errors
+    ///
+    /// See [`extract_tx`].
+    ///
+    /// [`extract_tx`]: Psbt::extract_tx
+    pub fn extract_tx_with_fee_rate_limit(
+        self,
+        max_fee_rate: FeeRate,
+    ) -> Result<Transaction, ExtractTxError> {
+        self.internal_extract_tx_with_fee_rate_limit(max_fee_rate)
+    }
+
+    /// Perform [`extract_tx_fee_rate_limit`] without the fee rate check.
+    ///
+    /// This can result in a transaction with absurdly high fees. Use with caution.
+    ///
+    /// [`extract_tx_fee_rate_limit`]: Psbt::extract_tx_fee_rate_limit
+    pub fn extract_tx_unchecked_fee_rate(self) -> Transaction { self.internal_extract_tx() }
+
+    #[inline]
+    fn internal_extract_tx(self) -> Transaction {
+        let mut tx: Transaction = self.unsigned_tx;
+
+        for (vin, psbtin) in tx.input.iter_mut().zip(self.inputs.into_iter()) {
+            vin.script_sig = psbtin.final_script_sig.unwrap_or_default();
+            vin.witness = psbtin.final_script_witness.unwrap_or_default();
+        }
+
+        tx
+    }
+
+    #[inline]
+    fn internal_extract_tx_with_fee_rate_limit(
+        self,
+        max_fee_rate: FeeRate,
+    ) -> Result<Transaction, ExtractTxError> {
+        let fee = match self.fee() {
+            Ok(fee) => fee,
+            Err(Error::MissingUtxo) =>
+                return Err(ExtractTxError::MissingInputValue { tx: self.internal_extract_tx() }),
+            Err(Error::NegativeFee) => return Err(ExtractTxError::SendingTooMuch { psbt: self }),
+            Err(Error::FeeOverflow) =>
+                return Err(ExtractTxError::AbsurdFeeRate {
+                    fee_rate: FeeRate::MAX,
+                    tx: self.internal_extract_tx(),
+                }),
+            _ => unreachable!(),
+        };
+
+        // Note: Move prevents usage of &self from now on.
+        let tx = self.internal_extract_tx();
+
+        // Now that the extracted Transaction is made, decide how to return it.
+        let fee_rate =
+            FeeRate::from_tap_per_kwu(fee.to_tap().saturating_mul(1000) / tx.weight().to_wu());
+        // Prefer to return an AbsurdFeeRate error when both trigger.
+        if fee_rate > max_fee_rate {
+            return Err(ExtractTxError::AbsurdFeeRate { fee_rate, tx });
+        }
+
+        Ok(tx)
+    }
+
+    /// Combines this [`Psbt`] with `other` PSBT as described by BIP 174.
+    ///
+    /// In accordance with BIP 174 this function is commutative i.e., `A.combine(B) == B.combine(A)`
+    pub fn combine(&mut self, other: Self) -> Result<(), Error> {
+        if self.unsigned_tx != other.unsigned_tx {
+            return Err(Error::UnexpectedUnsignedTx {
+                expected: Box::new(self.unsigned_tx.clone()),
+                actual: Box::new(other.unsigned_tx),
+            });
+        }
+
+        // BIP 174: The Combiner must remove any duplicate key-value pairs, in accordance with
+        //          the specification. It can pick arbitrarily when conflicts occur.
+
+        // Keeping the highest version
+        self.version = cmp::max(self.version, other.version);
+
+        // Merging xpubs
+        for (xpub, (fingerprint1, derivation1)) in other.xpub {
+            match self.xpub.entry(xpub) {
+                btree_map::Entry::Vacant(entry) => {
+                    entry.insert((fingerprint1, derivation1));
+                }
+                btree_map::Entry::Occupied(mut entry) => {
+                    // Here in case of the conflict we select the version with algorithm:
+                    // 1) if everything is equal we do nothing
+                    // 2) report an error if
+                    //    - derivation paths are equal and fingerprints are not
+                    //    - derivation paths are of the same length, but not equal
+                    //    - derivation paths has different length, but the shorter one
+                    //      is not the strict suffix of the longer one
+                    // 3) choose longest derivation otherwise
+
+                    let (fingerprint2, derivation2) = entry.get().clone();
+
+                    if (derivation1 == derivation2 && fingerprint1 == fingerprint2)
+                        || (derivation1.len() < derivation2.len()
+                            && derivation1[..]
+                                == derivation2[derivation2.len() - derivation1.len()..])
+                    {
+                        continue;
+                    } else if derivation2[..]
+                        == derivation1[derivation1.len() - derivation2.len()..]
+                    {
+                        entry.insert((fingerprint1, derivation1));
+                        continue;
+                    }
+                    return Err(Error::CombineInconsistentKeySources(Box::new(xpub)));
+                }
+            }
+        }
+
+        self.proprietary.extend(other.proprietary);
+        self.unknown.extend(other.unknown);
+
+        for (self_input, other_input) in self.inputs.iter_mut().zip(other.inputs.into_iter()) {
+            self_input.combine(other_input);
+        }
+
+        for (self_output, other_output) in self.outputs.iter_mut().zip(other.outputs.into_iter()) {
+            self_output.combine(other_output);
+        }
+
+        Ok(())
+    }
+
+    /// Attempts to create _all_ the required signatures for this PSBT using `k`.
+    ///
+    /// **NOTE**: Taproot inputs are, as yet, not supported by this function. We currently only
+    /// attempt to sign ECDSA inputs.
+    ///
+    /// If you just want to sign an input with one specific key consider using `sighash_ecdsa`. This
+    /// function does not support scripts that contain `OP_CODESEPARATOR`.
+    ///
+    /// # Returns
+    ///
+    /// Either Ok(SigningKeys) or Err((SigningKeys, SigningErrors)), where
+    /// - SigningKeys: A map of input index -> pubkey associated with secret key used to sign.
+    /// - SigningKeys: A map of input index -> the error encountered while attempting to sign.
+    ///
+    /// If an error is returned some signatures may already have been added to the PSBT. Since
+    /// `partial_sigs` is a [`BTreeMap`] it is safe to retry, previous sigs will be overwritten.
+    pub fn sign<C, K>(
+        &mut self,
+        k: &K,
+        secp: &Secp256k1<C>,
+    ) -> Result<SigningKeys, (SigningKeys, SigningErrors)>
+    where
+        C: Signing,
+        K: GetKey,
+    {
+        let tx = self.unsigned_tx.clone(); // clone because we need to mutably borrow when signing.
+        let mut cache = SighashCache::new(&tx);
+
+        let mut used = BTreeMap::new();
+        let mut errors = BTreeMap::new();
+
+        for i in 0..self.inputs.len() {
+            if let Ok(SigningAlgorithm::Ecdsa) = self.signing_algorithm(i) {
+                match self.bip32_sign_ecdsa(k, i, &mut cache, secp) {
+                    Ok(v) => {
+                        used.insert(i, v);
+                    }
+                    Err(e) => {
+                        errors.insert(i, e);
+                    }
+                }
+            };
+        }
+        if errors.is_empty() {
+            Ok(used)
+        } else {
+            Err((used, errors))
+        }
+    }
+
+    /// Attempts to create all signatures required by this PSBT's `bip32_derivation` field, adding
+    /// them to `partial_sigs`.
+    ///
+    /// # Returns
+    ///
+    /// - Ok: A list of the public keys used in signing.
+    /// - Err: Error encountered trying to calculate the sighash AND we had the signing key.
+    fn bip32_sign_ecdsa<C, K, T>(
+        &mut self,
+        k: &K,
+        input_index: usize,
+        cache: &mut SighashCache<T>,
+        secp: &Secp256k1<C>,
+    ) -> Result<Vec<PublicKey>, SignError>
+    where
+        C: Signing,
+        T: Borrow<Transaction>,
+        K: GetKey,
+    {
+        let msg_sighash_ty_res = self.sighash_ecdsa(input_index, cache);
+
+        let input = &mut self.inputs[input_index]; // Index checked in call to `sighash_ecdsa`.
+
+        let mut used = vec![]; // List of pubkeys used to sign the input.
+
+        for (pk, key_source) in input.bip32_derivation.iter() {
+            let sk = if let Ok(Some(sk)) = k.get_key(KeyRequest::Bip32(key_source.clone()), secp) {
+                sk
+            } else if let Ok(Some(sk)) = k.get_key(KeyRequest::Pubkey(PublicKey::new(*pk)), secp) {
+                sk
+            } else {
+                continue;
+            };
+
+            // Only return the error if we have a secret key to sign this input.
+            let (msg, sighash_ty) = match msg_sighash_ty_res {
+                Err(e) => return Err(e),
+                Ok((msg, sighash_ty)) => (msg, sighash_ty),
+            };
+
+            let sig =
+                ecdsa::Signature { sig: secp.sign_ecdsa(&msg, &sk.inner), hash_ty: sighash_ty };
+
+            let pk = sk.public_key(secp);
+
+            input.partial_sigs.insert(pk, sig);
+            used.push(pk);
+        }
+
+        Ok(used)
+    }
+
+    /// Returns the sighash message to sign an ECDSA input along with the sighash type.
+    ///
+    /// Uses the [`EcdsaSighashType`] from this input if one is specified. If no sighash type is
+    /// specified uses [`EcdsaSighashType::All`]. This function does not support scripts that
+    /// contain `OP_CODESEPARATOR`.
+    pub fn sighash_ecdsa<T: Borrow<Transaction>>(
+        &self,
+        input_index: usize,
+        cache: &mut SighashCache<T>,
+    ) -> Result<(Message, EcdsaSighashType), SignError> {
+        use OutputType::*;
+
+        if self.signing_algorithm(input_index)? != SigningAlgorithm::Ecdsa {
+            return Err(SignError::WrongSigningAlgorithm);
+        }
+
+        let input = self.checked_input(input_index)?;
+        let utxo = self.spend_utxo(input_index)?;
+        let spk = &utxo.script_pubkey; // scriptPubkey for input spend utxo.
+
+        let hash_ty = input.ecdsa_hash_ty().map_err(|_| SignError::InvalidSighashType)?; // Only support standard sighash types.
+
+        match self.output_type(input_index)? {
+            Bare => {
+                let sighash = cache.legacy_signature_hash(input_index, spk, hash_ty.to_u32())?;
+                Ok((Message::from_digest(sighash.to_byte_array()), hash_ty))
+            }
+            Sh => {
+                let script_code =
+                    input.redeem_script.as_ref().ok_or(SignError::MissingRedeemScript)?;
+                let sighash =
+                    cache.legacy_signature_hash(input_index, script_code, hash_ty.to_u32())?;
+                Ok((Message::from_digest(sighash.to_byte_array()), hash_ty))
+            }
+            Wpkh => {
+                let sighash = cache.p2wpkh_signature_hash(input_index, spk, utxo.value, hash_ty)?;
+                Ok((Message::from_digest(sighash.to_byte_array()), hash_ty))
+            }
+            ShWpkh => {
+                let redeem_script = input.redeem_script.as_ref().expect("checked above");
+                let sighash =
+                    cache.p2wpkh_signature_hash(input_index, redeem_script, utxo.value, hash_ty)?;
+                Ok((Message::from_digest(sighash.to_byte_array()), hash_ty))
+            }
+            Wsh | ShWsh => {
+                let witness_script =
+                    input.witness_script.as_ref().ok_or(SignError::MissingWitnessScript)?;
+                let sighash =
+                    cache.p2wsh_signature_hash(input_index, witness_script, utxo.value, hash_ty)?;
+                Ok((Message::from_digest(sighash.to_byte_array()), hash_ty))
+            }
+            Tr => {
+                // This PSBT signing API is WIP, taproot to come shortly.
+                Err(SignError::Unsupported)
+            }
+        }
+    }
+
+    /// Returns the spending utxo for this PSBT's input at `input_index`.
+    pub fn spend_utxo(&self, input_index: usize) -> Result<&TxOut, SignError> {
+        let input = self.checked_input(input_index)?;
+        let utxo = if let Some(witness_utxo) = &input.witness_utxo {
+            witness_utxo
+        } else if let Some(non_witness_utxo) = &input.non_witness_utxo {
+            let vout = self.unsigned_tx.input[input_index].previous_output.vout;
+            &non_witness_utxo.output[vout as usize]
+        } else {
+            return Err(SignError::MissingSpendUtxo);
+        };
+        Ok(utxo)
+    }
+
+    /// Gets the input at `input_index` after checking that it is a valid index.
+    fn checked_input(&self, input_index: usize) -> Result<&Input, IndexOutOfBoundsError> {
+        self.check_index_is_within_bounds(input_index)?;
+        Ok(&self.inputs[input_index])
+    }
+
+    /// Checks `input_index` is within bounds for the PSBT `inputs` array and
+    /// for the PSBT `unsigned_tx` `input` array.
+    fn check_index_is_within_bounds(
+        &self,
+        input_index: usize,
+    ) -> Result<(), IndexOutOfBoundsError> {
+        if input_index >= self.inputs.len() {
+            return Err(IndexOutOfBoundsError::Inputs {
+                index: input_index,
+                length: self.inputs.len(),
+            });
+        }
+
+        if input_index >= self.unsigned_tx.input.len() {
+            return Err(IndexOutOfBoundsError::TxInput {
+                index: input_index,
+                length: self.unsigned_tx.input.len(),
+            });
+        }
+
+        Ok(())
+    }
+
+    /// Returns the algorithm used to sign this PSBT's input at `input_index`.
+    fn signing_algorithm(&self, input_index: usize) -> Result<SigningAlgorithm, SignError> {
+        let output_type = self.output_type(input_index)?;
+        Ok(output_type.signing_algorithm())
+    }
+
+    /// Returns the [`OutputType`] of the spend utxo for this PBST's input at `input_index`.
+    fn output_type(&self, input_index: usize) -> Result<OutputType, SignError> {
+        let input = self.checked_input(input_index)?;
+        let utxo = self.spend_utxo(input_index)?;
+        let spk = utxo.script_pubkey.clone();
+
+        // Anything that is not segwit and is not p2sh is `Bare`.
+        if !(spk.is_witness_program() || spk.is_p2sh()) {
+            return Ok(OutputType::Bare);
+        }
+
+        if spk.is_p2wpkh() {
+            return Ok(OutputType::Wpkh);
+        }
+
+        if spk.is_p2wsh() {
+            return Ok(OutputType::Wsh);
+        }
+
+        if spk.is_p2sh() {
+            if input.redeem_script.as_ref().map(|s| s.is_p2wpkh()).unwrap_or(false) {
+                return Ok(OutputType::ShWpkh);
+            }
+            if input.redeem_script.as_ref().map(|x| x.is_p2wsh()).unwrap_or(false) {
+                return Ok(OutputType::ShWsh);
+            }
+            return Ok(OutputType::Sh);
+        }
+
+        if spk.is_p2tr() {
+            return Ok(OutputType::Tr);
+        }
+
+        // Something is wrong with the input scriptPubkey or we do not know how to sign
+        // because there has been a new softfork that we do not yet support.
+        Err(SignError::UnknownOutputType)
+    }
+
+    /// Calculates transaction fee.
+    ///
+    /// 'Fee' being the amount that will be paid for mining a transaction with the current inputs
+    /// and outputs i.e., the difference in value of the total inputs and the total outputs.
+    ///
+    /// ## Errors
+    ///
+    /// - [`Error::MissingUtxo`] when UTXO information for any input is not present or is invalid.
+    /// - [`Error::NegativeFee`] if calculated value is negative.
+    /// - [`Error::FeeOverflow`] if an integer overflow occurs.
+    pub fn fee(&self) -> Result<Amount, Error> {
+        let mut inputs: u64 = 0;
+        for utxo in self.iter_funding_utxos() {
+            inputs = inputs.checked_add(utxo?.value.to_tap()).ok_or(Error::FeeOverflow)?;
+        }
+        let mut outputs: u64 = 0;
+        for out in &self.unsigned_tx.output {
+            outputs = outputs.checked_add(out.value.to_tap()).ok_or(Error::FeeOverflow)?;
+        }
+        inputs.checked_sub(outputs).map(Amount::from_tap).ok_or(Error::NegativeFee)
+    }
+}
+
+/// Data required to call [`GetKey`] to get the private key to sign an input.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum KeyRequest {
+    /// Request a private key using the associated public key.
+    Pubkey(PublicKey),
+    /// Request a private key using BIP-32 fingerprint and derivation path.
+    Bip32(KeySource),
+}
+
+/// Trait to get a private key from a key request, key is then used to sign an input.
+pub trait GetKey {
+    /// An error occurred while getting the key.
+    type Error: core::fmt::Debug;
+
+    /// Attempts to get the private key for `key_request`.
+    ///
+    /// # Returns
+    /// - `Some(key)` if the key is found.
+    /// - `None` if the key was not found but no error was encountered.
+    /// - `Err` if an error was encountered while looking for the key.
+    fn get_key<C: Signing>(
+        &self,
+        key_request: KeyRequest,
+        secp: &Secp256k1<C>,
+    ) -> Result<Option<PrivateKey>, Self::Error>;
+}
+
+impl GetKey for Xpriv {
+    type Error = GetKeyError;
+
+    fn get_key<C: Signing>(
+        &self,
+        key_request: KeyRequest,
+        secp: &Secp256k1<C>,
+    ) -> Result<Option<PrivateKey>, Self::Error> {
+        match key_request {
+            KeyRequest::Pubkey(_) => Err(GetKeyError::NotSupported),
+            KeyRequest::Bip32((fingerprint, path)) => {
+                let key = if self.fingerprint(secp) == fingerprint {
+                    let k = self.derive_priv(secp, &path)?;
+                    Some(k.to_priv())
+                } else {
+                    None
+                };
+                Ok(key)
+            }
+        }
+    }
+}
+
+/// Map of input index -> pubkey associated with secret key used to create signature for that input.
+pub type SigningKeys = BTreeMap<usize, Vec<PublicKey>>;
+
+/// Map of input index -> the error encountered while attempting to sign that input.
+pub type SigningErrors = BTreeMap<usize, SignError>;
+
+#[rustfmt::skip]
+macro_rules! impl_get_key_for_set {
+    ($set:ident) => {
+
+impl GetKey for $set<Xpriv> {
+    type Error = GetKeyError;
+
+    fn get_key<C: Signing>(
+        &self,
+        key_request: KeyRequest,
+        secp: &Secp256k1<C>
+    ) -> Result<Option<PrivateKey>, Self::Error> {
+        match key_request {
+            KeyRequest::Pubkey(_) => Err(GetKeyError::NotSupported),
+            KeyRequest::Bip32((fingerprint, path)) => {
+                for xpriv in self.iter() {
+                    if xpriv.parent_fingerprint == fingerprint {
+                        let k = xpriv.derive_priv(secp, &path)?;
+                        return Ok(Some(k.to_priv()));
+                    }
+                }
+                Ok(None)
+            }
+        }
+    }
+}}}
+impl_get_key_for_set!(BTreeSet);
+#[cfg(feature = "std")]
+impl_get_key_for_set!(HashSet);
+
+#[rustfmt::skip]
+macro_rules! impl_get_key_for_map {
+    ($map:ident) => {
+
+impl GetKey for $map<PublicKey, PrivateKey> {
+    type Error = GetKeyError;
+
+    fn get_key<C: Signing>(
+        &self,
+        key_request: KeyRequest,
+        _: &Secp256k1<C>,
+    ) -> Result<Option<PrivateKey>, Self::Error> {
+        match key_request {
+            KeyRequest::Pubkey(pk) => Ok(self.get(&pk).cloned()),
+            KeyRequest::Bip32(_) => Err(GetKeyError::NotSupported),
+        }
+    }
+}}}
+impl_get_key_for_map!(BTreeMap);
+#[cfg(feature = "std")]
+impl_get_key_for_map!(HashMap);
+
+/// Errors when getting a key.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum GetKeyError {
+    /// A bip32 error.
+    Bip32(bip32::Error),
+    /// The GetKey operation is not supported for this key request.
+    NotSupported,
+}
+
+impl fmt::Display for GetKeyError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use GetKeyError::*;
+
+        match *self {
+            Bip32(ref e) => write_err!(f, "a bip23 error"; e),
+            NotSupported =>
+                f.write_str("the GetKey operation is not supported for this key request"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for GetKeyError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use GetKeyError::*;
+
+        match *self {
+            NotSupported => None,
+            Bip32(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<bip32::Error> for GetKeyError {
+    fn from(e: bip32::Error) -> Self { GetKeyError::Bip32(e) }
+}
+
+/// The various output types supported by the Bitcoin network.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
+pub enum OutputType {
+    /// An output of type: pay-to-pubkey or pay-to-pubkey-hash.
+    Bare,
+    /// A pay-to-witness-pubkey-hash output (P2WPKH).
+    Wpkh,
+    /// A pay-to-witness-script-hash output (P2WSH).
+    Wsh,
+    /// A nested segwit output, pay-to-witness-pubkey-hash nested in a pay-to-script-hash.
+    ShWpkh,
+    /// A nested segwit output, pay-to-witness-script-hash nested in a pay-to-script-hash.
+    ShWsh,
+    /// A pay-to-script-hash output excluding wrapped segwit (P2SH).
+    Sh,
+    /// A taproot output (P2TR).
+    Tr,
+}
+
+impl OutputType {
+    /// The signing algorithm used to sign this output type.
+    pub fn signing_algorithm(&self) -> SigningAlgorithm {
+        use OutputType::*;
+
+        match self {
+            Bare | Wpkh | Wsh | ShWpkh | ShWsh | Sh => SigningAlgorithm::Ecdsa,
+            Tr => SigningAlgorithm::Schnorr,
+        }
+    }
+}
+
+/// Signing algorithms supported by the Bitcoin network.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum SigningAlgorithm {
+    /// The Elliptic Curve Digital Signature Algorithm (see [wikipedia]).
+    ///
+    /// [wikipedia]: https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm
+    Ecdsa,
+    /// The Schnorr signature algorithm (see [wikipedia]).
+    ///
+    /// [wikipedia]: https://en.wikipedia.org/wiki/Schnorr_signature
+    Schnorr,
+}
+
+/// Errors encountered while calculating the sighash message.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum SignError {
+    /// Input index out of bounds.
+    IndexOutOfBounds(IndexOutOfBoundsError),
+    /// Invalid Sighash type.
+    InvalidSighashType,
+    /// Missing input utxo.
+    MissingInputUtxo,
+    /// Missing Redeem script.
+    MissingRedeemScript,
+    /// Missing spending utxo.
+    MissingSpendUtxo,
+    /// Missing witness script.
+    MissingWitnessScript,
+    /// Signing algorithm and key type does not match.
+    MismatchedAlgoKey,
+    /// Attempted to ECDSA sign an non-ECDSA input.
+    NotEcdsa,
+    /// The `scriptPubkey` is not a P2WPKH script.
+    NotWpkh,
+    /// Sighash computation error.
+    SighashComputation(sighash::Error),
+    /// Unable to determine the output type.
+    UnknownOutputType,
+    /// Unable to find key.
+    KeyNotFound,
+    /// Attempt to sign an input with the wrong signing algorithm.
+    WrongSigningAlgorithm,
+    /// Signing request currently unsupported.
+    Unsupported,
+}
+
+impl fmt::Display for SignError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use SignError::*;
+
+        match *self {
+            IndexOutOfBounds(ref e) => write_err!(f, "index out of bounds"; e),
+            InvalidSighashType => write!(f, "invalid sighash type"),
+            MissingInputUtxo => write!(f, "missing input utxo in PBST"),
+            MissingRedeemScript => write!(f, "missing redeem script"),
+            MissingSpendUtxo => write!(f, "missing spend utxo in PSBT"),
+            MissingWitnessScript => write!(f, "missing witness script"),
+            MismatchedAlgoKey => write!(f, "signing algorithm and key type does not match"),
+            NotEcdsa => write!(f, "attempted to ECDSA sign an non-ECDSA input"),
+            NotWpkh => write!(f, "the scriptPubkey is not a P2WPKH script"),
+            SighashComputation(ref e) => write!(f, "sighash: {}", e),
+            UnknownOutputType => write!(f, "unable to determine the output type"),
+            KeyNotFound => write!(f, "unable to find key"),
+            WrongSigningAlgorithm =>
+                write!(f, "attempt to sign an input with the wrong signing algorithm"),
+            Unsupported => write!(f, "signing request currently unsupported"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SignError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use SignError::*;
+
+        match *self {
+            SighashComputation(ref e) => Some(e),
+            IndexOutOfBounds(ref e) => Some(e),
+            InvalidSighashType
+            | MissingInputUtxo
+            | MissingRedeemScript
+            | MissingSpendUtxo
+            | MissingWitnessScript
+            | MismatchedAlgoKey
+            | NotEcdsa
+            | NotWpkh
+            | UnknownOutputType
+            | KeyNotFound
+            | WrongSigningAlgorithm
+            | Unsupported => None,
+        }
+    }
+}
+
+impl From<sighash::Error> for SignError {
+    fn from(e: sighash::Error) -> Self { SignError::SighashComputation(e) }
+}
+
+impl From<IndexOutOfBoundsError> for SignError {
+    fn from(e: IndexOutOfBoundsError) -> Self { SignError::IndexOutOfBounds(e) }
+}
+
+/// This error is returned when extracting a [`Transaction`] from a [`Psbt`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ExtractTxError {
+    /// The [`FeeRate`] is too high
+    AbsurdFeeRate {
+        /// The [`FeeRate`]
+        fee_rate: FeeRate,
+        /// The extracted [`Transaction`] (use this to ignore the error)
+        tx: Transaction,
+    },
+    /// One or more of the inputs lacks value information (witness_utxo or non_witness_utxo)
+    MissingInputValue {
+        /// The extracted [`Transaction`] (use this to ignore the error)
+        tx: Transaction,
+    },
+    /// Input value is less than Output Value, and the [`Transaction`] would be invalid.
+    SendingTooMuch {
+        /// The original [`Psbt`] is returned untouched.
+        psbt: Psbt,
+    },
+}
+
+impl fmt::Display for ExtractTxError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use ExtractTxError::*;
+
+        match *self {
+            AbsurdFeeRate { fee_rate, .. } =>
+                write!(f, "An absurdly high fee rate of {}", fee_rate),
+            MissingInputValue { .. } => write!(
+                f,
+                "One of the inputs lacked value information (witness_utxo or non_witness_utxo)"
+            ),
+            SendingTooMuch { .. } => write!(
+                f,
+                "Transaction would be invalid due to output value being greater than input value."
+            ),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ExtractTxError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use ExtractTxError::*;
+
+        match *self {
+            AbsurdFeeRate { .. } | MissingInputValue { .. } | SendingTooMuch { .. } => None,
+        }
+    }
+}
+
+/// Input index out of bounds (actual index, maximum index allowed).
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum IndexOutOfBoundsError {
+    /// The index is out of bounds for the `psbt.inputs` vector.
+    Inputs {
+        /// Attempted index access.
+        index: usize,
+        /// Length of the PBST inputs vector.
+        length: usize,
+    },
+    /// The index is out of bounds for the `psbt.unsigned_tx.input` vector.
+    TxInput {
+        /// Attempted index access.
+        index: usize,
+        /// Length of the PBST's unsigned transaction input vector.
+        length: usize,
+    },
+}
+
+impl fmt::Display for IndexOutOfBoundsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use IndexOutOfBoundsError::*;
+
+        match *self {
+            Inputs { ref index, ref length } => write!(
+                f,
+                "index {} is out-of-bounds for PSBT inputs vector length {}",
+                index, length
+            ),
+            TxInput { ref index, ref length } => write!(
+                f,
+                "index {} is out-of-bounds for PSBT unsigned tx input vector length {}",
+                index, length
+            ),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for IndexOutOfBoundsError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use IndexOutOfBoundsError::*;
+
+        match *self {
+            Inputs { .. } | TxInput { .. } => None,
+        }
+    }
+}
+
+#[cfg(feature = "base64")]
+mod display_from_str {
+    use core::fmt::{self, Display, Formatter};
+    use core::str::FromStr;
+
+    use base64::display::Base64Display;
+    use base64::prelude::{Engine as _, BASE64_STANDARD};
+    use internals::write_err;
+
+    use super::{Error, Psbt};
+
+    /// Error encountered during PSBT decoding from Base64 string.
+    #[derive(Debug)]
+    #[non_exhaustive]
+    pub enum PsbtParseError {
+        /// Error in internal PSBT data structure.
+        PsbtEncoding(Error),
+        /// Error in PSBT Base64 encoding.
+        Base64Encoding(::base64::DecodeError),
+    }
+
+    impl Display for PsbtParseError {
+        fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+            use self::PsbtParseError::*;
+
+            match *self {
+                PsbtEncoding(ref e) => write_err!(f, "error in internal PSBT data structure"; e),
+                Base64Encoding(ref e) => write_err!(f, "error in PSBT base64 encoding"; e),
+            }
+        }
+    }
+
+    #[cfg(feature = "std")]
+    impl std::error::Error for PsbtParseError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            use self::PsbtParseError::*;
+
+            match self {
+                PsbtEncoding(e) => Some(e),
+                Base64Encoding(e) => Some(e),
+            }
+        }
+    }
+
+    impl Display for Psbt {
+        fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+            write!(f, "{}", Base64Display::new(&self.serialize(), &BASE64_STANDARD))
+        }
+    }
+
+    impl FromStr for Psbt {
+        type Err = PsbtParseError;
+
+        fn from_str(s: &str) -> Result<Self, Self::Err> {
+            let data = BASE64_STANDARD.decode(s).map_err(PsbtParseError::Base64Encoding)?;
+            Psbt::deserialize(&data).map_err(PsbtParseError::PsbtEncoding)
+        }
+    }
+}
+#[cfg(feature = "base64")]
+pub use self::display_from_str::PsbtParseError;
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+
+    use hashes::{hash160, ripemd160, sha256, Hash};
+    use hex::{test_hex_unwrap as hex, FromHex};
+    use secp256k1::{self, Secp256k1};
+    #[cfg(feature = "rand-std")]
+    use secp256k1::{All, SecretKey};
+
+    use super::*;
+    use crate::bip32::{ChildNumber, KeySource, Xpriv, Xpub};
+    use crate::blockdata::locktime::absolute;
+    use crate::blockdata::script::ScriptBuf;
+    use crate::blockdata::transaction::{self, OutPoint, Sequence, Transaction, TxIn, TxOut};
+    use crate::blockdata::witness::Witness;
+    use crate::network::Network::Prod;
+    use crate::psbt::map::{Input, Output};
+    use crate::psbt::raw;
+    use crate::psbt::serialize::{Deserialize, Serialize};
+
+    #[track_caller]
+    pub fn hex_psbt(s: &str) -> Result<Psbt, crate::psbt::error::Error> {
+        let r: Result<Vec<u8>, hex::HexToBytesError> = Vec::from_hex(s);
+        match r {
+            Err(_e) => panic!("unable to parse hex string {}", s),
+            Ok(v) => Psbt::deserialize(&v),
+        }
+    }
+
+    #[track_caller]
+    fn psbt_with_values(input: u64, output: u64) -> Psbt {
+        Psbt {
+            unsigned_tx: Transaction {
+                version: transaction::Version::TWO,
+                lock_time: absolute::LockTime::ZERO,
+                input: vec![TxIn {
+                    previous_output: OutPoint {
+                        txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126"
+                            .parse()
+                            .unwrap(),
+                        vout: 0,
+                    },
+                    script_sig: ScriptBuf::new(),
+                    sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
+                    witness: Witness::default(),
+                }],
+                output: vec![TxOut {
+                    value: Amount::from_tap(output),
+                    script_pubkey: ScriptBuf::from_hex(
+                        "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
+                    )
+                    .unwrap(),
+                }],
+            },
+            xpub: Default::default(),
+            version: 0,
+            proprietary: BTreeMap::new(),
+            unknown: BTreeMap::new(),
+
+            inputs: vec![Input {
+                witness_utxo: Some(TxOut {
+                    value: Amount::from_tap(input),
+                    script_pubkey: ScriptBuf::from_hex(
+                        "a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587",
+                    )
+                    .unwrap(),
+                }),
+                ..Default::default()
+            }],
+            outputs: vec![],
+        }
+    }
+
+    #[test]
+    fn trivial_psbt() {
+        let psbt = Psbt {
+            unsigned_tx: Transaction {
+                version: transaction::Version::TWO,
+                lock_time: absolute::LockTime::ZERO,
+                input: vec![],
+                output: vec![],
+            },
+            xpub: Default::default(),
+            version: 0,
+            proprietary: BTreeMap::new(),
+            unknown: BTreeMap::new(),
+
+            inputs: vec![],
+            outputs: vec![],
+        };
+        assert_eq!(psbt.serialize_hex(), "70736274ff01000a0200000000000000000000");
+    }
+
+    #[test]
+    fn psbt_uncompressed_key() {
+        let psbt: Psbt = hex_psbt("70736274ff01003302000000010000000000000000000000000000000000000000000000000000000000000000ffffffff00ffffffff000000000000420204bb0d5d0cca36e7b9c80f63bc04c1240babb83bcd2803ef7ac8b6e2af594291daec281e856c98d210c5ab14dfd5828761f8ee7d5f45ca21ad3e4c4b41b747a3a047304402204f67e2afb76142d44fae58a2495d33a3419daa26cd0db8d04f3452b63289ac0f022010762a9fb67e94cc5cad9026f6dc99ff7f070f4278d30fbc7d0c869dd38c7fe70100").unwrap();
+        assert!(psbt.inputs[0].partial_sigs.len() == 1);
+        let pk = psbt.inputs[0].partial_sigs.iter().next().unwrap().0;
+        assert!(!pk.compressed);
+    }
+
+    #[test]
+    fn psbt_high_fee_checks() {
+        let psbt = psbt_with_values(5_000_000_000_000, 1000);
+        assert_eq!(
+            psbt.clone().extract_tx().map_err(|e| match e {
+                ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
+                _ => panic!(""),
+            }),
+            Err(FeeRate::from_tap_per_kwu(15060240960843))
+        );
+        assert_eq!(
+            psbt.clone().extract_tx_fee_rate_limit().map_err(|e| match e {
+                ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
+                _ => panic!(""),
+            }),
+            Err(FeeRate::from_tap_per_kwu(15060240960843))
+        );
+        assert_eq!(
+            psbt.clone()
+                .extract_tx_with_fee_rate_limit(FeeRate::from_tap_per_kwu(15060240960842))
+                .map_err(|e| match e {
+                    ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
+                    _ => panic!(""),
+                }),
+            Err(FeeRate::from_tap_per_kwu(15060240960843))
+        );
+        assert!(psbt
+            .extract_tx_with_fee_rate_limit(FeeRate::from_tap_per_kwu(15060240960843))
+            .is_ok());
+
+        // Testing that extract_tx will error at 25k tap/vbyte (6250000 tap/kwu)
+        assert_eq!(
+            psbt_with_values(2076001, 1000).extract_tx().map_err(|e| match e {
+                ExtractTxError::AbsurdFeeRate { fee_rate, .. } => fee_rate,
+                _ => panic!(""),
+            }),
+            Err(FeeRate::from_tap_per_kwu(6250003)) // 6250000 is 25k tap/vbyte
+        );
+
+        // Lowering the input tapyruses by 1 lowers the tap/kwu by 3
+        // Putting it exactly at 25k tap/vbyte
+        assert!(psbt_with_values(2076000, 1000).extract_tx().is_ok());
+    }
+
+    #[test]
+    fn serialize_then_deserialize_output() {
+        let secp = &Secp256k1::new();
+        let seed = hex!("000102030405060708090a0b0c0d0e0f");
+
+        let mut hd_keypaths: BTreeMap<secp256k1::PublicKey, KeySource> = Default::default();
+
+        let mut sk: Xpriv = Xpriv::new_master(Prod, &seed).unwrap();
+
+        let fprint = sk.fingerprint(secp);
+
+        let dpath: Vec<ChildNumber> = vec![
+            ChildNumber::from_normal_idx(0).unwrap(),
+            ChildNumber::from_normal_idx(1).unwrap(),
+            ChildNumber::from_normal_idx(2).unwrap(),
+            ChildNumber::from_normal_idx(4).unwrap(),
+            ChildNumber::from_normal_idx(42).unwrap(),
+            ChildNumber::from_hardened_idx(69).unwrap(),
+            ChildNumber::from_normal_idx(420).unwrap(),
+            ChildNumber::from_normal_idx(31337).unwrap(),
+        ];
+
+        sk = sk.derive_priv(secp, &dpath).unwrap();
+
+        let pk = Xpub::from_priv(secp, &sk);
+
+        hd_keypaths.insert(pk.public_key, (fprint, dpath.into()));
+
+        let expected: Output = Output {
+            redeem_script: Some(
+                ScriptBuf::from_hex("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
+            ),
+            witness_script: Some(
+                ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
+            ),
+            bip32_derivation: hd_keypaths,
+            ..Default::default()
+        };
+
+        let actual = Output::deserialize(&expected.serialize()).unwrap();
+
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn serialize_then_deserialize_global() {
+        let expected = Psbt {
+            unsigned_tx: Transaction {
+                version: transaction::Version::TWO,
+                lock_time: absolute::LockTime::from_consensus(1257139),
+                input: vec![TxIn {
+                    previous_output: OutPoint {
+                        txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126"
+                            .parse()
+                            .unwrap(),
+                        vout: 0,
+                    },
+                    script_sig: ScriptBuf::new(),
+                    sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
+                    witness: Witness::default(),
+                }],
+                output: vec![
+                    TxOut {
+                        value: Amount::from_tap(99_999_699),
+                        script_pubkey: ScriptBuf::from_hex(
+                            "76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac",
+                        )
+                        .unwrap(),
+                    },
+                    TxOut {
+                        value: Amount::from_tap(100_000_000),
+                        script_pubkey: ScriptBuf::from_hex(
+                            "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
+                        )
+                        .unwrap(),
+                    },
+                ],
+            },
+            xpub: Default::default(),
+            version: 0,
+            proprietary: Default::default(),
+            unknown: Default::default(),
+            inputs: vec![Input::default()],
+            outputs: vec![Output::default(), Output::default()],
+        };
+
+        let actual: Psbt = Psbt::deserialize(&expected.serialize()).unwrap();
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn serialize_then_deserialize_psbtkvpair() {
+        let expected = raw::Pair {
+            key: raw::Key { type_value: 0u8, key: vec![42u8, 69u8] },
+            value: vec![69u8, 42u8, 4u8],
+        };
+
+        let actual = raw::Pair::deserialize(&expected.serialize()).unwrap();
+
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn deserialize_and_serialize_psbt_with_two_partial_sigs() {
+        let hex = "70736274ff0100890200000001207ae985d787dfe6143d5c58fad79cc7105e0e799fcf033b7f2ba17e62d7b3200000000000ffffffff02563d03000000000022002019899534b9a011043c0dd57c3ff9a381c3522c5f27c6a42319085b56ca543a1d6adc020000000000220020618b47a07ebecca4e156edb1b9ea7c24bdee0139fc049237965ffdaf56d5ee73000000000001012b801a0600000000002200201148e93e9315e37dbed2121be5239257af35adc03ffdfc5d914b083afa44dab82202025fe7371376d53cf8a2783917c28bf30bd690b0a4d4a207690093ca2b920ee076473044022007e06b362e89912abd4661f47945430739b006a85d1b2a16c01dc1a4bd07acab022061576d7aa834988b7ab94ef21d8eebd996ea59ea20529a19b15f0c9cebe3d8ac01220202b3fe93530020a8294f0e527e33fbdff184f047eb6b5a1558a352f62c29972f8a473044022002787f926d6817504431ee281183b8119b6845bfaa6befae45e13b6d430c9d2f02202859f149a6cd26ae2f03a107e7f33c7d91730dade305fe077bae677b5d44952a01010547522102b3fe93530020a8294f0e527e33fbdff184f047eb6b5a1558a352f62c29972f8a21025fe7371376d53cf8a2783917c28bf30bd690b0a4d4a207690093ca2b920ee07652ae0001014752210283ef76537f2d58ae3aa3a4bd8ae41c3f230ccadffb1a0bd3ca504d871cff05e7210353d79cc0cb1396f4ce278d005f16d948e02a6aec9ed1109f13747ecb1507b37b52ae00010147522102b3937241777b6665e0d694e52f9c1b188433641df852da6fc42187b5d8a368a321034cdd474f01cc5aa7ff834ad8bcc882a87e854affc775486bc2a9f62e8f49bd7852ae00";
+        let psbt: Psbt = hex_psbt(hex).unwrap();
+        assert_eq!(hex, psbt.serialize_hex());
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_serde_psbt() {
+        //! Create a full PSBT value with various fields filled and make sure it can be JSONized.
+        use hashes::sha256d;
+
+        use crate::psbt::map::Input;
+
+        // create some values to use in the PSBT
+        let tx = Transaction {
+            version: transaction::Version::ONE,
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![TxIn {
+                previous_output: OutPoint {
+                    txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389"
+                        .parse()
+                        .unwrap(),
+                    vout: 1,
+                },
+                script_sig: ScriptBuf::from_hex("160014be18d152a9b012039daf3da7de4f53349eecb985")
+                    .unwrap(),
+                sequence: Sequence::MAX,
+                witness: Witness::from_slice(&[hex!(
+                    "03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105"
+                )]),
+            }],
+            output: vec![TxOut {
+                value: Amount::from_tap(190_303_501_938),
+                script_pubkey: ScriptBuf::from_hex(
+                    "a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587",
+                )
+                .unwrap(),
+            }],
+        };
+        let unknown: BTreeMap<raw::Key, Vec<u8>> =
+            vec![(raw::Key { type_value: 1, key: vec![0, 1] }, vec![3, 4, 5])]
+                .into_iter()
+                .collect();
+        let key_source = ("deadbeef".parse().unwrap(), "m/0'/1".parse().unwrap());
+        let keypaths: BTreeMap<secp256k1::PublicKey, KeySource> = vec![(
+            "0339880dc92394b7355e3d0439fa283c31de7590812ea011c4245c0674a685e883".parse().unwrap(),
+            key_source.clone(),
+        )]
+        .into_iter()
+        .collect();
+
+        let proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>> = vec![(
+            raw::ProprietaryKey {
+                prefix: "prefx".as_bytes().to_vec(),
+                subtype: 42,
+                key: "test_key".as_bytes().to_vec(),
+            },
+            vec![5, 6, 7],
+        )]
+        .into_iter()
+        .collect();
+
+        let psbt = Psbt {
+            version: 0,
+            xpub: {
+                let xpub: Xpub =
+                    "xpub661MyMwAqRbcGoRVtwfvzZsq2VBJR1LAHfQstHUoxqDorV89vRoMxUZ27kLrraAj6MPi\
+                    QfrDb27gigC1VS1dBXi5jGpxmMeBXEkKkcXUTg4".parse().unwrap();
+                vec![(xpub, key_source)].into_iter().collect()
+            },
+            unsigned_tx: {
+                let mut unsigned = tx.clone();
+                unsigned.input[0].script_sig = ScriptBuf::new();
+                unsigned.input[0].witness = Witness::default();
+                unsigned
+            },
+            proprietary: proprietary.clone(),
+            unknown: unknown.clone(),
+
+            inputs: vec![
+                Input {
+                    non_witness_utxo: Some(tx),
+                    witness_utxo: Some(TxOut {
+                        value: Amount::from_tap(190_303_501_938),
+                        script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
+                    }),
+                    sighash_type: Some("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY".parse::<PsbtSighashType>().unwrap()),
+                    redeem_script: Some(vec![0x51].into()),
+                    witness_script: None,
+                    partial_sigs: vec![(
+                        "0339880dc92394b7355e3d0439fa283c31de7590812ea011c4245c0674a685e883".parse().unwrap(),
+                        "304402204f67e2afb76142d44fae58a2495d33a3419daa26cd0db8d04f3452b63289ac0f022010762a9fb67e94cc5cad9026f6dc99ff7f070f4278d30fbc7d0c869dd38c7fe701".parse().unwrap(),
+                    )].into_iter().collect(),
+                    bip32_derivation: keypaths.clone(),
+                    final_script_witness: Some(Witness::from_slice(&[vec![1, 3], vec![5]])),
+                    ripemd160_preimages: vec![(ripemd160::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
+                    sha256_preimages: vec![(sha256::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
+                    hash160_preimages: vec![(hash160::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
+                    hash256_preimages: vec![(sha256d::Hash::hash(&[]), vec![1, 2])].into_iter().collect(),
+                    proprietary: proprietary.clone(),
+                    unknown: unknown.clone(),
+                    ..Default::default()
+                }
+            ],
+            outputs: vec![
+                Output {
+                    bip32_derivation: keypaths,
+                    proprietary,
+                    unknown,
+                    ..Default::default()
+                }
+            ],
+        };
+        let encoded = serde_json::to_string(&psbt).unwrap();
+        let decoded: Psbt = serde_json::from_str(&encoded).unwrap();
+        assert_eq!(psbt, decoded);
+    }
+
+    mod bip_vectors {
+        use std::collections::BTreeMap;
+        #[cfg(feature = "base64")]
+        use std::str::FromStr;
+
+        use super::*;
+        use crate::blockdata::locktime::absolute;
+        use crate::blockdata::script::ScriptBuf;
+        use crate::blockdata::transaction::{OutPoint, Sequence, Transaction, TxIn, TxOut};
+        use crate::blockdata::witness::Witness;
+        use crate::psbt::map::{Input, Map, Output};
+        use crate::psbt::{raw, Psbt};
+        use crate::sighash::EcdsaSighashType;
+
+        #[test]
+        #[should_panic(expected = "InvalidMagic")]
+        fn invalid_vector_1() {
+            hex_psbt("0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300").unwrap();
+        }
+
+        #[cfg(feature = "base64")]
+        #[test]
+        #[should_panic(expected = "InvalidMagic")]
+        fn invalid_vector_1_base64() {
+            Psbt::from_str("AgAAAAEmgXE3Ht/yhek3re6ks3t4AAwFZsuzrWRkFxPKQhcb9gAAAABqRzBEAiBwsiRRI+a/R01gxbUMBD1MaRpdJDXwmjSnZiqdwlF5CgIgATKcqdrPKAvfMHQOwDkEIkIsgctFg5RXrrdvwS7dlbMBIQJlfRGNM1e44PTCzUbbezn22cONmnCry5st5dyNv+TOMf7///8C09/1BQAAAAAZdqkU0MWZA8W6woaHYOkP1SGkZlqnZSCIrADh9QUAAAAAF6kUNUXm4zuDLEcFDyTT7rk8nAOUi8eHsy4TAA==").unwrap();
+        }
+
+        #[test]
+        #[should_panic(expected = "ConsensusEncoding")]
+        fn invalid_vector_2() {
+            hex_psbt("70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000000")
+                .unwrap();
+        }
+
+        #[cfg(feature = "base64")]
+        #[test]
+        #[should_panic(expected = "ConsensusEncoding")]
+        fn invalid_vector_2_base64() {
+            Psbt::from_str("cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAA==")
+                .unwrap();
+        }
+
+        #[test]
+        #[should_panic(expected = "UnsignedTxHasScriptSigs")]
+        fn invalid_vector_3() {
+            hex_psbt("70736274ff0100fd0a010200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be4000000006a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa88292feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000").unwrap();
+        }
+
+        #[cfg(feature = "base64")]
+        #[test]
+        #[should_panic(expected = "UnsignedTxHasScriptSigs")]
+        fn invalid_vector_3_base64() {
+            Psbt::from_str("cHNidP8BAP0KAQIAAAACqwlJoIxa98SbghL0F+LxWrP1wz3PFTghqBOfh3pbe+QAAAAAakcwRAIgR1lmF5fAGwNrJZKJSGhiGDR9iYZLcZ4ff89X0eURZYcCIFMJ6r9Wqk2Ikf/REf3xM286KdqGbX+EhtdVRs7tr5MZASEDXNxh/HupccC1AaZGoqg7ECy0OIEhfKaC3Ibi1z+ogpL+////qwlJoIxa98SbghL0F+LxWrP1wz3PFTghqBOfh3pbe+QBAAAAAP7///8CYDvqCwAAAAAZdqkUdopAu9dAy+gdmI5x3ipNXHE5ax2IrI4kAAAAAAAAGXapFG9GILVT+glechue4O/p+gOcykWXiKwAAAAAAAABASAA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHhwEEFgAUhdE1N/LiZUBaNNuvqePdoB+4IwgAAAA=").unwrap();
+        }
+
+        #[test]
+        #[should_panic(expected = "MustHaveUnsignedTx")]
+        fn invalid_vector_4() {
+            hex_psbt("70736274ff000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000000").unwrap();
+        }
+
+        #[cfg(feature = "base64")]
+        #[test]
+        #[should_panic(expected = "MustHaveUnsignedTx")]
+        fn invalid_vector_4_base64() {
+            Psbt::from_str("cHNidP8AAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAA==").unwrap();
+        }
+
+        #[test]
+        #[ignore] // TODO: Re-enable after modified PSBT for tapyrus
+        #[should_panic(expected = "DuplicateKey(Key { type_value: 0, key: [] })")]
+        fn invalid_vector_5() {
+            hex_psbt("70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000001003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a010000000000000000").unwrap();
+        }
+
+        #[cfg(feature = "base64")]
+        #[test]
+        #[ignore] // TODO: Re-enable after modified PSBT for tapyrus
+        #[should_panic(expected = "DuplicateKey(Key { type_value: 0, key: [] })")]
+        fn invalid_vector_5_base64() {
+            Psbt::from_str("cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAQA/AgAAAAH//////////////////////////////////////////wAAAAAA/////wEAAAAAAAAAAANqAQAAAAAAAAAA").unwrap();
+        }
+
+        #[test]
+        #[ignore] // TODO: Re-enable after modified PSBT for tapyrus
+        fn valid_vector_1() {
+            let unserialized = Psbt {
+                unsigned_tx: Transaction {
+                    version: transaction::Version::TWO,
+                    lock_time: absolute::LockTime::from_consensus(1257139),
+                    input: vec![
+                        TxIn {
+                            previous_output: OutPoint {
+                                txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126".parse().unwrap(),
+                                vout: 0,
+                            },
+                            script_sig: ScriptBuf::new(),
+                            sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
+                            witness: Witness::default(),
+                        }
+                    ],
+                    output: vec![
+                        TxOut {
+                            value: Amount::from_tap(99_999_699),
+                            script_pubkey: ScriptBuf::from_hex("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
+                        },
+                        TxOut {
+                            value: Amount::from_tap(100_000_000),
+                            script_pubkey: ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
+                        },
+                    ],
+                },
+                xpub: Default::default(),
+                version: 0,
+                proprietary: BTreeMap::new(),
+                unknown: BTreeMap::new(),
+
+                inputs: vec![
+                    Input {
+                        non_witness_utxo: Some(Transaction {
+                            version: transaction::Version::ONE,
+                            lock_time: absolute::LockTime::ZERO,
+                            input: vec![
+                                TxIn {
+                                    previous_output: OutPoint {
+                                        txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389".parse().unwrap(),
+                                        vout: 1,
+                                    },
+                                    script_sig: ScriptBuf::from_hex("160014be18d152a9b012039daf3da7de4f53349eecb985").unwrap(),
+                                    sequence: Sequence::MAX,
+                                    witness: Witness::from_slice(&[
+                                        hex!("304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c01"),
+                                        hex!("03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105"),
+                                    ]),
+                                },
+                                TxIn {
+                                    previous_output: OutPoint {
+                                        txid: "b490486aec3ae671012dddb2bb08466bef37720a533a894814ff1da743aaf886".parse().unwrap(),
+                                        vout: 1,
+                                    },
+                                    script_sig: ScriptBuf::from_hex("160014fe3e9ef1a745e974d902c4355943abcb34bd5353").unwrap(),
+                                    sequence: Sequence::MAX,
+                                    witness: Witness::from_slice(&[
+                                        hex!("3045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01"),
+                                        hex!("0223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab3"),
+                                    ]),
+                                }
+                            ],
+                            output: vec![
+                                TxOut {
+                                    value: Amount::from_tap(200_000_000),
+                                    script_pubkey: ScriptBuf::from_hex("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
+                                },
+                                TxOut {
+                                    value: Amount::from_tap(190_303_501_938),
+                                    script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
+                                },
+                            ],
+                        }),
+                        ..Default::default()
+                    },
+                ],
+                outputs: vec![
+                    Output {
+                        ..Default::default()
+                    },
+                    Output {
+                        ..Default::default()
+                    },
+                ],
+            };
+
+            let base16str = "70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab300000000000000";
+
+            assert_eq!(unserialized.serialize_hex(), base16str);
+            assert_eq!(unserialized, hex_psbt(base16str).unwrap());
+
+            #[cfg(feature = "base64")]
+            {
+                let base64str = "cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAAAA";
+                assert_eq!(Psbt::from_str(base64str).unwrap(), unserialized);
+                assert_eq!(base64str, unserialized.to_string());
+                assert_eq!(Psbt::from_str(base64str).unwrap(), hex_psbt(base16str).unwrap());
+            }
+        }
+
+        #[test]
+        fn valid_vector_2() {
+            let psbt: Psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac000000000001076a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa882920001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000").unwrap();
+
+            assert_eq!(psbt.inputs.len(), 2);
+            assert_eq!(psbt.outputs.len(), 2);
+
+            assert!(&psbt.inputs[0].final_script_sig.is_some());
+
+            let redeem_script = psbt.inputs[1].redeem_script.as_ref().unwrap();
+            let expected_out =
+                ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap();
+
+            assert!(redeem_script.is_p2wpkh());
+            assert_eq!(
+                redeem_script.to_p2sh(),
+                psbt.inputs[1].witness_utxo.as_ref().unwrap().script_pubkey
+            );
+            assert_eq!(redeem_script.to_p2sh(), expected_out);
+
+            for output in psbt.outputs {
+                assert_eq!(output.get_pairs().len(), 0)
+            }
+        }
+
+        #[test]
+        #[ignore] // TODO: Re-enable after modified PSBT for tapyrus
+        fn valid_vector_3() {
+            let psbt: Psbt = hex_psbt("70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000001030401000000000000").unwrap();
+
+            assert_eq!(psbt.inputs.len(), 1);
+            assert_eq!(psbt.outputs.len(), 2);
+
+            let tx_input = &psbt.unsigned_tx.input[0];
+            let psbt_non_witness_utxo = psbt.inputs[0].non_witness_utxo.as_ref().unwrap();
+
+            assert_eq!(tx_input.previous_output.txid, psbt_non_witness_utxo.malfix_txid());
+            assert!(psbt_non_witness_utxo.output[tx_input.previous_output.vout as usize]
+                .script_pubkey
+                .is_p2pkh());
+            assert_eq!(
+                psbt.inputs[0].sighash_type.as_ref().unwrap().ecdsa_hash_ty().unwrap(),
+                EcdsaSighashType::All
+            );
+        }
+
+        #[test]
+        fn valid_vector_4() {
+            let psbt: Psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000100df0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e13000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb8230800220202ead596687ca806043edc3de116cdf29d5e9257c196cd055cf698c8d02bf24e9910b4a6ba670000008000000080020000800022020394f62be9df19952c5587768aeb7698061ad2c4a25c894f47d8c162b4d7213d0510b4a6ba6700000080010000800200008000").unwrap();
+
+            assert_eq!(psbt.inputs.len(), 2);
+            assert_eq!(psbt.outputs.len(), 2);
+
+            assert!(&psbt.inputs[0].final_script_sig.is_none());
+            assert!(&psbt.inputs[1].final_script_sig.is_none());
+
+            let redeem_script = psbt.inputs[1].redeem_script.as_ref().unwrap();
+            let expected_out =
+                ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap();
+
+            assert!(redeem_script.is_p2wpkh());
+            assert_eq!(
+                redeem_script.to_p2sh(),
+                psbt.inputs[1].witness_utxo.as_ref().unwrap().script_pubkey
+            );
+            assert_eq!(redeem_script.to_p2sh(), expected_out);
+
+            for output in psbt.outputs {
+                assert!(!output.get_pairs().is_empty())
+            }
+        }
+
+        #[test]
+        fn valid_vector_5() {
+            let psbt: Psbt = hex_psbt("70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000").unwrap();
+
+            assert_eq!(psbt.inputs.len(), 1);
+            assert_eq!(psbt.outputs.len(), 1);
+
+            assert!(&psbt.inputs[0].final_script_sig.is_none());
+
+            let redeem_script = psbt.inputs[0].redeem_script.as_ref().unwrap();
+            let expected_out =
+                ScriptBuf::from_hex("a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87").unwrap();
+
+            assert!(redeem_script.is_p2wsh());
+            assert_eq!(
+                redeem_script.to_p2sh(),
+                psbt.inputs[0].witness_utxo.as_ref().unwrap().script_pubkey
+            );
+
+            assert_eq!(redeem_script.to_p2sh(), expected_out);
+        }
+
+        #[test]
+        fn valid_vector_6() {
+            let psbt: Psbt = hex_psbt("70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a010000000000000a0f0102030405060708090f0102030405060708090a0b0c0d0e0f0000").unwrap();
+
+            assert_eq!(psbt.inputs.len(), 1);
+            assert_eq!(psbt.outputs.len(), 1);
+
+            let tx = &psbt.unsigned_tx;
+            assert_eq!(
+                tx.txid(),
+                "75c5c9665a570569ad77dd1279e6fd4628a093c4dcbf8d41532614044c14c115".parse().unwrap(),
+            );
+
+            let mut unknown: BTreeMap<raw::Key, Vec<u8>> = BTreeMap::new();
+            let key: raw::Key = raw::Key { type_value: 0x0fu8, key: hex!("010203040506070809") };
+            let value: Vec<u8> = hex!("0102030405060708090a0b0c0d0e0f");
+
+            unknown.insert(key, value);
+
+            assert_eq!(psbt.inputs[0].unknown, unknown)
+        }
+    }
+
+    mod bip_371_vectors {
+        use super::*;
+
+        #[test]
+        fn invalid_vectors() {
+            let err = hex_psbt("70736274ff010071020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff02787c01000000000016001483a7e34bd99ff03a4962ef8a1a101bb295461ece606b042a010000001600147ac369df1b20e033d6116623957b0ac49f3c52e8000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a075701172102fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa232000000").unwrap_err();
+            assert_eq!(err.to_string(), "invalid xonly public key");
+            let err = hex_psbt("70736274ff010071020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff02787c01000000000016001483a7e34bd99ff03a4962ef8a1a101bb295461ece606b042a010000001600147ac369df1b20e033d6116623957b0ac49f3c52e8000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a0757011342173bb3d36c074afb716fec6307a069a2e450b995f3c82785945ab8df0e24260dcd703b0cbf34de399184a9481ac2b3586db6601f026a77f7e4938481bc34751701aa000000").unwrap_err();
+            #[cfg(feature = "std")]
+            assert_eq!(err.to_string(), "invalid taproot signature");
+            #[cfg(not(feature = "std"))]
+            assert_eq!(
+                err.to_string(),
+                "invalid taproot signature: invalid taproot signature size: 66"
+            );
+            let err = hex_psbt("70736274ff010071020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff02787c01000000000016001483a7e34bd99ff03a4962ef8a1a101bb295461ece606b042a010000001600147ac369df1b20e033d6116623957b0ac49f3c52e8000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a0757221602fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa2321900772b2da75600008001000080000000800100000000000000000000").unwrap_err();
+            assert_eq!(err.to_string(), "invalid xonly public key");
+            let err = hex_psbt("70736274ff01007d020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff02887b0100000000001600142382871c7e8421a00093f754d91281e675874b9f606b042a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a0757000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a0757000001052102fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa23200").unwrap_err();
+            assert_eq!(err.to_string(), "invalid xonly public key");
+            let err = hex_psbt("70736274ff01007d020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff02887b0100000000001600142382871c7e8421a00093f754d91281e675874b9f606b042a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a0757000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a07570000220702fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa2321900772b2da7560000800100008000000080010000000000000000").unwrap_err();
+            assert_eq!(err.to_string(), "invalid xonly public key");
+            let err = hex_psbt("70736274ff01005e02000000019bd48765230bf9a72e662001f972556e54f0c6f97feb56bcb5600d817f6995260100000000ffffffff0148e6052a01000000225120030da4fce4f7db28c2cb2951631e003713856597fe963882cb500e68112cca63000000000001012b00f2052a01000000225120c2247efbfd92ac47f6f40b8d42d169175a19fa9fa10e4a25d7f35eb4dd85b6924214022cb13ac68248de806aa6a3659cf3c03eb6821d09c8114a4e868febde865bb6d2cd970e15f53fc0c82f950fd560ffa919b76172be017368a89913af074f400b094089756aa3739ccc689ec0fcf3a360be32cc0b59b16e93a1e8bb4605726b2ca7a3ff706c4176649632b2cc68e1f912b8a578e3719ce7710885c7a966f49bcd43cb0000").unwrap_err();
+            #[cfg(feature = "std")]
+            assert_eq!(err.to_string(), "invalid hash when parsing slice");
+            #[cfg(not(feature = "std"))]
+            assert_eq!(
+                err.to_string(),
+                "invalid hash when parsing slice: invalid slice length 33 (expected 32)"
+            );
+            let err = hex_psbt("70736274ff01005e02000000019bd48765230bf9a72e662001f972556e54f0c6f97feb56bcb5600d817f6995260100000000ffffffff0148e6052a01000000225120030da4fce4f7db28c2cb2951631e003713856597fe963882cb500e68112cca63000000000001012b00f2052a01000000225120c2247efbfd92ac47f6f40b8d42d169175a19fa9fa10e4a25d7f35eb4dd85b69241142cb13ac68248de806aa6a3659cf3c03eb6821d09c8114a4e868febde865bb6d2cd970e15f53fc0c82f950fd560ffa919b76172be017368a89913af074f400b094289756aa3739ccc689ec0fcf3a360be32cc0b59b16e93a1e8bb4605726b2ca7a3ff706c4176649632b2cc68e1f912b8a578e3719ce7710885c7a966f49bcd43cb01010000").unwrap_err();
+            #[cfg(feature = "std")]
+            assert_eq!(err.to_string(), "invalid taproot signature");
+            #[cfg(not(feature = "std"))]
+            assert_eq!(
+                err.to_string(),
+                "invalid taproot signature: invalid taproot signature size: 66"
+            );
+            let err = hex_psbt("70736274ff01005e02000000019bd48765230bf9a72e662001f972556e54f0c6f97feb56bcb5600d817f6995260100000000ffffffff0148e6052a01000000225120030da4fce4f7db28c2cb2951631e003713856597fe963882cb500e68112cca63000000000001012b00f2052a01000000225120c2247efbfd92ac47f6f40b8d42d169175a19fa9fa10e4a25d7f35eb4dd85b69241142cb13ac68248de806aa6a3659cf3c03eb6821d09c8114a4e868febde865bb6d2cd970e15f53fc0c82f950fd560ffa919b76172be017368a89913af074f400b093989756aa3739ccc689ec0fcf3a360be32cc0b59b16e93a1e8bb4605726b2ca7a3ff706c4176649632b2cc68e1f912b8a578e3719ce7710885c7a966f49bcd43cb0000").unwrap_err();
+            #[cfg(feature = "std")]
+            assert_eq!(err.to_string(), "invalid taproot signature");
+            #[cfg(not(feature = "std"))]
+            assert_eq!(
+                err.to_string(),
+                "invalid taproot signature: invalid taproot signature size: 57"
+            );
+            let err = hex_psbt("70736274ff01005e02000000019bd48765230bf9a72e662001f972556e54f0c6f97feb56bcb5600d817f6995260100000000ffffffff0148e6052a01000000225120030da4fce4f7db28c2cb2951631e003713856597fe963882cb500e68112cca63000000000001012b00f2052a01000000225120c2247efbfd92ac47f6f40b8d42d169175a19fa9fa10e4a25d7f35eb4dd85b6926315c150929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac06f7d62059e9497a1a4a267569d9876da60101aff38e3529b9b939ce7f91ae970115f2e490af7cc45c4f78511f36057ce5c5a5c56325a29fb44dfc203f356e1f80023202cb13ac68248de806aa6a3659cf3c03eb6821d09c8114a4e868febde865bb6d2acc00000").unwrap_err();
+            assert_eq!(err.to_string(), "invalid control block");
+            let err = hex_psbt("70736274ff01005e02000000019bd48765230bf9a72e662001f972556e54f0c6f97feb56bcb5600d817f6995260100000000ffffffff0148e6052a01000000225120030da4fce4f7db28c2cb2951631e003713856597fe963882cb500e68112cca63000000000001012b00f2052a01000000225120c2247efbfd92ac47f6f40b8d42d169175a19fa9fa10e4a25d7f35eb4dd85b6926115c150929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac06f7d62059e9497a1a4a267569d9876da60101aff38e3529b9b939ce7f91ae970115f2e490af7cc45c4f78511f36057ce5c5a5c56325a29fb44dfc203f356e123202cb13ac68248de806aa6a3659cf3c03eb6821d09c8114a4e868febde865bb6d2acc00000").unwrap_err();
+            assert_eq!(err.to_string(), "invalid control block");
+        }
+
+        fn rtt_psbt(psbt: Psbt) {
+            let enc = Psbt::serialize(&psbt);
+            let psbt2 = Psbt::deserialize(&enc).unwrap();
+            assert_eq!(psbt, psbt2);
+        }
+
+        #[test]
+        fn valid_psbt_vectors() {
+            let psbt = hex_psbt("70736274ff010052020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff0148e6052a01000000160014768e1eeb4cf420866033f80aceff0f9720744969000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a07572116fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa2321900772b2da75600008001000080000000800100000000000000011720fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa232002202036b772a6db74d8753c98a827958de6c78ab3312109f37d3e0304484242ece73d818772b2da7540000800100008000000080000000000000000000").unwrap();
+            let internal_key = psbt.inputs[0].tap_internal_key.unwrap();
+            assert!(psbt.inputs[0].tap_key_origins.contains_key(&internal_key));
+            rtt_psbt(psbt);
+
+            // vector 2
+            let psbt = hex_psbt("70736274ff010052020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff0148e6052a01000000160014768e1eeb4cf420866033f80aceff0f9720744969000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a0757011340bb53ec917bad9d906af1ba87181c48b86ace5aae2b53605a725ca74625631476fc6f5baedaf4f2ee0f477f36f58f3970d5b8273b7e497b97af2e3f125c97af342116fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa2321900772b2da75600008001000080000000800100000000000000011720fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa232002202036b772a6db74d8753c98a827958de6c78ab3312109f37d3e0304484242ece73d818772b2da7540000800100008000000080000000000000000000").unwrap();
+            let internal_key = psbt.inputs[0].tap_internal_key.unwrap();
+            assert!(psbt.inputs[0].tap_key_origins.contains_key(&internal_key));
+            assert!(psbt.inputs[0].tap_key_sig.is_some());
+            rtt_psbt(psbt);
+
+            // vector 3
+            let psbt = hex_psbt("70736274ff01005e020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff0148e6052a0100000022512083698e458c6664e1595d75da2597de1e22ee97d798e706c4c0a4b5a9823cd743000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a07572116fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa2321900772b2da75600008001000080000000800100000000000000011720fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa232000105201124da7aec92ccd06c954562647f437b138b95721a84be2bf2276bbddab3e67121071124da7aec92ccd06c954562647f437b138b95721a84be2bf2276bbddab3e6711900772b2da7560000800100008000000080000000000500000000").unwrap();
+            let internal_key = psbt.outputs[0].tap_internal_key.unwrap();
+            assert!(psbt.outputs[0].tap_key_origins.contains_key(&internal_key));
+            rtt_psbt(psbt);
+
+            // vector 4
+            let psbt = hex_psbt("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").unwrap();
+            assert!(psbt.inputs[0].tap_internal_key.is_some());
+            assert!(psbt.inputs[0].tap_merkle_root.is_some());
+            assert!(!psbt.inputs[0].tap_key_origins.is_empty());
+            assert!(!psbt.inputs[0].tap_scripts.is_empty());
+            rtt_psbt(psbt);
+
+            // vector 5
+            let psbt = hex_psbt("70736274ff01005e020000000127744ababf3027fe0d6cf23a96eee2efb188ef52301954585883e69b6624b2420000000000ffffffff0148e6052a010000002251200a8cbdc86de1ce1c0f9caeb22d6df7ced3683fe423e05d1e402a879341d6f6f5000000000001012b00f2052a010000002251205a2c2cf5b52cf31f83ad2e8da63ff03183ecd8f609c7510ae8a48e03910a07572116fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa2321900772b2da75600008001000080000000800100000000000000011720fe349064c98d6e2a853fa3c9b12bd8b304a19c195c60efa7ee2393046d3fa2320001052050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac001066f02c02220736e572900fe1252589a2143c8f3c79f71a0412d2353af755e9701c782694a02ac02c02220631c5f3b5832b8fbdebfb19704ceeb323c21f40f7a24f43d68ef0cc26b125969ac01c0222044faa49a0338de488c8dfffecdfb6f329f380bd566ef20c8df6d813eab1c4273ac210744faa49a0338de488c8dfffecdfb6f329f380bd566ef20c8df6d813eab1c42733901f06b798b92a10ed9a9d0bbfd3af173a53b1617da3a4159ca008216cd856b2e0e772b2da75600008001000080010000800000000003000000210750929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac005007c461e5d2107631c5f3b5832b8fbdebfb19704ceeb323c21f40f7a24f43d68ef0cc26b125969390118ace409889785e0ea70ceebb8e1ca892a7a78eaede0f2e296cf435961a8f4ca772b2da756000080010000800200008000000000030000002107736e572900fe1252589a2143c8f3c79f71a0412d2353af755e9701c782694a02390129a5b4915090162d759afd3fe0f93fa3326056d0b4088cb933cae7826cb8d82c772b2da7560000800100008003000080000000000300000000").unwrap();
+            assert!(psbt.outputs[0].tap_internal_key.is_some());
+            assert!(!psbt.outputs[0].tap_key_origins.is_empty());
+            assert!(psbt.outputs[0].tap_tree.is_some());
+            rtt_psbt(psbt);
+
+            // vector 6
+            let psbt = hex_psbt("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").unwrap();
+            assert!(psbt.inputs[0].tap_internal_key.is_some());
+            assert!(psbt.inputs[0].tap_merkle_root.is_some());
+            assert!(!psbt.inputs[0].tap_scripts.is_empty());
+            assert!(!psbt.inputs[0].tap_script_sigs.is_empty());
+            assert!(!psbt.inputs[0].tap_key_origins.is_empty());
+            rtt_psbt(psbt);
+        }
+    }
+
+    #[test]
+    fn serialize_and_deserialize_preimage_psbt() {
+        // create a sha preimage map
+        let mut sha256_preimages = BTreeMap::new();
+        sha256_preimages.insert(sha256::Hash::hash(&[1u8, 2u8]), vec![1u8, 2u8]);
+        sha256_preimages.insert(sha256::Hash::hash(&[1u8]), vec![1u8]);
+
+        // same for hash160
+        let mut hash160_preimages = BTreeMap::new();
+        hash160_preimages.insert(hash160::Hash::hash(&[1u8, 2u8]), vec![1u8, 2u8]);
+        hash160_preimages.insert(hash160::Hash::hash(&[1u8]), vec![1u8]);
+
+        // same vector as valid_vector_1 from BIPs with added
+        let mut unserialized = Psbt {
+            unsigned_tx: Transaction {
+                version: transaction::Version::TWO,
+                lock_time: absolute::LockTime::from_consensus(1257139),
+                input: vec![
+                    TxIn {
+                        previous_output: OutPoint {
+                            txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126".parse().unwrap(),
+                            vout: 0,
+                        },
+                        script_sig: ScriptBuf::new(),
+                        sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
+                        witness: Witness::default(),
+                    }
+                ],
+                output: vec![
+                    TxOut {
+                        value: Amount::from_tap(99_999_699),
+                        script_pubkey: ScriptBuf::from_hex("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
+                    },
+                    TxOut {
+                        value: Amount::from_tap(100_000_000),
+                        script_pubkey: ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
+                    },
+                ],
+            },
+            version: 0,
+            xpub: Default::default(),
+            proprietary: Default::default(),
+            unknown: BTreeMap::new(),
+
+            inputs: vec![
+                Input {
+                    non_witness_utxo: Some(Transaction {
+                        version: transaction::Version::ONE,
+                        lock_time: absolute::LockTime::ZERO,
+                        input: vec![
+                            TxIn {
+                                previous_output: OutPoint {
+                                    txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389".parse().unwrap(),
+                                    vout: 1,
+                                },
+                                script_sig: ScriptBuf::from_hex("160014be18d152a9b012039daf3da7de4f53349eecb985").unwrap(),
+                                sequence: Sequence::MAX,
+                                witness: Witness::default(),
+                            },
+                            TxIn {
+                                previous_output: OutPoint {
+                                    txid: "b490486aec3ae671012dddb2bb08466bef37720a533a894814ff1da743aaf886".parse().unwrap(),
+                                    vout: 1,
+                                },
+                                script_sig: ScriptBuf::from_hex("160014fe3e9ef1a745e974d902c4355943abcb34bd5353").unwrap(),
+                                sequence: Sequence::MAX,
+                                witness: Witness::default(),
+                            }
+                        ],
+                        output: vec![
+                            TxOut {
+                                value: Amount::from_tap(200_000_000),
+                                script_pubkey: ScriptBuf::from_hex("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
+                            },
+                            TxOut {
+                                value: Amount::from_tap(190_303_501_938),
+                                script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
+                            },
+                        ],
+                    }),
+                    ..Default::default()
+                },
+            ],
+            outputs: vec![
+                Output {
+                    ..Default::default()
+                },
+                Output {
+                    ..Default::default()
+                },
+            ],
+        };
+        unserialized.inputs[0].hash160_preimages = hash160_preimages;
+        unserialized.inputs[0].sha256_preimages = sha256_preimages;
+
+        let rtt: Psbt = hex_psbt(&unserialized.serialize_hex()).unwrap();
+        assert_eq!(rtt, unserialized);
+
+        // Now add an ripemd160 with incorrect preimage
+        let mut ripemd160_preimages = BTreeMap::new();
+        ripemd160_preimages.insert(ripemd160::Hash::hash(&[17u8]), vec![18u8]);
+        unserialized.inputs[0].ripemd160_preimages = ripemd160_preimages;
+
+        // Now the roundtrip should fail as the preimage is incorrect.
+        let rtt: Result<Psbt, _> = hex_psbt(&unserialized.serialize_hex());
+        assert!(rtt.is_err());
+    }
+
+    #[test]
+    fn serialize_and_deserialize_proprietary() {
+        let mut psbt: Psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac000000000001076a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa882920001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000").unwrap();
+        psbt.proprietary.insert(
+            raw::ProprietaryKey { prefix: b"test".to_vec(), subtype: 0u8, key: b"test".to_vec() },
+            b"test".to_vec(),
+        );
+        assert!(!psbt.proprietary.is_empty());
+        let rtt: Psbt = hex_psbt(&psbt.serialize_hex()).unwrap();
+        assert!(!rtt.proprietary.is_empty());
+    }
+
+    // PSBTs taken from BIP 174 test vectors.
+    #[test]
+    fn combine_psbts() {
+        let mut psbt1 = hex_psbt(include_str!("../../tests/data/psbt1.hex")).unwrap();
+        let psbt2 = hex_psbt(include_str!("../../tests/data/psbt2.hex")).unwrap();
+        let psbt_combined = hex_psbt(include_str!("../../tests/data/psbt2.hex")).unwrap();
+
+        psbt1.combine(psbt2).expect("psbt combine to succeed");
+        assert_eq!(psbt1, psbt_combined);
+    }
+
+    #[test]
+    fn combine_psbts_commutative() {
+        let mut psbt1 = hex_psbt(include_str!("../../tests/data/psbt1.hex")).unwrap();
+        let mut psbt2 = hex_psbt(include_str!("../../tests/data/psbt2.hex")).unwrap();
+
+        let psbt1_clone = psbt1.clone();
+        let psbt2_clone = psbt2.clone();
+
+        psbt1.combine(psbt2_clone).expect("psbt1 combine to succeed");
+        psbt2.combine(psbt1_clone).expect("psbt2 combine to succeed");
+
+        assert_eq!(psbt1, psbt2);
+    }
+
+    #[cfg(feature = "rand-std")]
+    fn gen_keys() -> (PrivateKey, PublicKey, Secp256k1<All>) {
+        use secp256k1::rand::thread_rng;
+
+        let secp = Secp256k1::new();
+
+        let sk = SecretKey::new(&mut thread_rng());
+        let priv_key = PrivateKey::new(sk, crate::Network::Dev);
+        let pk = PublicKey::from_private_key(&secp, &priv_key);
+
+        (priv_key, pk, secp)
+    }
+
+    #[test]
+    #[cfg(feature = "rand-std")]
+    fn get_key_btree_map() {
+        let (priv_key, pk, secp) = gen_keys();
+
+        let mut key_map = BTreeMap::new();
+        key_map.insert(pk, priv_key);
+
+        let got = key_map.get_key(KeyRequest::Pubkey(pk), &secp).expect("failed to get key");
+        assert_eq!(got.unwrap(), priv_key)
+    }
+
+    #[test]
+    fn test_fee() {
+        let output_0_val = Amount::from_tap(99_999_699);
+        let output_1_val = Amount::from_tap(100_000_000);
+        let prev_output_val = Amount::from_tap(200_000_000);
+
+        let mut t = Psbt {
+            unsigned_tx: Transaction {
+                version: transaction::Version::TWO,
+                lock_time: absolute::LockTime::from_consensus(1257139),
+                input: vec![
+                    TxIn {
+                        previous_output: OutPoint {
+                            txid: "f61b1742ca13176464adb3cb66050c00787bb3a4eead37e985f2df1e37718126".parse().unwrap(),
+                            vout: 0,
+                        },
+                        sequence: Sequence::ENABLE_LOCKTIME_NO_RBF,
+                        ..Default::default()
+                    }
+                ],
+                output: vec![
+                    TxOut {
+                        value: output_0_val,
+                        script_pubkey:  ScriptBuf::new()
+                    },
+                    TxOut {
+                        value: output_1_val,
+                        script_pubkey:  ScriptBuf::new()
+                    },
+                ],
+            },
+            xpub: Default::default(),
+            version: 0,
+            proprietary: BTreeMap::new(),
+            unknown: BTreeMap::new(),
+
+            inputs: vec![
+                Input {
+                    non_witness_utxo: Some(Transaction {
+                        version: transaction::Version::ONE,
+                        lock_time: absolute::LockTime::ZERO,
+                        input: vec![
+                            TxIn {
+                                previous_output: OutPoint {
+                                    txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389".parse().unwrap(),
+                                    vout: 1,
+                                },
+                                sequence: Sequence::MAX,
+                                ..Default::default()
+                            },
+                            TxIn {
+                                previous_output: OutPoint {
+                                    txid: "b490486aec3ae671012dddb2bb08466bef37720a533a894814ff1da743aaf886".parse().unwrap(),
+                                    vout: 1,
+                                },
+                                sequence: Sequence::MAX,
+                                ..Default::default()
+                            }
+                        ],
+                        output: vec![
+                            TxOut {
+                                value: prev_output_val,
+                                script_pubkey:  ScriptBuf::new()
+                            },
+                            TxOut {
+                                value: Amount::from_tap(190_303_501_938),
+                                script_pubkey:  ScriptBuf::new()
+                            },
+                        ],
+                    }),
+                    ..Default::default()
+                },
+            ],
+            outputs: vec![
+                Output {
+                    ..Default::default()
+                },
+                Output {
+                    ..Default::default()
+                },
+            ],
+        };
+        assert_eq!(
+            t.fee().expect("fee calculation"),
+            prev_output_val - (output_0_val + output_1_val)
+        );
+        // no previous output
+        let mut t2 = t.clone();
+        t2.inputs[0].non_witness_utxo = None;
+        match t2.fee().unwrap_err() {
+            Error::MissingUtxo => {}
+            e => panic!("unexpected error: {:?}", e),
+        }
+        //  negative fee
+        let mut t3 = t.clone();
+        t3.unsigned_tx.output[0].value = prev_output_val;
+        match t3.fee().unwrap_err() {
+            Error::NegativeFee => {}
+            e => panic!("unexpected error: {:?}", e),
+        }
+        // overflow
+        t.unsigned_tx.output[0].value = Amount::MAX;
+        t.unsigned_tx.output[1].value = Amount::MAX;
+        match t.fee().unwrap_err() {
+            Error::FeeOverflow => {}
+            e => panic!("unexpected error: {:?}", e),
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "rand-std")]
+    fn sign_psbt() {
+        use crate::bip32::{DerivationPath, Fingerprint};
+        use crate::witness_version::WitnessVersion;
+        use crate::{WPubkeyHash, WitnessProgram};
+
+        let unsigned_tx = Transaction {
+            version: transaction::Version::TWO,
+            lock_time: absolute::LockTime::ZERO,
+            input: vec![TxIn::default(), TxIn::default()],
+            output: vec![TxOut::NULL],
+        };
+        let mut psbt = Psbt::from_unsigned_tx(unsigned_tx).unwrap();
+
+        let (priv_key, pk, secp) = gen_keys();
+
+        // key_map implements `GetKey` using KeyRequest::Pubkey. A pubkey key request does not use
+        // keysource so we use default `KeySource` (fingreprint and derivation path) below.
+        let mut key_map = BTreeMap::new();
+        key_map.insert(pk, priv_key);
+
+        // First input we can spend. See comment above on key_map for why we use defaults here.
+        let txout_wpkh = TxOut {
+            value: Amount::from_tap(10),
+            script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::hash(&pk.to_bytes())),
+        };
+        psbt.inputs[0].witness_utxo = Some(txout_wpkh);
+
+        let mut map = BTreeMap::new();
+        map.insert(pk.inner, (Fingerprint::default(), DerivationPath::default()));
+        psbt.inputs[0].bip32_derivation = map;
+
+        // Second input is unspendable by us e.g., from another wallet that supports future upgrades.
+        let unknown_prog = WitnessProgram::new(WitnessVersion::V4, vec![0xaa; 34]).unwrap();
+        let txout_unknown_future = TxOut {
+            value: Amount::from_tap(10),
+            script_pubkey: ScriptBuf::new_witness_program(&unknown_prog),
+        };
+        psbt.inputs[1].witness_utxo = Some(txout_unknown_future);
+
+        let sigs = psbt.sign(&key_map, &secp).unwrap();
+
+        assert!(sigs.len() == 1);
+        assert!(sigs[&0] == vec![pk]);
+    }
+}
diff --git a/tapyrus/src/psbt/raw.rs b/tapyrus/src/psbt/raw.rs
new file mode 100644
index 00000000..effd805b
--- /dev/null
+++ b/tapyrus/src/psbt/raw.rs
@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Raw PSBT key-value pairs.
+//!
+//! Raw PSBT key-value pairs as defined at
+//! <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki>.
+//!
+
+use core::convert::TryFrom;
+use core::fmt;
+
+use super::serialize::{Deserialize, Serialize};
+use crate::consensus::encode::{
+    self, deserialize, serialize, Decodable, Encodable, ReadExt, VarInt, WriteExt, MAX_VEC_SIZE,
+};
+use crate::io;
+use crate::prelude::*;
+use crate::psbt::Error;
+
+/// A PSBT key in its raw byte form.
+#[derive(Debug, PartialEq, Hash, Eq, Clone, Ord, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Key {
+    /// The type of this PSBT key.
+    pub type_value: u8,
+    /// The key itself in raw byte form.
+    /// `<key> := <keylen> <keytype> <keydata>`
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
+    pub key: Vec<u8>,
+}
+
+/// A PSBT key-value pair in its raw byte form.
+/// `<keypair> := <key> <value>`
+#[derive(Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct Pair {
+    /// The key of this key-value pair.
+    pub key: Key,
+    /// The value data of this key-value pair in raw byte form.
+    /// `<value> := <valuelen> <valuedata>`
+    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
+    pub value: Vec<u8>,
+}
+
+/// Default implementation for proprietary key subtyping
+pub type ProprietaryType = u8;
+
+/// Proprietary keys (i.e. keys starting with 0xFC byte) with their internal
+/// structure according to BIP 174.
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct ProprietaryKey<Subtype = ProprietaryType>
+where
+    Subtype: Copy + From<u8> + Into<u8>,
+{
+    /// 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>,
+}
+
+impl fmt::Display for Key {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "type: {:#x}, key: {:x}", self.type_value, self.key.as_hex())
+    }
+}
+
+impl Key {
+    pub(crate) fn decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        let VarInt(byte_size): VarInt = Decodable::consensus_decode(r)?;
+
+        if byte_size == 0 {
+            return Err(Error::NoMorePairs);
+        }
+
+        let key_byte_size: u64 = byte_size - 1;
+
+        if key_byte_size > MAX_VEC_SIZE as u64 {
+            return Err(encode::Error::OversizedVectorAllocation {
+                requested: key_byte_size as usize,
+                max: MAX_VEC_SIZE,
+            }
+            .into());
+        }
+
+        let type_value: u8 = Decodable::consensus_decode(r)?;
+
+        let mut key = Vec::with_capacity(key_byte_size as usize);
+        for _ in 0..key_byte_size {
+            key.push(Decodable::consensus_decode(r)?);
+        }
+
+        Ok(Key { type_value, key })
+    }
+}
+
+impl Serialize for Key {
+    fn serialize(&self) -> Vec<u8> {
+        let mut buf = Vec::new();
+        VarInt::from(self.key.len() + 1)
+            .consensus_encode(&mut buf)
+            .expect("in-memory writers don't error");
+
+        self.type_value.consensus_encode(&mut buf).expect("in-memory writers don't error");
+
+        for key in &self.key {
+            key.consensus_encode(&mut buf).expect("in-memory writers don't error");
+        }
+
+        buf
+    }
+}
+
+impl Serialize for Pair {
+    fn serialize(&self) -> Vec<u8> {
+        let mut buf = Vec::new();
+        buf.extend(self.key.serialize());
+        // <value> := <valuelen> <valuedata>
+        self.value.consensus_encode(&mut buf).unwrap();
+        buf
+    }
+}
+
+impl Deserialize for Pair {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let mut decoder = bytes;
+        Pair::decode(&mut decoder)
+    }
+}
+
+impl Pair {
+    pub(crate) fn decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, Error> {
+        Ok(Pair { key: Key::decode(r)?, value: Decodable::consensus_decode(r)? })
+    }
+}
+
+impl<Subtype> Encodable for ProprietaryKey<Subtype>
+where
+    Subtype: Copy + From<u8> + Into<u8>,
+{
+    fn consensus_encode<W: io::Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        let mut len = self.prefix.consensus_encode(w)? + 1;
+        w.emit_u8(self.subtype.into())?;
+        w.write_all(&self.key)?;
+        len += self.key.len();
+        Ok(len)
+    }
+}
+
+impl<Subtype> Decodable for ProprietaryKey<Subtype>
+where
+    Subtype: Copy + From<u8> + Into<u8>,
+{
+    fn consensus_decode<R: io::Read + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        let prefix = Vec::<u8>::consensus_decode(r)?;
+        let subtype = Subtype::from(r.read_u8()?);
+        let key = read_to_end(r)?;
+
+        Ok(ProprietaryKey { prefix, subtype, key })
+    }
+}
+
+impl<Subtype> ProprietaryKey<Subtype>
+where
+    Subtype: Copy + From<u8> + Into<u8>,
+{
+    /// Constructs full [Key] corresponding to this proprietary key type
+    pub fn to_key(&self) -> Key { Key { type_value: 0xFC, key: serialize(self) } }
+}
+
+impl<Subtype> TryFrom<Key> for ProprietaryKey<Subtype>
+where
+    Subtype: Copy + From<u8> + Into<u8>,
+{
+    type Error = Error;
+
+    /// Constructs a [`ProprietaryKey`] from a [`Key`].
+    ///
+    /// # Errors
+    /// Returns [`Error::InvalidProprietaryKey`] if `key` does not start with `0xFC` byte.
+    fn try_from(key: Key) -> Result<Self, Self::Error> {
+        if key.type_value != 0xFC {
+            return Err(Error::InvalidProprietaryKey);
+        }
+
+        Ok(deserialize(&key.key)?)
+    }
+}
+
+// core2 doesn't have read_to_end
+pub(crate) fn read_to_end<D: io::Read>(mut d: D) -> Result<Vec<u8>, io::Error> {
+    let mut result = vec![];
+    let mut buf = [0u8; 64];
+    loop {
+        match d.read(&mut buf) {
+            Ok(0) => break,
+            Ok(n) => result.extend_from_slice(&buf[0..n]),
+            Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
+            Err(e) => return Err(e),
+        };
+    }
+    Ok(result)
+}
diff --git a/tapyrus/src/psbt/serialize.rs b/tapyrus/src/psbt/serialize.rs
new file mode 100644
index 00000000..4dd7ea3d
--- /dev/null
+++ b/tapyrus/src/psbt/serialize.rs
@@ -0,0 +1,453 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! PSBT serialization.
+//!
+//! Traits to serialize PSBT values to and from raw bytes
+//! according to the BIP-174 specification.
+//!
+
+use core::convert::{TryFrom, TryInto};
+
+use hashes::{hash160, ripemd160, sha256, sha256d, Hash};
+use secp256k1::{self, XOnlyPublicKey};
+
+use super::map::{Input, Map, Output, PsbtSighashType};
+use crate::bip32::{ChildNumber, Fingerprint, KeySource};
+use crate::blockdata::script::ScriptBuf;
+use crate::blockdata::transaction::{Transaction, TxOut};
+use crate::blockdata::witness::Witness;
+use crate::consensus::encode::{self, deserialize_partial, serialize, Decodable, Encodable};
+use crate::crypto::key::PublicKey;
+use crate::crypto::{ecdsa, taproot};
+use crate::prelude::*;
+use crate::psbt::{Error, Psbt};
+use crate::taproot::{
+    ControlBlock, LeafVersion, TapLeafHash, TapNodeHash, TapTree, TaprootBuilder,
+};
+use crate::{io, VarInt};
+/// A trait for serializing a value as raw data for insertion into PSBT
+/// key-value maps.
+pub(crate) trait Serialize {
+    /// Serialize a value as raw data.
+    fn serialize(&self) -> Vec<u8>;
+}
+
+/// A trait for deserializing a value from raw data in PSBT key-value maps.
+pub(crate) trait Deserialize: Sized {
+    /// Deserialize a value from raw data.
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error>;
+}
+
+impl Psbt {
+    /// Serialize a value as bytes in hex.
+    pub fn serialize_hex(&self) -> String { self.serialize().to_lower_hex_string() }
+
+    /// Serialize as raw binary data
+    pub fn serialize(&self) -> Vec<u8> {
+        let mut buf: Vec<u8> = Vec::new();
+
+        //  <magic>
+        buf.extend_from_slice(b"psbt");
+
+        buf.push(0xff_u8);
+
+        buf.extend(self.serialize_map());
+
+        for i in &self.inputs {
+            buf.extend(i.serialize_map());
+        }
+
+        for i in &self.outputs {
+            buf.extend(i.serialize_map());
+        }
+
+        buf
+    }
+
+    /// Deserialize a value from raw binary data.
+    pub fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        const MAGIC_BYTES: &[u8] = b"psbt";
+        if bytes.get(0..MAGIC_BYTES.len()) != Some(MAGIC_BYTES) {
+            return Err(Error::InvalidMagic);
+        }
+
+        const PSBT_SERPARATOR: u8 = 0xff_u8;
+        if bytes.get(MAGIC_BYTES.len()) != Some(&PSBT_SERPARATOR) {
+            return Err(Error::InvalidSeparator);
+        }
+
+        let mut d = bytes.get(5..).ok_or(Error::NoMorePairs)?;
+
+        let mut global = Psbt::decode_global(&mut d)?;
+        global.unsigned_tx_checks()?;
+
+        let inputs: Vec<Input> = {
+            let inputs_len: usize = (global.unsigned_tx.input).len();
+
+            let mut inputs: Vec<Input> = Vec::with_capacity(inputs_len);
+
+            for _ in 0..inputs_len {
+                inputs.push(Input::decode(&mut d)?);
+            }
+
+            inputs
+        };
+
+        let outputs: Vec<Output> = {
+            let outputs_len: usize = (global.unsigned_tx.output).len();
+
+            let mut outputs: Vec<Output> = Vec::with_capacity(outputs_len);
+
+            for _ in 0..outputs_len {
+                outputs.push(Output::decode(&mut d)?);
+            }
+
+            outputs
+        };
+
+        global.inputs = inputs;
+        global.outputs = outputs;
+        Ok(global)
+    }
+}
+impl_psbt_de_serialize!(Transaction);
+impl_psbt_de_serialize!(TxOut);
+impl_psbt_de_serialize!(Witness);
+impl_psbt_hash_de_serialize!(ripemd160::Hash);
+impl_psbt_hash_de_serialize!(sha256::Hash);
+impl_psbt_hash_de_serialize!(TapLeafHash);
+impl_psbt_hash_de_serialize!(TapNodeHash);
+impl_psbt_hash_de_serialize!(hash160::Hash);
+impl_psbt_hash_de_serialize!(sha256d::Hash);
+
+// taproot
+impl_psbt_de_serialize!(Vec<TapLeafHash>);
+
+impl Serialize for ScriptBuf {
+    fn serialize(&self) -> Vec<u8> { self.to_bytes() }
+}
+
+impl Deserialize for ScriptBuf {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> { Ok(Self::from(bytes.to_vec())) }
+}
+
+impl Serialize for PublicKey {
+    fn serialize(&self) -> Vec<u8> {
+        let mut buf = Vec::new();
+        self.write_into(&mut buf).expect("vecs don't error");
+        buf
+    }
+}
+
+impl Deserialize for PublicKey {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        PublicKey::from_slice(bytes).map_err(Error::InvalidPublicKey)
+    }
+}
+
+impl Serialize for secp256k1::PublicKey {
+    fn serialize(&self) -> Vec<u8> { self.serialize().to_vec() }
+}
+
+impl Deserialize for secp256k1::PublicKey {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        secp256k1::PublicKey::from_slice(bytes).map_err(Error::InvalidSecp256k1PublicKey)
+    }
+}
+
+impl Serialize for ecdsa::Signature {
+    fn serialize(&self) -> Vec<u8> { self.to_vec() }
+}
+
+impl Deserialize for ecdsa::Signature {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        // NB: Since BIP-174 says "the signature as would be pushed to the stack from
+        // a scriptSig or witness" we should ideally use a consensus deserialization and do
+        // not error on a non-standard values. However,
+        //
+        // 1) the current implementation of from_u32_consensus(`flag`) does not preserve
+        // the sighash byte `flag` mapping all unknown values to EcdsaSighashType::All or
+        // EcdsaSighashType::AllPlusAnyOneCanPay. Therefore, break the invariant
+        // EcdsaSig::from_slice(&sl[..]).to_vec = sl.
+        //
+        // 2) This would cause to have invalid signatures because the sighash message
+        // also has a field sighash_u32 (See BIP141). For example, when signing with non-standard
+        // 0x05, the sighash message would have the last field as 0x05u32 while, the verification
+        // would use check the signature assuming sighash_u32 as `0x01`.
+        ecdsa::Signature::from_slice(bytes).map_err(|e| match e {
+            ecdsa::Error::EmptySignature => Error::InvalidEcdsaSignature(e),
+            ecdsa::Error::SighashType(err) => Error::NonStandardSighashType(err.0),
+            ecdsa::Error::Secp256k1(..) => Error::InvalidEcdsaSignature(e),
+            ecdsa::Error::Hex(..) => unreachable!("Decoding from slice, not hex"),
+        })
+    }
+}
+
+impl Serialize for KeySource {
+    fn serialize(&self) -> Vec<u8> {
+        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)))
+        }
+
+        rv
+    }
+}
+
+impl Deserialize for KeySource {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        if bytes.len() < 4 {
+            return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into());
+        }
+
+        let fprint: Fingerprint = bytes[0..4].try_into().expect("4 is the fingerprint length");
+        let mut dpath: Vec<ChildNumber> = Default::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.into()),
+            }
+        }
+
+        Ok((fprint, dpath.into()))
+    }
+}
+
+// partial sigs
+impl Serialize for Vec<u8> {
+    fn serialize(&self) -> Vec<u8> { self.clone() }
+}
+
+impl Deserialize for Vec<u8> {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> { Ok(bytes.to_vec()) }
+}
+
+impl Serialize for PsbtSighashType {
+    fn serialize(&self) -> Vec<u8> { serialize(&self.to_u32()) }
+}
+
+impl Deserialize for PsbtSighashType {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let raw: u32 = encode::deserialize(bytes)?;
+        Ok(PsbtSighashType { inner: raw })
+    }
+}
+
+// Taproot related ser/deser
+impl Serialize for XOnlyPublicKey {
+    fn serialize(&self) -> Vec<u8> { XOnlyPublicKey::serialize(self).to_vec() }
+}
+
+impl Deserialize for XOnlyPublicKey {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        XOnlyPublicKey::from_slice(bytes).map_err(|_| Error::InvalidXOnlyPublicKey)
+    }
+}
+
+impl Serialize for taproot::Signature {
+    fn serialize(&self) -> Vec<u8> { self.to_vec() }
+}
+
+impl Deserialize for taproot::Signature {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        use taproot::SigFromSliceError::*;
+
+        taproot::Signature::from_slice(bytes).map_err(|e| match e {
+            SighashType(err) => Error::NonStandardSighashType(err.0),
+            InvalidSignatureSize(_) => Error::InvalidTaprootSignature(e),
+            Secp256k1(..) => Error::InvalidTaprootSignature(e),
+        })
+    }
+}
+
+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_byte_array().len());
+        buf.extend(&ser_pk);
+        buf.extend(self.1.as_byte_array());
+        buf
+    }
+}
+
+impl Deserialize for (XOnlyPublicKey, TapLeafHash) {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        if bytes.len() < 32 {
+            return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into());
+        }
+        let a: XOnlyPublicKey = Deserialize::deserialize(&bytes[..32])?;
+        let b: TapLeafHash = Deserialize::deserialize(&bytes[32..])?;
+        Ok((a, b))
+    }
+}
+
+impl Serialize for ControlBlock {
+    fn serialize(&self) -> Vec<u8> { ControlBlock::serialize(self) }
+}
+
+impl Deserialize for ControlBlock {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        Self::decode(bytes).map_err(|_| Error::InvalidControlBlock)
+    }
+}
+
+// Versioned ScriptBuf
+impl Serialize for (ScriptBuf, LeafVersion) {
+    fn serialize(&self) -> Vec<u8> {
+        let mut buf = Vec::with_capacity(self.0.len() + 1);
+        buf.extend(self.0.as_bytes());
+        buf.push(self.1.to_consensus());
+        buf
+    }
+}
+
+impl Deserialize for (ScriptBuf, LeafVersion) {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        if bytes.is_empty() {
+            return Err(io::Error::from(io::ErrorKind::UnexpectedEof).into());
+        }
+        // The last byte is LeafVersion.
+        let script = ScriptBuf::deserialize(&bytes[..bytes.len() - 1])?;
+        let leaf_ver = LeafVersion::from_consensus(bytes[bytes.len() - 1])
+            .map_err(|_| Error::InvalidLeafVersion)?;
+        Ok((script, leaf_ver))
+    }
+}
+
+impl Serialize for (Vec<TapLeafHash>, KeySource) {
+    fn serialize(&self) -> Vec<u8> {
+        let mut buf = Vec::with_capacity(32 * self.0.len() + key_source_len(&self.1));
+        self.0.consensus_encode(&mut buf).expect("Vecs don't error allocation");
+        // TODO: Add support for writing into a writer for key-source
+        buf.extend(self.1.serialize());
+        buf
+    }
+}
+
+impl Deserialize for (Vec<TapLeafHash>, KeySource) {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let (leafhash_vec, consumed) = deserialize_partial::<Vec<TapLeafHash>>(bytes)?;
+        let key_source = KeySource::deserialize(&bytes[consumed..])?;
+        Ok((leafhash_vec, key_source))
+    }
+}
+
+impl Serialize for TapTree {
+    fn serialize(&self) -> Vec<u8> {
+        let capacity = self
+            .script_leaves()
+            .map(|l| {
+                l.script().len() + VarInt::from(l.script().len()).size() // script version
+            + 1 // merkle branch
+            + 1 // leaf version
+            })
+            .sum::<usize>();
+        let mut buf = Vec::with_capacity(capacity);
+        for leaf_info in self.script_leaves() {
+            // # Cast Safety:
+            //
+            // TaprootMerkleBranch can only have len atmost 128(TAPROOT_CONTROL_MAX_NODE_COUNT).
+            // safe to cast from usize to u8
+            buf.push(leaf_info.merkle_branch().len() as u8);
+            buf.push(leaf_info.version().to_consensus());
+            leaf_info.script().consensus_encode(&mut buf).expect("Vecs dont err");
+        }
+        buf
+    }
+}
+
+impl Deserialize for TapTree {
+    fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
+        let mut builder = TaprootBuilder::new();
+        let mut bytes_iter = bytes.iter();
+        while let Some(depth) = bytes_iter.next() {
+            let version = bytes_iter.next().ok_or(Error::Taproot("Invalid Taproot Builder"))?;
+            let (script, consumed) = deserialize_partial::<ScriptBuf>(bytes_iter.as_slice())?;
+            if consumed > 0 {
+                bytes_iter.nth(consumed - 1);
+            }
+            let leaf_version =
+                LeafVersion::from_consensus(*version).map_err(|_| Error::InvalidLeafVersion)?;
+            builder = builder
+                .add_leaf_with_ver(*depth, script, leaf_version)
+                .map_err(|_| Error::Taproot("Tree not in DFS order"))?;
+        }
+        TapTree::try_from(builder).map_err(Error::TapTree)
+    }
+}
+
+// Helper function to compute key source len
+fn key_source_len(key_source: &KeySource) -> usize { 4 + 4 * (key_source.1).as_ref().len() }
+
+#[cfg(test)]
+mod tests {
+    use core::convert::TryFrom;
+
+    use super::*;
+
+    // Composes tree matching a given depth map, filled with dumb script leafs,
+    // each of which consists of a single push-int op code, with int value
+    // increased for each consecutive leaf.
+    pub fn compose_taproot_builder<'map>(
+        opcode: u8,
+        depth_map: impl IntoIterator<Item = &'map u8>,
+    ) -> TaprootBuilder {
+        let mut val = opcode;
+        let mut builder = TaprootBuilder::new();
+        for depth in depth_map {
+            let script = ScriptBuf::from_hex(&format!("{:02x}", val)).unwrap();
+            builder = builder.add_leaf(*depth, script).unwrap();
+            let (new_val, _) = val.overflowing_add(1);
+            val = new_val;
+        }
+        builder
+    }
+
+    #[test]
+    fn taptree_hidden() {
+        let mut builder = compose_taproot_builder(0x51, &[2, 2, 2]);
+        builder = builder
+            .add_leaf_with_ver(
+                3,
+                ScriptBuf::from_hex("b9").unwrap(),
+                LeafVersion::from_consensus(0xC2).unwrap(),
+            )
+            .unwrap();
+        builder = builder.add_hidden_node(3, TapNodeHash::all_zeros()).unwrap();
+        assert!(TapTree::try_from(builder).is_err());
+    }
+
+    #[test]
+    fn taptree_roundtrip() {
+        let mut builder = compose_taproot_builder(0x51, &[2, 2, 2, 3]);
+        builder = builder
+            .add_leaf_with_ver(
+                3,
+                ScriptBuf::from_hex("b9").unwrap(),
+                LeafVersion::from_consensus(0xC2).unwrap(),
+            )
+            .unwrap();
+        let tree = TapTree::try_from(builder).unwrap();
+        let tree_prime = TapTree::deserialize(&tree.serialize()).unwrap();
+        assert_eq!(tree, tree_prime);
+    }
+
+    #[test]
+    fn can_deserialize_non_standard_psbt_sighash_type() {
+        let non_standard_sighash = [222u8, 0u8, 0u8, 0u8]; // 32 byte value.
+        let sighash = PsbtSighashType::deserialize(&non_standard_sighash);
+        assert!(sighash.is_ok())
+    }
+
+    #[test]
+    #[should_panic(expected = "InvalidMagic")]
+    fn invalid_vector_1() {
+        let hex_psbt = b"0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300";
+        Psbt::deserialize(hex_psbt).unwrap();
+    }
+}
diff --git a/tapyrus/src/serde_utils.rs b/tapyrus/src/serde_utils.rs
new file mode 100644
index 00000000..c0789e0c
--- /dev/null
+++ b/tapyrus/src/serde_utils.rs
@@ -0,0 +1,530 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin serde utilities.
+//!
+//! This module is for special serde serializations.
+//!
+
+pub(crate) struct SerializeBytesAsHex<'a>(pub(crate) &'a [u8]);
+
+impl<'a> serde::Serialize for SerializeBytesAsHex<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use hex::DisplayHex;
+
+        serializer.collect_str(&format_args!("{:x}", self.0.as_hex()))
+    }
+}
+
+pub mod btreemap_byte_values {
+    //! Module for serialization of BTreeMaps with hex byte values.
+    #![allow(missing_docs)]
+
+    // NOTE: This module can be exactly copied to use with HashMap.
+
+    use hex::FromHex;
+    use serde;
+
+    use crate::prelude::*;
+
+    pub fn serialize<S, T>(v: &BTreeMap<T, Vec<u8>>, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+        T: serde::Serialize + core::hash::Hash + Eq + Ord,
+    {
+        use serde::ser::SerializeMap;
+
+        // Don't do anything special when not human readable.
+        if !s.is_human_readable() {
+            serde::Serialize::serialize(v, s)
+        } else {
+            let mut map = s.serialize_map(Some(v.len()))?;
+            for (key, value) in v.iter() {
+                map.serialize_entry(key, &super::SerializeBytesAsHex(value))?;
+            }
+            map.end()
+        }
+    }
+
+    pub fn deserialize<'de, D, T>(d: D) -> Result<BTreeMap<T, Vec<u8>>, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+        T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
+    {
+        use core::marker::PhantomData;
+
+        struct Visitor<T>(PhantomData<T>);
+        impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
+        where
+            T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
+        {
+            type Value = BTreeMap<T, Vec<u8>>;
+
+            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "a map with hexadecimal values")
+            }
+
+            fn visit_map<A: serde::de::MapAccess<'de>>(
+                self,
+                mut a: A,
+            ) -> Result<Self::Value, A::Error> {
+                let mut ret = BTreeMap::new();
+                while let Some((key, value)) = a.next_entry()? {
+                    ret.insert(key, FromHex::from_hex(value).map_err(serde::de::Error::custom)?);
+                }
+                Ok(ret)
+            }
+        }
+
+        // Don't do anything special when not human readable.
+        if !d.is_human_readable() {
+            serde::Deserialize::deserialize(d)
+        } else {
+            d.deserialize_map(Visitor(PhantomData))
+        }
+    }
+}
+
+pub mod btreemap_as_seq {
+    //! Module for serialization of BTreeMaps as lists of sequences because
+    //! serde_json will not serialize hashmaps with non-string keys be default.
+    #![allow(missing_docs)]
+
+    // NOTE: This module can be exactly copied to use with HashMap.
+
+    use serde;
+
+    use crate::prelude::*;
+
+    pub fn serialize<S, T, U>(v: &BTreeMap<T, U>, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+        T: serde::Serialize + core::hash::Hash + Eq + Ord,
+        U: serde::Serialize,
+    {
+        use serde::ser::SerializeSeq;
+
+        // Don't do anything special when not human readable.
+        if !s.is_human_readable() {
+            serde::Serialize::serialize(v, s)
+        } else {
+            let mut seq = s.serialize_seq(Some(v.len()))?;
+            for pair in v.iter() {
+                seq.serialize_element(&pair)?;
+            }
+            seq.end()
+        }
+    }
+
+    pub fn deserialize<'de, D, T, U>(d: D) -> Result<BTreeMap<T, U>, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+        T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
+        U: serde::Deserialize<'de>,
+    {
+        use core::marker::PhantomData;
+
+        struct Visitor<T, U>(PhantomData<(T, U)>);
+        impl<'de, T, U> serde::de::Visitor<'de> for Visitor<T, U>
+        where
+            T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
+            U: serde::Deserialize<'de>,
+        {
+            type Value = BTreeMap<T, U>;
+
+            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "a sequence of pairs")
+            }
+
+            fn visit_seq<A: serde::de::SeqAccess<'de>>(
+                self,
+                mut a: A,
+            ) -> Result<Self::Value, A::Error> {
+                let mut ret = BTreeMap::new();
+                while let Some((key, value)) = a.next_element()? {
+                    ret.insert(key, value);
+                }
+                Ok(ret)
+            }
+        }
+
+        // Don't do anything special when not human readable.
+        if !d.is_human_readable() {
+            serde::Deserialize::deserialize(d)
+        } else {
+            d.deserialize_seq(Visitor(PhantomData))
+        }
+    }
+}
+
+pub mod btreemap_as_seq_byte_values {
+    //! Module for serialization of BTreeMaps as lists of sequences because
+    //! serde_json will not serialize hashmaps with non-string keys be default.
+    #![allow(missing_docs)]
+
+    // NOTE: This module can be exactly copied to use with HashMap.
+
+    use serde;
+
+    use crate::prelude::*;
+
+    /// 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 + core::hash::Hash + Eq + Ord + 'static,
+    {
+        use serde::ser::SerializeSeq;
+
+        // Don't do anything special when not human readable.
+        if !s.is_human_readable() {
+            serde::Serialize::serialize(v, s)
+        } else {
+            let mut seq = s.serialize_seq(Some(v.len()))?;
+            for (key, value) in v.iter() {
+                seq.serialize_element(&BorrowedPair(key, value))?;
+            }
+            seq.end()
+        }
+    }
+
+    pub fn deserialize<'de, D, T>(d: D) -> Result<BTreeMap<T, Vec<u8>>, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+        T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
+    {
+        use core::marker::PhantomData;
+
+        struct Visitor<T>(PhantomData<T>);
+        impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
+        where
+            T: serde::Deserialize<'de> + core::hash::Hash + Eq + Ord,
+        {
+            type Value = BTreeMap<T, Vec<u8>>;
+
+            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "a sequence of pairs")
+            }
+
+            fn visit_seq<A: serde::de::SeqAccess<'de>>(
+                self,
+                mut a: A,
+            ) -> Result<Self::Value, A::Error> {
+                let mut ret = BTreeMap::new();
+                while let Option::Some(OwnedPair(key, value)) = a.next_element()? {
+                    ret.insert(key, value);
+                }
+                Ok(ret)
+            }
+        }
+
+        // Don't do anything special when not human readable.
+        if !d.is_human_readable() {
+            serde::Deserialize::deserialize(d)
+        } else {
+            d.deserialize_seq(Visitor(PhantomData))
+        }
+    }
+}
+
+pub mod hex_bytes {
+    //! Module for serialization of byte arrays as hex strings.
+    #![allow(missing_docs)]
+
+    use hex::FromHex;
+    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 {
+            serde::Serialize::serialize(&super::SerializeBytesAsHex(bytes.as_ref()), s)
+        }
+    }
+
+    pub fn deserialize<'de, D, B>(d: D) -> Result<B, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+        B: serde::Deserialize<'de> + FromHex,
+    {
+        struct Visitor<B>(core::marker::PhantomData<B>);
+
+        impl<'de, B: FromHex> serde::de::Visitor<'de> for Visitor<B> {
+            type Value = B;
+
+            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
+                formatter.write_str("an ASCII hex string")
+            }
+
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                if let Ok(hex) = core::str::from_utf8(v) {
+                    FromHex::from_hex(hex).map_err(E::custom)
+                } else {
+                    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(core::marker::PhantomData))
+        }
+    }
+}
+
+macro_rules! serde_string_serialize_impl {
+    ($name:ty, $expecting:literal) => {
+        impl $crate::serde::Serialize for $name {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: $crate::serde::Serializer,
+            {
+                serializer.collect_str(&self)
+            }
+        }
+    };
+}
+
+macro_rules! serde_string_deserialize_impl {
+    ($name:ty, $expecting:literal) => {
+        impl<'de> $crate::serde::Deserialize<'de> for $name {
+            fn deserialize<D>(deserializer: D) -> Result<$name, D::Error>
+            where
+                D: $crate::serde::de::Deserializer<'de>,
+            {
+                use core::fmt::{self, Formatter};
+
+                struct Visitor;
+                impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
+                    type Value = $name;
+
+                    fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                        f.write_str($expecting)
+                    }
+
+                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                    where
+                        E: $crate::serde::de::Error,
+                    {
+                        v.parse::<$name>().map_err(E::custom)
+                    }
+                }
+
+                deserializer.deserialize_str(Visitor)
+            }
+        }
+    };
+}
+
+macro_rules! serde_string_impl {
+    ($name:ty, $expecting:literal) => {
+        $crate::serde_utils::serde_string_deserialize_impl!($name, $expecting);
+        $crate::serde_utils::serde_string_serialize_impl!($name, $expecting);
+    };
+}
+pub(crate) use {serde_string_deserialize_impl, serde_string_impl, serde_string_serialize_impl};
+
+/// A combination macro where the human-readable serialization is done like
+/// serde_string_impl and the non-human-readable impl is done as a struct.
+macro_rules! serde_struct_human_string_impl {
+    ($name:ident, $expecting:literal, $($fe:ident),*) => (
+        impl<'de> $crate::serde::Deserialize<'de> for $name {
+            fn deserialize<D>(deserializer: D) -> Result<$name, D::Error>
+            where
+                D: $crate::serde::de::Deserializer<'de>,
+            {
+                if deserializer.is_human_readable() {
+                    use core::fmt::{self, Formatter};
+                    use core::str::FromStr;
+
+                    struct Visitor;
+                    impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
+                        type Value = $name;
+
+                        fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                            f.write_str($expecting)
+                        }
+
+                        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                        where
+                            E: $crate::serde::de::Error,
+                        {
+                            $name::from_str(v).map_err(E::custom)
+                        }
+
+                    }
+
+                    deserializer.deserialize_str(Visitor)
+                } else {
+                    use core::fmt::{self, Formatter};
+                    use $crate::serde::de::IgnoredAny;
+
+                    #[allow(non_camel_case_types)]
+                    enum Enum { Unknown__Field, $($fe),* }
+
+                    struct EnumVisitor;
+                    impl<'de> $crate::serde::de::Visitor<'de> for EnumVisitor {
+                        type Value = Enum;
+
+                        fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                            f.write_str("a field name")
+                        }
+
+                        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                        where
+                            E: $crate::serde::de::Error,
+                        {
+                            match v {
+                                $(
+                                stringify!($fe) => Ok(Enum::$fe)
+                                ),*,
+                                _ => Ok(Enum::Unknown__Field)
+                            }
+                        }
+                    }
+
+                    impl<'de> $crate::serde::Deserialize<'de> for Enum {
+                        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                        where
+                            D: $crate::serde::de::Deserializer<'de>,
+                        {
+                            deserializer.deserialize_str(EnumVisitor)
+                        }
+                    }
+
+                    struct Visitor;
+
+                    impl<'de> $crate::serde::de::Visitor<'de> for Visitor {
+                        type Value = $name;
+
+                        fn expecting(&self, f: &mut Formatter) -> fmt::Result {
+                            f.write_str("a struct")
+                        }
+
+                        fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
+                        where
+                            V: $crate::serde::de::SeqAccess<'de>,
+                        {
+                            use $crate::serde::de::Error;
+
+                            let length = 0;
+                            $(
+                                let $fe = seq.next_element()?.ok_or_else(|| {
+                                    Error::invalid_length(length, &self)
+                                })?;
+                                #[allow(unused_variables)]
+                                let length = length + 1;
+                            )*
+
+                            let ret = $name {
+                                $($fe),*
+                            };
+
+                            Ok(ret)
+                        }
+
+                        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+                        where
+                            A: $crate::serde::de::MapAccess<'de>,
+                        {
+                            use $crate::serde::de::Error;
+
+                            $(let mut $fe = None;)*
+
+                            loop {
+                                match map.next_key::<Enum>()? {
+                                    Some(Enum::Unknown__Field) => {
+                                        map.next_value::<IgnoredAny>()?;
+                                    }
+                                    $(
+                                        Some(Enum::$fe) => {
+                                            $fe = Some(map.next_value()?);
+                                        }
+                                    )*
+                                    None => { break; }
+                                }
+                            }
+
+                            $(
+                                let $fe = match $fe {
+                                    Some(x) => x,
+                                    None => return Err(A::Error::missing_field(stringify!($fe))),
+                                };
+                            )*
+
+                            let ret = $name {
+                                $($fe),*
+                            };
+
+                            Ok(ret)
+                        }
+                    }
+                    // end type defs
+
+                    static FIELDS: &'static [&'static str] = &[$(stringify!($fe)),*];
+
+                    deserializer.deserialize_struct(stringify!($name), FIELDS, Visitor)
+                }
+            }
+        }
+
+        impl $crate::serde::Serialize for $name {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: $crate::serde::Serializer,
+            {
+                if serializer.is_human_readable() {
+                    serializer.collect_str(&self)
+                } else {
+                    use $crate::serde::ser::SerializeStruct;
+
+                    // Only used to get the struct length.
+                    static FIELDS: &'static [&'static str] = &[$(stringify!($fe)),*];
+
+                    let mut st = serializer.serialize_struct(stringify!($name), FIELDS.len())?;
+
+                    $(
+                        st.serialize_field(stringify!($fe), &self.$fe)?;
+                    )*
+
+                    st.end()
+                }
+            }
+        }
+    )
+}
+pub(crate) use serde_struct_human_string_impl;
diff --git a/tapyrus/src/sign_message.rs b/tapyrus/src/sign_message.rs
new file mode 100644
index 00000000..394998ad
--- /dev/null
+++ b/tapyrus/src/sign_message.rs
@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Signature
+//!
+//! This module provides signature related functions including secp256k1 signature recovery when
+//! library is used with the `secp-recovery` feature.
+//!
+
+use hashes::{sha256d, Hash, HashEngine};
+
+#[cfg(feature = "secp-recovery")]
+pub use self::message_signing::{MessageSignature, MessageSignatureError};
+use crate::consensus::{encode, Encodable};
+
+/// The prefix for signed messages using Bitcoin's message signing protocol.
+pub const BITCOIN_SIGNED_MSG_PREFIX: &[u8] = b"\x18Bitcoin Signed Message:\n";
+
+#[cfg(feature = "secp-recovery")]
+mod message_signing {
+    use core::fmt;
+
+    use hashes::{sha256d, Hash};
+    use internals::write_err;
+    use secp256k1;
+    use secp256k1::ecdsa::{RecoverableSignature, RecoveryId};
+
+    use crate::address::{Address, AddressType};
+    use crate::crypto::key::PublicKey;
+
+    /// An error used for dealing with Bitcoin Signed Messages.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    #[non_exhaustive]
+    pub enum MessageSignatureError {
+        /// Signature is expected to be 65 bytes.
+        InvalidLength,
+        /// The signature is invalidly constructed.
+        InvalidEncoding(secp256k1::Error),
+        /// Invalid base64 encoding.
+        InvalidBase64,
+        /// Unsupported Address Type
+        UnsupportedAddressType(AddressType),
+    }
+
+    impl fmt::Display for MessageSignatureError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            use MessageSignatureError::*;
+
+            match *self {
+                InvalidLength => write!(f, "length not 65 bytes"),
+                InvalidEncoding(ref e) => write_err!(f, "invalid encoding"; e),
+                InvalidBase64 => write!(f, "invalid base64"),
+                UnsupportedAddressType(ref address_type) =>
+                    write!(f, "unsupported address type: {}", address_type),
+            }
+        }
+    }
+
+    #[cfg(feature = "std")]
+    impl std::error::Error for MessageSignatureError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            use MessageSignatureError::*;
+
+            match *self {
+                InvalidEncoding(ref e) => Some(e),
+                InvalidLength | InvalidBase64 | UnsupportedAddressType(_) => None,
+            }
+        }
+    }
+
+    impl From<secp256k1::Error> for MessageSignatureError {
+        fn from(e: secp256k1::Error) -> MessageSignatureError {
+            MessageSignatureError::InvalidEncoding(e)
+        }
+    }
+
+    /// A signature on a Bitcoin Signed Message.
+    ///
+    /// In order to use the `to_base64` and `from_base64` methods, as well as the
+    /// `fmt::Display` and `str::FromStr` implementations, the `base64` feature
+    /// must be enabled.
+    #[derive(Copy, Clone, PartialEq, Eq, Debug)]
+    pub struct MessageSignature {
+        /// The inner recoverable signature.
+        pub signature: RecoverableSignature,
+        /// Whether or not this signature was created with a compressed key.
+        pub compressed: bool,
+    }
+
+    impl MessageSignature {
+        /// Create a new [MessageSignature].
+        pub fn new(signature: RecoverableSignature, compressed: bool) -> MessageSignature {
+            MessageSignature { signature, compressed }
+        }
+
+        /// Serialize to bytes.
+        pub fn serialize(&self) -> [u8; 65] {
+            let (recid, raw) = self.signature.serialize_compact();
+            let mut serialized = [0u8; 65];
+            serialized[0] = 27;
+            serialized[0] += recid.to_i32() as u8;
+            if self.compressed {
+                serialized[0] += 4;
+            }
+            serialized[1..].copy_from_slice(&raw[..]);
+            serialized
+        }
+
+        /// Create from a byte slice.
+        pub fn from_slice(bytes: &[u8]) -> Result<MessageSignature, MessageSignatureError> {
+            if bytes.len() != 65 {
+                return Err(MessageSignatureError::InvalidLength);
+            }
+            // We just check this here so we can safely subtract further.
+            if bytes[0] < 27 {
+                return Err(MessageSignatureError::InvalidEncoding(
+                    secp256k1::Error::InvalidRecoveryId,
+                ));
+            };
+            let recid = RecoveryId::from_i32(((bytes[0] - 27) & 0x03) as i32)?;
+            Ok(MessageSignature {
+                signature: RecoverableSignature::from_compact(&bytes[1..], recid)?,
+                compressed: ((bytes[0] - 27) & 0x04) != 0,
+            })
+        }
+
+        /// Attempt to recover a public key from the signature and the signed message.
+        ///
+        /// To get the message hash from a message, use [super::signed_msg_hash].
+        pub fn recover_pubkey<C: secp256k1::Verification>(
+            &self,
+            secp_ctx: &secp256k1::Secp256k1<C>,
+            msg_hash: sha256d::Hash,
+        ) -> Result<PublicKey, MessageSignatureError> {
+            let msg = secp256k1::Message::from_digest(msg_hash.to_byte_array());
+            let pubkey = secp_ctx.recover_ecdsa(&msg, &self.signature)?;
+            Ok(PublicKey { inner: pubkey, compressed: self.compressed })
+        }
+
+        /// Verify that the signature signs the message and was signed by the given address.
+        ///
+        /// To get the message hash from a message, use [super::signed_msg_hash].
+        pub fn is_signed_by_address<C: secp256k1::Verification>(
+            &self,
+            secp_ctx: &secp256k1::Secp256k1<C>,
+            address: &Address,
+            msg_hash: sha256d::Hash,
+        ) -> Result<bool, MessageSignatureError> {
+            match address.address_type() {
+                Some(AddressType::P2pkh) => {
+                    let pubkey = self.recover_pubkey(secp_ctx, msg_hash)?;
+                    Ok(*address == Address::p2pkh(&pubkey, *address.network()))
+                }
+                Some(address_type) =>
+                    Err(MessageSignatureError::UnsupportedAddressType(address_type)),
+                None => Ok(false),
+            }
+        }
+    }
+
+    #[cfg(feature = "base64")]
+    mod base64_impls {
+        use base64::prelude::{Engine as _, BASE64_STANDARD};
+
+        use super::*;
+        use crate::prelude::String;
+
+        impl MessageSignature {
+            /// Convert a signature from base64 encoding.
+            pub fn from_base64(s: &str) -> Result<MessageSignature, MessageSignatureError> {
+                let bytes =
+                    BASE64_STANDARD.decode(s).map_err(|_| MessageSignatureError::InvalidBase64)?;
+                MessageSignature::from_slice(&bytes)
+            }
+
+            /// Convert to base64 encoding.
+            pub fn to_base64(self) -> String { BASE64_STANDARD.encode(self.serialize()) }
+        }
+
+        impl fmt::Display for MessageSignature {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                let bytes = self.serialize();
+                // This avoids the allocation of a String.
+                write!(f, "{}", base64::display::Base64Display::new(&bytes, &BASE64_STANDARD))
+            }
+        }
+
+        impl core::str::FromStr for MessageSignature {
+            type Err = MessageSignatureError;
+            fn from_str(s: &str) -> Result<MessageSignature, MessageSignatureError> {
+                MessageSignature::from_base64(s)
+            }
+        }
+    }
+}
+
+/// Hash message for signature using Bitcoin's message signing format.
+pub fn signed_msg_hash(msg: &str) -> sha256d::Hash {
+    let mut engine = sha256d::Hash::engine();
+    engine.input(BITCOIN_SIGNED_MSG_PREFIX);
+    let msg_len = encode::VarInt::from(msg.len());
+    msg_len.consensus_encode(&mut engine).expect("engines don't error");
+    engine.input(msg.as_bytes());
+    sha256d::Hash::from_engine(engine)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_signed_msg_hash() {
+        let hash = signed_msg_hash("test");
+        assert_eq!(
+            hash.to_string(),
+            "a6f87fe6d58a032c320ff8d1541656f0282c2c7bfcc69d61af4c8e8ed528e49c"
+        );
+    }
+
+    #[test]
+    #[cfg(all(feature = "secp-recovery", feature = "base64", feature = "rand-std"))]
+    fn test_message_signature() {
+        use core::str::FromStr;
+
+        use secp256k1;
+
+        use crate::{Address, Network};
+
+        let secp = secp256k1::Secp256k1::new();
+        let message = "rust-tapyrus MessageSignature test";
+        let msg_hash = super::signed_msg_hash(message);
+        let msg = secp256k1::Message::from_digest(msg_hash.to_byte_array());
+        let privkey = secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng());
+        let secp_sig = secp.sign_ecdsa_recoverable(&msg, &privkey);
+        let signature = super::MessageSignature { signature: secp_sig, compressed: true };
+
+        assert_eq!(signature.to_base64(), signature.to_string());
+        let signature2 = super::MessageSignature::from_str(&signature.to_string()).unwrap();
+        let pubkey = signature2.recover_pubkey(&secp, msg_hash).unwrap();
+        assert!(pubkey.compressed);
+        assert_eq!(pubkey.inner, secp256k1::PublicKey::from_secret_key(&secp, &privkey));
+
+        let p2pkh = Address::p2pkh(&pubkey, Network::Prod);
+        assert_eq!(signature2.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(true));
+    }
+
+    #[test]
+    #[cfg(all(feature = "secp-recovery", feature = "base64"))]
+    fn test_incorrect_message_signature() {
+        use base64::prelude::{Engine as _, BASE64_STANDARD};
+        use secp256k1;
+
+        use crate::crypto::key::PublicKey;
+        use crate::{Address, Network};
+
+        let secp = secp256k1::Secp256k1::new();
+        let message = "a different message from what was signed";
+        let msg_hash = super::signed_msg_hash(message);
+
+        // Signature of msg = "rust-tapyrus MessageSignature test"
+        // Signed with pk "UuOGDsfLPr4HIMKQX0ipjJeRaj1geCq3yPUF2COP5ME="
+        let signature_base64 = "IAM2qX24tYx/bdBTIgVLhD8QEAjrPlJpmjB4nZHdRYGIBa4DmVulAcwjPnWe6Q5iEwXH6F0pUCJP/ZeHPWS1h1o=";
+        let pubkey_base64 = "A1FTfMEntPpAty3qkEo0q2Dc1FEycI10a3jmwEFy+Qr6";
+        let signature =
+            super::MessageSignature::from_base64(signature_base64).expect("message signature");
+
+        let pubkey =
+            PublicKey::from_slice(&BASE64_STANDARD.decode(pubkey_base64).expect("base64 string"))
+                .expect("pubkey slice");
+
+        let p2pkh = Address::p2pkh(&pubkey, Network::Prod);
+        assert_eq!(signature.is_signed_by_address(&secp, &p2pkh, msg_hash), Ok(false));
+    }
+}
diff --git a/tapyrus/src/string.rs b/tapyrus/src/string.rs
new file mode 100644
index 00000000..a7aba38a
--- /dev/null
+++ b/tapyrus/src/string.rs
@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin string parsing utilities.
+//!
+//! This module provides utility types and traits
+//! to support handling and parsing strings within `rust-tapyrus`.
+
+use core::fmt;
+
+use internals::write_err;
+
+use crate::prelude::String;
+
+/// Trait that allows types to be initialized from hex strings
+pub trait FromHexStr: Sized {
+    /// An error occurred while parsing the hex string.
+    type Error;
+
+    /// Parses provided string as hex requiring 0x prefix.
+    ///
+    /// This is intended for user-supplied inputs or already-existing protocols in which 0x prefix is used.
+    fn from_hex_str<S: AsRef<str> + Into<String>>(s: S) -> Result<Self, FromHexError<Self::Error>> {
+        if !s.as_ref().starts_with("0x") {
+            Err(FromHexError::MissingPrefix(s.into()))
+        } else {
+            Ok(Self::from_hex_str_no_prefix(s.as_ref().trim_start_matches("0x"))?)
+        }
+    }
+
+    /// Parses provided string as hex without requiring 0x prefix.
+    ///
+    /// This is **not** recommended for user-supplied inputs because of possible confusion with decimals.
+    /// It should be only used for existing protocols which always encode values as hex without 0x prefix.
+    fn from_hex_str_no_prefix<S: AsRef<str> + Into<String>>(s: S) -> Result<Self, Self::Error>;
+}
+
+/// Hex parsing error
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum FromHexError<E> {
+    /// The input was not a valid hex string, contains the error that occurred while parsing.
+    ParseHex(E),
+    /// The input is missing `0x` prefix, contains the invalid input.
+    MissingPrefix(String),
+}
+
+impl<E> From<E> for FromHexError<E> {
+    fn from(e: E) -> Self { FromHexError::ParseHex(e) }
+}
+
+impl<E: fmt::Display> fmt::Display for FromHexError<E> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use FromHexError::*;
+
+        match *self {
+            ParseHex(ref e) => write_err!(f, "failed to parse hex string"; e),
+            MissingPrefix(ref value) =>
+                write_err!(f, "the input value `{}` is missing the `0x` prefix", value; self),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<E> std::error::Error for FromHexError<E>
+where
+    E: std::error::Error + 'static,
+{
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use FromHexError::*;
+
+        match *self {
+            ParseHex(ref e) => Some(e),
+            MissingPrefix(_) => None,
+        }
+    }
+}
diff --git a/tapyrus/src/taproot.rs b/tapyrus/src/taproot.rs
new file mode 100644
index 00000000..ba7dd31e
--- /dev/null
+++ b/tapyrus/src/taproot.rs
@@ -0,0 +1,1890 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin Taproot.
+//!
+//! This module provides support for taproot tagged hashes.
+//!
+
+use core::cmp::Reverse;
+use core::convert::TryFrom;
+use core::fmt;
+use core::iter::FusedIterator;
+
+use hashes::{sha256t_hash_newtype, Hash, HashEngine};
+use internals::write_err;
+use secp256k1::{self, Scalar, Secp256k1};
+
+use crate::consensus::Encodable;
+use crate::crypto::key::{TapTweak, TweakedPublicKey, UntweakedPublicKey, XOnlyPublicKey};
+// Re-export these so downstream only has to use one `taproot` module.
+pub use crate::crypto::taproot::{SigFromSliceError, Signature};
+use crate::prelude::*;
+use crate::{io, Script, ScriptBuf};
+
+// Taproot test vectors from BIP-341 state the hashes without any reversing
+sha256t_hash_newtype! {
+    pub struct TapLeafTag = hash_str("TapLeaf");
+
+    /// Taproot-tagged hash with tag \"TapLeaf\".
+    ///
+    /// This is used for computing tapscript script spend hash.
+    #[hash_newtype(forward)]
+    pub struct TapLeafHash(_);
+
+    pub struct TapBranchTag = hash_str("TapBranch");
+
+    /// Tagged hash used in taproot trees.
+    ///
+    /// See BIP-340 for tagging rules.
+    #[hash_newtype(forward)]
+    pub struct TapNodeHash(_);
+
+    pub struct TapTweakTag = hash_str("TapTweak");
+
+    /// Taproot-tagged hash with tag \"TapTweak\".
+    ///
+    /// This hash type is used while computing the tweaked public key.
+    #[hash_newtype(forward)]
+    pub struct TapTweakHash(_);
+}
+
+impl TapTweakHash {
+    /// Creates a new BIP341 [`TapTweakHash`] from key and tweak. Produces `H_taptweak(P||R)` where
+    /// `P` is the internal key and `R` is the merkle root.
+    pub fn from_key_and_tweak(
+        internal_key: UntweakedPublicKey,
+        merkle_root: Option<TapNodeHash>,
+    ) -> TapTweakHash {
+        let mut eng = TapTweakHash::engine();
+        // always hash the key
+        eng.input(&internal_key.serialize());
+        if let Some(h) = merkle_root {
+            eng.input(h.as_ref());
+        } else {
+            // nothing to hash
+        }
+        TapTweakHash::from_engine(eng)
+    }
+
+    /// 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 {
+    /// Computes the leaf hash from components.
+    pub fn from_script(script: &Script, ver: LeafVersion) -> TapLeafHash {
+        let mut eng = TapLeafHash::engine();
+        ver.to_consensus().consensus_encode(&mut eng).expect("engines don't error");
+        script.consensus_encode(&mut eng).expect("engines don't error");
+        TapLeafHash::from_engine(eng)
+    }
+}
+
+impl From<LeafNode> for TapNodeHash {
+    fn from(leaf: LeafNode) -> TapNodeHash { leaf.node_hash() }
+}
+
+impl From<&LeafNode> for TapNodeHash {
+    fn from(leaf: &LeafNode) -> TapNodeHash { leaf.node_hash() }
+}
+
+impl TapNodeHash {
+    /// Computes branch hash given two hashes of the nodes underneath it.
+    pub fn from_node_hashes(a: TapNodeHash, b: TapNodeHash) -> TapNodeHash {
+        Self::combine_node_hashes(a, b).0
+    }
+
+    /// Computes branch hash given two hashes of the nodes underneath it and returns
+    /// whether the left node was the one hashed first.
+    fn combine_node_hashes(a: TapNodeHash, b: TapNodeHash) -> (TapNodeHash, bool) {
+        let mut eng = TapNodeHash::engine();
+        if a < b {
+            eng.input(a.as_ref());
+            eng.input(b.as_ref());
+        } else {
+            eng.input(b.as_ref());
+            eng.input(a.as_ref());
+        };
+        (TapNodeHash::from_engine(eng), a < b)
+    }
+
+    /// Assumes the given 32 byte array as hidden [`TapNodeHash`].
+    ///
+    /// Similar to [`TapLeafHash::from_byte_array`], but explicitly conveys that the
+    /// hash is constructed from a hidden node. This also has better ergonomics
+    /// because it does not require the caller to import the Hash trait.
+    pub fn assume_hidden(hash: [u8; 32]) -> TapNodeHash { TapNodeHash::from_byte_array(hash) }
+
+    /// Computes the [`TapNodeHash`] from a script and a leaf version.
+    pub fn from_script(script: &Script, ver: LeafVersion) -> TapNodeHash {
+        TapNodeHash::from(TapLeafHash::from_script(script, ver))
+    }
+}
+
+impl From<TapLeafHash> for TapNodeHash {
+    fn from(leaf: TapLeafHash) -> TapNodeHash { TapNodeHash::from_byte_array(leaf.to_byte_array()) }
+}
+
+/// Maximum depth of a taproot tree script spend path.
+// https://github.com/bitcoin/bitcoin/blob/e826b22da252e0599c61d21c98ff89f366b3120f/src/script/interpreter.h#L229
+pub const TAPROOT_CONTROL_MAX_NODE_COUNT: usize = 128;
+/// Size of a taproot control node.
+// https://github.com/bitcoin/bitcoin/blob/e826b22da252e0599c61d21c98ff89f366b3120f/src/script/interpreter.h#L228
+pub const TAPROOT_CONTROL_NODE_SIZE: usize = 32;
+/// Tapleaf mask for getting the leaf version from first byte of control block.
+// https://github.com/bitcoin/bitcoin/blob/e826b22da252e0599c61d21c98ff89f366b3120f/src/script/interpreter.h#L225
+pub const TAPROOT_LEAF_MASK: u8 = 0xfe;
+/// Tapscript leaf version.
+// https://github.com/bitcoin/bitcoin/blob/e826b22da252e0599c61d21c98ff89f366b3120f/src/script/interpreter.h#L226
+pub const TAPROOT_LEAF_TAPSCRIPT: u8 = 0xc0;
+/// Taproot annex prefix.
+pub const TAPROOT_ANNEX_PREFIX: u8 = 0x50;
+/// Tapscript control base size.
+// https://github.com/bitcoin/bitcoin/blob/e826b22da252e0599c61d21c98ff89f366b3120f/src/script/interpreter.h#L227
+pub const TAPROOT_CONTROL_BASE_SIZE: usize = 33;
+/// Tapscript control max size.
+// https://github.com/bitcoin/bitcoin/blob/e826b22da252e0599c61d21c98ff89f366b3120f/src/script/interpreter.h#L230
+pub const TAPROOT_CONTROL_MAX_SIZE: usize =
+    TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT;
+
+// type alias for versioned tap script corresponding merkle proof
+type ScriptMerkleProofMap = BTreeMap<(ScriptBuf, LeafVersion), BTreeSet<TaprootMerkleBranch>>;
+
+/// Represents taproot spending information.
+///
+/// Taproot output corresponds to a combination of a single public key condition (known as the
+/// internal key), and zero or more general conditions encoded in scripts organized in the form of a
+/// binary tree.
+///
+/// Taproot can be spent by either:
+/// - Spending using the key path i.e., with secret key corresponding to the tweaked `output_key`.
+/// - By satisfying any of the scripts in the script spend 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.
+///
+/// If one or more of the spending conditions consist of just a single key (after aggregation), the
+/// most likely key should be made the internal key.
+/// See [BIP341](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki) for more details on
+/// choosing internal keys for a taproot application.
+///
+/// Note: This library currently does not support
+/// [annex](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_note-5).
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+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<TapNodeHash>,
+    /// The sign final output pubkey as per BIP 341.
+    output_key_parity: secp256k1::Parity,
+    /// The tweaked output key.
+    output_key: TweakedPublicKey,
+    /// 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 a full tree can be constructed again from spending data if required.
+    script_map: ScriptMerkleProofMap,
+}
+
+impl TaprootSpendInfo {
+    /// Creates a new [`TaprootSpendInfo`] from a list of scripts (with default script version) and
+    /// weights of satisfaction for that script.
+    ///
+    /// See [`TaprootBuilder::with_huffman_tree`] for more detailed documentation.
+    pub fn with_huffman_tree<C, I>(
+        secp: &Secp256k1<C>,
+        internal_key: UntweakedPublicKey,
+        script_weights: I,
+    ) -> Result<Self, TaprootBuilderError>
+    where
+        I: IntoIterator<Item = (u32, ScriptBuf)>,
+        C: secp256k1::Verification,
+    {
+        let builder = TaprootBuilder::with_huffman_tree(script_weights)?;
+        Ok(builder.finalize(secp, internal_key).expect("Huffman Tree is always complete"))
+    }
+
+    /// Creates a new key spend with `internal_key` and `merkle_root`. Provide [`None`] for
+    /// the `merkle_root` if there is no script path.
+    ///
+    /// *Note*: As per BIP341
+    ///
+    /// When the merkle root is [`None`], the output key commits to an unspendable script path
+    /// instead of having no script path. This is achieved by computing the output key point as
+    /// `Q = P + int(hashTapTweak(bytes(P)))G`. See also [`TaprootSpendInfo::tap_tweak`].
+    ///
+    /// Refer to BIP 341 footnote ('Why should the output key always have a taproot commitment, even
+    /// if there is no script path?') for more details.
+    pub fn new_key_spend<C: secp256k1::Verification>(
+        secp: &Secp256k1<C>,
+        internal_key: UntweakedPublicKey,
+        merkle_root: Option<TapNodeHash>,
+    ) -> Self {
+        let (output_key, parity) = internal_key.tap_tweak(secp, merkle_root);
+        Self {
+            internal_key,
+            merkle_root,
+            output_key_parity: parity,
+            output_key,
+            script_map: BTreeMap::new(),
+        }
+    }
+
+    /// Returns the `TapTweakHash` for this [`TaprootSpendInfo`] i.e., the tweak using `internal_key`
+    /// and `merkle_root`.
+    pub fn tap_tweak(&self) -> TapTweakHash {
+        TapTweakHash::from_key_and_tweak(self.internal_key, self.merkle_root)
+    }
+
+    /// Returns the internal key for this [`TaprootSpendInfo`].
+    pub fn internal_key(&self) -> UntweakedPublicKey { self.internal_key }
+
+    /// Returns the merkle root for this [`TaprootSpendInfo`].
+    pub fn merkle_root(&self) -> Option<TapNodeHash> { self.merkle_root }
+
+    /// Returns the output key (the key used in script pubkey) for this [`TaprootSpendInfo`].
+    pub fn output_key(&self) -> TweakedPublicKey { self.output_key }
+
+    /// Returns the parity of the output key. See also [`TaprootSpendInfo::output_key`].
+    pub fn output_key_parity(&self) -> secp256k1::Parity { self.output_key_parity }
+
+    /// Returns a reference to the internal script map.
+    pub fn script_map(&self) -> &ScriptMerkleProofMap { &self.script_map }
+
+    /// Computes the [`TaprootSpendInfo`] from `internal_key` and `node`.
+    ///
+    /// This is useful when you want to manually build a taproot tree without using
+    /// [`TaprootBuilder`].
+    pub fn from_node_info<C: secp256k1::Verification>(
+        secp: &Secp256k1<C>,
+        internal_key: UntweakedPublicKey,
+        node: NodeInfo,
+    ) -> TaprootSpendInfo {
+        // Create as if it is a key spend path with the given merkle root
+        let root_hash = Some(node.hash);
+        let mut info = TaprootSpendInfo::new_key_spend(secp, internal_key, root_hash);
+
+        for leaves in node.leaves {
+            match leaves.leaf {
+                TapLeaf::Hidden(_) => {
+                    // We don't store any information about hidden nodes in TaprootSpendInfo.
+                }
+                TapLeaf::Script(script, ver) => {
+                    let key = (script, ver);
+                    let value = leaves.merkle_branch;
+                    match info.script_map.get_mut(&key) {
+                        None => {
+                            let mut set = BTreeSet::new();
+                            set.insert(value);
+                            info.script_map.insert(key, set);
+                        }
+                        Some(set) => {
+                            set.insert(value);
+                        }
+                    }
+                }
+            }
+        }
+        info
+    }
+
+    /// Returns the internal script map.
+    #[deprecated(since = "0.31.0", note = "use Self::script_map instead")]
+    pub fn as_script_map(&self) -> &ScriptMerkleProofMap { self.script_map() }
+
+    /// Constructs a [`ControlBlock`] for particular script with the given version.
+    ///
+    /// # Returns
+    ///
+    /// - If there are multiple control blocks possible, returns the shortest one.
+    /// - If the script is not contained in the [`TaprootSpendInfo`], returns `None`.
+    pub fn control_block(&self, script_ver: &(ScriptBuf, LeafVersion)) -> Option<ControlBlock> {
+        let merkle_branch_set = self.script_map.get(script_ver)?;
+        // Choose the smallest one amongst the multiple script maps
+        let smallest = merkle_branch_set
+            .iter()
+            .min_by(|x, y| x.0.len().cmp(&y.0.len()))
+            .expect("Invariant: ScriptBuf map key must contain non-empty set value");
+        Some(ControlBlock {
+            internal_key: self.internal_key,
+            output_key_parity: self.output_key_parity,
+            leaf_version: script_ver.1,
+            merkle_branch: smallest.clone(),
+        })
+    }
+}
+
+impl From<TaprootSpendInfo> for TapTweakHash {
+    fn from(spend_info: TaprootSpendInfo) -> TapTweakHash { spend_info.tap_tweak() }
+}
+
+impl From<&TaprootSpendInfo> for TapTweakHash {
+    fn from(spend_info: &TaprootSpendInfo) -> TapTweakHash { spend_info.tap_tweak() }
+}
+
+/// Builder for building taproot iteratively. Users can specify tap leaf or omitted/hidden branches
+/// in a depth-first search (DFS) walk order to construct this tree.
+///
+/// See Wikipedia for more details on [DFS](https://en.wikipedia.org/wiki/Depth-first_search).
+// Similar to Taproot Builder in Bitcoin Core.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct TaprootBuilder {
+    // The following doc-comment is from Bitcoin Core, but modified for Rust. It describes the
+    // current state of the builder for a given tree.
+    //
+    // For each level in the tree, one NodeInfo object may be present. Branch at index 0 is
+    // information about the root; further values are for deeper subtrees being explored.
+    //
+    // During the construction of Taptree, for every right branch taken to reach the position we're
+    // currently working on, there will be a `(Some(_))` entry in branch corresponding to the left
+    // branch at that level.
+    //
+    // For example, imagine this tree:     - N0 -
+    //                                    /      \
+    //                                   N1      N2
+    //                                  /  \    /  \
+    //                                 A    B  C   N3
+    //                                            /  \
+    //                                           D    E
+    //
+    // Initially, branch is empty. After processing leaf A, it would become {None, None, A}. When
+    // processing leaf B, an entry at level 2 already exists, and it would thus be combined with it
+    // to produce a level 1 entry, resulting in {None, N1}. Adding C and D takes us to {None, N1, C}
+    // and {None, N1, C, D} respectively. When E is processed, it is combined with D, and then C,
+    // and then N1, to produce the root, resulting in {N0}.
+    //
+    // This structure allows processing with just O(log n) overhead if the leaves are computed on
+    // the fly.
+    //
+    // As an invariant, there can never be None entries at the end. There can also not be more than
+    // 128 entries (as that would mean more than 128 levels in the tree). The depth of newly added
+    // entries will always be at least equal to the current size of branch (otherwise it does not
+    // correspond to a depth-first traversal of a tree). A branch is only empty if no entries have
+    // ever be processed. A branch having length 1 corresponds to being done.
+    branch: Vec<Option<NodeInfo>>,
+}
+
+impl TaprootBuilder {
+    /// Creates a new instance of [`TaprootBuilder`].
+    pub fn new() -> Self { TaprootBuilder { branch: vec![] } }
+
+    /// Creates a new instance of [`TaprootBuilder`] with a capacity hint for `size` elements.
+    ///
+    /// The size here should be maximum depth of the tree.
+    pub fn with_capacity(size: usize) -> Self {
+        TaprootBuilder { branch: Vec::with_capacity(size) }
+    }
+
+    /// Creates a new [`TaprootSpendInfo`] from a list of scripts (with default script version) and
+    /// weights of satisfaction for that script.
+    ///
+    /// The weights represent the probability of each branch being taken. If probabilities/weights
+    /// for each condition are known, constructing the tree as a Huffman Tree is the optimal way to
+    /// minimize average case satisfaction cost. This function takes as input an iterator of
+    /// `tuple(u32, ScriptBuf)` where `u32` represents the satisfaction weights of the branch. For
+    /// 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:
+    ///
+    /// - When the optimal Huffman Tree has a depth more than 128.
+    /// - If the provided list of script weights is empty.
+    ///
+    /// # Edge Cases:
+    ///
+    /// If the script weight calculations overflow, a sub-optimal tree may be generated. This should
+    /// not happen unless you are dealing with billions of branches with weights close to 2^32.
+    ///
+    /// [`TapTree`]: crate::taproot::TapTree
+    pub fn with_huffman_tree<I>(script_weights: I) -> Result<Self, TaprootBuilderError>
+    where
+        I: IntoIterator<Item = (u32, ScriptBuf)>,
+    {
+        let mut node_weights = BinaryHeap::<(Reverse<u32>, NodeInfo)>::new();
+        for (p, leaf) in script_weights {
+            node_weights
+                .push((Reverse(p), NodeInfo::new_leaf_with_ver(leaf, LeafVersion::TapScript)));
+        }
+        if node_weights.is_empty() {
+            return Err(TaprootBuilderError::EmptyTree);
+        }
+        while node_weights.len() > 1 {
+            // Combine the last two elements and insert a new node
+            let (p1, s1) = node_weights.pop().expect("len must be at least two");
+            let (p2, s2) = node_weights.pop().expect("len must be at least two");
+            // Insert the sum of first two in the tree as a new node
+            // N.B.: p1 + p2 can not practically saturate as you would need to have 2**32 max u32s
+            // from the input to overflow. However, saturating is a reasonable behavior here as
+            // huffman tree construction would treat all such elements as "very likely".
+            let p = Reverse(p1.0.saturating_add(p2.0));
+            node_weights.push((p, NodeInfo::combine(s1, s2)?));
+        }
+        // Every iteration of the loop reduces the node_weights.len() by exactly 1
+        // Therefore, the loop will eventually terminate with exactly 1 element
+        debug_assert_eq!(node_weights.len(), 1);
+        let node = node_weights.pop().expect("huffman tree algorithm is broken").1;
+        Ok(TaprootBuilder { branch: vec![Some(node)] })
+    }
+
+    /// Adds a leaf script at `depth` to the builder with script version `ver`. Errors if the leaves
+    /// are not provided in DFS walk order. The depth of the root node is 0.
+    pub fn add_leaf_with_ver(
+        self,
+        depth: u8,
+        script: ScriptBuf,
+        ver: LeafVersion,
+    ) -> Result<Self, TaprootBuilderError> {
+        let leaf = NodeInfo::new_leaf_with_ver(script, ver);
+        self.insert(leaf, depth)
+    }
+
+    /// Adds a leaf script at `depth` to the builder with default script version. Errors if the
+    /// leaves are not provided in DFS walk order. The depth of the root node is 0.
+    ///
+    /// See [`TaprootBuilder::add_leaf_with_ver`] for adding a leaf with specific version.
+    pub fn add_leaf(self, depth: u8, script: ScriptBuf) -> Result<Self, TaprootBuilderError> {
+        self.add_leaf_with_ver(depth, script, LeafVersion::TapScript)
+    }
+
+    /// Adds a hidden/omitted node at `depth` to the builder. Errors if the leaves are not provided
+    /// in DFS walk order. The depth of the root node is 0.
+    pub fn add_hidden_node(
+        self,
+        depth: u8,
+        hash: TapNodeHash,
+    ) -> Result<Self, TaprootBuilderError> {
+        let node = NodeInfo::new_hidden_node(hash);
+        self.insert(node, depth)
+    }
+
+    /// Checks if the builder has finalized building a tree.
+    pub fn is_finalizable(&self) -> bool { self.branch.len() == 1 && self.branch[0].is_some() }
+
+    /// Converts the builder into a [`NodeInfo`] if the builder is a full tree with possibly
+    /// hidden nodes
+    ///
+    /// # Errors:
+    ///
+    /// [`IncompleteBuilderError::NotFinalized`] if the builder is not finalized. The builder
+    /// can be restored by calling [`IncompleteBuilderError::into_builder`]
+    pub fn try_into_node_info(mut self) -> Result<NodeInfo, IncompleteBuilderError> {
+        if self.branch().len() != 1 {
+            return Err(IncompleteBuilderError::NotFinalized(self));
+        }
+        Ok(self
+            .branch
+            .pop()
+            .expect("length checked above")
+            .expect("invariant guarantees node info exists"))
+    }
+
+    /// Converts the builder into a [`TapTree`] if the builder is a full tree and
+    /// does not contain any hidden nodes
+    pub fn try_into_taptree(self) -> Result<TapTree, IncompleteBuilderError> {
+        let node = self.try_into_node_info()?;
+        if node.has_hidden_nodes {
+            // Reconstruct the builder as it was if it has hidden nodes
+            return Err(IncompleteBuilderError::HiddenParts(TaprootBuilder {
+                branch: vec![Some(node)],
+            }));
+        }
+        Ok(TapTree(node))
+    }
+
+    /// Checks if the builder has hidden nodes.
+    pub fn has_hidden_nodes(&self) -> bool {
+        self.branch.iter().flatten().any(|node| node.has_hidden_nodes)
+    }
+
+    /// Creates a [`TaprootSpendInfo`] with the given internal key.
+    ///
+    /// Returns the unmodified builder as Err if the builder is not finalizable.
+    /// See also [`TaprootBuilder::is_finalizable`]
+    pub fn finalize<C: secp256k1::Verification>(
+        mut self,
+        secp: &Secp256k1<C>,
+        internal_key: UntweakedPublicKey,
+    ) -> Result<TaprootSpendInfo, TaprootBuilder> {
+        match self.branch.len() {
+            0 => Ok(TaprootSpendInfo::new_key_spend(secp, internal_key, None)),
+            1 =>
+                if let Some(Some(node)) = self.branch.pop() {
+                    Ok(TaprootSpendInfo::from_node_info(secp, internal_key, node))
+                } else {
+                    unreachable!("Size checked above. Builder guarantees the last element is Some")
+                },
+            _ => Err(self),
+        }
+    }
+
+    pub(crate) fn branch(&self) -> &[Option<NodeInfo>] { &self.branch }
+
+    /// Inserts a leaf at `depth`.
+    fn insert(mut self, mut node: NodeInfo, mut depth: u8) -> Result<Self, TaprootBuilderError> {
+        // early error on invalid depth. Though this will be checked later
+        // while constructing TaprootMerkelBranch
+        if depth as usize > TAPROOT_CONTROL_MAX_NODE_COUNT {
+            return Err(TaprootBuilderError::InvalidMerkleTreeDepth(depth as usize));
+        }
+        // We cannot insert a leaf at a lower depth while a deeper branch is unfinished. Doing
+        // so would mean the add_leaf/add_hidden invocations do not correspond to a DFS traversal of a
+        // binary tree.
+        if (depth as usize + 1) < self.branch.len() {
+            return Err(TaprootBuilderError::NodeNotInDfsOrder);
+        }
+
+        while self.branch.len() == depth as usize + 1 {
+            let child = match self.branch.pop() {
+                None => unreachable!("Len of branch checked to be >= 1"),
+                Some(Some(child)) => child,
+                // Needs an explicit push to add the None that we just popped.
+                // Cannot use .last() because of borrow checker issues.
+                Some(None) => {
+                    self.branch.push(None);
+                    break;
+                } // Cannot combine further
+            };
+            if depth == 0 {
+                // We are trying to combine two nodes at root level.
+                // Can't propagate further up than the root
+                return Err(TaprootBuilderError::OverCompleteTree);
+            }
+            node = NodeInfo::combine(node, child)?;
+            // Propagate to combine nodes at a lower depth
+            depth -= 1;
+        }
+
+        if self.branch.len() < depth as usize + 1 {
+            // add enough nodes so that we can insert node at depth `depth`
+            let num_extra_nodes = depth as usize + 1 - self.branch.len();
+            self.branch.extend((0..num_extra_nodes).map(|_| None));
+        }
+        // Push the last node to the branch
+        self.branch[depth as usize] = Some(node);
+        Ok(self)
+    }
+}
+
+impl Default for TaprootBuilder {
+    fn default() -> Self { Self::new() }
+}
+
+/// Error happening when [`TapTree`] is constructed from a [`TaprootBuilder`]
+/// having hidden branches or not being finalized.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum IncompleteBuilderError {
+    /// Indicates an attempt to construct a tap tree from a builder containing incomplete branches.
+    NotFinalized(TaprootBuilder),
+    /// Indicates an attempt to construct a tap tree from a builder containing hidden parts.
+    HiddenParts(TaprootBuilder),
+}
+
+impl IncompleteBuilderError {
+    /// Converts error into the original incomplete [`TaprootBuilder`] instance.
+    pub fn into_builder(self) -> TaprootBuilder {
+        use IncompleteBuilderError::*;
+
+        match self {
+            NotFinalized(builder) | HiddenParts(builder) => builder,
+        }
+    }
+}
+
+impl core::fmt::Display for IncompleteBuilderError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use IncompleteBuilderError::*;
+
+        f.write_str(match self {
+            NotFinalized(_) =>
+                "an attempt to construct a tap tree from a builder containing incomplete branches.",
+            HiddenParts(_) =>
+                "an attempt to construct a tap tree from a builder containing hidden parts.",
+        })
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for IncompleteBuilderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use IncompleteBuilderError::*;
+
+        match *self {
+            NotFinalized(_) | HiddenParts(_) => None,
+        }
+    }
+}
+
+/// Error happening when [`TapTree`] is constructed from a [`NodeInfo`]
+/// having hidden branches.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum HiddenNodesError {
+    /// Indicates an attempt to construct a tap tree from a builder containing hidden parts.
+    HiddenParts(NodeInfo),
+}
+
+impl HiddenNodesError {
+    /// Converts error into the original incomplete [`NodeInfo`] instance.
+    pub fn into_node_info(self) -> NodeInfo {
+        use HiddenNodesError::*;
+
+        match self {
+            HiddenParts(node_info) => node_info,
+        }
+    }
+}
+
+impl core::fmt::Display for HiddenNodesError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use HiddenNodesError::*;
+
+        f.write_str(match self {
+            HiddenParts(_) =>
+                "an attempt to construct a tap tree from a node_info containing hidden parts.",
+        })
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for HiddenNodesError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use HiddenNodesError::*;
+
+        match self {
+            HiddenParts(_) => None,
+        }
+    }
+}
+
+/// Taproot Tree representing a complete binary tree without any hidden nodes.
+///
+/// This is in contrast to [`NodeInfo`], which allows hidden nodes.
+/// The implementations for Eq, PartialEq and Hash compare the merkle root of the tree
+//
+// This is a bug in BIP370 that does not specify how to share trees with hidden nodes,
+// for which we need a separate type.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", serde(into = "NodeInfo"))]
+#[cfg_attr(feature = "serde", serde(try_from = "NodeInfo"))]
+pub struct TapTree(NodeInfo);
+
+impl From<TapTree> for NodeInfo {
+    #[inline]
+    fn from(tree: TapTree) -> Self { tree.into_node_info() }
+}
+
+impl TapTree {
+    /// Gets the reference to inner [`NodeInfo`] of this tree root.
+    pub fn node_info(&self) -> &NodeInfo { &self.0 }
+
+    /// Gets the inner [`NodeInfo`] of this tree root.
+    pub fn into_node_info(self) -> NodeInfo { self.0 }
+
+    /// Returns [`TapTreeIter<'_>`] iterator for a taproot script tree, operating in DFS order over
+    /// tree [`ScriptLeaf`]s.
+    pub fn script_leaves(&self) -> ScriptLeaves { ScriptLeaves { leaf_iter: self.0.leaf_nodes() } }
+}
+
+impl TryFrom<TaprootBuilder> for TapTree {
+    type Error = IncompleteBuilderError;
+
+    /// Constructs [`TapTree`] from a [`TaprootBuilder`] if it is complete binary tree.
+    ///
+    /// # Returns
+    ///
+    /// A [`TapTree`] iff the `builder` is complete, otherwise return [`IncompleteBuilderError`]
+    /// error with the content of incomplete `builder` instance.
+    fn try_from(builder: TaprootBuilder) -> Result<Self, Self::Error> { builder.try_into_taptree() }
+}
+
+impl TryFrom<NodeInfo> for TapTree {
+    type Error = HiddenNodesError;
+
+    /// Constructs [`TapTree`] from a [`NodeInfo`] if it is complete binary tree.
+    ///
+    /// # Returns
+    ///
+    /// A [`TapTree`] iff the [`NodeInfo`] has no hidden nodes, otherwise return
+    /// [`HiddenNodesError`] error with the content of incomplete [`NodeInfo`] instance.
+    fn try_from(node_info: NodeInfo) -> Result<Self, Self::Error> {
+        if node_info.has_hidden_nodes {
+            Err(HiddenNodesError::HiddenParts(node_info))
+        } else {
+            Ok(TapTree(node_info))
+        }
+    }
+}
+
+/// Iterator for a taproot script tree, operating in DFS order yielding [`ScriptLeaf`].
+///
+/// Returned by [`TapTree::script_leaves`]. [`TapTree`] does not allow hidden nodes,
+/// so this iterator is guaranteed to yield all known leaves.
+pub struct ScriptLeaves<'tree> {
+    leaf_iter: LeafNodes<'tree>,
+}
+
+impl<'tree> Iterator for ScriptLeaves<'tree> {
+    type Item = ScriptLeaf<'tree>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> { ScriptLeaf::from_leaf_node(self.leaf_iter.next()?) }
+
+    fn size_hint(&self) -> (usize, Option<usize>) { self.leaf_iter.size_hint() }
+}
+
+impl<'tree> ExactSizeIterator for ScriptLeaves<'tree> {}
+
+impl<'tree> FusedIterator for ScriptLeaves<'tree> {}
+
+impl<'tree> DoubleEndedIterator for ScriptLeaves<'tree> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        ScriptLeaf::from_leaf_node(self.leaf_iter.next_back()?)
+    }
+}
+/// Iterator for a taproot script tree, operating in DFS order yielding [`LeafNode`].
+///
+/// Returned by [`NodeInfo::leaf_nodes`]. This can potentially yield hidden nodes.
+pub struct LeafNodes<'a> {
+    leaf_iter: core::slice::Iter<'a, LeafNode>,
+}
+
+impl<'a> Iterator for LeafNodes<'a> {
+    type Item = &'a LeafNode;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> { self.leaf_iter.next() }
+
+    fn size_hint(&self) -> (usize, Option<usize>) { self.leaf_iter.size_hint() }
+}
+
+impl<'tree> ExactSizeIterator for LeafNodes<'tree> {}
+
+impl<'tree> FusedIterator for LeafNodes<'tree> {}
+
+impl<'tree> DoubleEndedIterator for LeafNodes<'tree> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> { self.leaf_iter.next_back() }
+}
+/// Represents the node information in taproot tree. In contrast to [`TapTree`], this
+/// is allowed to have hidden leaves as children.
+///
+/// Helper type used in merkle tree construction allowing one to build sparse merkle trees. The node
+/// represents part of the tree that has information about all of its descendants.
+/// See how [`TaprootBuilder`] works for more details.
+///
+/// You can use [`TaprootSpendInfo::from_node_info`] to a get a [`TaprootSpendInfo`] from the merkle
+/// root [`NodeInfo`].
+#[derive(Debug, Clone, PartialOrd, Ord)]
+pub struct NodeInfo {
+    /// Merkle hash for this node.
+    pub(crate) hash: TapNodeHash,
+    /// Information about leaves inside this node.
+    pub(crate) leaves: Vec<LeafNode>,
+    /// Tracks information on hidden nodes below this node.
+    pub(crate) has_hidden_nodes: bool,
+}
+
+impl PartialEq for NodeInfo {
+    fn eq(&self, other: &Self) -> bool { self.hash.eq(&other.hash) }
+}
+
+impl core::hash::Hash for NodeInfo {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) { self.hash.hash(state) }
+}
+
+impl Eq for NodeInfo {}
+
+impl NodeInfo {
+    /// Creates a new [`NodeInfo`] with omitted/hidden info.
+    pub fn new_hidden_node(hash: TapNodeHash) -> Self {
+        Self { hash, leaves: vec![], has_hidden_nodes: true }
+    }
+
+    /// Creates a new leaf [`NodeInfo`] with given [`ScriptBuf`] and [`LeafVersion`].
+    pub fn new_leaf_with_ver(script: ScriptBuf, ver: LeafVersion) -> Self {
+        Self {
+            hash: TapNodeHash::from_script(&script, ver),
+            leaves: vec![LeafNode::new_script(script, ver)],
+            has_hidden_nodes: false,
+        }
+    }
+
+    /// Combines two [`NodeInfo`] 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());
+        let (hash, left_first) = TapNodeHash::combine_node_hashes(a.hash, b.hash);
+        let (a, b) = if left_first { (a, b) } else { (b, a) };
+        for mut a_leaf in a.leaves {
+            a_leaf.merkle_branch.push(b.hash)?; // add hashing partner
+            all_leaves.push(a_leaf);
+        }
+        for mut b_leaf in b.leaves {
+            b_leaf.merkle_branch.push(a.hash)?; // add hashing partner
+            all_leaves.push(b_leaf);
+        }
+        Ok(Self {
+            hash,
+            leaves: all_leaves,
+            has_hidden_nodes: a.has_hidden_nodes || b.has_hidden_nodes,
+        })
+    }
+
+    /// Creates an iterator over all leaves (including hidden leaves) in the tree.
+    pub fn leaf_nodes(&self) -> LeafNodes { LeafNodes { leaf_iter: self.leaves.iter() } }
+}
+
+impl TryFrom<TaprootBuilder> for NodeInfo {
+    type Error = IncompleteBuilderError;
+
+    fn try_from(builder: TaprootBuilder) -> Result<Self, Self::Error> {
+        builder.try_into_node_info()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for NodeInfo {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeSeq;
+        let mut seq = serializer.serialize_seq(Some(self.leaves.len() * 2))?;
+        for tap_leaf in self.leaves.iter() {
+            seq.serialize_element(&tap_leaf.merkle_branch().len())?;
+            seq.serialize_element(&tap_leaf.leaf)?;
+        }
+        seq.end()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for NodeInfo {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct SeqVisitor;
+        impl<'de> serde::de::Visitor<'de> for SeqVisitor {
+            type Value = NodeInfo;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("Taproot tree in DFS walk order")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: serde::de::SeqAccess<'de>,
+            {
+                let size = seq
+                    .size_hint()
+                    .map(|x| core::mem::size_of::<usize>() * 8 - x.leading_zeros() as usize)
+                    .map(|x| x / 2) // Each leaf is serialized as two elements.
+                    .unwrap_or(0)
+                    .min(TAPROOT_CONTROL_MAX_NODE_COUNT); // no more than 128 nodes
+                let mut builder = TaprootBuilder::with_capacity(size);
+                while let Some(depth) = seq.next_element()? {
+                    let tap_leaf: TapLeaf = seq
+                        .next_element()?
+                        .ok_or_else(|| serde::de::Error::custom("Missing tap_leaf"))?;
+                    match tap_leaf {
+                        TapLeaf::Script(script, ver) => {
+                            builder =
+                                builder.add_leaf_with_ver(depth, script, ver).map_err(|e| {
+                                    serde::de::Error::custom(format!("Leaf insertion error: {}", e))
+                                })?;
+                        }
+                        TapLeaf::Hidden(h) => {
+                            builder = builder.add_hidden_node(depth, h).map_err(|e| {
+                                serde::de::Error::custom(format!(
+                                    "Hidden node insertion error: {}",
+                                    e
+                                ))
+                            })?;
+                        }
+                    }
+                }
+                NodeInfo::try_from(builder).map_err(|e| {
+                    serde::de::Error::custom(format!("Incomplete taproot tree: {}", e))
+                })
+            }
+        }
+
+        deserializer.deserialize_seq(SeqVisitor)
+    }
+}
+
+/// Leaf node in a taproot tree. Can be either hidden or known.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub enum TapLeaf {
+    /// A known script
+    Script(ScriptBuf, LeafVersion),
+    /// Hidden Node with the given leaf hash
+    Hidden(TapNodeHash),
+}
+
+impl TapLeaf {
+    /// Obtains the hidden leaf hash if the leaf is hidden.
+    pub fn as_hidden(&self) -> Option<&TapNodeHash> {
+        if let Self::Hidden(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+
+    /// Obtains a reference to script and version if the leaf is known.
+    pub fn as_script(&self) -> Option<(&Script, LeafVersion)> {
+        if let Self::Script(script, ver) = self {
+            Some((script, *ver))
+        } else {
+            None
+        }
+    }
+}
+
+/// Store information about taproot leaf node.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct LeafNode {
+    /// The [`TapLeaf`]
+    leaf: TapLeaf,
+    /// The merkle proof (hashing partners) to get this node.
+    merkle_branch: TaprootMerkleBranch,
+}
+
+impl LeafNode {
+    /// Creates an new [`ScriptLeaf`] from `script` and `ver` and no merkle branch.
+    pub fn new_script(script: ScriptBuf, ver: LeafVersion) -> Self {
+        Self { leaf: TapLeaf::Script(script, ver), merkle_branch: TaprootMerkleBranch(vec![]) }
+    }
+
+    /// Creates an new [`ScriptLeaf`] from `hash` and no merkle branch.
+    pub fn new_hidden(hash: TapNodeHash) -> Self {
+        Self { leaf: TapLeaf::Hidden(hash), merkle_branch: TaprootMerkleBranch(vec![]) }
+    }
+
+    /// Returns the depth of this script leaf in the tap tree.
+    #[inline]
+    pub fn depth(&self) -> u8 {
+        // Depth is guarded by TAPROOT_CONTROL_MAX_NODE_COUNT.
+        u8::try_from(self.merkle_branch().0.len()).expect("depth is guaranteed to fit in a u8")
+    }
+
+    /// Computes a leaf hash for this [`ScriptLeaf`] if the leaf is known.
+    ///
+    /// This [`TapLeafHash`] is useful while signing taproot script spends.
+    ///
+    /// See [`LeafNode::node_hash`] for computing the [`TapNodeHash`] which returns the hidden node
+    /// hash if the node is hidden.
+    #[inline]
+    pub fn leaf_hash(&self) -> Option<TapLeafHash> {
+        let (script, ver) = self.leaf.as_script()?;
+        Some(TapLeafHash::from_script(script, ver))
+    }
+
+    /// Computes the [`TapNodeHash`] for this [`ScriptLeaf`]. This returns the
+    /// leaf hash if the leaf is known and the hidden node hash if the leaf is
+    /// hidden.
+    /// See also, [`LeafNode::leaf_hash`].
+    #[inline]
+    pub fn node_hash(&self) -> TapNodeHash {
+        match self.leaf {
+            TapLeaf::Script(ref script, ver) => TapLeafHash::from_script(script, ver).into(),
+            TapLeaf::Hidden(ref hash) => *hash,
+        }
+    }
+
+    /// Returns reference to the leaf script if the leaf is known.
+    #[inline]
+    pub fn script(&self) -> Option<&Script> { self.leaf.as_script().map(|x| x.0) }
+
+    /// Returns leaf version of the script if the leaf is known.
+    #[inline]
+    pub fn leaf_version(&self) -> Option<LeafVersion> { self.leaf.as_script().map(|x| x.1) }
+
+    /// Returns reference to the merkle proof (hashing partners) to get this
+    /// node in form of [`TaprootMerkleBranch`].
+    #[inline]
+    pub fn merkle_branch(&self) -> &TaprootMerkleBranch { &self.merkle_branch }
+
+    /// Returns a reference to the leaf of this [`ScriptLeaf`].
+    #[inline]
+    pub fn leaf(&self) -> &TapLeaf { &self.leaf }
+}
+
+/// Script leaf node in a taproot tree along with the merkle proof to get this node.
+/// Returned by [`TapTree::script_leaves`]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ScriptLeaf<'leaf> {
+    /// The version of the script leaf.
+    version: LeafVersion,
+    /// The script.
+    script: &'leaf Script,
+    /// The merkle proof (hashing partners) to get this node.
+    merkle_branch: &'leaf TaprootMerkleBranch,
+}
+
+impl<'leaf> ScriptLeaf<'leaf> {
+    /// Obtains the version of the script leaf.
+    pub fn version(&self) -> LeafVersion { self.version }
+
+    /// Obtains a reference to the script inside the leaf.
+    pub fn script(&self) -> &Script { self.script }
+
+    /// Obtains a reference to the merkle proof of the leaf.
+    pub fn merkle_branch(&self) -> &TaprootMerkleBranch { self.merkle_branch }
+
+    /// Obtains a script leaf from the leaf node if the leaf is not hidden.
+    pub fn from_leaf_node(leaf_node: &'leaf LeafNode) -> Option<Self> {
+        let (script, ver) = leaf_node.leaf.as_script()?;
+        Some(Self { version: ver, script, merkle_branch: &leaf_node.merkle_branch })
+    }
+}
+
+/// The merkle proof for inclusion of a tree in a taptree hash.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde", serde(into = "Vec<TapNodeHash>"))]
+#[cfg_attr(feature = "serde", serde(try_from = "Vec<TapNodeHash>"))]
+pub struct TaprootMerkleBranch(Vec<TapNodeHash>);
+
+impl TaprootMerkleBranch {
+    /// Returns a reference to the inner vector of hashes.
+    pub fn as_inner(&self) -> &[TapNodeHash] { &self.0 }
+
+    /// Returns the number of nodes in this merkle proof.
+    pub fn len(&self) -> usize { self.0.len() }
+
+    /// Checks if this merkle proof is empty.
+    pub fn is_empty(&self) -> bool { self.0.is_empty() }
+
+    /// Decodes bytes from control block.
+    ///
+    /// This reads the branch as encoded in the control block: the concatenated 32B byte chunks -
+    /// one for each hash.
+    ///
+    /// # Errors
+    ///
+    /// The function returns an error if the the number of bytes is not an integer multiple of 32 or
+    /// if the number of hashes exceeds 128.
+    pub fn decode(sl: &[u8]) -> Result<Self, TaprootError> {
+        if sl.len() % TAPROOT_CONTROL_NODE_SIZE != 0 {
+            Err(TaprootError::InvalidMerkleBranchSize(sl.len()))
+        } else if sl.len() > TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT {
+            Err(TaprootError::InvalidMerkleTreeDepth(sl.len() / TAPROOT_CONTROL_NODE_SIZE))
+        } else {
+            let inner = sl
+                .chunks_exact(TAPROOT_CONTROL_NODE_SIZE)
+                .map(|chunk| {
+                    TapNodeHash::from_slice(chunk)
+                        .expect("chunks_exact always returns the correct size")
+                })
+                .collect();
+
+            Ok(TaprootMerkleBranch(inner))
+        }
+    }
+
+    /// Creates a merkle proof from list of hashes.
+    ///
+    /// # Errors
+    /// If inner proof length is more than [`TAPROOT_CONTROL_MAX_NODE_COUNT`] (128).
+    fn from_collection<T: AsRef<[TapNodeHash]> + Into<Vec<TapNodeHash>>>(
+        collection: T,
+    ) -> Result<Self, TaprootError> {
+        if collection.as_ref().len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
+            Err(TaprootError::InvalidMerkleTreeDepth(collection.as_ref().len()))
+        } else {
+            Ok(TaprootMerkleBranch(collection.into()))
+        }
+    }
+
+    /// Serializes to a writer.
+    ///
+    /// # Returns
+    ///
+    /// The number of bytes written to the writer.
+    pub fn encode<Write: io::Write>(&self, mut writer: Write) -> io::Result<usize> {
+        for hash in self.0.iter() {
+            writer.write_all(hash.as_ref())?;
+        }
+        Ok(self.0.len() * TapNodeHash::LEN)
+    }
+
+    /// Serializes `self` as bytes.
+    pub fn serialize(&self) -> Vec<u8> {
+        self.0.iter().flat_map(|e| e.as_byte_array()).copied().collect::<Vec<u8>>()
+    }
+
+    /// Appends elements to proof.
+    fn push(&mut self, h: TapNodeHash) -> Result<(), TaprootBuilderError> {
+        if self.0.len() >= TAPROOT_CONTROL_MAX_NODE_COUNT {
+            Err(TaprootBuilderError::InvalidMerkleTreeDepth(self.0.len()))
+        } else {
+            self.0.push(h);
+            Ok(())
+        }
+    }
+
+    /// Returns the inner list of hashes.
+    pub fn into_inner(self) -> Vec<TapNodeHash> { self.0 }
+}
+
+macro_rules! impl_try_from {
+    ($from:ty) => {
+        impl TryFrom<$from> for TaprootMerkleBranch {
+            type Error = TaprootError;
+
+            /// Creates a merkle proof from list of hashes.
+            ///
+            /// # Errors
+            /// If inner proof length is more than [`TAPROOT_CONTROL_MAX_NODE_COUNT`] (128).
+            fn try_from(v: $from) -> Result<Self, Self::Error> {
+                TaprootMerkleBranch::from_collection(v)
+            }
+        }
+    };
+}
+impl_try_from!(&[TapNodeHash]);
+impl_try_from!(Vec<TapNodeHash>);
+impl_try_from!(Box<[TapNodeHash]>);
+
+macro_rules! impl_try_from_array {
+    ($($len:expr),* $(,)?) => {
+        $(
+            impl From<[TapNodeHash; $len]> for TaprootMerkleBranch {
+                fn from(a: [TapNodeHash; $len]) -> Self {
+                    Self(a.to_vec())
+                }
+            }
+        )*
+    }
+}
+// Implement for all values [0, 128] inclusive.
+//
+// The reason zero is included is that `TaprootMerkleBranch` doesn't contain the hash of the node
+// that's being proven - it's not needed because the script is already right before control block.
+impl_try_from_array!(
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+    26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
+    50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
+    74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
+    98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
+    117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128
+);
+
+impl From<TaprootMerkleBranch> for Vec<TapNodeHash> {
+    fn from(branch: TaprootMerkleBranch) -> Self { branch.0 }
+}
+
+/// Control block data structure used in Tapscript satisfaction.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+pub struct ControlBlock {
+    /// The tapleaf version.
+    pub leaf_version: LeafVersion,
+    /// The parity of the output key (NOT THE INTERNAL KEY WHICH IS ALWAYS XONLY).
+    pub output_key_parity: secp256k1::Parity,
+    /// The internal key.
+    pub internal_key: UntweakedPublicKey,
+    /// The merkle proof of a script associated with this leaf.
+    pub merkle_branch: TaprootMerkleBranch,
+}
+
+impl ControlBlock {
+    /// Decodes bytes representing a `ControlBlock`.
+    ///
+    /// 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
+    ///
+    /// - [`TaprootError::InvalidControlBlockSize`] if `sl` is not of size 1 + 32 + 32N for any N >= 0.
+    /// - [`TaprootError::InvalidParity`] if first byte of `sl` is not a valid output key parity.
+    /// - [`TaprootError::InvalidTaprootLeafVersion`] if first byte of `sl` is not a valid leaf version.
+    /// - [`TaprootError::InvalidInternalKey`] if internal key is invalid (first 32 bytes after the parity byte).
+    /// - [`TaprootError::InvalidMerkleTreeDepth`] if merkle tree is too deep (more than 128 levels).
+    pub fn decode(sl: &[u8]) -> Result<ControlBlock, TaprootError> {
+        if sl.len() < TAPROOT_CONTROL_BASE_SIZE
+            || (sl.len() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE != 0
+        {
+            return Err(TaprootError::InvalidControlBlockSize(sl.len()));
+        }
+        let output_key_parity =
+            secp256k1::Parity::from_i32((sl[0] & 1) as i32).map_err(TaprootError::InvalidParity)?;
+        let leaf_version = LeafVersion::from_consensus(sl[0] & TAPROOT_LEAF_MASK)?;
+        let internal_key = UntweakedPublicKey::from_slice(&sl[1..TAPROOT_CONTROL_BASE_SIZE])
+            .map_err(TaprootError::InvalidInternalKey)?;
+        let merkle_branch = TaprootMerkleBranch::decode(&sl[TAPROOT_CONTROL_BASE_SIZE..])?;
+        Ok(ControlBlock { leaf_version, output_key_parity, internal_key, merkle_branch })
+    }
+
+    /// Returns the size of control block. Faster and more efficient than calling
+    /// `Self::serialize().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()
+    }
+
+    /// Serializes to a writer.
+    ///
+    /// # Returns
+    ///
+    /// The number of bytes written to the writer.
+    pub fn encode<Write: io::Write>(&self, mut writer: Write) -> io::Result<usize> {
+        let first_byte: u8 =
+            i32::from(self.output_key_parity) as u8 | self.leaf_version.to_consensus();
+        writer.write_all(&[first_byte])?;
+        writer.write_all(&self.internal_key.serialize())?;
+        self.merkle_branch.encode(&mut writer)?;
+        Ok(self.size())
+    }
+
+    /// Serializes the control block.
+    ///
+    /// This would be required when using [`ControlBlock`] as a witness element while spending an
+    /// output via script path. This serialization does not include the [`crate::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());
+        self.encode(&mut buf).expect("writers don't error");
+        buf
+    }
+
+    /// Verifies that a control block is correct proof for a given output key and script.
+    ///
+    /// Only checks that script is contained inside the taptree described by output key. Full
+    /// verification must also execute the script with witness data.
+    pub fn verify_taproot_commitment<C: secp256k1::Verification>(
+        &self,
+        secp: &Secp256k1<C>,
+        output_key: XOnlyPublicKey,
+        script: &Script,
+    ) -> bool {
+        // compute the script hash
+        // Initially the curr_hash is the leaf hash
+        let mut curr_hash = TapNodeHash::from_script(script, self.leaf_version);
+        // Verify the proof
+        for elem in self.merkle_branch.as_inner() {
+            // Recalculate the curr hash as parent hash
+            curr_hash = TapNodeHash::from_node_hashes(curr_hash, *elem);
+        }
+        // compute the taptweak
+        let tweak =
+            TapTweakHash::from_key_and_tweak(self.internal_key, Some(curr_hash)).to_scalar();
+        self.internal_key.tweak_add_check(secp, &output_key, self.output_key_parity, tweak)
+    }
+}
+
+/// Inner type representing future (non-tapscript) leaf versions. See [`LeafVersion::Future`].
+///
+/// NB: NO PUBLIC CONSTRUCTOR!
+/// The only way to construct this is by converting `u8` to [`LeafVersion`] and then extracting it.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
+pub struct FutureLeafVersion(u8);
+
+impl FutureLeafVersion {
+    pub(self) fn from_consensus(version: u8) -> Result<FutureLeafVersion, TaprootError> {
+        match version {
+            TAPROOT_LEAF_TAPSCRIPT => unreachable!(
+                "FutureLeafVersion::from_consensus should be never called for 0xC0 value"
+            ),
+            TAPROOT_ANNEX_PREFIX =>
+                Err(TaprootError::InvalidTaprootLeafVersion(TAPROOT_ANNEX_PREFIX)),
+            odd if odd & 0xFE != odd => Err(TaprootError::InvalidTaprootLeafVersion(odd)),
+            even => Ok(FutureLeafVersion(even)),
+        }
+    }
+
+    /// Returns the consensus representation of this [`FutureLeafVersion`].
+    #[inline]
+    pub fn to_consensus(self) -> u8 { self.0 }
+}
+
+impl fmt::Display for FutureLeafVersion {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
+}
+
+impl fmt::LowerHex for FutureLeafVersion {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
+}
+
+impl fmt::UpperHex for FutureLeafVersion {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::UpperHex::fmt(&self.0, f) }
+}
+
+/// The leaf version for tapleafs.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum LeafVersion {
+    /// BIP-342 tapscript.
+    TapScript,
+
+    /// Future leaf version.
+    Future(FutureLeafVersion),
+}
+
+impl LeafVersion {
+    /// Creates a [`LeafVersion`] from consensus byte representation.
+    ///
+    /// # Errors
+    ///
+    /// - If the last bit of the `version` is odd.
+    /// - If the `version` is 0x50 ([`TAPROOT_ANNEX_PREFIX`]).
+    pub fn from_consensus(version: u8) -> Result<Self, TaprootError> {
+        match version {
+            TAPROOT_LEAF_TAPSCRIPT => Ok(LeafVersion::TapScript),
+            TAPROOT_ANNEX_PREFIX =>
+                Err(TaprootError::InvalidTaprootLeafVersion(TAPROOT_ANNEX_PREFIX)),
+            future => FutureLeafVersion::from_consensus(future).map(LeafVersion::Future),
+        }
+    }
+
+    /// Returns the consensus representation of this [`LeafVersion`].
+    pub fn to_consensus(self) -> u8 {
+        match self {
+            LeafVersion::TapScript => TAPROOT_LEAF_TAPSCRIPT,
+            LeafVersion::Future(version) => version.to_consensus(),
+        }
+    }
+}
+
+impl fmt::Display for LeafVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match (self, f.alternate()) {
+            (LeafVersion::TapScript, true) => f.write_str("tapscript"),
+            (LeafVersion::TapScript, false) => fmt::Display::fmt(&TAPROOT_LEAF_TAPSCRIPT, f),
+            (LeafVersion::Future(version), true) => write!(f, "future_script_{:#02x}", version.0),
+            (LeafVersion::Future(version), false) => fmt::Display::fmt(version, f),
+        }
+    }
+}
+
+impl fmt::LowerHex for LeafVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::LowerHex::fmt(&self.to_consensus(), f)
+    }
+}
+
+impl fmt::UpperHex for LeafVersion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::UpperHex::fmt(&self.to_consensus(), f)
+    }
+}
+
+/// Serializes [`LeafVersion`] as a `u8` using consensus encoding.
+#[cfg(feature = "serde")]
+impl serde::Serialize for LeafVersion {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_u8(self.to_consensus())
+    }
+}
+
+/// Deserializes [`LeafVersion`] as a `u8` using consensus encoding.
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for LeafVersion {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct U8Visitor;
+        impl<'de> serde::de::Visitor<'de> for U8Visitor {
+            type Value = LeafVersion;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a valid consensus-encoded taproot leaf version")
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                let value = u8::try_from(value).map_err(|_| {
+                    E::invalid_value(
+                        serde::de::Unexpected::Unsigned(value),
+                        &"consensus-encoded leaf version as u8",
+                    )
+                })?;
+                LeafVersion::from_consensus(value).map_err(|_| {
+                    E::invalid_value(
+                        ::serde::de::Unexpected::Unsigned(value as u64),
+                        &"consensus-encoded leaf version as u8",
+                    )
+                })
+            }
+        }
+
+        deserializer.deserialize_u8(U8Visitor)
+    }
+}
+
+/// Detailed error type for taproot builder.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum TaprootBuilderError {
+    /// Merkle tree depth must not be more than 128.
+    InvalidMerkleTreeDepth(usize),
+    /// Nodes must be added specified in DFS walk order.
+    NodeNotInDfsOrder,
+    /// Two nodes at depth 0 are not allowed.
+    OverCompleteTree,
+    /// Invalid taproot internal key.
+    InvalidInternalKey(secp256k1::Error),
+    /// Called finalize on a empty tree.
+    EmptyTree,
+}
+
+impl fmt::Display for TaprootBuilderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use TaprootBuilderError::*;
+
+        match *self {
+            InvalidMerkleTreeDepth(d) => {
+                write!(
+                    f,
+                    "Merkle Tree depth({}) must be less than {}",
+                    d, TAPROOT_CONTROL_MAX_NODE_COUNT
+                )
+            }
+            NodeNotInDfsOrder => {
+                write!(f, "add_leaf/add_hidden must be called in DFS walk order",)
+            }
+            OverCompleteTree => write!(
+                f,
+                "Attempted to create a tree with two nodes at depth 0. There must\
+                only be a exactly one node at depth 0",
+            ),
+            InvalidInternalKey(ref e) => {
+                write_err!(f, "invalid internal x-only key"; e)
+            }
+            EmptyTree => {
+                write!(f, "Called finalize on an empty tree")
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TaprootBuilderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TaprootBuilderError::*;
+
+        match self {
+            InvalidInternalKey(e) => Some(e),
+            InvalidMerkleTreeDepth(_) | NodeNotInDfsOrder | OverCompleteTree | EmptyTree => None,
+        }
+    }
+}
+
+/// Detailed error type for taproot utilities.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum TaprootError {
+    /// Proof size must be a multiple of 32.
+    InvalidMerkleBranchSize(usize),
+    /// Merkle tree depth must not be more than 128.
+    InvalidMerkleTreeDepth(usize),
+    /// The last bit of tapleaf version must be zero.
+    InvalidTaprootLeafVersion(u8),
+    /// Invalid control block size.
+    InvalidControlBlockSize(usize),
+    /// Invalid taproot internal key.
+    InvalidInternalKey(secp256k1::Error),
+    /// Invalid parity for internal key.
+    InvalidParity(secp256k1::InvalidParityValue),
+    /// Empty tap tree.
+    EmptyTree,
+}
+
+impl fmt::Display for TaprootError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use TaprootError::*;
+
+        match *self {
+            InvalidMerkleBranchSize(sz) => write!(
+                f,
+                "Merkle branch size({}) must be a multiple of {}",
+                sz, TAPROOT_CONTROL_NODE_SIZE
+            ),
+            InvalidMerkleTreeDepth(d) => write!(
+                f,
+                "Merkle Tree depth({}) must be less than {}",
+                d, TAPROOT_CONTROL_MAX_NODE_COUNT
+            ),
+            InvalidTaprootLeafVersion(v) => {
+                write!(f, "Leaf version({}) must have the least significant bit 0", v)
+            }
+            InvalidControlBlockSize(sz) => write!(
+                f,
+                "Control Block size({}) must be of the form 33 + 32*m where  0 <= m <= {} ",
+                sz, TAPROOT_CONTROL_MAX_NODE_COUNT
+            ),
+            InvalidInternalKey(ref e) => {
+                write_err!(f, "invalid internal x-only key"; e)
+            }
+            InvalidParity(_) => write!(f, "invalid parity value for internal key"),
+            EmptyTree => write!(f, "Taproot Tree must contain at least one script"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TaprootError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TaprootError::*;
+
+        match self {
+            InvalidInternalKey(e) => Some(e),
+            InvalidMerkleBranchSize(_)
+            | InvalidMerkleTreeDepth(_)
+            | InvalidTaprootLeafVersion(_)
+            | InvalidControlBlockSize(_)
+            | InvalidParity(_)
+            | EmptyTree => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use core::str::FromStr;
+
+    use hashes::sha256t::Tag;
+    use hashes::{sha256, Hash, HashEngine};
+    use hex::FromHex;
+    use secp256k1::{VerifyOnly, XOnlyPublicKey};
+
+    use super::*;
+    use crate::sighash::{TapSighash, TapSighashTag};
+    extern crate serde_json;
+
+    #[cfg(feature = "serde")]
+    use {
+        hex::test_hex_unwrap as hex,
+        serde_test::Configure,
+        serde_test::{assert_tokens, Token},
+    };
+
+    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.as_ref());
+        engine.input(tag_hash.as_ref());
+        engine
+    }
+
+    #[test]
+    fn test_midstates() {
+        // test that engine creation roundtrips
+        assert_eq!(tag_engine("TapLeaf").midstate(), TapLeafTag::engine().midstate());
+        assert_eq!(tag_engine("TapBranch").midstate(), TapBranchTag::engine().midstate());
+        assert_eq!(tag_engine("TapTweak").midstate(), TapTweakTag::engine().midstate());
+        assert_eq!(tag_engine("TapSighash").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(&[]);
+            TapNodeHash::from_engine(e).to_byte_array()
+        }
+        assert_eq!(empty_hash("TapLeaf"), TapLeafHash::hash(&[]).to_byte_array());
+        assert_eq!(empty_hash("TapBranch"), TapNodeHash::hash(&[]).to_byte_array());
+        assert_eq!(empty_hash("TapTweak"), TapTweakHash::hash(&[]).to_byte_array());
+        assert_eq!(empty_hash("TapSighash"), TapSighash::hash(&[]).to_byte_array());
+    }
+
+    #[test]
+    fn test_vectors_core() {
+        //! Test vectors taken from Core
+
+        // uninitialized writers
+        //   CHashWriter writer = HasherTapLeaf;
+        //   writer.GetSHA256().GetHex()
+        assert_eq!(
+            TapLeafHash::from_engine(TapLeafTag::engine()).to_string(),
+            "5212c288a377d1f8164962a5a13429f9ba6a7b84e59776a52c6637df2106facb"
+        );
+        assert_eq!(
+            TapNodeHash::from_engine(TapBranchTag::engine()).to_string(),
+            "53c373ec4d6f3c53c1f5fb2ff506dcefe1a0ed74874f93fa93c8214cbe9ffddf"
+        );
+        assert_eq!(
+            TapTweakHash::from_engine(TapTweakTag::engine()).to_string(),
+            "8aa4229474ab0100b2d6f0687f031d1fc9d8eef92a042ad97d279bff456b15e4"
+        );
+        assert_eq!(
+            TapSighash::from_engine(TapSighashTag::engine()).to_string(),
+            "dabc11914abcd8072900042a2681e52f8dba99ce82e224f97b5fdb7cd4b9c803"
+        );
+
+        // 0-byte
+        //   CHashWriter writer = HasherTapLeaf;
+        //   writer << std::vector<unsigned char>{};
+        //   writer.GetSHA256().GetHex()
+        // Note that Core writes the 0 length prefix when an empty vector is written.
+        assert_eq!(
+            TapLeafHash::hash(&[0]).to_string(),
+            "ed1382037800c9dd938dd8854f1a8863bcdeb6705069b4b56a66ec22519d5829"
+        );
+        assert_eq!(
+            TapNodeHash::hash(&[0]).to_string(),
+            "92534b1960c7e6245af7d5fda2588db04aa6d646abc2b588dab2b69e5645eb1d"
+        );
+        assert_eq!(
+            TapTweakHash::hash(&[0]).to_string(),
+            "cd8737b5e6047fc3f16f03e8b9959e3440e1bdf6dd02f7bb899c352ad490ea1e"
+        );
+        assert_eq!(
+            TapSighash::hash(&[0]).to_string(),
+            "c2fd0de003889a09c4afcf676656a0d8a1fb706313ff7d509afb00c323c010cd"
+        );
+    }
+
+    fn _verify_tap_commitments(
+        secp: &Secp256k1<VerifyOnly>,
+        out_spk_hex: &str,
+        script_hex: &str,
+        control_block_hex: &str,
+    ) {
+        let out_pk = XOnlyPublicKey::from_str(&out_spk_hex[4..]).unwrap();
+        let out_pk = TweakedPublicKey::dangerous_assume_tweaked(out_pk);
+        let script = ScriptBuf::from_hex(script_hex).unwrap();
+        let control_block =
+            ControlBlock::decode(&Vec::<u8>::from_hex(control_block_hex).unwrap()).unwrap();
+        assert_eq!(control_block_hex, control_block.serialize().to_lower_hex_string());
+        assert!(control_block.verify_taproot_commitment(secp, out_pk.to_inner(), &script));
+    }
+
+    #[test]
+    fn control_block_verify() {
+        let secp = Secp256k1::verification_only();
+        // test vectors obtained from printing values in feature_taproot.py from Bitcoin Core
+        _verify_tap_commitments(&secp, "51205dc8e62b15e0ebdf44751676be35ba32eed2e84608b290d4061bbff136cd7ba9", "6a", "c1a9d6f66cd4b25004f526bfa873e56942f98e8e492bd79ed6532b966104817c2bda584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e0641e660d1e5392fb79d64838c2b84faf04b7f5f283c9d8bf83e39e177b64372a0cd22eeab7e093873e851e247714eff762d8a30be699ba4456cfe6491b282e193a071350ae099005a5950d74f73ba13077a57bc478007fb0e4d1099ce9cf3d4");
+        _verify_tap_commitments(&secp, "5120e208c869c40d8827101c5ad3238018de0f3f5183d77a0c53d18ac28ddcbcd8ad", "f4", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40090ab1f4890d51115998242ebce636efb9ede1b516d9eb8952dc1068e0335306199aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4da14e029b1e154a85bfd9139e7aa2720b6070a4ceba8264ca61d5d3ac27aceb9ef4b54cd43c2d1fd5e11b5c2e93cf29b91ea3dc5b832201f02f7473a28c63246");
+        _verify_tap_commitments(
+            &secp,
+            "5120567666e7df90e0450bb608e17c01ed3fbcfa5355a5f8273e34e583bfaa70ce09",
+            "203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ac",
+            "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
+        );
+        _verify_tap_commitments(&secp, "5120580a19e47269414a55eb86d5d0c6c9b371455d9fd2154412a57dec840df99fe1", "6a", "bca0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40042ba1bd1c63c03ccff60d4c4d53a653f87909eb3358e7fa45c9d805231fb08c933e1f4e0f9d17f591df1419df7d5b7eb5f744f404c5ef9ecdb1b89b18cafa3a816d8b5dba3205f9a9c05f866d91f40d2793a7586d502cb42f46c7a11f66ad4aa");
+        _verify_tap_commitments(&secp, "5120228b94a4806254a38d6efa8a134c28ebc89546209559dfe40b2b0493bafacc5b", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009c9aed3dfd11ab0e78bf87ef3bf296269dc4b0f7712140386d6980992bab4b45");
+        _verify_tap_commitments(
+            &secp,
+            "5120567666e7df90e0450bb608e17c01ed3fbcfa5355a5f8273e34e583bfaa70ce09",
+            "203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ac",
+            "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
+        );
+        _verify_tap_commitments(
+            &secp,
+            "5120b0a79103c31fe51eea61d2873bad8a25a310da319d7e7a85f825fa7a00ea3f85",
+            "203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ad51",
+            "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
+        );
+        _verify_tap_commitments(&secp, "5120f2f62e854a0012aeba78cd4ba4a0832447a5262d4c6eb4f1c95c7914b536fc6c", "6a86", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4009ad3d30479f0689dbdf59a6b840d60ad485b2effbed1825a75ce19a44e460e09056f60ea686d79cfa4fb79f197b2e905ac857a983be4a5a41a4873e865aa950780c0237de279dc063e67deec46ef8e1bc351bf12c4d67a6d568001faf097e797e6ee620f53cfe0f8acaddf2063c39c3577853bb46d61ffcba5a024c3e1216837");
+        _verify_tap_commitments(&secp, "51202a4772070b49bae68b44315032cdbf9c40c7c2f896781b32b931b73dbfb26d7e", "6af8", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4006f183944a14618fc7fe9ceade0f58e43a19d3c3b179ea6c43c29616413b6971c99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4c3462adec78cd04f3cc156bdadec50def99feae0dc6a23664e8a2b0d42d6ca9eb968dfdf46c23af642b2688351904e0a0630e71ffac5bcaba33b9b2c8a7495ec");
+        _verify_tap_commitments(&secp, "5120a32b0b8cfafe0f0f8d5870030ba4d19a8725ad345cb3c8420f86ac4e0dff6207", "4c", "e8a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400615da7ac8d078e5fc7f4690fc2127ba40f0f97cc070ade5b3a7919783d91ef3f13734aab908ae998e57848a01268fe8217d70bc3ee8ea8ceae158ae964a4b5f3af20b50d7019bf47fde210eee5c52f1cfe71cfca78f2d3e7c1fd828c80351525");
+        _verify_tap_commitments(
+            &secp,
+            "5120b0a79103c31fe51eea61d2873bad8a25a310da319d7e7a85f825fa7a00ea3f85",
+            "203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ad51",
+            "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400",
+        );
+        _verify_tap_commitments(&secp, "51208678459f1fa0f80e9b89b8ffdcaf46a022bdf60aa45f1fed9a96145edf4ec400", "6a50", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001eff29e1a89e650076b8d3c56302881d09c9df215774ed99993aaed14acd6615");
+        _verify_tap_commitments(&secp, "5120017316303aed02bcdec424c851c9eacbe192b013139bd9634c4e19b3475b06e1", "61", "02a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f40050462265ca552b23cbb4fe021b474313c8cb87d4a18b3f7bdbeb2b418279ba31fc6509d829cd42336f563363cb3538d78758e0876c71e13012eb2b656eb0edb051a2420a840d5c8c6c762abc7410af2c311f606b20ca2ace56a8139f84b1379a");
+        _verify_tap_commitments(&secp, "5120896d4d5d2236e86c6e9320e86d1a7822e652907cbd508360e8c71aefc127c77d", "61", "14a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4001ab0e9d9a4858a0e69605fe9c5a42d739fbe26fa79650e7074f462b02645f7ea1c91802b298cd91e6b5af57c6a013d93397cd2ecbd5569382cc27becf44ff4fff8960b20f846160c159c58350f6b6072cf1b3daa5185b7a42524fb72cbc252576ae46732b8e31ac24bfa7d72f4c3713e8696f99d8ac6c07e4c820a03f249f144");
+        _verify_tap_commitments(&secp, "512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
+        _verify_tap_commitments(&secp, "5120b28d75a7179de6feb66b8bb0bfa2b2c739d1a41cf7366a1b393804a844db8a28", "61", "c4a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400eebc95ded88fb8050094e8dfa958c3be0894eaff0fafae678206b26918d8d7ac47039d40fe34d04b4155df7f1be7f2a49253c7e87812ea9e569e683ac27459e652d6503aa32d64734d00adfee8798b2eed28858abf3bd038e8fa58eb7df4a2d9");
+        _verify_tap_commitments(&secp, "512043e4aa733fc6f43c78a31c2b3c192623acf5cc8c01199ebcc4de88067baca83e", "bd4c", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003f7be6f8848b5bddf332c4d7bd83077f73701e2479f70e02b5730e841234d082b8b41ebea96ffd937715d9faeaa6895e6ef3b22919c554b75df12b3371d328023e443d1df50634ecc1cd169803a1e546f0d44304d8fc5056c408e597fed469b8437d6660eaad3cf72e35ba6e5ff7ddd5e293c1e7e813c871df4f46508e9946ec");
+        _verify_tap_commitments(&secp, "5120ee9aecb28f5f35ce1f8b5ec80275ac0f81bca4a21b29b4632fb4bcbef8823e6a", "2021a5981b13be29c9d4ea179ea44a8b773ea8c02d68f6f6eefd98de20d4bd055fac", "c13359c284c196b6e80f0cf1d93b6a397cf7ee722f0427b705bd954b88ada8838bd2622fd0e104fc50aa763b43c6a792d7d117029983abd687223b4344a9402c618bba7f5fc3fa8a57491f6842acde88c1e675ca35caea3b1a69ee2c2d9b10f615");
+        _verify_tap_commitments(&secp, "5120885274df2252b44764dcef53c21f21154e8488b7e79fafbc96b9ebb22ad0200d", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4000793597254158918e3369507f2d6fdbef17d18b1028bbb0719450ded0f42c58f");
+        _verify_tap_commitments(&secp, "512066f6f6f91d47674d198a28388e1eb05ec24e6ddbba10f16396b1a80c08675121", "6a50", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400fe92aff70a2e8e2a4f34a913b99612468a41e0f8ecaff9a729a173d11013c27e");
+        _verify_tap_commitments(&secp, "5120868ed9307bd4637491ff03e3aa2c216a08fe213cac8b6cedbb9ab31dbfa6512c", "61", "a2a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400da584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e46c7eccffefd2d573ec014130e508f0c9963ccebd7830409f7b1b1301725e9fa759d4ef857ec8e0bb42d6d31609d3c7e77de3bfa28c38f93393a6ddbabe819ec560ed4f061fbe742a5fd2a648d5209469420434c8753da3fa7067cc2bb4c172a");
+        _verify_tap_commitments(&secp, "5120c1a00a9baa82888fd7d30291135a7eaa9e9966a5f16db2b10460572f8b108d8d", "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "5ba0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007960d7b37dd1361aee34510e77acb4d27ddca17648a17e28475032538c1eb500f5a747f2c0893f79fe153ae918ac3d696de9322aa679aae62051ff5ed83aa502b338bd907346abd4cd9cf06117cb35d55a5a8dd950843522f8de7b5c7fba1804c38b0778d3d76b383f6db6fdf9d6e770da8fffbfa5152c0b8b38129885bcdee6");
+        _verify_tap_commitments(&secp, "5120bb9abeff7286b76dfc61800c548fe2621ff47506e47201a85c543b4a9a96fead", "75203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf47342796ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6ead6eadac", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4003eb5cdc419e0a6a800f34583ce750f387be34879c26f4230991bd61da743ad9d34d288e79397b709ac22ad8cc57645d593af3e15b97a876362117177ab2519c000000000000000000000000000000000000000000000000000000000000000007160c3a48c8b17bc3aeaf01db9e0a96ac47a5a9fa329e046856e7765e89c8a93ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff07feb9aa7cd72c78e66a85414cd19289f8b0ab1415013dc2a007666aa9248ec1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001fccc8bea662a9442a94f7ba0643c1d7ee7cc689f3b3506b7c8c99fd3f3b3d7772972dcdf2550cf95b65098aea67f72fef10abdcf1cef9815af8f4c4644b060e0000000000000000000000000000000000000000000000000000000000000000");
+        _verify_tap_commitments(&secp, "5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "4d09024747703eb9f759ce5ecd839109fecc40974ab16f5173ea390daaa5a78f7abe898165c90990062af998c5dc7989818393158a2c62b7ece727e7f5400d2efd33db8732599f6d1dce6b5b68d2d47317f2de6c9df118f61227f98453225036618aaf058140f2415d134fa69ba041c724ad81387f8c568d12ddc49eb32a71532096181b3f85fd465b8e9a176bb19f45c070baad47a2cc4505414b88c31cb5b0a192b2d2d56c404a37070b04d42c875c4ac351224f5b254f9ad0b820f43cad292d6565f796bf083173e14723f1e543c85a61689ddd5cb6666b240c15c38ce3320bf0c3be9e0322e5ef72366c294d3a2d7e8b8e7db875e7ae814537554f10b91c72b8b413e026bd5d5e917de4b54fa8f43f38771a7f242aa32dcb7ca1b0588dbf54af7ab9455047fbb894cdfdd242166db784276430eb47d4df092a6b8cb160eb982fe7d14a44283bdb4a9861ca65c06fd8b2546cfbfe38bc77f527de1b9bfd2c95a3e283b7b1d1d2b2fa291256a90a7003aefcef47ceabf113865a494af43e96a38b0b00919855eb7722ea2363e0ddfc9c51c08631d01e2a2d56e786b4ff6f1e5d415facc9c2619c285d9ad43001878294157cb025f639fb954271fd1d6173f6bc16535672f6abdd72b0284b4ff3eaf5b7247719d7c39365622610efae6562bef6e08a0b370fba75bb04dbdb90a482d8417e057f8bd021ea6ac32d0d48b08be9f77833b11e5e739960c9837d7583", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400ff698adfda0327f188e2ee35f7aecc0f90c9138a350d450648d968c2b5dd7ef94ddd3ec418dc0d03ee4956feb708d838ed2b20e5a193465a6a1467fd3054e1ea141ea4c4c503a6271e19a090e2a69a24282e3be04c4f98720f7a0eb274d9693d13a8e3c139aa625fa2aefd09854570527f9ac545bda1b689719f5cb715612c07");
+        _verify_tap_commitments(&secp, "5120afddc189ea51094b4cbf463806792e9c8b35dfdc5e01228c78376380d0046b00", "83", "c0a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f4007388cda01113397d4cd00bcfbd08fd68c3cfe3a42cbfe3a7651c1d5e6dacf1ad99aaf103cceb41d9bc37ec231aca89b984b5fd3c65977ce764d51033ac65adb4b59764bec92507e4a4c3f01a06f05980163ca10f1c549bfe01f85fa4f109a1295e607f5ed9f1008048474de336f11f67a1fbf2012f58944dede0ab19a3ca81f5");
+        _verify_tap_commitments(&secp, "512093c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", "04ffffffff203455139bf238a3067bd72ed77e0ab8db590330f55ed58dba7366b53bf4734279ba04feffffff87ab", "c1a0eb12e60a52614986c623cbb6621dcdba3a47e3be6b37e032b7a11c7b98f400c9a5cd1f6c8a81f5648e39f9810591df1c9a8f1fe97c92e03ecd7c0c016c951983e05473c6e8238cb4c780ea2ce62552b2a3eee068ceffc00517cd7b97e10dad");
+    }
+
+    #[test]
+    fn build_huffman_tree() {
+        let secp = Secp256k1::verification_only();
+        let internal_key = UntweakedPublicKey::from_str(
+            "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51",
+        )
+        .unwrap();
+
+        let script_weights = vec![
+            (10, ScriptBuf::from_hex("51").unwrap()), // semantics of script don't matter for this test
+            (20, ScriptBuf::from_hex("52").unwrap()),
+            (20, ScriptBuf::from_hex("53").unwrap()),
+            (30, ScriptBuf::from_hex("54").unwrap()),
+            (19, ScriptBuf::from_hex("55").unwrap()),
+        ];
+        let tree_info =
+            TaprootSpendInfo::with_huffman_tree(&secp, internal_key, script_weights.clone())
+                .unwrap();
+
+        /* The resulting tree should put the scripts into a tree similar
+         * to the following:
+         *
+         *   1      __/\__
+         *         /      \
+         *        /\     / \
+         *   2   54 52  53 /\
+         *   3            55 51
+         */
+
+        for (script, length) in [("51", 3), ("52", 2), ("53", 2), ("54", 2), ("55", 3)].iter() {
+            assert_eq!(
+                *length,
+                tree_info
+                    .script_map
+                    .get(&(ScriptBuf::from_hex(script).unwrap(), LeafVersion::TapScript))
+                    .expect("Present Key")
+                    .iter()
+                    .next()
+                    .expect("Present Path")
+                    .0
+                    .len()
+            );
+        }
+
+        // Obtain the output key
+        let output_key = tree_info.output_key();
+
+        // Try to create and verify a control block from each path
+        for (_weights, script) in script_weights {
+            let ver_script = (script, LeafVersion::TapScript);
+            let ctrl_block = tree_info.control_block(&ver_script).unwrap();
+            assert!(ctrl_block.verify_taproot_commitment(
+                &secp,
+                output_key.to_inner(),
+                &ver_script.0
+            ))
+        }
+    }
+
+    #[test]
+    fn taptree_builder() {
+        let secp = Secp256k1::verification_only();
+        let internal_key = UntweakedPublicKey::from_str(
+            "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51",
+        )
+        .unwrap();
+
+        let builder = TaprootBuilder::new();
+        // Create a tree as shown below
+        // For example, imagine this tree:
+        // A, B , C are at depth 2 and D,E are at 3
+        //                                       ....
+        //                                     /      \
+        //                                    /\      /\
+        //                                   /  \    /  \
+        //                                  A    B  C  / \
+        //                                            D   E
+        let a = ScriptBuf::from_hex("51").unwrap();
+        let b = ScriptBuf::from_hex("52").unwrap();
+        let c = ScriptBuf::from_hex("53").unwrap();
+        let d = ScriptBuf::from_hex("54").unwrap();
+        let e = ScriptBuf::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();
+
+        // Trying to finalize an incomplete tree returns the Err(builder)
+        let builder = builder.finalize(&secp, internal_key).unwrap_err();
+        let builder = builder.add_leaf(3, e.clone()).unwrap();
+
+        #[cfg(feature = "serde")]
+        {
+            let tree = TapTree::try_from(builder.clone()).unwrap();
+            // test roundtrip serialization with serde_test
+            #[rustfmt::skip]
+            assert_tokens(&tree.readable(), &[
+                Token::Seq { len: Some(10) },
+                Token::U64(2), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("51"), Token::U8(192), Token::TupleVariantEnd,
+                Token::U64(2), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("52"), Token::U8(192), Token::TupleVariantEnd,
+                Token::U64(3), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("55"), Token::U8(192), Token::TupleVariantEnd,
+                Token::U64(3), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("54"), Token::U8(192), Token::TupleVariantEnd,
+                Token::U64(2), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("53"), Token::U8(192), Token::TupleVariantEnd,
+                Token::SeqEnd,
+            ],);
+
+            let node_info = TapTree::try_from(builder.clone()).unwrap().into_node_info();
+            // test roundtrip serialization with serde_test
+            #[rustfmt::skip]
+            assert_tokens(&node_info.readable(), &[
+                Token::Seq { len: Some(10) },
+                Token::U64(2), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("51"), Token::U8(192), Token::TupleVariantEnd,
+                Token::U64(2), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("52"), Token::U8(192), Token::TupleVariantEnd,
+                Token::U64(3), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("55"), Token::U8(192), Token::TupleVariantEnd,
+                Token::U64(3), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("54"), Token::U8(192), Token::TupleVariantEnd,
+                Token::U64(2), Token::TupleVariant { name: "TapLeaf", variant: "Script", len: 2}, Token::Str("53"), Token::U8(192), Token::TupleVariantEnd,
+                Token::SeqEnd,
+            ],);
+        }
+
+        let tree_info = builder.finalize(&secp, internal_key).unwrap();
+        let output_key = tree_info.output_key();
+
+        for script in [a, b, c, d, e] {
+            let ver_script = (script, LeafVersion::TapScript);
+            let ctrl_block = tree_info.control_block(&ver_script).unwrap();
+            assert!(ctrl_block.verify_taproot_commitment(
+                &secp,
+                output_key.to_inner(),
+                &ver_script.0
+            ))
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_leaf_version_serde() {
+        let leaf_version = LeafVersion::TapScript;
+        // use serde_test to test serialization and deserialization
+        assert_tokens(&leaf_version, &[Token::U8(192)]);
+
+        let json = serde_json::to_string(&leaf_version).unwrap();
+        let leaf_version2 = serde_json::from_str(&json).unwrap();
+        assert_eq!(leaf_version, leaf_version2);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_merkle_branch_serde() {
+        let dummy_hash = hex!("03ba2a4dcd914fed29a1c630c7e811271b081a0e2f2f52cf1c197583dfd46c1b");
+        let hash1 = TapNodeHash::from_slice(&dummy_hash).unwrap();
+        let dummy_hash = hex!("8d79dedc2fa0b55167b5d28c61dbad9ce1191a433f3a1a6c8ee291631b2c94c9");
+        let hash2 = TapNodeHash::from_slice(&dummy_hash).unwrap();
+        let merkle_branch = TaprootMerkleBranch::from_collection(vec![hash1, hash2]).unwrap();
+        // use serde_test to test serialization and deserialization
+        serde_test::assert_tokens(
+            &merkle_branch.readable(),
+            &[
+                Token::Seq { len: Some(2) },
+                Token::Str("03ba2a4dcd914fed29a1c630c7e811271b081a0e2f2f52cf1c197583dfd46c1b"),
+                Token::Str("8d79dedc2fa0b55167b5d28c61dbad9ce1191a433f3a1a6c8ee291631b2c94c9"),
+                Token::SeqEnd,
+            ],
+        );
+    }
+}
diff --git a/tapyrus/src/test_macros.rs b/tapyrus/src/test_macros.rs
new file mode 100644
index 00000000..cbcbd4bd
--- /dev/null
+++ b/tapyrus/src/test_macros.rs
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Bitcoin serde macros.
+//!
+//! This module provides internal macros used for unit tests.
+//!
+
+#[cfg(feature = "serde")]
+macro_rules! serde_round_trip (
+    ($var:expr) => ({
+        use serde_json;
+
+        let encoded = serde_json::to_value(&$var).unwrap();
+        let decoded = serde_json::from_value(encoded).unwrap();
+        assert_eq!($var, decoded);
+    })
+);
diff --git a/tapyrus/tests/data/README.md b/tapyrus/tests/data/README.md
new file mode 100644
index 00000000..70ed7a4e
--- /dev/null
+++ b/tapyrus/tests/data/README.md
@@ -0,0 +1,4 @@
+Test vector data
+================
+
+This file contains data (hex strings) taken from BIP test vectors.
diff --git a/tapyrus/tests/data/bip341_tests.json b/tapyrus/tests/data/bip341_tests.json
new file mode 100644
index 00000000..11261b00
--- /dev/null
+++ b/tapyrus/tests/data/bip341_tests.json
@@ -0,0 +1,452 @@
+{
+    "version": 1,
+    "scriptPubKey": [
+        {
+            "given": {
+                "internalPubkey": "d6889cb081036e0faefa3a35157ad71086b123b2b144b649798b494c300a961d",
+                "scriptTree": null
+            },
+            "intermediary": {
+                "merkleRoot": null,
+                "tweak": "b86e7be8f39bab32a6f2c0443abbc210f0edac0e2c53d501b36b64437d9c6c70",
+                "tweakedPubkey": "53a1f6e454df1aa2776a2814a721372d6258050de330b3c6d10ee8f4e0dda343"
+            },
+            "expected": {
+                "scriptPubKey": "512053a1f6e454df1aa2776a2814a721372d6258050de330b3c6d10ee8f4e0dda343",
+                "bip350Address": "bc1p2wsldez5mud2yam29q22wgfh9439spgduvct83k3pm50fcxa5dps59h4z5"
+            }
+        },
+        {
+            "given": {
+                "internalPubkey": "187791b6f712a8ea41c8ecdd0ee77fab3e85263b37e1ec18a3651926b3a6cf27",
+                "scriptTree": {
+                    "id": 0,
+                    "script": "20d85a959b0290bf19bb89ed43c916be835475d013da4b362117393e25a48229b8ac",
+                    "leafVersion": 192
+                }
+            },
+            "intermediary": {
+                "leafHashes": [
+                    "5b75adecf53548f3ec6ad7d78383bf84cc57b55a3127c72b9a2481752dd88b21"
+                ],
+                "merkleRoot": "5b75adecf53548f3ec6ad7d78383bf84cc57b55a3127c72b9a2481752dd88b21",
+                "tweak": "cbd8679ba636c1110ea247542cfbd964131a6be84f873f7f3b62a777528ed001",
+                "tweakedPubkey": "147c9c57132f6e7ecddba9800bb0c4449251c92a1e60371ee77557b6620f3ea3"
+            },
+            "expected": {
+                "scriptPubKey": "5120147c9c57132f6e7ecddba9800bb0c4449251c92a1e60371ee77557b6620f3ea3",
+                "bip350Address": "bc1pz37fc4cn9ah8anwm4xqqhvxygjf9rjf2resrw8h8w4tmvcs0863sa2e586",
+                "scriptPathControlBlocks": [
+                    "c1187791b6f712a8ea41c8ecdd0ee77fab3e85263b37e1ec18a3651926b3a6cf27"
+                ]
+            }
+        },
+        {
+            "given": {
+                "internalPubkey": "93478e9488f956df2396be2ce6c5cced75f900dfa18e7dabd2428aae78451820",
+                "scriptTree": {
+                    "id": 0,
+                    "script": "20b617298552a72ade070667e86ca63b8f5789a9fe8731ef91202a91c9f3459007ac",
+                    "leafVersion": 192
+                }
+            },
+            "intermediary": {
+                "leafHashes": [
+                    "c525714a7f49c28aedbbba78c005931a81c234b2f6c99a73e4d06082adc8bf2b"
+                ],
+                "merkleRoot": "c525714a7f49c28aedbbba78c005931a81c234b2f6c99a73e4d06082adc8bf2b",
+                "tweak": "6af9e28dbf9d6aaf027696e2598a5b3d056f5fd2355a7fd5a37a0e5008132d30",
+                "tweakedPubkey": "e4d810fd50586274face62b8a807eb9719cef49c04177cc6b76a9a4251d5450e"
+            },
+            "expected": {
+                "scriptPubKey": "5120e4d810fd50586274face62b8a807eb9719cef49c04177cc6b76a9a4251d5450e",
+                "bip350Address": "bc1punvppl2stp38f7kwv2u2spltjuvuaayuqsthe34hd2dyy5w4g58qqfuag5",
+                "scriptPathControlBlocks": [
+                    "c093478e9488f956df2396be2ce6c5cced75f900dfa18e7dabd2428aae78451820"
+                ]
+            }
+        },
+        {
+            "given": {
+                "internalPubkey": "ee4fe085983462a184015d1f782d6a5f8b9c2b60130aff050ce221ecf3786592",
+                "scriptTree": [
+                    {
+                        "id": 0,
+                        "script": "20387671353e273264c495656e27e39ba899ea8fee3bb69fb2a680e22093447d48ac",
+                        "leafVersion": 192
+                    },
+                    {
+                        "id": 1,
+                        "script": "06424950333431",
+                        "leafVersion": 250
+                    }
+                ]
+            },
+            "intermediary": {
+                "leafHashes": [
+                    "8ad69ec7cf41c2a4001fd1f738bf1e505ce2277acdcaa63fe4765192497f47a7",
+                    "f224a923cd0021ab202ab139cc56802ddb92dcfc172b9212261a539df79a112a"
+                ],
+                "merkleRoot": "6c2dc106ab816b73f9d07e3cd1ef2c8c1256f519748e0813e4edd2405d277bef",
+                "tweak": "9e0517edc8259bb3359255400b23ca9507f2a91cd1e4250ba068b4eafceba4a9",
+                "tweakedPubkey": "712447206d7a5238acc7ff53fbe94a3b64539ad291c7cdbc490b7577e4b17df5"
+            },
+            "expected": {
+                "scriptPubKey": "5120712447206d7a5238acc7ff53fbe94a3b64539ad291c7cdbc490b7577e4b17df5",
+                "bip350Address": "bc1pwyjywgrd0ffr3tx8laflh6228dj98xkjj8rum0zfpd6h0e930h6saqxrrm",
+                "scriptPathControlBlocks": [
+                    "c0ee4fe085983462a184015d1f782d6a5f8b9c2b60130aff050ce221ecf3786592f224a923cd0021ab202ab139cc56802ddb92dcfc172b9212261a539df79a112a",
+                    "faee4fe085983462a184015d1f782d6a5f8b9c2b60130aff050ce221ecf37865928ad69ec7cf41c2a4001fd1f738bf1e505ce2277acdcaa63fe4765192497f47a7"
+                ]
+            }
+        },
+        {
+            "given": {
+                "internalPubkey": "f9f400803e683727b14f463836e1e78e1c64417638aa066919291a225f0e8dd8",
+                "scriptTree": [
+                    {
+                        "id": 0,
+                        "script": "2044b178d64c32c4a05cc4f4d1407268f764c940d20ce97abfd44db5c3592b72fdac",
+                        "leafVersion": 192
+                    },
+                    {
+                        "id": 1,
+                        "script": "07546170726f6f74",
+                        "leafVersion": 192
+                    }
+                ]
+            },
+            "intermediary": {
+                "leafHashes": [
+                    "64512fecdb5afa04f98839b50e6f0cb7b1e539bf6f205f67934083cdcc3c8d89",
+                    "2cb2b90daa543b544161530c925f285b06196940d6085ca9474d41dc3822c5cb"
+                ],
+                "merkleRoot": "ab179431c28d3b68fb798957faf5497d69c883c6fb1e1cd9f81483d87bac90cc",
+                "tweak": "639f0281b7ac49e742cd25b7f188657626da1ad169209078e2761cefd91fd65e",
+                "tweakedPubkey": "77e30a5522dd9f894c3f8b8bd4c4b2cf82ca7da8a3ea6a239655c39c050ab220"
+            },
+            "expected": {
+                "scriptPubKey": "512077e30a5522dd9f894c3f8b8bd4c4b2cf82ca7da8a3ea6a239655c39c050ab220",
+                "bip350Address": "bc1pwl3s54fzmk0cjnpl3w9af39je7pv5ldg504x5guk2hpecpg2kgsqaqstjq",
+                "scriptPathControlBlocks": [
+                    "c1f9f400803e683727b14f463836e1e78e1c64417638aa066919291a225f0e8dd82cb2b90daa543b544161530c925f285b06196940d6085ca9474d41dc3822c5cb",
+                    "c1f9f400803e683727b14f463836e1e78e1c64417638aa066919291a225f0e8dd864512fecdb5afa04f98839b50e6f0cb7b1e539bf6f205f67934083cdcc3c8d89"
+                ]
+            }
+        },
+        {
+            "given": {
+                "internalPubkey": "e0dfe2300b0dd746a3f8674dfd4525623639042569d829c7f0eed9602d263e6f",
+                "scriptTree": [
+                    {
+                        "id": 0,
+                        "script": "2072ea6adcf1d371dea8fba1035a09f3d24ed5a059799bae114084130ee5898e69ac",
+                        "leafVersion": 192
+                    },
+                    [
+                        {
+                            "id": 1,
+                            "script": "202352d137f2f3ab38d1eaa976758873377fa5ebb817372c71e2c542313d4abda8ac",
+                            "leafVersion": 192
+                        },
+                        {
+                            "id": 2,
+                            "script": "207337c0dd4253cb86f2c43a2351aadd82cccb12a172cd120452b9bb8324f2186aac",
+                            "leafVersion": 192
+                        }
+                    ]
+                ]
+            },
+            "intermediary": {
+                "leafHashes": [
+                    "2645a02e0aac1fe69d69755733a9b7621b694bb5b5cde2bbfc94066ed62b9817",
+                    "ba982a91d4fc552163cb1c0da03676102d5b7a014304c01f0c77b2b8e888de1c",
+                    "9e31407bffa15fefbf5090b149d53959ecdf3f62b1246780238c24501d5ceaf6"
+                ],
+                "merkleRoot": "ccbd66c6f7e8fdab47b3a486f59d28262be857f30d4773f2d5ea47f7761ce0e2",
+                "tweak": "b57bfa183d28eeb6ad688ddaabb265b4a41fbf68e5fed2c72c74de70d5a786f4",
+                "tweakedPubkey": "91b64d5324723a985170e4dc5a0f84c041804f2cd12660fa5dec09fc21783605"
+            },
+            "expected": {
+                "scriptPubKey": "512091b64d5324723a985170e4dc5a0f84c041804f2cd12660fa5dec09fc21783605",
+                "bip350Address": "bc1pjxmy65eywgafs5tsunw95ruycpqcqnev6ynxp7jaasylcgtcxczs6n332e",
+                "scriptPathControlBlocks": [
+                    "c0e0dfe2300b0dd746a3f8674dfd4525623639042569d829c7f0eed9602d263e6fffe578e9ea769027e4f5a3de40732f75a88a6353a09d767ddeb66accef85e553",
+                    "c0e0dfe2300b0dd746a3f8674dfd4525623639042569d829c7f0eed9602d263e6f9e31407bffa15fefbf5090b149d53959ecdf3f62b1246780238c24501d5ceaf62645a02e0aac1fe69d69755733a9b7621b694bb5b5cde2bbfc94066ed62b9817",
+                    "c0e0dfe2300b0dd746a3f8674dfd4525623639042569d829c7f0eed9602d263e6fba982a91d4fc552163cb1c0da03676102d5b7a014304c01f0c77b2b8e888de1c2645a02e0aac1fe69d69755733a9b7621b694bb5b5cde2bbfc94066ed62b9817"
+                ]
+            }
+        },
+        {
+            "given": {
+                "internalPubkey": "55adf4e8967fbd2e29f20ac896e60c3b0f1d5b0efa9d34941b5958c7b0a0312d",
+                "scriptTree": [
+                    {
+                        "id": 0,
+                        "script": "2071981521ad9fc9036687364118fb6ccd2035b96a423c59c5430e98310a11abe2ac",
+                        "leafVersion": 192
+                    },
+                    [
+                        {
+                            "id": 1,
+                            "script": "20d5094d2dbe9b76e2c245a2b89b6006888952e2faa6a149ae318d69e520617748ac",
+                            "leafVersion": 192
+                        },
+                        {
+                            "id": 2,
+                            "script": "20c440b462ad48c7a77f94cd4532d8f2119dcebbd7c9764557e62726419b08ad4cac",
+                            "leafVersion": 192
+                        }
+                    ]
+                ]
+            },
+            "intermediary": {
+                "leafHashes": [
+                    "f154e8e8e17c31d3462d7132589ed29353c6fafdb884c5a6e04ea938834f0d9d",
+                    "737ed1fe30bc42b8022d717b44f0d93516617af64a64753b7a06bf16b26cd711",
+                    "d7485025fceb78b9ed667db36ed8b8dc7b1f0b307ac167fa516fe4352b9f4ef7"
+                ],
+                "merkleRoot": "2f6b2c5397b6d68ca18e09a3f05161668ffe93a988582d55c6f07bd5b3329def",
+                "tweak": "6579138e7976dc13b6a92f7bfd5a2fc7684f5ea42419d43368301470f3b74ed9",
+                "tweakedPubkey": "75169f4001aa68f15bbed28b218df1d0a62cbbcf1188c6665110c293c907b831"
+            },
+            "expected": {
+                "scriptPubKey": "512075169f4001aa68f15bbed28b218df1d0a62cbbcf1188c6665110c293c907b831",
+                "bip350Address": "bc1pw5tf7sqp4f50zka7629jrr036znzew70zxyvvej3zrpf8jg8hqcssyuewe",
+                "scriptPathControlBlocks": [
+                    "c155adf4e8967fbd2e29f20ac896e60c3b0f1d5b0efa9d34941b5958c7b0a0312d3cd369a528b326bc9d2133cbd2ac21451acb31681a410434672c8e34fe757e91",
+                    "c155adf4e8967fbd2e29f20ac896e60c3b0f1d5b0efa9d34941b5958c7b0a0312dd7485025fceb78b9ed667db36ed8b8dc7b1f0b307ac167fa516fe4352b9f4ef7f154e8e8e17c31d3462d7132589ed29353c6fafdb884c5a6e04ea938834f0d9d",
+                    "c155adf4e8967fbd2e29f20ac896e60c3b0f1d5b0efa9d34941b5958c7b0a0312d737ed1fe30bc42b8022d717b44f0d93516617af64a64753b7a06bf16b26cd711f154e8e8e17c31d3462d7132589ed29353c6fafdb884c5a6e04ea938834f0d9d"
+                ]
+            }
+        }
+    ],
+    "keyPathSpending": [
+        {
+            "given": {
+                "rawUnsignedTx": "02000000097de20cbff686da83a54981d2b9bab3586f4ca7e48f57f5b55963115f3b334e9c010000000000000000d7b7cab57b1393ace2d064f4d4a2cb8af6def61273e127517d44759b6dafdd990000000000fffffffff8e1f583384333689228c5d28eac13366be082dc57441760d957275419a418420000000000fffffffff0689180aa63b30cb162a73c6d2a38b7eeda2a83ece74310fda0843ad604853b0100000000feffffffaa5202bdf6d8ccd2ee0f0202afbbb7461d9264a25e5bfd3c5a52ee1239e0ba6c0000000000feffffff956149bdc66faa968eb2be2d2faa29718acbfe3941215893a2a3446d32acd050000000000000000000e664b9773b88c09c32cb70a2a3e4da0ced63b7ba3b22f848531bbb1d5d5f4c94010000000000000000e9aa6b8e6c9de67619e6a3924ae25696bb7b694bb677a632a74ef7eadfd4eabf0000000000ffffffffa778eb6a263dc090464cd125c466b5a99667720b1c110468831d058aa1b82af10100000000ffffffff0200ca9a3b000000001976a91406afd46bcdfd22ef94ac122aa11f241244a37ecc88ac807840cb0000000020ac9a87f5594be208f8532db38cff670c450ed2fea8fcdefcc9a663f78bab962b0065cd1d",
+                "utxosSpent": [
+                    {
+                        "scriptPubKey": "512053a1f6e454df1aa2776a2814a721372d6258050de330b3c6d10ee8f4e0dda343",
+                        "amountSats": 420000000
+                    },
+                    {
+                        "scriptPubKey": "5120147c9c57132f6e7ecddba9800bb0c4449251c92a1e60371ee77557b6620f3ea3",
+                        "amountSats": 462000000
+                    },
+                    {
+                        "scriptPubKey": "76a914751e76e8199196d454941c45d1b3a323f1433bd688ac",
+                        "amountSats": 294000000
+                    },
+                    {
+                        "scriptPubKey": "5120e4d810fd50586274face62b8a807eb9719cef49c04177cc6b76a9a4251d5450e",
+                        "amountSats": 504000000
+                    },
+                    {
+                        "scriptPubKey": "512091b64d5324723a985170e4dc5a0f84c041804f2cd12660fa5dec09fc21783605",
+                        "amountSats": 630000000
+                    },
+                    {
+                        "scriptPubKey": "00147dd65592d0ab2fe0d0257d571abf032cd9db93dc",
+                        "amountSats": 378000000
+                    },
+                    {
+                        "scriptPubKey": "512075169f4001aa68f15bbed28b218df1d0a62cbbcf1188c6665110c293c907b831",
+                        "amountSats": 672000000
+                    },
+                    {
+                        "scriptPubKey": "5120712447206d7a5238acc7ff53fbe94a3b64539ad291c7cdbc490b7577e4b17df5",
+                        "amountSats": 546000000
+                    },
+                    {
+                        "scriptPubKey": "512077e30a5522dd9f894c3f8b8bd4c4b2cf82ca7da8a3ea6a239655c39c050ab220",
+                        "amountSats": 588000000
+                    }
+                ]
+            },
+            "intermediary": {
+                "hashAmounts": "58a6964a4f5f8f0b642ded0a8a553be7622a719da71d1f5befcefcdee8e0fde6",
+                "hashOutputs": "a2e6dab7c1f0dcd297c8d61647fd17d821541ea69c3cc37dcbad7f90d4eb4bc5",
+                "hashPrevouts": "e3b33bb4ef3a52ad1fffb555c0d82828eb22737036eaeb02a235d82b909c4c3f",
+                "hashScriptPubkeys": "23ad0f61ad2bca5ba6a7693f50fce988e17c3780bf2b1e720cfbb38fbdd52e21",
+                "hashSequences": "18959c7221ab5ce9e26c3cd67b22c24f8baa54bac281d8e6b05e400e6c3a957e"
+            },
+            "inputSpending": [
+                {
+                    "given": {
+                        "txinIndex": 0,
+                        "internalPrivkey": "6b973d88838f27366ed61c9ad6367663045cb456e28335c109e30717ae0c6baa",
+                        "merkleRoot": null,
+                        "hashType": 3
+                    },
+                    "intermediary": {
+                        "internalPubkey": "d6889cb081036e0faefa3a35157ad71086b123b2b144b649798b494c300a961d",
+                        "tweak": "b86e7be8f39bab32a6f2c0443abbc210f0edac0e2c53d501b36b64437d9c6c70",
+                        "tweakedPrivkey": "2405b971772ad26915c8dcdf10f238753a9b837e5f8e6a86fd7c0cce5b7296d9",
+                        "sigMsg": "0003020000000065cd1de3b33bb4ef3a52ad1fffb555c0d82828eb22737036eaeb02a235d82b909c4c3f58a6964a4f5f8f0b642ded0a8a553be7622a719da71d1f5befcefcdee8e0fde623ad0f61ad2bca5ba6a7693f50fce988e17c3780bf2b1e720cfbb38fbdd52e2118959c7221ab5ce9e26c3cd67b22c24f8baa54bac281d8e6b05e400e6c3a957e0000000000d0418f0e9a36245b9a50ec87f8bf5be5bcae434337b87139c3a5b1f56e33cba0",
+                        "precomputedUsed": [
+                            "hashAmounts",
+                            "hashPrevouts",
+                            "hashScriptPubkeys",
+                            "hashSequences"
+                        ],
+                        "sigHash": "2514a6272f85cfa0f45eb907fcb0d121b808ed37c6ea160a5a9046ed5526d555"
+                    },
+                    "expected": {
+                        "witness": [
+                            "ed7c1647cb97379e76892be0cacff57ec4a7102aa24296ca39af7541246d8ff14d38958d4cc1e2e478e4d4a764bbfd835b16d4e314b72937b29833060b87276c03"
+                        ]
+                    }
+                },
+                {
+                    "given": {
+                        "txinIndex": 1,
+                        "internalPrivkey": "1e4da49f6aaf4e5cd175fe08a32bb5cb4863d963921255f33d3bc31e1343907f",
+                        "merkleRoot": "5b75adecf53548f3ec6ad7d78383bf84cc57b55a3127c72b9a2481752dd88b21",
+                        "hashType": 131
+                    },
+                    "intermediary": {
+                        "internalPubkey": "187791b6f712a8ea41c8ecdd0ee77fab3e85263b37e1ec18a3651926b3a6cf27",
+                        "tweak": "cbd8679ba636c1110ea247542cfbd964131a6be84f873f7f3b62a777528ed001",
+                        "tweakedPrivkey": "ea260c3b10e60f6de018455cd0278f2f5b7e454be1999572789e6a9565d26080",
+                        "sigMsg": "0083020000000065cd1d00d7b7cab57b1393ace2d064f4d4a2cb8af6def61273e127517d44759b6dafdd9900000000808f891b00000000225120147c9c57132f6e7ecddba9800bb0c4449251c92a1e60371ee77557b6620f3ea3ffffffffffcef8fb4ca7efc5433f591ecfc57391811ce1e186a3793024def5c884cba51d",
+                        "precomputedUsed": [],
+                        "sigHash": "325a644af47e8a5a2591cda0ab0723978537318f10e6a63d4eed783b96a71a4d"
+                    },
+                    "expected": {
+                        "witness": [
+                            "052aedffc554b41f52b521071793a6b88d6dbca9dba94cf34c83696de0c1ec35ca9c5ed4ab28059bd606a4f3a657eec0bb96661d42921b5f50a95ad33675b54f83"
+                        ]
+                    }
+                },
+                {
+                    "given": {
+                        "txinIndex": 3,
+                        "internalPrivkey": "d3c7af07da2d54f7a7735d3d0fc4f0a73164db638b2f2f7c43f711f6d4aa7e64",
+                        "merkleRoot": "c525714a7f49c28aedbbba78c005931a81c234b2f6c99a73e4d06082adc8bf2b",
+                        "hashType": 1
+                    },
+                    "intermediary": {
+                        "internalPubkey": "93478e9488f956df2396be2ce6c5cced75f900dfa18e7dabd2428aae78451820",
+                        "tweak": "6af9e28dbf9d6aaf027696e2598a5b3d056f5fd2355a7fd5a37a0e5008132d30",
+                        "tweakedPrivkey": "97323385e57015b75b0339a549c56a948eb961555973f0951f555ae6039ef00d",
+                        "sigMsg": "0001020000000065cd1de3b33bb4ef3a52ad1fffb555c0d82828eb22737036eaeb02a235d82b909c4c3f58a6964a4f5f8f0b642ded0a8a553be7622a719da71d1f5befcefcdee8e0fde623ad0f61ad2bca5ba6a7693f50fce988e17c3780bf2b1e720cfbb38fbdd52e2118959c7221ab5ce9e26c3cd67b22c24f8baa54bac281d8e6b05e400e6c3a957ea2e6dab7c1f0dcd297c8d61647fd17d821541ea69c3cc37dcbad7f90d4eb4bc50003000000",
+                        "precomputedUsed": [
+                            "hashAmounts",
+                            "hashOutputs",
+                            "hashPrevouts",
+                            "hashScriptPubkeys",
+                            "hashSequences"
+                        ],
+                        "sigHash": "bf013ea93474aa67815b1b6cc441d23b64fa310911d991e713cd34c7f5d46669"
+                    },
+                    "expected": {
+                        "witness": [
+                            "ff45f742a876139946a149ab4d9185574b98dc919d2eb6754f8abaa59d18b025637a3aa043b91817739554f4ed2026cf8022dbd83e351ce1fabc272841d2510a01"
+                        ]
+                    }
+                },
+                {
+                    "given": {
+                        "txinIndex": 4,
+                        "internalPrivkey": "f36bb07a11e469ce941d16b63b11b9b9120a84d9d87cff2c84a8d4affb438f4e",
+                        "merkleRoot": "ccbd66c6f7e8fdab47b3a486f59d28262be857f30d4773f2d5ea47f7761ce0e2",
+                        "hashType": 0
+                    },
+                    "intermediary": {
+                        "internalPubkey": "e0dfe2300b0dd746a3f8674dfd4525623639042569d829c7f0eed9602d263e6f",
+                        "tweak": "b57bfa183d28eeb6ad688ddaabb265b4a41fbf68e5fed2c72c74de70d5a786f4",
+                        "tweakedPrivkey": "a8e7aa924f0d58854185a490e6c41f6efb7b675c0f3331b7f14b549400b4d501",
+                        "sigMsg": "0000020000000065cd1de3b33bb4ef3a52ad1fffb555c0d82828eb22737036eaeb02a235d82b909c4c3f58a6964a4f5f8f0b642ded0a8a553be7622a719da71d1f5befcefcdee8e0fde623ad0f61ad2bca5ba6a7693f50fce988e17c3780bf2b1e720cfbb38fbdd52e2118959c7221ab5ce9e26c3cd67b22c24f8baa54bac281d8e6b05e400e6c3a957ea2e6dab7c1f0dcd297c8d61647fd17d821541ea69c3cc37dcbad7f90d4eb4bc50004000000",
+                        "precomputedUsed": [
+                            "hashAmounts",
+                            "hashOutputs",
+                            "hashPrevouts",
+                            "hashScriptPubkeys",
+                            "hashSequences"
+                        ],
+                        "sigHash": "4f900a0bae3f1446fd48490c2958b5a023228f01661cda3496a11da502a7f7ef"
+                    },
+                    "expected": {
+                        "witness": [
+                            "b4010dd48a617db09926f729e79c33ae0b4e94b79f04a1ae93ede6315eb3669de185a17d2b0ac9ee09fd4c64b678a0b61a0a86fa888a273c8511be83bfd6810f"
+                        ]
+                    }
+                },
+                {
+                    "given": {
+                        "txinIndex": 6,
+                        "internalPrivkey": "415cfe9c15d9cea27d8104d5517c06e9de48e2f986b695e4f5ffebf230e725d8",
+                        "merkleRoot": "2f6b2c5397b6d68ca18e09a3f05161668ffe93a988582d55c6f07bd5b3329def",
+                        "hashType": 2
+                    },
+                    "intermediary": {
+                        "internalPubkey": "55adf4e8967fbd2e29f20ac896e60c3b0f1d5b0efa9d34941b5958c7b0a0312d",
+                        "tweak": "6579138e7976dc13b6a92f7bfd5a2fc7684f5ea42419d43368301470f3b74ed9",
+                        "tweakedPrivkey": "241c14f2639d0d7139282aa6abde28dd8a067baa9d633e4e7230287ec2d02901",
+                        "sigMsg": "0002020000000065cd1de3b33bb4ef3a52ad1fffb555c0d82828eb22737036eaeb02a235d82b909c4c3f58a6964a4f5f8f0b642ded0a8a553be7622a719da71d1f5befcefcdee8e0fde623ad0f61ad2bca5ba6a7693f50fce988e17c3780bf2b1e720cfbb38fbdd52e2118959c7221ab5ce9e26c3cd67b22c24f8baa54bac281d8e6b05e400e6c3a957e0006000000",
+                        "precomputedUsed": [
+                            "hashAmounts",
+                            "hashPrevouts",
+                            "hashScriptPubkeys",
+                            "hashSequences"
+                        ],
+                        "sigHash": "15f25c298eb5cdc7eb1d638dd2d45c97c4c59dcaec6679cfc16ad84f30876b85"
+                    },
+                    "expected": {
+                        "witness": [
+                            "a3785919a2ce3c4ce26f298c3d51619bc474ae24014bcdd31328cd8cfbab2eff3395fa0a16fe5f486d12f22a9cedded5ae74feb4bbe5351346508c5405bcfee002"
+                        ]
+                    }
+                },
+                {
+                    "given": {
+                        "txinIndex": 7,
+                        "internalPrivkey": "c7b0e81f0a9a0b0499e112279d718cca98e79a12e2f137c72ae5b213aad0d103",
+                        "merkleRoot": "6c2dc106ab816b73f9d07e3cd1ef2c8c1256f519748e0813e4edd2405d277bef",
+                        "hashType": 130
+                    },
+                    "intermediary": {
+                        "internalPubkey": "ee4fe085983462a184015d1f782d6a5f8b9c2b60130aff050ce221ecf3786592",
+                        "tweak": "9e0517edc8259bb3359255400b23ca9507f2a91cd1e4250ba068b4eafceba4a9",
+                        "tweakedPrivkey": "65b6000cd2bfa6b7cf736767a8955760e62b6649058cbc970b7c0871d786346b",
+                        "sigMsg": "0082020000000065cd1d00e9aa6b8e6c9de67619e6a3924ae25696bb7b694bb677a632a74ef7eadfd4eabf00000000804c8b2000000000225120712447206d7a5238acc7ff53fbe94a3b64539ad291c7cdbc490b7577e4b17df5ffffffff",
+                        "precomputedUsed": [],
+                        "sigHash": "cd292de50313804dabe4685e83f923d2969577191a3e1d2882220dca88cbeb10"
+                    },
+                    "expected": {
+                        "witness": [
+                            "ea0c6ba90763c2d3a296ad82ba45881abb4f426b3f87af162dd24d5109edc1cdd11915095ba47c3a9963dc1e6c432939872bc49212fe34c632cd3ab9fed429c482"
+                        ]
+                    }
+                },
+                {
+                    "given": {
+                        "txinIndex": 8,
+                        "internalPrivkey": "77863416be0d0665e517e1c375fd6f75839544eca553675ef7fdf4949518ebaa",
+                        "merkleRoot": "ab179431c28d3b68fb798957faf5497d69c883c6fb1e1cd9f81483d87bac90cc",
+                        "hashType": 129
+                    },
+                    "intermediary": {
+                        "internalPubkey": "f9f400803e683727b14f463836e1e78e1c64417638aa066919291a225f0e8dd8",
+                        "tweak": "639f0281b7ac49e742cd25b7f188657626da1ad169209078e2761cefd91fd65e",
+                        "tweakedPrivkey": "ec18ce6af99f43815db543f47b8af5ff5df3b2cb7315c955aa4a86e8143d2bf5",
+                        "sigMsg": "0081020000000065cd1da2e6dab7c1f0dcd297c8d61647fd17d821541ea69c3cc37dcbad7f90d4eb4bc500a778eb6a263dc090464cd125c466b5a99667720b1c110468831d058aa1b82af101000000002b0c230000000022512077e30a5522dd9f894c3f8b8bd4c4b2cf82ca7da8a3ea6a239655c39c050ab220ffffffff",
+                        "precomputedUsed": [
+                            "hashOutputs"
+                        ],
+                        "sigHash": "cccb739eca6c13a8a89e6e5cd317ffe55669bbda23f2fd37b0f18755e008edd2"
+                    },
+                    "expected": {
+                        "witness": [
+                            "bbc9584a11074e83bc8c6759ec55401f0ae7b03ef290c3139814f545b58a9f8127258000874f44bc46db7646322107d4d86aec8e73b8719a61fff761d75b5dd981"
+                        ]
+                    }
+                }
+            ],
+            "auxiliary": {
+                "fullySignedTx": "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"
+            }
+        }
+    ]
+}
diff --git a/tapyrus/tests/data/block_13b8a.hex b/tapyrus/tests/data/block_13b8a.hex
new file mode 100644
index 00000000..13b6021b
--- /dev/null
+++ b/tapyrus/tests/data/block_13b8a.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tapyrus/tests/data/block_3ec84b_hex b/tapyrus/tests/data/block_3ec84b_hex
new file mode 100644
index 00000000..e015f72e
--- /dev/null
+++ b/tapyrus/tests/data/block_3ec84b_hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tapyrus/tests/data/blockfilters.json b/tapyrus/tests/data/blockfilters.json
new file mode 100644
index 00000000..ec623925
--- /dev/null
+++ b/tapyrus/tests/data/blockfilters.json
@@ -0,0 +1,13 @@
+[
+["Block Height,Block Hash,Block,[Prev Output Scripts for Block],Previous Basic Header,Basic Filter,Basic Header,Notes"],
+[0,"000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943","0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff001d0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000",[],"0000000000000000000000000000000000000000000000000000000000000000","019dfca8","21584579b7eb08997773e5aeff3a7f932700042d0ed2a6129012b7d7ae81b750","Genesis block"],
+[2,"000000006c02c8ea6e4ff69651f7fcde348fb9d557a06e6957b65552002a7820","0100000006128e87be8b1b4dea47a7247d5528d2702c96826c7a648497e773b800000000e241352e3bec0a95a6217e10c3abb54adfa05abb12c126695595580fb92e222032e7494dffff001d0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e0432e7494d010e062f503253482fffffffff0100f2052a010000002321038a7f6ef1c8ca0c588aa53fa860128077c9e6c11e6830f4d7ee4e763a56b7718fac00000000",[],"d7bdac13a59d745b1add0d2ce852f1a0442e8945fc1bf3848d3cbffd88c24fe1","0174a170","186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0",""],
+[3,"000000008b896e272758da5297bcd98fdc6d97c9b765ecec401e286dc1fdbe10","0100000020782a005255b657696ea057d5b98f34defcf75196f64f6eeac8026c0000000041ba5afc532aae03151b8aa87b65e1594f97504a768e010c98c0add79216247186e7494dffff001d0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e0486e7494d0151062f503253482fffffffff0100f2052a01000000232103f6d9ff4c12959445ca5549c811683bf9c88e637b222dd2e0311154c4c85cf423ac00000000",[],"186afd11ef2b5e7e3504f2e8cbf8df28a1fd251fe53d60dff8b1467d1b386cf0","016cf7a0","8d63aadf5ab7257cb6d2316a57b16f517bff1c6388f124ec4c04af1212729d2a",""],
+[15007,"0000000038c44c703bae0f98cdd6bf30922326340a5996cc692aaae8bacf47ad","0100000002394092aa378fe35d7e9ac79c869b975c4de4374cd75eb5484b0e1e00000000eb9b8670abd44ad6c55cee18e3020fb0c6519e7004b01a16e9164867531b67afc33bc94fffff001d0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0e04c33bc94f0115062f503253482fffffffff0100f2052a01000000232103f268e9ae07e0f8cb2f6e901d87c510d650b97230c0365b021df8f467363cafb1ac00000000",[],"18b5c2b0146d2d09d24fb00ff5b52bd0742f36c9e65527abdb9de30c027a4748","013c3710","07384b01311867949e0c046607c66b7a766d338474bb67f66c8ae9dbd454b20e","Tx has non-standard OP_RETURN output followed by opcodes"],
+[49291,"0000000018b07dca1b28b4b5a119f6d6e71698ce1ed96f143f54179ce177a19c","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",["5221033423007d8f263819a2e42becaaf5b06f34cb09919e06304349d950668209eaed21021d69e2b68c3960903b702af7829fadcd80bd89b158150c85c4a75b2c8cb9c39452ae","52210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821021d69e2b68c3960903b702af7829fadcd80bd89b158150c85c4a75b2c8cb9c39452ae","522102a7ae1e0971fc1689bd66d2a7296da3a1662fd21a53c9e38979e0f090a375c12d21022adb62335f41eb4e27056ac37d462cda5ad783fa8e0e526ed79c752475db285d52ae","52210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821022adb62335f41eb4e27056ac37d462cda5ad783fa8e0e526ed79c752475db285d52ae","512103b9d1d0e2b4355ec3cdef7c11a5c0beff9e8b8d8372ab4b4e0aaf30e80173001951ae","76a9149144761ebaccd5b4bbdc2a35453585b5637b2f8588ac","522103f1848b40621c5d48471d9784c8174ca060555891ace6d2b03c58eece946b1a9121020ee5d32b54d429c152fdc7b1db84f2074b0564d35400d89d11870f9273ec140c52ae","76a914f4fa1cc7de742d135ea82c17adf0bb9cf5f4fb8388ac"],"ed47705334f4643892ca46396eb3f4196a5e30880589e4009ef38eae895d4a13","0afbc2920af1b027f31f87b592276eb4c32094bb4d3697021b4c6380","b6d98692cec5145f67585f3434ec3c2b3030182e1cb3ec58b855c5c164dfaaa3","Tx pays to empty output script"],
+[180480,"00000000fd3ceb2404ff07a785c7fdcc76619edc8ed61bd25134eaa22084366a","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",["","","","76a9142903b138c24be9e070b3e73ec495d77a204615e788ac","76a91433a1941fd9a37b9821d376f5a51bd4b52fa50e2888ac","76a914e4374e8155d0865742ca12b8d4d14d41b57d682f88ac","76a914001fa7459a6cfc64bdc178ba7e7a21603bb2568f88ac","76a914f6039952bc2b307aeec5371bfb96b66078ec17f688ac"],"d34ef98386f413769502808d4bac5f20f8dfd5bffc9eedafaa71de0eb1f01489","0db414c859a07e8205876354a210a75042d0463404913d61a8e068e58a3ae2aa080026","c582d51c0ca365e3fcf36c51cb646d7f83a67e867cb4743fd2128e3e022b700c","Tx spends from empty output script"],
+[926485,"000000000000015d6077a411a8f5cc95caf775ccf11c54e27df75ce58d187313","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",["a914feb8a29635c56d9cd913122f90678756bf23887687","76a914c01a7ca16b47be50cbdbc60724f701d52d75156688ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac","76a914913bcc2be49cb534c20474c4dee1e9c4c317e7eb88ac"],"8f13b9a9c85611635b47906c3053ac53cfcec7211455d4cb0d63dc9acc13d472","09027acea61b6cc3fb33f5d52f7d088a6b2f75d234e89ca800","546c574a0472144bcaf9b6aeabf26372ad87c7af7d1ee0dbfae5e099abeae49c","Duplicate pushdata 913bcc2be49cb534c20474c4dee1e9c4c317e7eb"],
+[987876,"0000000000000c00901f2049055e2a437c819d79a3d54fd63e6af796cd7b8a79","000000202694f74969fdb542090e95a56bc8aa2d646e27033850e32f1c5f000000000000f7e53676b3f12d5beb524ed617f2d25f5a93b5f4f52c1ba2678260d72712f8dd0a6dfe5740257e1a0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff1603e4120ff9c30a1c216900002f424d4920546573742fffffff0001205fa012000000001e76a914c486de584a735ec2f22da7cd9681614681f92173d83d0aa68688ac00000000",[],"fe4d230dbb0f4fec9bed23a5283e08baf996e3f32b93f52c7de1f641ddfd04ad","010c0b40","0965a544743bbfa36f254446e75630c09404b3d164a261892372977538928ed5","Coinbase tx has unparseable output script"],
+[1263442,"000000006f27ddfe1dd680044a34548f41bed47eba9e6f0b310da21423bc5f33","000000201c8d1a529c39a396db2db234d5ec152fa651a2872966daccbde028b400000000083f14492679151dbfaa1a825ef4c18518e780c1f91044180280a7d33f4a98ff5f45765aaddc001d02010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff230352471300fe5f45765afe94690a000963676d696e6572343208000000000000000000ffffffff024423a804000000001976a914f2c25ac3d59f3d674b1d1d0a25c27339aaac0ba688ac0000000000000000266a24aa21a9edcb26cb3052426b9ebb4d19c819ef87c19677bbf3a7c46ef0855bd1b2abe83491012000000000000000000000000000000000000000000000000000000000000000000000000002000000000101d20978463906ba4ff5e7192494b88dd5eb0de85d900ab253af909106faa22cc5010000000004000000014777ff000000000016001446c29eabe8208a33aa1023c741fa79aa92e881ff0347304402207d7ca96134f2bcfdd6b536536fdd39ad17793632016936f777ebb32c22943fda02206014d2fb8a6aa58279797f861042ba604ebd2f8f61e5bddbd9d3be5a245047b201004b632103eeaeba7ce5dc2470221e9517fb498e8d6bd4e73b85b8be655196972eb9ccd5566754b2752103a40b74d43df244799d041f32ce1ad515a6cd99501701540e38750d883ae21d3a68ac00000000",["002027a5000c7917f785d8fc6e5a55adfca8717ecb973ebb7743849ff956d896a7ed"],"31d66d516a9eda7de865df29f6ef6cb8e4bf9309e5dac899968a9a62a5df61e3","0385acb4f0fe889ef0","4e6d564c2a2452065c205dd7eb2791124e0c4e0dbb064c410c24968572589dec","Includes witness data"],
+[1414221,"0000000000000027b2b3b3381f114f674f481544ff2be37ae3788d7e078383b1","000000204ea88307a7959d8207968f152bedca5a93aefab253f1fb2cfb032a400000000070cebb14ec6dbc27a9dfd066d9849a4d3bac5f674665f73a5fe1de01a022a0c851fda85bf05f4c190102000000010000000000000000000000000000000000000000000000000000000000000000ffffffff18034d94154d696e6572476174653030310d000000f238f401ffffffff01c817a804000000000000000000",[],"5e5e12d90693c8e936f01847859404c67482439681928353ca1296982042864e","00","021e8882ef5a0ed932edeebbecfeda1d7ce528ec7b3daa27641acf1189d7b5dc","Empty data"]
+]
diff --git a/tapyrus/tests/data/combine_psbt_hex b/tapyrus/tests/data/combine_psbt_hex
new file mode 100644
index 00000000..47f38701
--- /dev/null
+++ b/tapyrus/tests/data/combine_psbt_hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tapyrus/tests/data/create_psbt_hex b/tapyrus/tests/data/create_psbt_hex
new file mode 100644
index 00000000..b5ef8d5e
--- /dev/null
+++ b/tapyrus/tests/data/create_psbt_hex
@@ -0,0 +1 @@
+70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000000000000000000
\ No newline at end of file
diff --git a/tapyrus/tests/data/extract_tx_hex b/tapyrus/tests/data/extract_tx_hex
new file mode 100644
index 00000000..41c22961
--- /dev/null
+++ b/tapyrus/tests/data/extract_tx_hex
@@ -0,0 +1 @@
+0200000000010258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd7500000000da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752aeffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d01000000232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00000000
\ No newline at end of file
diff --git a/tapyrus/tests/data/finalize_psbt_hex b/tapyrus/tests/data/finalize_psbt_hex
new file mode 100644
index 00000000..2866b82b
--- /dev/null
+++ b/tapyrus/tests/data/finalize_psbt_hex
@@ -0,0 +1 @@
+70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000107da00473044022074018ad4180097b873323c0015720b3684cc8123891048e7dbcd9b55ad679c99022073d369b740e3eb53dcefa33823c8070514ca55a7dd9544f157c167913261118c01483045022100f61038b308dc1da865a34852746f015772934208c6d24454393cd99bdf2217770220056e675a675a6d0a02b85b14e5e29074d8a25a9b5760bea2816f661910a006ea01475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae0001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870107232200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b20289030108da0400473044022062eb7a556107a7c73f45ac4ab5a1dddf6f7075fb1275969a7f383efff784bcb202200c05dbb7470dbf2f08557dd356c7325c1ed30913e996cd3840945db12228da5f01473044022065f45ba5998b59a27ffe1a7bed016af1f1f90d54b3aa8f7450aa5f56a25103bd02207f724703ad1edb96680b284b56d4ffcb88f7fb759eabbe08aa30f29b851383d20147522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae00220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000
\ No newline at end of file
diff --git a/tapyrus/tests/data/legacy_sighash.json b/tapyrus/tests/data/legacy_sighash.json
new file mode 100644
index 00000000..ea7d9fef
--- /dev/null
+++ b/tapyrus/tests/data/legacy_sighash.json
@@ -0,0 +1,292 @@
+[
+    ["tx, script, input_index, hash_type, expected_sighash"],
+    ["907c2bc503ade11cc3b04eb2918b6f547b0630ab569273824748c87ea14b0696526c66ba740200000004ab65ababfd1f9bdd4ef073c7afc4ae00da8a66f429c917a0081ad1e1dabce28d373eab81d8628de802000000096aab5253ab52000052ad042b5f25efb33beec9f3364e8a9139e8439d9d7e26529c3c30b6c3fd89f8684cfd68ea0200000009ab53526500636a52ab599ac2fe02a526ed040000000008535300516352515164370e010000000003006300ab2ec229", "", 2, 1864164639, "31af167a6cf3f9d5f6875caa4d31704ceb0eba078d132b78dab52c3b8997317e"],
+    ["a0aa3126041621a6dea5b800141aa696daf28408959dfb2df96095db9fa425ad3f427f2f6103000000015360290e9c6063fa26912c2e7fb6a0ad80f1c5fea1771d42f12976092e7a85a4229fdb6e890000000001abc109f6e47688ac0e4682988785744602b8c87228fcef0695085edf19088af1a9db126e93000000000665516aac536affffffff8fe53e0806e12dfd05d67ac68f4768fdbe23fc48ace22a5aa8ba04c96d58e2750300000009ac51abac63ab5153650524aa680455ce7b000000000000499e50030000000008636a00ac526563ac5051ee030000000003abacabd2b6fe000000000003516563910fb6b5", "65", 0, -1391424484, "48d6a1bd2cd9eec54eb866fc71209418a950402b5d7e52363bfb75c98e141175"],
+    ["73107cbd025c22ebc8c3e0a47b2a760739216a528de8d4dab5d45cbeb3051cebae73b01ca10200000007ab6353656a636affffffffe26816dffc670841e6a6c8c61c586da401df1261a330a6c6b3dd9f9a0789bc9e000000000800ac6552ac6aac51ffffffff0174a8f0010000000004ac52515100000000", "5163ac63635151ac", 1, 1190874345, "06e328de263a87b09beabe222a21627a6ea5c7f560030da31610c4611f4a46bc"],
+    ["50818f4c01b464538b1e7e7f5ae4ed96ad23c68c830e78da9a845bc19b5c3b0b20bb82e5e9030000000763526a63655352ffffffff023b3f9c040000000008630051516a6a5163a83caf01000000000553ab65510000000000", "6aac", 0, 946795545, "746306f322de2b4b58ffe7faae83f6a72433c22f88062cdde881d4dd8a5a4e2d"],
+    ["a93e93440250f97012d466a6cc24839f572def241c814fe6ae94442cf58ea33eb0fdd9bcc1030000000600636a0065acffffffff5dee3a6e7e5ad6310dea3e5b3ddda1a56bf8de7d3b75889fc024b5e233ec10f80300000007ac53635253ab53ffffffff0160468b04000000000800526a5300ac526a00000000", "ac00636a53", 1, 1773442520, "5c9d3a2ce9365bb72cfabbaa4579c843bb8abf200944612cf8ae4b56a908bcbd"],
+    ["d3b7421e011f4de0f1cea9ba7458bf3486bee722519efab711a963fa8c100970cf7488b7bb0200000003525352dcd61b300148be5d05000000000000000000", "535251536aac536a", 0, -1960128125, "29aa6d2d752d3310eba20442770ad345b7f6a35f96161ede5f07b33e92053e2a"],
+    ["04bac8c5033460235919a9c63c42b2db884c7c8f2ed8fcd69ff683a0a2cccd9796346a04050200000003655351fcad3a2c5a7cbadeb4ec7acc9836c3f5c3e776e5c566220f7f965cf194f8ef98efb5e3530200000007526a006552526526a2f55ba5f69699ece76692552b399ba908301907c5763d28a15b08581b23179cb01eac03000000075363ab6a516351073942c2025aa98a05000000000765006aabac65abd7ffa6030000000004516a655200000000", "53ac6365ac526a", 1, 764174870, "bf5fdc314ded2372a0ad078568d76c5064bf2affbde0764c335009e56634481b"],
+    ["c363a70c01ab174230bbe4afe0c3efa2d7f2feaf179431359adedccf30d1f69efe0c86ed390200000002ab51558648fe0231318b04000000000151662170000000000008ac5300006a63acac00000000", "", 0, 2146479410, "191ab180b0d753763671717d051f138d4866b7cb0d1d4811472e64de595d2c70"],
+    ["8d437a7304d8772210a923fd81187c425fc28c17a5052571501db05c7e89b11448b36618cd02000000026a6340fec14ad2c9298fde1477f1e8325e5747b61b7e2ff2a549f3d132689560ab6c45dd43c3010000000963ac00ac000051516a447ed907a7efffebeb103988bf5f947fc688aab2c6a7914f48238cf92c337fad4a79348102000000085352ac526a5152517436edf2d80e3ef06725227c970a816b25d0b58d2cd3c187a7af2cea66d6b27ba69bf33a0300000007000063ab526553f3f0d6140386815d030000000003ab6300de138f00000000000900525153515265abac1f87040300000000036aac6500000000", "51", 3, -315779667, "b6632ac53578a741ae8c36d8b69e79f39b89913a2c781cdf1bf47a8c29d997a5"],
+    ["fd878840031e82fdbe1ad1d745d1185622b0060ac56638290ec4f66b1beef4450817114a2c0000000009516a63ab53650051abffffffff37b7a10322b5418bfd64fb09cd8a27ddf57731aeb1f1f920ffde7cb2dfb6cdb70300000008536a5365ac53515369ecc034f1594690dbe189094dc816d6d57ea75917de764cbf8eccce4632cbabe7e116cd0100000003515352ffffffff035777fc000000000003515200abe9140300000000050063005165bed6d10200000000076300536363ab65195e9110", "635265", 0, 1729787658, "6e3735d37a4b28c45919543aabcb732e7a3e1874db5315abb7cc6b143d62ff10"],
+    ["a63bc673049c75211aa2c09ecc38e360eaa571435fedd2af1116b5c1fa3d0629c269ecccbf0000000008ac65ab516352ac52ffffffffbf1a76fdda7f451a5f0baff0f9ccd0fe9136444c094bb8c544b1af0fa2774b06010000000463535253ffffffff13d6b7c3ddceef255d680d87181e100864eeb11a5bb6a3528cb0d70d7ee2bbbc02000000056a0052abab951241809623313b198bb520645c15ec96bfcc74a2b0f3db7ad61d455cc32db04afc5cc702000000016309c9ae25014d9473020000000004abab6aac3bb1e803", "", 3, -232881718, "6e48f3da3a4ac07eb4043a232df9f84e110485d7c7669dd114f679c27d15b97e"],
+    ["4c565efe04e7d32bac03ae358d63140c1cfe95de15e30c5b84f31bb0b65bb542d637f49e0f010000000551abab536348ae32b31c7d3132030a510a1b1aacf7b7c3f19ce8dc49944ef93e5fa5fe2d356b4a73a00100000009abac635163ac00ab514c8bc57b6b844e04555c0a4f4fb426df139475cd2396ae418bc7015820e852f711519bc202000000086a00510000abac52488ff4aec72cbcfcc98759c58e20a8d2d9725aa4a80f83964e69bc4e793a4ff25cd75dc701000000086a52ac6aac5351532ec6b10802463e0200000000000553005265523e08680100000000002f39a6b0", "", 3, 70712784, "c6076b6a45e6fcfba14d3df47a34f6aadbacfba107e95621d8d7c9c0e40518ed"],
+    ["fd22692802db8ae6ab095aeae3867305a954278f7c076c542f0344b2591789e7e33e4d29f4020000000151ffffffffb9409129cfed9d3226f3b6bab7a2c83f99f48d039100eeb5796f00903b0e5e5e0100000006656552ac63abd226abac0403e649000000000007abab51ac5100ac8035f10000000000095165006a63526a52510d42db030000000007635365ac6a63ab24ef5901000000000453ab6a0000000000", "536a52516aac6a", 1, 309309168, "7ca0f75e6530ec9f80d031fc3513ca4ecd67f20cb38b4dacc6a1d825c3cdbfdb"],
+    ["a43f85f701ffa54a3cc57177510f3ea28ecb6db0d4431fc79171cad708a6054f6e5b4f89170000000008ac6a006a536551652bebeaa2013e779c05000000000665ac5363635100000000", "ac", 0, 2028978692, "58294f0d7f2e68fe1fd30c01764fe1619bcc7961d68968944a0e263af6550437"],
+    ["c2b0b99001acfecf7da736de0ffaef8134a9676811602a6299ba5a2563a23bb09e8cbedf9300000000026300ffffffff042997c50300000000045252536a272437030000000007655353ab6363ac663752030000000002ab6a6d5c900000000000066a6a5265abab00000000", "52ac525163515251", 0, -894181723, "8b300032a1915a4ac05cea2f7d44c26f2a08d109a71602636f15866563eaafdc"],
+    ["82f9f10304c17a9d954cf3380db817814a8c738d2c811f0412284b2c791ec75515f38c4f8c020000000265ab5729ca7db1b79abee66c8a757221f29280d0681355cb522149525f36da760548dbd7080a0100000001510b477bd9ce9ad5bb81c0306273a3a7d051e053f04ecf3a1dbeda543e20601a5755c0cfae030000000451ac656affffffff71141a04134f6c292c2e0d415e6705dfd8dcee892b0d0807828d5aeb7d11f5ef0300000001520b6c6dc802a6f3dd0000000000056aab515163bfb6800300000000015300000000", "", 3, -635779440, "d55ed1e6c53510f2608716c12132a11fb5e662ec67421a513c074537eeccc34b"],
+    ["2074bad5011847f14df5ea7b4afd80cd56b02b99634893c6e3d5aaad41ca7c8ee8e5098df003000000026a6affffffff018ad59700000000000900ac656a526551635300000000", "65635265", 0, -1804671183, "663c999a52288c9999bff36c9da2f8b78d5c61b8347538f76c164ccba9868d0a"],
+    ["7100b11302e554d4ef249ee416e7510a485e43b2ba4b8812d8fe5529fe33ea75f36d392c4403000000020000ffffffff3d01a37e075e9a7715a657ae1bdf1e44b46e236ad16fd2f4c74eb9bf370368810000000007636553ac536365ffffffff01db696a0400000000065200ac656aac00000000", "63005151", 0, -1210499507, "b9c3aee8515a4a3b439de1ffc9c156824bda12cb75bfe5bc863164e8fd31bd7a"],
+    ["02c1017802091d1cb08fec512db7b012fe4220d57a5f15f9e7676358b012786e1209bcff950100000004acab6352ffffffff799bc282724a970a6fea1828984d0aeb0f16b67776fa213cbdc4838a2f1961a3010000000951516a536552ab6aabffffffff016c7b4b03000000000865abac5253ac5352b70195ad", "65655200516a", 0, -241626954, "be567cb47170b34ff81c66c1142cb9d27f9b6898a384d6dfc4fce16b75b6cb14"],
+    ["4504cb1904c7a4acf375ddae431a74de72d5436efc73312cf8e9921f431267ea6852f9714a01000000066a656a656553a2fbd587c098b3a1c5bd1d6480f730a0d6d9b537966e20efc0e352d971576d0f87df0d6d01000000016321aeec3c4dcc819f1290edb463a737118f39ab5765800547522708c425306ebfca3f396603000000055300ac656a1d09281d05bfac57b5eb17eb3fa81ffcedfbcd3a917f1be0985c944d473d2c34d245eb350300000007656a51525152ac263078d9032f470f0500000000066aac00000052e12da60200000000003488410200000000076365006300ab539981e432", "52536a52526a", 1, -31909119, "f0a2deee7fd8a3a9fad6927e763ded11c940ee47e9e6d410f94fda5001f82e0c"],
+    ["14bc7c3e03322ec0f1311f4327e93059c996275302554473104f3f7b46ca179bfac9ef753503000000016affffffff9d405eaeffa1ca54d9a05441a296e5cc3a3e32bb8307afaf167f7b57190b07e00300000008abab51ab5263abab45533aa242c61bca90dd15d46079a0ab0841d85df67b29ba87f2393cd764a6997c372b55030000000452005263ffffffff0250f40e02000000000651516a0063630e95ab0000000000046a5151ac00000000", "6a65005151", 0, -1460947095, "aa418d096929394c9147be8818d8c9dafe6d105945ab9cd7ec682df537b5dd79"],
+    ["a08ff466049fb7619e25502ec22fedfb229eaa1fe275aa0b5a23154b318441bf547989d0510000000005ab5363636affffffff2b0e335cb5383886751cdbd993dc0720817745a6b1c9b8ab3d15547fc9aafd03000000000965656a536a52656a532b53d10584c290d3ac1ab74ab0a19201a4a039cb59dc58719821c024f6bf2eb26322b33f010000000965ac6aac0053ab6353ffffffff048decba6ebbd2db81e416e39dde1f821ba69329725e702bcdea20c5cc0ecc6402000000086363ab5351ac6551466e377b0468c0fa00000000000651ab53ac6a513461c6010000000008636a636365535100eeb3dc010000000006526a52ac516a43f362010000000005000063536500000000", "0063516a", 1, -1158911348, "f6a1ecb50bd7c2594ebecea5a1aa23c905087553e40486dade793c2f127fdfae"],
+    ["f10a0356031cd569d652dbca8e7a4d36c8da33cdff428d003338602b7764fe2c96c505175b010000000465ac516affffffffbb54563c71136fa944ee20452d78dc87073ac2365ba07e638dce29a5d179da600000000003635152ffffffff9a411d8e2d421b1e6085540ee2809901e590940bbb41532fa38bd7a16b68cc350100000007535251635365636195df1603b61c45010000000002ab65bf6a310400000000026352fcbba10200000000016aa30b7ff0", "5351", 0, 1552495929, "9eb8adf2caecb4bf9ac59d7f46bd20e83258472db2f569ee91aba4cf5ee78e29"],
+    ["c3325c9b012f659466626ca8f3c61dfd36f34670abc054476b7516a1839ec43cd0870aa0c0000000000753525265005351e7e3f04b0112650500000000000363ac6300000000", "acac", 0, -68961433, "5ca70e727d91b1a42b78488af2ed551642c32d3de4712a51679f60f1456a8647"],
+    ["b500ca48011ec57c2e5252e5da6432089130603245ffbafb0e4c5ffe6090feb629207eeb0e010000000652ab6a636aab8302c9d2042b44f40500000000015278c05a050000000004ac5251524be080020000000007636aac63ac5252c93a9a04000000000965ab6553636aab5352d91f9ddb", "52005100", 0, -2024394677, "49c8a6940a461cc7225637f1e512cdd174c99f96ec05935a59637ededc77124c"],
+    ["f52ff64b02ee91adb01f3936cc42e41e1672778962b68cf013293d649536b519bc3271dd2c00000000020065afee11313784849a7c15f44a61cd5fd51ccfcdae707e5896d131b082dc9322a19e12858501000000036aac654e8ca882022deb7c020000000006006a515352abd3defc0000000000016300000000", "63520063", 0, 1130989496, "7f208df9a5507e98c62cebc5c1e2445eb632e95527594929b9577b53363e96f6"],
+    ["ab7d6f36027a7adc36a5cf7528fe4fb5d94b2c96803a4b38a83a675d7806dda62b380df86a0000000003000000ffffffff5bc00131e29e22057c04be854794b4877dda42e416a7a24706b802ff9da521b20000000007ac6a0065ac52ac957cf45501b9f06501000000000500ac6363ab25f1110b", "00526500536a635253", 0, 911316637, "5fa09d43c8aef6f6fa01c383a69a5a61a609cd06e37dce35a39dc9eae3ddfe6c"],
+    ["f940888f023dce6360263c850372eb145b864228fdbbb4c1186174fa83aab890ff38f8c9a90300000000ffffffff01e80ccdb081e7bbae1c776531adcbfb77f2e5a7d0e5d0d0e2e6c8758470e85f00000000020053ffffffff03b49088050000000004656a52ab428bd604000000000951630065ab63ac636a0cbacf0400000000070063ac5265ac53d6e16604", "ac63", 0, 39900215, "713ddeeefcfe04929e7b6593c792a4efbae88d2b5280d1f0835d2214eddcbad6"],
+    ["530ecd0b01ec302d97ef6f1b5a6420b9a239714013e20d39aa3789d191ef623fc215aa8b940200000005ac5351ab6a3823ab8202572eaa04000000000752ab6a51526563fd8a270100000000036a006581a798f0", "525153656a0063", 0, 1784562684, "fe42f73a8742676e640698222b1bd6b9c338ff1ccd766d3d88d7d3c6c6ac987e"],
+    ["5d781d9303acfcce964f50865ddfddab527ea971aee91234c88e184979985c00b4de15204b0100000003ab6352a009c8ab01f93c8ef2447386c434b4498538f061845862c3f9d5751ad0fce52af442b3a902000000045165ababb909c66b5a3e7c81b3c45396b944be13b8aacfc0204f3f3c105a66fa8fa6402f1b5efddb01000000096a65ac636aacab656ac3c677c402b79fa4050000000004006aab5133e35802000000000751ab635163ab0078c2e025", "6aac51636a6a005265", 0, -882306874, "551ce975d58647f10adefb3e529d9bf9cda34751627ec45e690f135ef0034b95"],
+    ["a9c57b1a018551bcbc781b256642532bbc09967f1cbe30a227d352a19365d219d3f11649a3030000000451655352b140942203182894030000000006ab00ac6aab654add350400000000003d379505000000000553abacac00e1739d36", "5363", 0, -1069721025, "6da32416deb45a0d720a1dbe6d357886eabc44029dd5db74d50feaffbe763245"],
+    ["05c4fb94040f5119dc0b10aa9df054871ed23c98c890f1e931a98ffb0683dac45e98619fdc0200000007acab6a525263513e7495651c9794c4d60da835d303eb4ee6e871f8292f6ad0b32e85ef08c9dc7aa4e03c9c010000000500ab52acacfffffffffee953259cf14ced323fe8d567e4c57ba331021a1ef5ac2fa90f7789340d7c550100000007ac6aacac6a6a53ffffffff08d9dc820d00f18998af247319f9de5c0bbd52a475ea587f16101af3afab7c210100000003535363569bca7c0468e34f00000000000863536353ac51ac6584e319010000000006650052ab6a533debea030000000003ac0053ee7070020000000006ac52005253ac00000000", "6351005253", 2, 1386916157, "76c4013c40bfa1481badd9d342b6d4b8118de5ab497995fafbf73144469e5ff0"],
+    ["ca66ae10049533c2b39f1449791bd6d3f039efe0a121ab7339d39ef05d6dcb200ec3fb2b3b020000000465006a53ffffffff534b8f97f15cc7fb4f4cea9bf798472dc93135cd5b809e4ca7fe4617a61895980100000000ddd83c1dc96f640929dd5e6f1151dab1aa669128591f153310d3993e562cc7725b6ae3d903000000046a52536582f8ccddb8086d8550f09128029e1782c3f2624419abdeaf74ecb24889cc45ac1a64492a0100000002516a4867b41502ee6ccf03000000000752acacab52ab6a4b7ba80000000000075151ab0052536300000000", "6553", 2, -62969257, "8085e904164ab9a8c20f58f0d387f6adb3df85532e11662c03b53c3df8c943cb"],
+    ["ba646d0b0453999f0c70cb0430d4cab0e2120457bb9128ed002b6e9500e9c7f8d7baa20abe0200000001652a4e42935b21db02b56bf6f08ef4be5adb13c38bc6a0c3187ed7f6197607ba6a2c47bc8a03000000040052516affffffffa55c3cbfc19b1667594ac8681ba5d159514b623d08ed4697f56ce8fcd9ca5b0b00000000096a6a5263ac655263ab66728c2720fdeabdfdf8d9fb2bfe88b295d3b87590e26a1e456bad5991964165f888c03a0200000006630051ac00acffffffff0176fafe0100000000070063acac65515200000000", "63", 1, 2002322280, "9db4e320208185ee70edb4764ee195deca00ba46412d5527d9700c1cf1c3d057"],
+    ["2ddb8f84039f983b45f64a7a79b74ff939e3b598b38f436def7edd57282d0803c7ef34968d02000000026a537eb00c4187de96e6e397c05f11915270bcc383959877868ba93bac417d9f6ed9f627a7930300000004516551abffffffffacc12f1bb67be3ae9f1d43e55fda8b885340a0df1175392a8bbd9f959ad3605003000000025163ffffffff02ff0f4700000000000070bd99040000000003ac53abf8440b42", "", 2, -393923011, "0133f1a161363b71dfb3a90065c7128c56bd0028b558b610142df79e055ab5c7"],
+    ["b21fc15403b4bdaa994204444b59323a7b8714dd471bd7f975a4e4b7b48787e720cbd1f5f00000000000ffffffff311533001cb85c98c1d58de0a5fbf27684a69af850d52e22197b0dc941bc6ca9030000000765ab6363ab5351a8ae2c2c7141ece9a4ff75c43b7ea9d94ec79b7e28f63e015ac584d984a526a73fe1e04e0100000007526352536a5365ffffffff02a0a9ea030000000002ab52cfc4f300000000000465525253e8e0f342", "000000", 1, 1305253970, "d1df1f4bba2484cff8a816012bb6ec91c693e8ca69fe85255e0031711081c46a"],
+    ["f821a042036ad43634d29913b77c0fc87b4af593ac86e9a816a9d83fd18dfcfc84e1e1d57102000000076a63ac52006351ffffffffbcdaf490fc75086109e2f832c8985716b3a624a422cf9412fe6227c10585d21203000000095252abab5352ac526affffffff2efed01a4b73ad46c7f7bc7fa3bc480f8e32d741252f389eaca889a2e9d2007e000000000353ac53ffffffff032ac8b3020000000009636300000063516300d3d9f2040000000006510065ac656aafa5de0000000000066352ab5300ac9042b57d", "525365", 1, 667065611, "0d17a92c8d5041ba09b506ddf9fd48993be389d000aad54f9cc2a44fcc70426b"],
+    ["d62f183e037e0d52dcf73f9b31f70554bce4f693d36d17552d0e217041e01f15ad3840c838000000000963acac6a6a6a63ab63ffffffffabdfb395b6b4e63e02a763830f536fc09a35ff8a0cf604021c3c751fe4c88f4d0300000006ab63ab65ac53aa4d30de95a2327bccf9039fb1ad976f84e0b4a0936d82e67eafebc108993f1e57d8ae39000000000165ffffffff04364ad30500000000036a005179fd84010000000007ab636aac6363519b9023030000000008510065006563ac6acd2a4a02000000000000000000", "52", 1, 595020383, "da8405db28726dc4e0f82b61b2bfd82b1baa436b4e59300305cc3b090b157504"],
+    ["44c200a5021238de8de7d80e7cce905606001524e21c8d8627e279335554ca886454d692e6000000000500acac52abbb8d1dc876abb1f514e96b21c6e83f429c66accd961860dc3aed5071e153e556e6cf076d02000000056553526a51870a928d0360a580040000000004516a535290e1e302000000000851ab6a00510065acdd7fc5040000000007515363ab65636abb1ec182", "6363", 0, -785766894, "ed53cc766cf7cb8071cec9752460763b504b2183442328c5a9761eb005c69501"],
+    ["d682d52d034e9b062544e5f8c60f860c18f029df8b47716cabb6c1b4a4b310a0705e754556020000000400656a0016eeb88eef6924fed207fba7ddd321ff3d84f09902ff958c815a2bf2bb692eb52032c4d803000000076365ac516a520099788831f8c8eb2552389839cfb81a9dc55ecd25367acad4e03cfbb06530f8cccf82802701000000085253655300656a53ffffffff02d543200500000000056a510052ac03978b05000000000700ac51525363acfdc4f784", "", 2, -696035135, "e1a256854099907050cfee7778f2018082e735a1f1a3d91437584850a74c87bb"],
+    ["e8c0dec5026575ddf31343c20aeeca8770afb33d4e562aa8ee52eeda6b88806fdfd4fe0a97030000000953acabab65ab516552ffffffffdde122c2c3e9708874286465f8105f43019e837746686f442666629088a970e0010000000153ffffffff01f98eee0100000000025251fe87379a", "63", 1, 633826334, "abe441209165d25bc6d8368f2e7e7dc21019056719fef1ace45542aa2ef282e2"],
+    ["b288c331011c17569293c1e6448e33a64205fc9dc6e35bc756a1ac8b97d18e912ea88dc0770200000007635300ac6aacabfc3c890903a3ccf8040000000004656500ac9c65c9040000000009ab6a6aabab65abac63ac5f7702000000000365005200000000", "526a63", 0, 1574937329, "0dd1bd5c25533bf5f268aa316ce40f97452cca2061f0b126a59094ca5b65f7a0"],
+    ["6b68ba00023bb4f446365ea04d68d48539aae66f5b04e31e6b38b594d2723ab82d44512460000000000200acffffffff5dfc6febb484fff69c9eeb7c7eb972e91b6d949295571b8235b1da8955f3137b020000000851ac6352516a535325828c8a03365da801000000000800636aabac6551ab0f594d03000000000963ac536365ac63636a45329e010000000005abac53526a00000000", "005151", 0, 1317038910, "42f5ba6f5fe1e00e652a08c46715871dc4b40d89d9799fd7c0ea758f86eab6a7"],
+    ["046ac25e030a344116489cc48025659a363da60bc36b3a8784df137a93b9afeab91a04c1ed020000000951ab0000526a65ac51ffffffff6c094a03869fde55b9a8c4942a9906683f0a96e2d3e5a03c73614ea3223b2c29020000000500ab636a6affffffff3da7aa5ecef9071600866267674b54af1740c5aeb88a290c459caa257a2683cb0000000004ab6565ab7e2a1b900301b916030000000005abac63656308f4ed03000000000852ab53ac63ac51ac73d620020000000003ab00008deb1285", "6a", 2, 1299505108, "f79e6b776e2592bad45ca328c54abf14050c241d8f822d982c36ea890fd45757"],
+    ["ff5400dd02fec5beb9a396e1cbedc82bedae09ed44bae60ba9bef2ff375a6858212478844b03000000025253ffffffff01e46c203577a79d1172db715e9cc6316b9cfc59b5e5e4d9199fef201c6f9f0f000000000900ab6552656a5165acffffffff02e8ce62040000000002515312ce3e00000000000251513f119316", "", 0, 1541581667, "1e0da47eedbbb381b0e0debbb76e128d042e02e65b11125e17fd127305fc65cd"],
+    ["b54bf5ac043b62e97817abb892892269231b9b220ba08bc8dbc570937cd1ea7cdc13d9676c010000000451ab5365a10adb7b35189e1e8c00b86250f769319668189b7993d6bdac012800f1749150415b2deb0200000003655300ffffffff60b9f4fb9a7e17069fd00416d421f804e2ef2f2c67de4ca04e0241b9f9c1cc5d0200000003ab6aacfffffffff048168461cce1d40601b42fbc5c4f904ace0d35654b7cc1937ccf53fe78505a0100000008526563525265abacffffffff01dbf4e6040000000007acac656553636500000000", "63", 2, 882302077, "f5b38b0f06e246e47ce622e5ee27d5512c509f8ac0e39651b3389815eff2ab93"],
+    ["ebf628b30360bab3fa4f47ce9e0dcbe9ceaf6675350e638baff0c2c197b2419f8e4fb17e16000000000452516365ac4d909a79be207c6e5fb44fbe348acc42fc7fe7ef1d0baa0e4771a3c4a6efdd7e2c118b0100000003acacacffffffffa6166e9101f03975721a3067f1636cc390d72617be72e5c3c4f73057004ee0ee010000000863636a6a516a5252c1b1e82102d8d54500000000000153324c900400000000015308384913", "0063516a51", 1, -1658428367, "eb2d8dea38e9175d4d33df41f4087c6fea038a71572e3bad1ea166353bf22184"],
+    ["d6a8500303f1507b1221a91adb6462fb62d741b3052e5e7684ea7cd061a5fc0b0e93549fa50100000004acab65acfffffffffdec79bf7e139c428c7cfd4b35435ae94336367c7b5e1f8e9826fcb0ebaaaea30300000000ffffffffd115fdc00713d52c35ea92805414bd57d1e59d0e6d3b79a77ee18a3228278ada020000000453005151ffffffff040231510300000000085100ac6a6a000063c6041c0400000000080000536a6563acac138a0b04000000000263abd25fbe03000000000900656a00656aac510000000000", "ac526aac6a00", 1, -2007972591, "13d12a51598b34851e7066cd93ab8c5212d60c6ed2dae09d91672c10ccd7f87c"],
+    ["e92492cc01aec4e62df67ea3bc645e2e3f603645b3c5b353e4ae967b562d23d6e043badecd0100000003acab65ffffffff02c7e5ea040000000002ab52e1e584010000000005536365515195d16047", "6551", 0, -424930556, "93c34627f526d73f4bea044392d1a99776b4409f7d3d835f23b03c358f5a61c2"],
+    ["b28d5f5e015a7f24d5f9e7b04a83cd07277d452e898f78b50aae45393dfb87f94a26ef57720200000008ababac630053ac52ffffffff046475ed040000000008ab5100526363ac65c9834a04000000000251abae26b30100000000040000ac65ceefb900000000000000000000", "ac6551ac6a536553", 0, -1756558188, "5848d93491044d7f21884eef7a244fe7d38886f8ae60df49ce0dfb2a342cd51a"],
+    ["efb8b09801f647553b91922a5874f8e4bb2ed8ddb3536ed2d2ed0698fac5e0e3a298012391030000000952ac005263ac52006affffffff04cdfa0f050000000007ac53ab51abac65b68d1b02000000000553ab65ac00d057d50000000000016a9e1fda010000000007ac63ac536552ac00000000", "6aac", 0, 1947322973, "603a9b61cd30fcea43ef0a5c18b88ca372690b971b379ee9e01909c336280511"],
+    ["67761f2a014a16f3940dcb14a22ba5dc057fcffdcd2cf6150b01d516be00ef55ef7eb07a830100000004636a6a51ffffffff01af67bd050000000008526553526300510000000000", "6a00", 0, 1570943676, "079fa62e9d9d7654da8b74b065da3154f3e63c315f25751b4d896733a1d67807"],
+    ["ec02fbee03120d02fde12574649660c441b40d330439183430c6feb404064d4f507e704f3c0100000000ffffffffe108d99c7a4e5f75cc35c05debb615d52fac6e3240a6964a29c1704d98017fb60200000002ab63fffffffff726ec890038977adfc9dadbeaf5e486d5fcb65dc23acff0dd90b61b8e2773410000000002ac65e9dace55010f881b010000000005ac00ab650000000000", "51ac525152ac6552", 2, -1564046020, "3f988922d8cd11c7adff1a83ce9499019e5ab5f424752d8d361cf1762e04269b"],
+    ["33b03bf00222c7ca35c2f8870bbdef2a543b70677e413ce50494ac9b22ea673287b6aa55c50000000005ab00006a52ee4d97b527eb0b427e4514ea4a76c81e68c34900a23838d3e57d0edb5410e62eeb8c92b6000000000553ac6aacac42e59e170326245c000000000009656553536aab516aabb1a10603000000000852ab52ab6a516500cc89c802000000000763ac6a63ac516300000000", "", 0, 557416556, "41bead1b073e1e9fee065dd612a617ca0689e8f9d3fed9d0acfa97398ebb404c"],
+    ["813eda1103ac8159850b4524ef65e4644e0fc30efe57a5db0c0365a30446d518d9b9aa8fdd0000000003656565c2f1e89448b374b8f12055557927d5b33339c52228f7108228149920e0b77ef0bcd69da60000000006abac00ab63ab82cdb7978d28630c5e1dc630f332c4245581f787936f0b1e84d38d33892141974c75b4750300000004ac53ab65ffffffff0137edfb02000000000000000000", "0063", 1, -1948560575, "71dfcd2eb7f2e6473aed47b16a6d5fcbd0af22813d892e9765023151e07771ec"],
+    ["9e45d9aa0248c16dbd7f435e8c54ae1ad086de50c7b25795a704f3d8e45e1886386c653fbf01000000025352fb4a1acefdd27747b60d1fb79b96d14fb88770c75e0da941b7803a513e6d4c908c6445c7010000000163ffffffff014069a8010000000001520a794fb3", "51ac005363", 1, -719113284, "0d31a221c69bd322ef7193dd7359ddfefec9e0a1521d4a8740326d46e44a5d6a"],
+    ["c3efabba03cb656f154d1e159aa4a1a4bf9423a50454ebcef07bc3c42a35fb8ad84014864d0000000000d1cc73d260980775650caa272e9103dc6408bdacaddada6b9c67c88ceba6abaa9caa2f7d020000000553536a5265ffffffff9f946e8176d9b11ff854b76efcca0a4c236d29b69fb645ba29d406480427438e01000000066a0065005300ffffffff040419c0010000000003ab6a63cdb5b6010000000009006300ab5352656a63f9fe5e050000000004acac5352611b980100000000086a00acac00006a512d7f0c40", "0053", 0, -59089911, "c503001c16fbff82a99a18d88fe18720af63656fccd8511bca1c3d0d69bd7fc0"],
+    ["efb55c2e04b21a0c25e0e29f6586be9ef09f2008389e5257ebf2f5251051cdc6a79fce2dac020000000351006affffffffaba73e5b6e6c62048ba5676d18c33ccbcb59866470bb7911ccafb2238cfd493802000000026563ffffffffe62d7cb8658a6eca8a8babeb0f1f4fa535b62f5fc0ec70eb0111174e72bbec5e0300000009abababac516365526affffffffbf568789e681032d3e3be761642f25e46c20322fa80346c1146cb47ac999cf1b0300000000b3dbd55902528828010000000001ab0aac7b0100000000015300000000", "acac52", 3, 1638140535, "e84444d91580da41c8a7dcf6d32229bb106f1be0c811b2292967ead5a96ce9d4"],
+    ["91d3b21903629209b877b3e1aef09cd59aca6a5a0db9b83e6b3472aceec3bc2109e64ab85a0200000003530065ffffffffca5f92de2f1b7d8478b8261eaf32e5656b9eabbc58dcb2345912e9079a33c4cd010000000700ab65ab00536ad530611da41bbd51a389788c46678a265fe85737b8d317a83a8ff7a839debd18892ae5c80300000007ab6aac65ab51008b86c501038b8a9a05000000000263525b3f7a040000000007ab535353ab00abd4e3ff04000000000665ac51ab65630b7b656f", "6551525151516a00", 2, 499657927, "ef4bd7622eb7b2bbbbdc48663c1bc90e01d5bde90ff4cb946596f781eb420a0c"],
+    ["ceecfa6c02b7e3345445b82226b15b7a097563fa7d15f3b0c979232b138124b62c0be007890200000009abac51536a63525253ffffffffbae481ccb4f15d94db5ec0d8854c24c1cc8642bd0c6300ede98a91ca13a4539a0200000001ac50b0813d023110f5020000000006acabac526563e2b0d0040000000009656aac0063516a536300000000", "0063526500", 0, -1862053821, "e1600e6df8a6160a79ac32aa40bb4644daa88b5f76c0d7d13bf003327223f70c"],
+    ["f06f64af04fdcb830464b5efdb3d5ee25869b0744005375481d7b9d7136a0eb8828ad1f0240200000003516563fffffffffd3ba192dabe9c4eb634a1e3079fca4f072ee5ceb4b57deb6ade5527053a92c5000000000165ffffffff39f43401a36ba13a5c6dd7f1190e793933ae32ee3bf3e7bfb967be51e681af760300000009650000536552636a528e34f50b21183952cad945a83d4d56294b55258183e1627d6e8fb3beb8457ec36cadb0630000000005abab530052334a7128014bbfd10100000000085352ab006a63656afc424a7c", "53650051635253ac00", 2, 313255000, "d309da5afd91b7afa257cfd62df3ca9df036b6a9f4b38f5697d1daa1f587312b"],
+    ["6dfd2f98046b08e7e2ef5fff153e00545faf7076699012993c7a30cb1a50ec528281a9022f030000000152ffffffff1f535e4851920b968e6c437d84d6ecf586984ebddb7d5db6ae035bd02ba222a8010000000651006a53ab51605072acb3e17939fa0737bc3ee43bc393b4acd58451fc4ffeeedc06df9fc649828822d5010000000253525a4955221715f27788d302382112cf60719be9ae159c51f394519bd5f7e70a4f9816c7020200000009526a6a51636aab656a36d3a5ff0445548e0100000000086a6a00516a52655167030b050000000004ac6a63525cfda8030000000000e158200000000000010000000000", "535263ac6a65515153", 3, 585774166, "72b7da10704c3ca7d1deb60c31b718ee12c70dc9dfb9ae3461edce50789fe2ba"],
+    ["2a45cd1001bf642a2315d4a427eddcc1e2b0209b1c6abd2db81a800c5f1af32812de42032702000000050051525200ffffffff032177db050000000005530051abac49186f000000000004ab6aab00645c0000000000000765655263acabac00000000", "6a65", 0, -1774715722, "6a9ac3f7da4c7735fbc91f728b52ecbd602233208f96ac5592656074a5db118a"],
+    ["ca816e7802cd43d66b9374cd9bf99a8da09402d69c688d8dcc5283ace8f147e1672b757e020200000005516aabab5240fb06c95c922342279fcd88ba6cd915933e320d7becac03192e0941e0345b79223e89570300000004005151ac353ecb5d0264dfbd010000000005ac6aacababd5d70001000000000752ac53ac6a5151ec257f71", "63ac", 1, 774695685, "cc180c4f797c16a639962e7aec58ec4b209853d842010e4d090895b22e7a7863"],
+    ["b42b955303942fedd7dc77bbd9040aa0de858afa100f399d63c7f167b7986d6c2377f66a7403000000066aac00525100ffffffff0577d04b64880425a3174055f94191031ad6b4ca6f34f6da9be7c3411d8b51fc000000000300526a6391e1cf0f22e45ef1c44298523b516b3e1249df153590f592fcb5c5fc432dc66f3b57cb03000000046a6aac65ffffffff0393a6c9000000000004516a65aca674ac0400000000046a525352c82c370000000000030053538e577f89", "", 1, -1237094944, "566953eb806d40a9fb684d46c1bf8c69dea86273424d562bd407b9461c8509af"],
+    ["92c9fe210201e781b72554a0ed5e22507fb02434ddbaa69aff6e74ea8bad656071f1923f3f02000000056a63ac6a514470cef985ba83dcb8eee2044807bedbf0d983ae21286421506ae276142359c8c6a34d68020000000863ac63525265006aa796dd0102ca3f9d05000000000800abab52ab535353cd5c83010000000007ac00525252005322ac75ee", "5165", 0, 97879971, "6e6307cef4f3a9b386f751a6f40acebab12a0e7e17171d2989293cbec7fd45c2"],
+    ["ccca1d5b01e40fe2c6b3ee24c660252134601dab785b8f55bd6201ffaf2fddc7b3e2192325030000000365535100496d4703b4b66603000000000665535253ac633013240000000000015212d2a502000000000951abac636353636a5337b82426", "0052", 0, -1691630172, "577bf2b3520b40aef44899a20d37833f1cded6b167e4d648fc5abe203e43b649"],
+    ["bc1a7a3c01691e2d0c4266136f12e391422f93655c71831d90935fbda7e840e50770c61da20000000008635253abac516353ffffffff031f32aa020000000003636563786dbc0200000000003e950f00000000000563516a655184b8a1de", "51536a", 0, -1627072905, "730bc25699b46703d7718fd5f5c34c4b5f00f594a9968ddc247fa7d5175124ed"],
+    ["076d209e02d904a6c40713c7225d23e7c25d4133c3c3477828f98c7d6dbd68744023dbb66b030000000753ab00536565acffffffff10975f1b8db8861ca94c8cc7c7cff086ddcd83e10b5fffd4fc8f2bdb03f9463c0100000000ffffffff029dff76010000000006526365530051a3be6004000000000000000000", "515253ac65acacac", 1, -1207502445, "66c488603b2bc53f0d22994a1f0f66fb2958203102eba30fe1d37b27a55de7a5"],
+    ["cac6382d0462375e83b67c7a86c922b569a7473bfced67f17afd96c3cd2d896cf113febf9e0300000003006a53ffffffffaa4913b7eae6821487dd3ca43a514e94dcbbf350f8cc4cafff9c1a88720711b800000000096a6a525300acac6353ffffffff184fc4109c34ea27014cc2c1536ef7ed1821951797a7141ddacdd6e429fae6ff01000000055251655200ffffffff9e7b79b4e6836e290d7b489ead931cba65d1030ccc06f20bd4ca46a40195b33c030000000008f6bc8304a09a2704000000000563655353511dbc73050000000000cf34c500000000000091f76e0000000000085200ab00005100abd07208cb", "0063656a", 2, -1488731031, "bf078519fa87b79f40abc38f1831731422722c59f88d86775535f209cb41b9b1"],
+    ["1711146502c1a0b82eaa7893976fefe0fb758c3f0e560447cef6e1bde11e42de91a125f71c030000000015bd8c04703b4030496c7461482481f290c623be3e76ad23d57a955807c9e851aaaa20270300000000d04abaf20326dcb7030000000001632225350400000000075263ac00520063dddad9020000000000af23d148", "52520053510063", 0, 1852122830, "e33d5ee08c0f3c130a44d7ce29606450271b676f4a80c52ab9ffab00cecf67f8"],
+    ["22d81c740469695a6a83a9a4824f77ecff8804d020df23713990afce2b72591ed7de98500502000000065352526a6a6affffffff90dc85e118379b1005d7bbc7d2b8b0bab104dad7eaa49ff5bead892f17d8c3ba010000000665656300ab51ffffffff965193879e1d5628b52005d8560a35a2ba57a7f19201a4045b7cbab85133311d0200000003ac005348af21a13f9b4e0ad90ed20bf84e4740c8a9d7129632590349afc03799414b76fd6e826200000000025353ffffffff04a0d40d04000000000060702700000000000652655151516ad31f1502000000000365ac0069a1ac0500000000095100655300ab53525100000000", "51636a52ac", 0, -1644680765, "add7f5da27262f13da6a1e2cc2feafdc809bd66a67fb8ae2a6f5e6be95373b6f"],
+    ["a27dcbc801e3475174a183586082e0914c314bc9d79d1570f29b54591e5e0dff07fbb45a7f0000000004ac53ab51ffffffff027347f5020000000005535351ab63d0e5c9030000000009ac65ab6a63515200ab7cd632ed", "ac63636553", 0, -686435306, "883a6ea3b2cc53fe8a803c229106366ca14d25ffbab9fef8367340f65b201da6"],
+    ["0728c606014c1fd6005ccf878196ba71a54e86cc8c53d6db500c3cc0ac369a26fac6fcbc210000000005ab53ac5365ba9668290182d7870100000000066a000053655100000000", "65", 0, 1789961588, "ab6baa6da3b2bc853868d166f8996ad31d63ef981179f9104f49968fd61c8427"],
+    ["ed3bb93802ddbd08cb030ef60a2247f715a0226de390c9c1a81d52e83f8674879065b5f87d0300000003ab6552ffffffff04d2c5e60a21fb6da8de20bf206db43b720e2a24ce26779bca25584c3f765d1e0200000008ab656a6aacab00ab6e946ded025a811d04000000000951abac6352ac00ab5143cfa3030000000005635200636a00000000", "5352ac650065535300", 1, -668727133, "e9995065e1fddef72a796eef5274de62012249660dc9d233a4f24e02a2979c87"],
+    ["59f4629d030fa5d115c33e8d55a79ea3cba8c209821f979ed0e285299a9c72a73c5bba00150200000002636affffffffd8aca2176df3f7a96d0dc4ee3d24e6cecde1582323eec2ebef9a11f8162f17ac0000000007ab6565acab6553ffffffffeebc10af4f99c7a21cbc1d1074bd9f0ee032482a71800f44f26ee67491208e0403000000065352ac656351ffffffff0434e955040000000004ab515152caf2b305000000000365ac007b1473030000000003ab530033da970500000000060051536a5253bb08ab51", "", 2, 396340944, "0e9c47973ef2c292b2252c623f465bbb92046fe0b893eebf4e1c9e02cb01c397"],
+    ["33a98004029d262f951881b20a8d746c8c707ea802cd2c8b02a33b7e907c58699f97e42be80100000007ac53536552abacdee04cc01d205fd8a3687fdf265b064d42ab38046d76c736aad8865ca210824b7c622ecf02000000070065006a536a6affffffff01431c5d010000000000270d48ee", "", 1, 921554116, "ff9d7394002f3f196ea25472ea6c46f753bd879a7244795157bb7235c9322902"],
+    ["aac18f2b02b144ed481557c53f2146ae523f24fcde40f3445ab0193b6b276c315dc2894d2300000000075165650000636a233526947dbffc76aec7db1e1baa6868ad4799c76e14794dcbaaec9e713a83967f6a65170200000005abac6551ab27d518be01b652a30000000000015300000000", "52ac5353", 1, 1559377136, "59fc2959bb7bb24576cc8a237961ed95bbb900679d94da6567734c4390cb6ef5"],
+    ["5ab79881033555b65fe58c928883f70ce7057426fbdd5c67d7260da0fe8b1b9e6a2674cb850300000009ac516aac6aac006a6affffffffa5be9223b43c2b1a4d120b5c5b6ec0484f637952a3252181d0f8e813e76e11580200000000e4b5ceb8118cb77215bbeedc9a076a4d087bb9cd1473ea32368b71daeeeacc451ec209010000000005acac5153aced7dc34e02bc5d11030000000005ac5363006a54185803000000000552ab00636a00000000", "5100", 1, 1927062711, "e9f53d531c12cce1c50abed4ac521a372b4449b6a12f9327c80020df6bff66c0"],
+    ["6c2c8fac0124b0b7d4b610c3c5b91dee32b7c927ac71abdf2d008990ca1ac40de0dfd530660300000006ababac5253656bd7eada01d847ec000000000004ac52006af4232ec8", "6a6a6a0051", 0, -340809707, "fb51eb9d7e47d32ff2086205214f90c7c139e08c257a64829ae4d2b301071c6a"],
+    ["0e803682024f79337b25c98f276d412bc27e56a300aa422c42994004790cee213008ff1b8303000000080051ac65ac655165f421a331892b19a44c9f88413d057fea03c3c4a6c7de4911fe6fe79cf2e9b3b10184b1910200000005525163630096cb1c670398277204000000000253acf7d5d502000000000963536a6a636a5363ab381092020000000002ac6a911ccf32", "6565", 1, -1492094009, "f0672638a0e568a919e9d8a9cbd7c0189a3e132940beeb52f111a89dcc2daa2c"],
+    ["7d71669d03022f9dd90edac323cde9e56354c6804c6b8e687e9ae699f46805aafb8bcaa636000000000253abffffffff698a5fdd3d7f2b8b000c68333e4dd58fa8045b3e2f689b889beeb3156cecdb490300000009525353abab0051acabc53f0aa821cdd69b473ec6e6cf45cf9b38996e1c8f52c27878a01ec8bb02e8cb31ad24e500000000055353ab0052ffffffff0447a23401000000000565ab53ab5133aaa0030000000006515163656563057d110300000000056a6aacac52cf13b5000000000003526a5100000000", "6a6a51", 1, -1349253507, "722efdd69a7d51d3d77bed0ac5544502da67e475ea5857cd5af6bdf640a69945"],
+    ["9ff618e60136f8e6bb7eabaaac7d6e2535f5fba95854be6d2726f986eaa9537cb283c701ff02000000026a65ffffffff012d1c0905000000000865ab00ac6a516a652f9ad240", "51515253635351ac", 0, 1571304387, "659cd3203095d4a8672646add7d77831a1926fc5b66128801979939383695a79"],
+    ["09adb2e90175ca0e816326ae2dce7750c1b27941b16f6278023dbc294632ab97977852a09d030000000465ab006affffffff027739cf0100000000075151ab63ac65ab8a5bb601000000000653ac5151520011313cdc", "ac", 0, -76831756, "478ee06501b4965b40bdba6cbaad9b779b38555a970912bb791b86b7191c54bc"],
+    ["fd22ebaa03bd588ad16795bea7d4aa7f7d48df163d75ea3afebe7017ce2f350f6a0c1cb0bb00000000086aabac5153526363ffffffff488e0bb22e26a565d77ba07178d17d8f85702630ee665ec35d152fa05af3bda10200000004515163abffffffffeb21035849e85ad84b2805e1069a91bb36c425dc9c212d9bae50a95b6bfde1200300000001ab5df262fd02b69848040000000008ab6363636a6363ace23bf2010000000007655263635253534348c1da", "006353526563516a00", 0, -1491036196, "92364ba3c7a85d4e88885b8cb9b520dd81fc29e9d2b750d0790690e9c1246673"],
+    ["b04154610363fdade55ceb6942d5e5a723323863b48a0cb04fdcf56210717955763f56b08d0300000009ac526a525151635151ffffffff93a176e76151a9eabdd7af00ef2af72f9e7af5ecb0aa4d45d00618f394cdd03c030000000074d818b332ebe05dc24c44d776cf9d275c61f471cc01efce12fd5a16464157f1842c65cb00000000066a0000ac6352d3c4134f01d8a1c0030000000005520000005200000000", "5200656a656351", 2, -9757957, "6e3e5ba77f760b6b5b5557b13043f1262418f3dd2ce7f0298b012811fc8ad5bc"],
+    ["94533db7015e70e8df715066efa69dbb9c3a42ff733367c18c22ff070392f988f3b93920820000000006535363636300ce4dac3e03169af80300000000080065ac6a53ac65ac39c050020000000006abacab6aacac708a02050000000005ac5251520000000000", "6553", 0, -360458507, "5418cf059b5f15774836edd93571e0eed3855ba67b2b08c99dccab69dc87d3e9"],
+    ["c8597ada04f59836f06c224a2640b79f3a8a7b41ef3efa2602592ddda38e7597da6c639fee0300000009005251635351acabacffffffff4c518f347ee694884b9d4072c9e916b1a1f0a7fc74a1c90c63fdf8e5a185b6ae02000000007113af55afb41af7518ea6146786c7c726641c68c8829a52925e8d4afd07d8945f68e7230300000008ab00ab65ab650063ffffffffc28e46d7598312c420e11dfaae12add68b4d85adb182ae5b28f8340185394b63000000000165ffffffff04dbabb7010000000000ee2f6000000000000852ab6500ab6a51acb62a27000000000009ac53515300ac006a6345fb7505000000000752516a0051636a00000000", "", 3, 15199787, "0d66003aff5bf78cf492ecbc8fd40c92891acd58d0a271be9062e035897f317e"],
+    ["c33028b301d5093e1e8397270d75a0b009b2a6509a01861061ab022ca122a6ba935b8513320200000000ffffffff013bcf5a0500000000015200000000", "", 0, -513413204, "6b1459536f51482f5dbf42d7e561896557461e1e3b6bf67871e2b51faae2832c"],
+    ["43b2727901a7dd06dd2abf690a1ccedc0b0739cb551200796669d9a25f24f71d8d101379f50300000000ffffffff0418e031040000000000863d770000000000085352ac526563ac5174929e040000000004ac65ac00ec31ac0100000000066a51ababab5300000000", "65", 0, -492874289, "154ff7a9f0875edcfb9f8657a0b98dd9600fabee3c43eb88af37cf99286d516c"],
+    ["fe6ddf3a02657e42a7496ef170b4a8caf245b925b91c7840fd28e4a22c03cb459cb498b8d603000000065263656a650071ce6bf8d905106f9f1faf6488164f3decac65bf3c5afe1dcee20e6bc3cb6d052561985a030000000163295b117601343dbb0000000000026563dba521df", "", 1, -1696179931, "d9684685c99ce48f398fb467a91a1a59629a850c429046fb3071f1fa9a5fe816"],
+    ["c61523ef0129bb3952533cbf22ed797fa2088f307837dd0be1849f20decf709cf98c6f032f03000000026563c0f1d378044338310400000000066363516a5165a14fcb0400000000095163536a6a00ab53657271d60200000000001d953f0500000000010000000000", "53516353005153", 0, 1141615707, "7e975a72db5adaa3c48d525d9c28ac11cf116d0f8b16ce08f735ad75a80aec66"],
+    ["ba3dac6c0182562b0a26d475fe1e36315f0913b6869bdad0ecf21f1339a5fcbccd32056c840200000000ffffffff04300351050000000000220ed405000000000851abac636565ac53dbbd19020000000007636363ac6a52acbb005a0500000000016abd0c78a8", "63006a635151005352", 0, 1359658828, "47bc8ab070273e1f4a0789c37b45569a6e16f3f3092d1ce94dddc3c34a28f9f4"],
+    ["ac27e7f5025fc877d1d99f7fc18dd4cadbafa50e34e1676748cc89c202f93abf36ed46362101000000036300abffffffff958cd5381962b765e14d87fc9524d751e4752dd66471f973ed38b9d562e525620100000003006500ffffffff02b67120050000000004ac51516adc330c0300000000015200000000", "656352", 1, 15049991, "f3374253d64ac264055bdbcc32e27426416bd595b7c7915936c70f839e504010"],
+    ["7e50207303146d1f7ad62843ae8017737a698498d4b9118c7a89bb02e8370307fa4fada41d000000000753006300005152b7afefc85674b1104ba33ef2bf37c6ed26316badbc0b4aa6cb8b00722da4f82ff3555a6c020000000900ac656363ac51ac52ffffffff93fab89973bd322c5d7ad7e2b929315453e5f7ada3072a36d8e33ca8bebee6e0020000000300acab930da52b04384b04000000000004650052ac435e380200000000076a6a515263ab6aa9494705000000000600ab6a525252af8ba90100000000096565acab526353536a279b17ad", "acac005263536aac63", 1, -34754133, "4e6357da0057fb7ff79da2cc0f20c5df27ff8b2f8af4c1709e6530459f7972b0"],
+    ["5a59e0b9040654a3596d6dab8146462363cd6549898c26e2476b1f6ae42915f73fd9aedfda00000000036363abffffffff9ac9e9ca90be0187be2214251ff08ba118e6bf5e2fd1ba55229d24e50a510d53010000000165ffffffff41d42d799ac4104644969937522873c0834cc2fcdab7cdbecd84d213c0e96fd60000000000ffffffffd838db2c1a4f30e2eaa7876ef778470f8729fcf258ad228b388df2488709f8410300000000fdf2ace002ceb6d903000000000265654c1310040000000003ac00657e91c0ec", "536a63ac", 0, 82144555, "98ccde2dc14d14f5d8b1eeea5364bd18fc84560fec2fcea8de4d88b49c00695e"],
+    ["156ebc8202065d0b114984ee98c097600c75c859bfee13af75dc93f57c313a877efb09f230010000000463536a51ffffffff81114e8a697be3ead948b43b5005770dd87ffb1d5ccd4089fa6c8b33d3029e9c03000000066a5251656351ffffffff01a87f140000000000050000ac51ac00000000", "00", 0, -362221092, "a903c84d8c5e71134d1ab6dc1e21ac307c4c1a32c90c90f556f257b8a0ec1bf5"],
+    ["6d97a9a5029220e04f4ccc342d8394c751282c328bf1c132167fc05551d4ca4da4795f6d4e02000000076a0052ab525165ffffffff9516a205e555fa2a16b73e6db6c223a9e759a7e09c9a149a8f376c0a7233fa1b0100000007acab51ab63ac6affffffff04868aed04000000000652ac65ac536a396edf01000000000044386c0000000000076aab5363655200894d48010000000001ab8ebefc23", "6351526aac51", 1, 1943666485, "f0bd4ca8e97203b9b4e86bc24bdc8a1a726db5e99b91000a14519dc83fc55c29"],
+    ["05921d7c048cf26f76c1219d0237c226454c2a713c18bf152acc83c8b0647a94b13477c07f0300000003ac526afffffffff2f494453afa0cabffd1ba0a626c56f90681087a5c1bd81d6adeb89184b27b7402000000036a6352ffffffff0ad10e2d3ce355481d1b215030820da411d3f571c3f15e8daf22fe15342fed04000000000095f29f7b93ff814a9836f54dc6852ec414e9c4e16a506636715f569151559100ccfec1d100000000055263656a53ffffffff04f4ffef010000000008ac6a6aabacabab6a0e6689040000000006ab536a5352abe364d005000000000965536363655251ab53807e00010000000004526aab63f18003e3", "6363ac51", 3, -375891099, "001b0b176f0451dfe2d9787b42097ceb62c70d324e925ead4c58b09eebdf7f67"],
+    ["b9b44d9f04b9f15e787d7704e6797d51bc46382190c36d8845ec68dfd63ee64cf7a467b21e00000000096aac00530052ab636aba1bcb110a80c5cbe073f12c739e3b20836aa217a4507648d133a8eedd3f02cb55c132b203000000076a000063526352b1c288e3a9ff1f2da603f230b32ef7c0d402bdcf652545e2322ac01d725d75f5024048ad0100000000ffffffffffd882d963be559569c94febc0ef241801d09dc69527c9490210f098ed8203c700000000056a006300ab9109298d01719d9a0300000000066a52ab006365d7894c5b", "ac6351650063636a", 3, -622355349, "ac87b1b93a6baab6b2c6624f10e8ebf6849b0378ef9660a3329073e8f5553c8d"],
+    ["ff60473b02574f46d3e49814c484081d1adb9b15367ba8487291fc6714fd6e3383d5b335f001000000026a6ae0b82da3dc77e5030db23d77b58c3c20fa0b70aa7d341a0f95f3f72912165d751afd57230300000008ac536563516a6363ffffffff04f86c0200000000000553acab636ab13111000000000003510065f0d3f305000000000951ab516a65516aabab730a3a010000000002515200000000", "ac6a", 1, 1895032314, "0767e09bba8cd66d55915677a1c781acd5054f530d5cf6de2d34320d6c467d80"],
+    ["f218026204f4f4fc3d3bd0eada07c57b88570d544a0436ae9f8b753792c0c239810bb30fbc0200000002536affffffff8a468928d6ec4cc10aa0f73047697970e99fa64ae8a3b4dca7551deb0b639149010000000851ab520052650051ffffffffa98dc5df357289c9f6873d0f5afcb5b030d629e8f23aa082cf06ec9a95f3b0cf0000000000ffffffffea2c2850c5107705fd380d6f29b03f533482fd036db88739122aac9eff04e0aa010000000365536a03bd37db034ac4c4020000000007515152655200ac33b27705000000000151efb71e0000000000007b65425b", "515151", 3, -1772252043, "de35c84a58f2458c33f564b9e58bc57c3e028d629f961ad1b3c10ee020166e5a"],
+    ["48e7d42103b260b27577b70530d1ac2fed2551e9dd607cbcf66dca34bb8c03862cf8f5fd5401000000075151526aacab00ffffffff1e3d3b841552f7c6a83ee379d9d66636836673ce0b0eda95af8f2d2523c91813030000000665acac006365ffffffff388b3c386cd8c9ef67c83f3eaddc79f1ff910342602c9152ffe8003bce51b28b0100000008636363006a636a52ffffffff04b8f67703000000000852005353ac6552520cef720200000000085151ab6352ab00ab5096d6030000000005516a005100662582020000000001ac6c137280", "6a65", 1, 1513618429, "e2fa3e1976aed82c0987ab30d4542da2cb1cffc2f73be13480132da8c8558d5c"],
+    ["91ebc4cf01bc1e068d958d72ee6e954b196f1d85b3faf75a521b88a78021c543a06e056279000000000265ab7c12df0503832121030000000000cc41a6010000000005ab5263516540a951050000000006ab63ab65acac00000000", "526a0065636a6a6aac", 0, -614046478, "7de4ba875b2e584a7b658818c112e51ee5e86226f5a80e5f6b15528c86400573"],
+    ["3cd4474201be7a6c25403bf00ca62e2aa8f8f4f700154e1bb4d18c66f7bb7f9b975649f0dc0100000006535151535153ffffffff01febbeb000000000006005151006aac00000000", "", 0, -1674687131, "6b77ca70cc452cc89acb83b69857cda98efbfc221688fe816ef4cb4faf152f86"],
+    ["92fc95f00307a6b3e2572e228011b9c9ed41e58ddbaefe3b139343dbfb3b34182e9fcdc3f50200000002acab847bf1935fde8bcfe41c7dd99683289292770e7f163ad09deff0e0665ed473cd2b56b0f40300000006516551ab6351294dab312dd87b9327ce2e95eb44b712cfae0e50fda15b07816c8282e8365b643390eaab01000000026aacffffffff016e0b6b040000000001ac00000000", "650065acac005300", 2, -1885164012, "bd7d26bb3a98fc8c90c972500618bf894cb1b4fe37bf5481ff60eef439d3b970"],
+    ["4db591ab018adcef5f4f3f2060e41f7829ce3a07ea41d681e8cb70a0e37685561e4767ac3b0000000005000052acabd280e63601ae6ef20000000000036a636326c908f7", "ac6a51526300630052", 0, 862877446, "355ccaf30697c9c5b966e619a554d3323d7494c3ea280a9b0dfb73f953f5c1cb"],
+    ["c80abebd042cfec3f5c1958ee6970d2b4586e0abec8305e1d99eb9ee69ecc6c2cbd76374380000000007ac53006300ac510acee933b44817db79320df8094af039fd82111c7726da3b33269d3820123694d849ee5001000000056a65ab526562699bea8530dc916f5d61f0babea709dac578774e8a4dcd9c640ec3aceb6cb2443f24f302000000020063ea780e9e57d1e4245c1e5df19b4582f1bf704049c5654f426d783069bcc039f2d8fa659f030000000851ab53635200006a8d00de0b03654e8500000000000463ab635178ebbb0400000000055100636aab239f1d030000000006ab006300536500000000", "6565ac515100", 3, 1460851377, "b35bb1b72d02fab866ed6bbbea9726ab32d968d33a776686df3ac16aa445871e"],
+    ["0337b2d5043eb6949a76d6632b8bb393efc7fe26130d7409ef248576708e2d7f9d0ced9d3102000000075352636a5163007034384dfa200f52160690fea6ce6c82a475c0ef1caf5c9e5a39f8f9ddc1c8297a5aa0eb02000000026a51ffffffff38e536298799631550f793357795d432fb2d4231f4effa183c4e2f61a816bcf0030000000463ac5300706f1cd3454344e521fde05b59b96e875c8295294da5d81d6cc7efcfe8128f150aa54d6503000000008f4a98c704c1561600000000000072cfa6000000000000e43def01000000000100cf31cc0500000000066365526a6500cbaa8e2e", "", 3, 2029506437, "7615b4a7b3be865633a31e346bc3db0bcc410502c8358a65b8127089d81b01f8"],
+    ["cbc79b10020b15d605680a24ee11d8098ad94ae5203cb6b0589e432832e20c27b72a926af20300000006ab65516a53acbb854f3146e55c508ece25fa3d99dbfde641a58ed88c051a8a51f3dacdffb1afb827814b02000000026352c43e6ef30302410a020000000000ff4bd90100000000065100ab63000008aa8e0400000000095265526565ac5365abc52c8a77", "53526aac0051", 0, 202662340, "984efe0d8d12e43827b9e4b27e97b3777ece930fd1f589d616c6f9b71dab710e"],
+    ["4e8594d803b1d0a26911a2bcdd46d7cbc987b7095a763885b1a97ca9cbb747d32c5ab9aa91030000000353ac53a0cc4b215e07f1d648b6eeb5cdbe9fa32b07400aa773b9696f582cebfd9930ade067b2b200000000060065abab6500fc99833216b8e27a02defd9be47fafae4e4a97f52a9d2a210d08148d2a4e5d02730bcd460100000004516351ac37ce3ae1033baa55040000000006006a636a63acc63c990400000000025265eb1919030000000005656a6a516a00000000", "", 1, -75217178, "04c5ee48514cd033b82a28e336c4d051074f477ef2675ce0ce4bafe565ee9049"],
+    ["44e1a2b4010762af23d2027864c784e34ef322b6e24c70308a28c8f2157d90d17b99cd94a401000000085163656565006300ffffffff0198233d020000000002000000000000", "52525153656365", 0, 1119696980, "d9096de94d70c6337da6202e6e588166f31bff5d51bb5adc9468594559d65695"],
+    ["44ca65b901259245abd50a745037b17eb51d9ce1f41aa7056b4888285f48c6f26cb97b7a25020000000552636363abffffffff047820350400000000040053acab14f3e603000000000652635100ab630ce66c03000000000001bdc704000000000765650065ac51ac3e886381", "51", 0, -263340864, "ed5622ac642d11f90e68c0feea6a2fe36d880ecae6b8c0d89c4ea4b3d162bd90"],
+    ["cfa147d2017fe84122122b4dda2f0d6318e59e60a7207a2d00737b5d89694d480a2c26324b0000000006006351526552ffffffff0456b5b804000000000800516aab525363ab166633000000000004655363ab254c0e02000000000952ab6a6a00ab525151097c1b020000000009656a52ac6300530065ad0d6e50", "6a535165ac6a536500", 0, -574683184, "f926d4036eac7f019a2b0b65356c4ee2fe50e089dd7a70f1843a9f7bc6997b35"],
+    ["91c5d5f6022fea6f230cc4ae446ce040d8313071c5ac1749c82982cc1988c94cb1738aa48503000000016a19e204f30cb45dd29e68ff4ae160da037e5fc93538e21a11b92d9dd51cf0b5efacba4dd70000000005656a6aac51ffffffff03db126905000000000953006a53ab6563636a36a273030000000006656a52656552b03ede00000000000352516500000000", "530052526a00", 1, 1437328441, "255c125b60ee85f4718b2972174c83588ee214958c3627f51f13b5fb56c8c317"],
+    ["03f20dc202c886907b607e278731ebc5d7373c348c8c66cac167560f19b341b782dfb634cb03000000076a51ac6aab63abea3e8de7adb9f599c9caba95aa3fa852e947fc88ed97ee50e0a0ec0d14d164f44c0115c10100000004ab5153516fdd679e0414edbd000000000005ac636a53512021f2040000000007006a0051536a52c73db2050000000005525265ac5369046e000000000003ab006a1ef7bd1e", "52656a", 0, 1360223035, "5a0a05e32ce4cd0558aabd5d79cd5fcbffa95c07137506e875a9afcba4bef5a2"],
+    ["d9611140036881b61e01627078512bc3378386e1d4761f959d480fdb9d9710bebddba2079d020000000763536aab5153ab819271b41e228f5b04daa1d4e72c8e1955230accd790640b81783cfc165116a9f535a74c000000000163ffffffffa2e7bb9a28e810624c251ff5ba6b0f07a356ac082048cf9f39ec036bba3d431a02000000076a000000ac65acffffffff01678a820000000000085363515153ac635100000000", "535353", 2, -82213851, "52b9e0778206af68998cbc4ebdaad5a9469e04d0a0a6cef251abfdbb74e2f031"],
+    ["98b3a0bf034233afdcf0df9d46ac65be84ef839e58ee9fa59f32daaa7d684b6bdac30081c60200000007636351acabababffffffffc71cf82ded4d1593e5825618dc1d5752ae30560ecfaa07f192731d68ea768d0f0100000006650052636563f3a2888deb5ddd161430177ce298242c1a86844619bc60ca2590d98243b5385bc52a5b8f00000000095365acacab520052ac50d4722801c3b8a60300000000035165517e563b65", "51", 1, -168940690, "b6b684e2d2ecec8a8dce4ed3fc1147f8b2e45732444222aa8f52d860c2a27a9d"],
+    ["97be4f7702dc20b087a1fdd533c7de762a3f2867a8f439bddf0dcec9a374dfd0276f9c55cc0300000000cdfb1dbe6582499569127bda6ca4aaff02c132dc73e15dcd91d73da77e92a32a13d1a0ba0200000002ab51ffffffff048cfbe202000000000900516351515363ac535128ce0100000000076aac5365ab6aabc84e8302000000000863536a53ab6a6552f051230500000000066aac535153510848d813", "ac51", 0, 229541474, "e5da9a416ea883be1f8b8b2d178463633f19de3fa82ae25d44ffb531e35bdbc8"],
+    ["085b6e04040b5bff81e29b646f0ed4a45e05890a8d32780c49d09643e69cdccb5bd81357670100000001abffffffffa5c981fe758307648e783217e3b4349e31a557602225e237f62b636ec26df1a80300000004650052ab4792e1da2930cc90822a8d2a0a91ea343317bce5356b6aa8aae6c3956076aa33a5351a9c0300000004abac5265e27ddbcd472a2f13325cc6be40049d53f3e266ac082172f17f6df817db1936d9ff48c02b000000000152ffffffff021aa7670500000000085353635163ab51ac14d584000000000001aca4d136cc", "6a525300536352536a", 0, -1398925877, "41ecca1e8152ec55074f4c39f8f2a7204dda48e9ec1e7f99d5e7e4044d159d43"],
+    ["eec32fff03c6a18b12cd7b60b7bdc2dd74a08977e53fdd756000af221228fe736bd9c42d870100000007005353ac515265ffffffff037929791a188e9980e8b9cc154ad1b0d05fb322932501698195ab5b219488fc02000000070063510065ab6a0bfc176aa7e84f771ea3d45a6b9c24887ceea715a0ff10ede63db8f089e97d927075b4f1000000000551abab63abffffffff02eb933c000000000000262c420000000000036563632549c2b6", "6352", 2, 1480445874, "ff8a4016dfdd918f53a45d3a1f62b12c407cd147d68ca5c92b7520e12c353ff5"],
+    ["3ab70f4604e8fc7f9de395ec3e4c3de0d560212e84a63f8d75333b604237aa52a10da17196000000000763526a6553ac63a25de6fd66563d71471716fe59087be0dde98e969e2b359282cf11f82f14b00f1c0ac70f02000000050052516aacdffed6bb6889a13e46956f4b8af20752f10185838fd4654e3191bf49579c961f5597c36c0100000005ac636363abc3a1785bae5b8a1b4be5d0cbfadc240b4f7acaa7dfed6a66e852835df5eb9ac3c553766801000000036a65630733b7530218569602000000000952006a6a6a51acab52777f06030000000007ac0063530052abc08267c9", "000000536aac0000", 1, 1919096509, "df1c87cf3ba70e754d19618a39fdbd2970def0c1bfc4576260cba5f025b87532"],
+    ["bdb6b4d704af0b7234ced671c04ba57421aba7ead0a117d925d7ebd6ca078ec6e7b93eea6600000000026565ffffffff3270f5ad8f46495d69b9d71d4ab0238cbf86cc4908927fbb70a71fa3043108e6010000000700516a65655152ffffffff6085a0fdc03ae8567d0562c584e8bfe13a1bd1094c518690ebcb2b7c6ce5f04502000000095251530052536a53aba576a37f2c516aad9911f687fe83d0ae7983686b6269b4dd54701cb5ce9ec91f0e6828390300000000ffffffff04cc76cc020000000002656a01ffb702000000000253ab534610040000000009acab006565516a00521f55f5040000000000389dfee9", "6a525165", 0, 1336204763, "71c294523c48fd7747eebefbf3ca06e25db7b36bff6d95b41c522fecb264a919"],
+    ["54258edd017d22b274fbf0317555aaf11318affef5a5f0ae45a43d9ca4aa652c6e85f8a040010000000953ac65ab5251656500ffffffff03321d450000000000085265526a51526a529ede8b030000000003635151ce6065020000000001534c56ec1b", "acac", 0, 2094130012, "110d90fea9470dfe6c5048f45c3af5e8cc0cb77dd58fd13d338268e1c24b1ccc"],
+    ["ce0d322e04f0ffc7774218b251530a7b64ebefca55c90db3d0624c0ff4b3f03f918e8cf6f60300000003656500ffffffff9cce943872da8d8af29022d0b6321af5fefc004a281d07b598b95f6dcc07b1830200000007abab515351acab8d926410e69d76b7e584aad1470a97b14b9c879c8b43f9a9238e52a2c2fefc2001c56af8010000000400ab5253cd2cd1fe192ce3a93b5478af82fa250c27064df82ba416dfb0debf4f0eb307a746b6928901000000096500abacac6a0063514214524502947efc0200000000035251652c40340100000000096a6aab52000052656a5231c54c", "51", 2, -2090320538, "0322ca570446869ec7ec6ad66d9838cff95405002d474c0d3c17708c7ee039c6"],
+    ["233cd90b043916fc41eb870c64543f0111fb31f3c486dc72457689dea58f75c16ae59e9eb2000000000500536a6a6affffffff9ae30de76be7cd57fb81220fce78d74a13b2dbcad4d023f3cadb3c9a0e45a3ce000000000965ac6353ac5165515130834512dfb293f87cb1879d8d1b20ebad9d7d3d5c3e399a291ce86a3b4d30e4e32368a9020000000453005165ffffffff26d84ae93eb58c81158c9b3c3cbc24a84614d731094f38d0eea8686dec02824d0300000005636a65abacf02c784001a0bd5d03000000000900655351ab65ac516a416ef503", "", 1, -295106477, "b79f31c289e95d9dadec48ebf88e27c1d920661e50d090e422957f90ff94cb6e"],
+    ["9200e26b03ff36bc4bf908143de5f97d4d02358db642bd5a8541e6ff709c420d1482d471b70000000008abab65536a636553ffffffff61ba6d15f5453b5079fb494af4c48de713a0c3e7f6454d7450074a2a80cb6d880300000007ac6a00ab5165515dfb7574fbce822892c2acb5d978188b1d65f969e4fe874b08db4c791d176113272a5cc10100000000ffffffff0420958d000000000009ac63516a0063516353dd885505000000000465ac00007b79e901000000000066d8bf010000000005525252006a00000000", "ac5152", 0, 2089531339, "89ec7fab7cfe7d8d7d96956613c49dc48bf295269cfb4ea44f7333d88c170e62"],
+    ["45f335ba01ce2073a8b0273884eb5b48f56df474fc3dff310d9706a8ac7202cf5ac188272103000000025363ffffffff049d859502000000000365ab6a8e98b1030000000002ac51f3a80603000000000752535151ac00000306e30300000000020051b58b2b3a", "", 0, 1899564574, "78e01310a228f645c23a2ad0acbb8d91cedff4ecdf7ca997662c6031eb702b11"],
+    ["94083c840288d40a6983faca876d452f7c52a07de9268ad892e70a81e150d602a773c175ad03000000007ec3637d7e1103e2e7e0c61896cbbf8d7e205b2ecc93dd0d6d7527d39cdbf6d335789f660300000000ffffffff019e1f7b03000000000800ac0051acac0053539cb363", "", 1, -183614058, "a17b66d6bb427f42653d08207a22b02353dd19ccf2c7de6a9a3a2bdb7c49c9e7"],
+    ["30e0d4d20493d0cd0e640b757c9c47a823120e012b3b64c9c1890f9a087ae4f2001ca22a61010000000152f8f05468303b8fcfaad1fb60534a08fe90daa79bff51675472528ebe1438b6f60e7f60c10100000009526aab6551ac510053ffffffffaaab73957ea2133e32329795221ed44548a0d3a54d1cf9c96827e7cffd1706df0200000009ab00526a005265526affffffffd19a6fe54352015bf170119742821696f64083b5f14fb5c7d1b5a721a3d7786801000000085265abababac53abffffffff020f39bd030000000004ab6aac52049f6c050000000004ab52516aba5b4c60", "6a6365516a6a655253", 0, -624256405, "8e221a6c4bf81ca0d8a0464562674dcd14a76a32a4b7baf99450dd9195d411e6"],
+    ["5c0ac112032d6885b7a9071d3c5f493aa16c610a4a57228b2491258c38de8302014276e8be030000000300ab6a17468315215262ad5c7393bb5e0c5a6429fd1911f78f6f72dafbbbb78f3149a5073e24740300000003ac5100ffffffff33c7a14a062bdea1be3c9c8e973f54ade53fe4a69dcb5ab019df5f3345050be00100000008ac63655163526aab428defc0033ec36203000000000765516365536a00ae55b2000000000002ab53f4c0080400000000095265516a536563536a00000000", "6a005151006a", 2, 272749594, "91082410630337a5d89ff19145097090f25d4a20bdd657b4b953927b2f62c73b"],
+    ["e3683329026720010b08d4bec0faa244f159ae10aa582252dd0f3f80046a4e145207d54d31000000000852acac52656aacac3aaf2a5017438ad6adfa3f9d05f53ebed9ceb1b10d809d507bcf75e0604254a8259fc29c020000000653526552ab51f926e52c04b44918030000000000f7679c0100000000090000525152005365539e3f48050000000009516500ab635363ab008396c905000000000253650591024f", "6a6365", 0, 908746924, "458aec3b5089a585b6bad9f99fd37a2b443dc5a2eefac2b7e8c5b06705efc9db"],
+    ["00b20fd104dd59705b84d67441019fa26c4c3dec5fd3b50eca1aa549e750ef9ddb774dcabe000000000651ac656aac65ffffffff52d4246f2db568fc9eea143e4d260c698a319f0d0670f84c9c83341204fde48b0200000000ffffffffb8aeabb85d3bcbc67b132f1fd815b451ea12dcf7fc169c1bc2e2cf433eb6777a03000000086a51ac6aab6563acd510d209f413da2cf036a31b0def1e4dcd8115abf2e511afbcccb5ddf41d9702f28c52900100000006ac52ab6a0065ffffffff039c8276000000000008ab53655200656a52401561010000000003acab0082b7160100000000035100ab00000000", "535265", 1, -947367579, "3212c6d6dd8d9d3b2ac959dec11f4638ccde9be6ed5d36955769294e23343da0"],
+    ["624d28cb02c8747915e9af2b13c79b417eb34d2fa2a73547897770ace08c6dd9de528848d3030000000651ab63abab533c69d3f9b75b6ef8ed2df50c2210fd0bf4e889c42477d58682f711cbaece1a626194bb85030000000765acab53ac5353ffffffff018cc280040000000009abacabac52636352ac6859409e", "ac51ac", 1, 1005144875, "919144aada50db8675b7f9a6849c9d263b86450570293a03c245bd1e3095e292"],
+    ["8f28471d02f7d41b2e70e9b4c804f2d90d23fb24d53426fa746bcdcfffea864925bdeabe3e0200000001acffffffff76d1d35d04db0e64d65810c808fe40168f8d1f2143902a1cc551034fd193be0e0000000001acffffffff048a5565000000000005005151516afafb610400000000045263ac53648bb30500000000086363516a6a5165513245de01000000000000000000", "6a0053510053", 1, -1525137460, "305fc8ff5dc04ebd9b6448b03c9a3d945a11567206c8d5214666b30ec6d0d6cc"],
+    ["10ec50d7046b8b40e4222a3c6449490ebe41513aad2eca7848284a08f3069f3352c2a9954f0000000009526aac656352acac53ffffffff0d979f236155aa972472d43ee6f8ce22a2d052c740f10b59211454ff22cb7fd00200000007acacacab63ab53ffffffffbbf97ebde8969b35725b2e240092a986a2cbfd58de48c4475fe077bdd493a20c010000000663ab5365ababffffffff4600722d33b8dba300d3ad037bcfc6038b1db8abfe8008a15a1de2da2264007302000000035351ac6dbdafaf020d0ccf04000000000663ab6a51ab6ae06e5e0200000000036aabab00000000", "", 0, -1658960232, "2420dd722e229eccafae8508e7b8d75c6920bfdb3b5bac7cb8e23419480637c2"],
+    ["43559290038f32fda86580dd8a4bc4422db88dd22a626b8bd4f10f1c9dd325c8dc49bf479f01000000026351ffffffff401339530e1ed3ffe996578a17c3ec9d6fccb0723dd63e7b3f39e2c44b976b7b0300000006ab6a65656a51ffffffff6fb9ba041c96b886482009f56c09c22e7b0d33091f2ac5418d05708951816ce7000000000551ac525100ffffffff020921e40500000000035365533986f40500000000016a00000000", "52ac51", 0, 1769771809, "02040283ef2291d8e1f79bb71bdabe7c1546c40d7ed615c375643000a8b9600d"],
+    ["35b6fc06047ebad04783a5167ab5fc9878a00c4eb5e7d70ef297c33d5abd5137a2dea9912402000000036aacacffffffff21dc291763419a584bdb3ed4f6f8c60b218aaa5b99784e4ba8acfec04993e50c03000000046a00ac6affffffff69e04d77e4b662a82db71a68dd72ef0af48ca5bebdcb40f5edf0caf591bb41020200000000b5db78a16d93f5f24d7d932f93a29bb4b784febd0cbb1943f90216dc80bba15a0567684b000000000853ab52ab5100006a1be2208a02f6bdc103000000000265ab8550ea04000000000365636a00000000", "", 0, -1114114836, "1c8655969b241e717b841526f87e6bd68b2329905ba3fc9e9f72526c0b3ea20c"],
+    ["f35befbc03faf8c25cc4bc0b92f6239f477e663b44b83065c9cb7cf231243032cf367ce3130000000005ab65526a517c4c334149a9c9edc39e29276a4b3ffbbab337de7908ea6f88af331228bd90086a6900ba020000000151279d19950d2fe81979b72ce3a33c6d82ebb92f9a2e164b6471ac857f3bbd3c0ea213b542010000000953ab51635363520065052657c20300a9ba04000000000452636a6a0516ea020000000008535253656365ababcfdd3f01000000000865ac516aac00530000000000", "", 2, -99793521, "c834a5485e68dc13edb6c79948784712122440d7fa5bbaa5cd2fc3d4dac8185d"],
+    ["d3da18520216601acf885414538ce2fb4d910997eeb91582cac42eb6982c9381589587794f0300000000fffffffff1b1c9880356852e10cf41c02e928748dd8fae2e988be4e1c4cb32d0bfaea6f7000000000465ab6aabffffffff02fb0d69050000000002ababeda8580500000000085163526565ac52522b913c95", "ac", 1, -1247973017, "99b32b5679d91e0f9cdd6737afeb07459806e5acd7630c6a3b9ab5d550d0c003"],
+    ["8218eb740229c695c252e3630fc6257c42624f974bc856b7af8208df643a6c520ef681bfd00000000002510066f30f270a09b2b420e274c14d07430008e7886ec621ba45665057120afce58befca96010300000004525153ab84c380a9015d96100000000000076a5300acac526500000000", "ac005263", 0, -1855679695, "5071f8acf96aea41c7518bd1b5b6bbe16258b529df0c03f9e374b83c66b742c6"],
+    ["1123e7010240310013c74e5def60d8e14dd67aedff5a57d07a24abc84d933483431b8cf8ea0300000003530051fc6775ff1a23c627a2e605dd2560e84e27f4208300071e90f4589e762ad9c9fe8d0da95e020000000465655200ffffffff04251598030000000004ab65ab639d28d90400000000096563636aacac525153474df801000000000851525165ac51006a75e23b040000000000e5bd3a4a", "6363636565", 0, -467124448, "9cb0dd04e9fe287b112e94a1647590d27e8b164ca13c4fe70c610fd13f82c2fd"],
+    ["3b937e05032b8895d2f4945cb7e3679be2fbd15311e2414f4184706dbfc0558cf7de7b4d000000000001638b91a12668a3c3ce349788c961c26aa893c862f1e630f18d80e7843686b6e1e6fc396310000000000852635353ab65ac51eeb09dd1c9605391258ee6f74b9ae17b5e8c2ef010dc721c5433dcdc6e93a1593e3b6d1700000000085365ac6553526351ffffffff0308b18e04000000000253acb6dd00040000000008536aac5153ac516ab0a88201000000000500ac006500804e3ff2", "", 0, 416167343, "595a3c02254564634e8085283ec4ea7c23808da97ce9c5da7aecd7b553e7fd7f"],
+    ["a48f27ca047997470da74c8ee086ddad82f36d9c22e790bd6f8603ee6e27ad4d3174ea875403000000095153ac636aab6aacabffffffffefc936294e468d2c9a99e09909ba599978a8c0891ad47dc00ba424761627cef202000000056a51630053ffffffff304cae7ed2d3dbb4f2fbd679da442aed06221ffda9aee460a28ceec5a9399f4e0200000000f5bddf82c9c25fc29c5729274c1ff0b43934303e5f595ce86316fc66ad263b96ca46ab8d0100000003536500d7cf226b0146b00c04000000000200ac5c2014ce", "515100636563", 0, 1991799059, "9c051a7092fe17fa62b1720bc2c4cb2ffc1527d9fb0b006d2e142bb8fe07bf3c"],
+    ["180cd53101c5074cf0b7f089d139e837fe49932791f73fa2342bd823c6df6a2f72fe6dba1303000000076a6a63ac53acabffffffff03853bc1020000000007ac526a6a6a6a003c4a8903000000000453515163a0fbbd030000000005ab656a5253253d64cf", "ac65", 0, -1548453970, "4d8efb3b99b9064d2f6be33b194a903ffabb9d0e7baa97a48fcec038072aac06"],
+    ["c21ec8b60376c47e057f2c71caa90269888d0ffd5c46a471649144a920d0b409e56f190b700000000008acac6a526a536365ffffffff5d315d9da8bf643a9ba11299450b1f87272e6030fdb0c8adc04e6c1bfc87de9a0000000000ea43a9a142e5830c96b0ce827663af36b23b0277244658f8f606e95384574b91750b8e940000000007516a63ac0063acffffffff023c61be0400000000055165ab5263313cc8020000000006006a53526551ed8c3d56", "6a", 1, 1160627414, "a638cc17fd91f4b1e77877e8d82448c84b2a4e100df1373f779de7ad32695112"],
+    ["b8fd394001ed255f49ad491fecc990b7f38688e9c837ccbc7714ddbbf5404f42524e68c18f0000000007ab6353535363ab081e15ee02706f7d050000000008515200535351526364c7ec040000000005636a53acac9206cbe1", "655352ac", 0, -1251578838, "8e0697d8cd8a9ccea837fd798cc6c5ed29f6fbd1892ee9bcb6c944772778af19"],
+    ["e42a76740264677829e30ed610864160c7f97232c16528fe5610fc08814b21c34eefcea69d010000000653006a6a0052ffffffff647046cf44f217d040e6a8ff3f295312ab4dd5a0df231c66968ad1c6d8f4428000000000025352ffffffff0199a7f900000000000000000000", "655263006a005163", 1, 1122505713, "7cda43f1ff9191c646c56a4e29b1a8c6cb3f7b331da6883ef2f0480a515d0861"],
+    ["a2dfa4690214c1ab25331815a5128f143219de51a47abdc7ce2d367e683eeb93960a31af9f010000000363636affffffff8be0628abb1861b078fcc19c236bc4cc726fa49068b88ad170adb2a97862e7460200000004ac655363ffffffff0441f11103000000000153dbab0c000000000009ab53ac5365526aab63abbb95050000000004ab52516a29a029040000000003ac526a00000000", "6a52ac63", 1, -1302210567, "913060c7454e6c80f5ba3835454b54db2188e37dc4ce72a16b37d11a430b3d23"],
+    ["9dbc591f04521670af83fb3bb591c5d4da99206f5d38e020289f7db95414390dddbbeb56680100000004ac5100acffffffffb6a40b5e29d5e459f8e72d39f800089529f0889006cad3d734011991da8ef09d0100000009526a5100acab536a515fc427436df97cc51dc8497642ffc868857ee245314d28b356bd70adba671bd6071301fc0000000000ffffffff487efde2f620566a9b017b2e6e6d42525e4070f73a602f85c6dfd58304518db30000000005516353006a8d8090180244904a0200000000046a65656ab1e9c203000000000451ab63aba06a5449", "", 0, -1414953913, "bae189eb3d64aedbc28a6c28f6c0ccbd58472caaf0cf45a5aabae3e031dd1fea"],
+    ["1345fb2c04bb21a35ae33a3f9f295bece34650308a9d8984a989dfe4c977790b0c21ff9a7f0000000006ac52ac6a0053ffffffff7baee9e8717d81d375a43b691e91579be53875350dfe23ba0058ea950029fcb7020000000753ab53ab63ab52ffffffff684b6b3828dfb4c8a92043b49b8cb15dd3a7c98b978da1d314dce5b9570dadd202000000086353ab6a5200ac63d1a8647bf667ceb2eae7ec75569ca249fbfd5d1b582acfbd7e1fcf5886121fca699c011d0100000003ac006affffffff049b1eb00300000000001e46dc0100000000080065ab6a6a630065ca95b40300000000030051520c8499010000000006ab6aac526a6500000000", "53526aac636300", 2, 1809978100, "cfeaa36790bc398783d4ca45e6354e1ea52ee74e005df7f9ebd10a680e9607bf"],
+    ["7d75dc8f011e5f9f7313ba6aedef8dbe10d0a471aca88bbfc0c4a448ce424a2c5580cda1560300000003ab5152ffffffff01997f8e0200000000096552ac6a65656563530d93bbcc", "00656a6563", 0, 1414485913, "ec91eda1149f75bffb97612569a78855498c5d5386d473752a2c81454f297fa7"],
+    ["1459179504b69f01c066e8ade5e124c748ae5652566b34ed673eea38568c483a5a4c4836ca0100000008ac5352006563656affffffff5d4e037880ab1975ce95ea378d2874dcd49d5e01e1cdbfae3343a01f383fa35800000000095251ac52ac6aac6500ffffffff7de3ae7d97373b7f2aeb4c55137b5e947b2d5fb325e892530cb589bc4f92abd503000000086563ac53ab520052ffffffffb4db36a32d6e543ef49f4bafde46053cb85b2a6c4f0e19fa0860d9083901a1190300000003ab51531bbcfe5504a6dbda040000000008536a5365abac6500d660c80300000000096565abab6a53536a6a54e84e010000000003acac52df2ccf0500000000025351220c857e", "", 2, 1879181631, "3aad18a209fab8db44954eb55fd3cc7689b5ec9c77373a4d5f4dae8f7ae58d14"],
+    ["cabb1b06045a895e6dcfc0c1e971e94130c46feace286759f69a16d298c8b0f6fd0afef8f20300000004ac006352ffffffffa299f5edac903072bfb7d29b663c1dd1345c2a33546a508ba5cf17aab911234602000000056a65515365ffffffff89a20dc2ee0524b361231092a070ace03343b162e7162479c96b757739c8394a0300000002abab92ec524daf73fabee63f95c1b79fa8b84e92d0e8bac57295e1d0adc55dc7af5534ebea410200000001534d70e79b04674f6f00000000000600abacab53517d60cc0200000000035265ab96c51d040000000004ac6300ac62a787050000000008006a516563ab63639e2e7ff7", "6551ac6351ac", 3, 1942663262, "d0c4a780e4e0bc22e2f231e23f01c9d536b09f6e5be51c123d218e906ec518be"],
+    ["8b96d7a30132f6005b5bd33ea82aa325e2bcb441f46f63b5fca159ac7094499f380f6b7e2e00000000076aacabac6300acffffffff0158056700000000000465005100c319e6d0", "52006a", 0, -1100733473, "fb4bd26a91b5cf225dd3f170eb09bad0eac314bc1e74503cc2a3f376833f183e"],
+    ["112191b7013cfbe18a175eaf09af7a43cbac2c396f3695bbe050e1e5f4250603056d60910e02000000001c8a5bba03738a22010000000005525352656a77a149010000000002510003b52302000000000351ac52722be8e6", "65ac6565", 0, -1847972737, "8e795aeef18f510d117dfa2b9f4a2bd2e2847a343205276cedd2ba14548fd63f"],
+    ["ce6e1a9e04b4c746318424705ea69517e5e0343357d131ad55d071562d0b6ebfedafd6cb840100000003656553ffffffff67bd2fa78e2f52d9f8900c58b84c27ef9d7679f67a0a6f78645ce61b883fb8de000000000100d699a56b9861d99be2838e8504884af4d30b909b1911639dd0c5ad47c557a0773155d4d303000000046a5151abffffffff9fdb84b77c326921a8266854f7bbd5a71305b54385e747fe41af8a397e78b7fa010000000863acac6a51ab00ac0d2e9b9d049b8173010000000007ac53526a650063ba9b7e010000000008526a00525263acac0ab3fd030000000000ea8a0303000000000200aca61a97b9", "", 1, -1276952681, "b6ed4a3721be3c3c7305a5128c9d418efa58e419580cec0d83f133a93e3a22c5"],
+    ["2f7353dd02e395b0a4d16da0f7472db618857cd3de5b9e2789232952a9b154d249102245fd030000000151617fd88f103280b85b0a198198e438e7cab1a4c92ba58409709997cc7a65a619eb9eec3c0200000003636aabffffffff0397481c0200000000045300636a0dc97803000000000009d389030000000003ac6a53134007bb", "0000536552526a", 0, -1912746174, "30c4cd4bd6b291f7e9489cc4b4440a083f93a7664ea1f93e77a9597dab8ded9c"],
+    ["89e7928c04363cb520eff4465251fd8e41550cbd0d2cdf18c456a0be3d634382abcfd4a2130200000006ac516a6a656355042a796061ed72db52ae47d1607b1ceef6ca6aea3b7eea48e7e02429f382b378c4e51901000000085351ab6352ab5252ffffffff53631cbda79b40183000d6ede011c778f70147dc6fa1aed3395d4ce9f7a8e69701000000096a6553ab52516a52abad0de418d80afe059aab5da73237e0beb60af4ac490c3394c12d66665d1bac13bdf29aa8000000000153f2b59ab6027a33eb040000000007005351ac5100ac88b941030000000003ab0052e1e8a143", "63656a", 0, 1258533326, "b575a04b0bb56e38bbf26e1a396a76b99fb09db01527651673a073a75f0a7a34"],
+    ["ca356e2004bea08ec2dd2df203dc275765dc3f6073f55c46513a588a7abcc4cbde2ff011c7020000000553525100003aefec4860ef5d6c1c6be93e13bd2d2a40c6fb7361694136a7620b020ecbaca9413bcd2a030000000965ac00536352535100ace4289e00e97caaea741f2b89c1143060011a1f93090dc230bee3f05e34fbd8d8b6c399010000000365526affffffff48fc444238bda7a757cb6a98cb89fb44338829d3e24e46a60a36d4e24ba05d9002000000026a53ffffffff03d70b440200000000056a6a526aac853c97010000000002515335552202000000000351635300000000", "0052", 3, -528192467, "fc93cc056c70d5e033933d730965f36ad81ef64f1762e57f0bc5506c5b507e24"],
+    ["82d4fa65017958d53e562fac073df233ab154bd0cf6e5a18f57f4badea8200b217975e31030200000004636aab51ac0891a204227cc9050000000006635200655365bfef8802000000000865650051635252acfc2d09050000000006ab65ac51516380195e030000000007ac52525352510063d50572", "53", 0, -713567171, "e095003ca82af89738c1863f0f5488ec56a96fb81ea7df334f9344fcb1d0cf40"],
+    ["75f6949503e0e47dd70426ef32002d6cdb564a45abedc1575425a18a8828bf385fa8e808e600000000036aabab82f9fd14e9647d7a1b5284e6c55169c8bd228a7ea335987cef0195841e83da45ec28aa2e0300000002516350dc6fe239d150efdb1b51aa288fe85f9b9f741c72956c11d9dcd176889963d699abd63f0000000001ab429a63f502777d20010000000007abac52ac516a53d081d9020000000003acac630c3cc3a8", "535152516551510000", 1, 973814968, "c6ec1b7cb5c16a1bfd8a3790db227d2acc836300534564252b57bd66acf95092"],
+    ["e86a24bc03e4fae784cdf81b24d120348cb5e52d937cd9055402fdba7e43281e482e77a1c100000000046363006affffffffa5447e9bdcdab22bd20d88b19795d4c8fb263fbbf7ce8f4f9a85f865953a6325020000000663ac53535253ffffffff9f8b693bc84e0101fc73748e0513a8cecdc264270d8a4ee1a1b6717607ee1eaa00000000026a513417bf980158d82c020000000009005253005351acac5200000000", "6353516365536a6a", 2, -563792735, "508129278ef07b43112ac32faf00170ad38a500eed97615a860fd58baaad174b"],
+    ["536bc5e60232eb60954587667d6bcdd19a49048d67a027383cc0c2a29a48b960dc38c5a0370300000005ac636300abffffffff8f1cfc102f39b1c9348a2195d496e602c77d9f57e0769dabde7eaaedf9c69e250100000006acabab6a6351ffffffff0432f56f0400000000046a5365517fd54b0400000000035265539484e4050000000003536a5376dc25020000000008ac536aab6aab536ab978e686", "ac0051006a006a006a", 0, -273074082, "f151f1ec305f698d9fdce18ea292b145a58d931f1518cf2a4c83484d9a429638"],
+    ["fab796ee03f737f07669160d1f1c8bf0800041157e3ac7961fea33a293f976d79ce49c02ab0200000003ac5252eb097ea1a6d1a7ae9dace338505ba559e579a1ee98a2e9ad96f30696d6337adcda5a85f403000000096500abab656a6a656396d5d41a9b11f571d91e4242ddc0cf2420eca796ad4882ef1251e84e42b930398ec69dd80100000005526551ac6a8e5d0de804f763bb0400000000015288271a010000000001acf2bf2905000000000300ab51c9641500000000000952655363636365ac5100000000", "00ac536552", 0, -1854521113, "f3bbab70b759fe6cfae1bf349ce10716dbc64f6e9b32916904be4386eb461f1f"],
+    ["f2b539a401e4e8402869d5e1502dbc3156dbce93583f516a4947b333260d5af1a34810c6a00200000003525363ffffffff01d305e2000000000005acab535200a265fe77", "", 0, -1435650456, "41617b27321a830c712638dbb156dae23d4ef181c7a06728ccbf3153ec53d7dd"],
+    ["9f10b1d8033aee81ac04d84ceee0c03416a784d1017a2af8f8a34d2f56b767aea28ff88c8f02000000025352ffffffff748cb29843bea8e9c44ed5ff258df1faf55fbb9146870b8d76454786c4549de100000000016a5ba089417305424d05112c0ca445bc7107339083e7da15e430050d578f034ec0c589223b0200000007abac53ac6565abffffffff025a4ecd010000000006636563ab65ab40d2700000000000056a6553526333fa296c", "", 0, -395044364, "20fd0eee5b5716d6cbc0ddf852614b686e7a1534693570809f6719b6fcb0a626"],
+    ["ff2ecc09041b4cf5abb7b760e910b775268abee2792c7f21cc5301dd3fecc1b4233ee70a2c0200000009acac5300006a51526affffffffeb39c195a5426afff38379fc85369771e4933587218ef4968f3f05c51d6b7c92000000000165453a5f039b8dbef7c1ffdc70ac383b481f72f99f52b0b3a5903c825c45cfa5d2c0642cd50200000001654b5038e6c49daea8c0a9ac8611cfe904fc206dad03a41fb4e5b1d6d85b1ecad73ecd4c0102000000096a51000053ab656565bdb5548302cc719200000000000452655265214a3603000000000300ab6a00000000", "52516a006a63", 1, -2113289251, "37ed6fae36fcb3360c69cac8b359daa62230fc1419b2cf992a32d8f3e079dcff"],
+    ["70a8577804e553e462a859375957db68cfdf724d68caeacf08995e80d7fa93db7ebc04519d02000000045352ab53619f4f2a428109c5fcf9fee634a2ab92f4a09dc01a5015e8ecb3fc0d9279c4a77fb27e900000000006ab6a51006a6affffffff3ed1a0a0d03f25c5e8d279bb5d931b7eb7e99c8203306a6c310db113419a69ad010000000565516300abffffffff6bf668d4ff5005ef73a1b0c51f32e8235e67ab31fe019bf131e1382050b39a630000000004536a6563ffffffff02faf0bb00000000000163cf2b4b05000000000752ac635363acac15ab369f", "ac", 0, -1175809030, "1c9d6816c20865849078f9777544b5ddf37c8620fe7bd1618e4b72fb72dddca1"],
+    ["a3604e5304caa5a6ba3c257c20b45dcd468f2c732a8ca59016e77b6476ac741ce8b16ca8360200000004acac6553ffffffff695e7006495517e0b79bd4770f955040610e74d35f01e41c9932ab8ccfa3b55d0300000007ac5253515365acffffffff6153120efc5d73cd959d72566fc829a4eb00b3ef1a5bd3559677fb5aae116e38000000000400abab52c29e7abd06ff98372a3a06227386609adc7665a602e511cadcb06377cc6ac0b8f63d4fdb03000000055100acabacffffffff04209073050000000009ab5163ac525253ab6514462e05000000000952abacab636300656a20672c0400000000025153b276990000000000056565ab6a5300000000", "5351", 0, 1460890590, "249c4513a49076c6618aabf736dfd5ae2172be4311844a62cf313950b4ba94be"],
+    ["c6a72ed403313b7d027f6864e705ec6b5fa52eb99169f8ea7cd884f5cdb830a150cebade870100000009ac63ab516565ab6a51ffffffff398d5838735ff43c390ca418593dbe43f3445ba69394a6d665b5dc3b4769b5d700000000075265acab515365ffffffff7ee5616a1ee105fd18189806a477300e2a9cf836bf8035464e8192a0d785eea3030000000700ac6a51516a52ffffffff018075fd0000000000015100000000", "005251acac5252", 2, -656067295, "2cc1c7514fdc512fd45ca7ba4f7be8a9fe6d3318328bc1a61ae6e7675047e654"],
+    ["93c12cc30270fc4370c960665b8f774e07942a627c83e58e860e38bd6b0aa2cb7a2c1e060901000000036300abffffffff4d9b618035f9175f564837f733a2b108c0f462f28818093372eec070d9f0a5440300000001acffffffff039c2137020000000001525500990100000000055265ab636a07980e0300000000005ba0e9d1", "656a5100", 1, 18954182, "6beca0e0388f824ca33bf3589087a3c8ad0857f9fe7b7609ae3704bef0eb83e2"],
+    ["97bddc63015f1767619d56598ad0eb5c7e9f880b24a928fea1e040e95429c930c1dc653bdb0100000008ac53acac00005152aaa94eb90235ed10040000000000287bdd0400000000016a8077673a", "acac6a536352655252", 0, -813649781, "5990b139451847343c9bb89cdba0e6daee6850b60e5b7ea505b04efba15f5d92"],
+    ["cc3c9dd303637839fb727270261d8e9ddb8a21b7f6cbdcf07015ba1e5cf01dc3c3a327745d0300000000d2d7804fe20a9fca9659a0e49f258800304580499e8753046276062f69dbbde85d17cd2201000000096352536a520000acabffffffffbc75dfa9b5f81f3552e4143e08f485dfb97ae6187330e6cd6752de6c21bdfd21030000000600ab53650063ffffffff0313d0140400000000096565515253526aacac167f0a040000000008acab00535263536a9a52f8030000000006abab5151ab63f75b66f2", "6a635353636a65ac65", 1, 377286607, "dbc7935d718328d23d73f8a6dc4f53a267b8d4d9816d0091f33823bd1f0233e9"],
+    ["236f91b702b8ffea3b890700b6f91af713480769dda5a085ae219c8737ebae90ff25915a3203000000056300ac6300811a6a10230f12c9faa28dae5be2ebe93f37c06a79e76214feba49bb017fb25305ff84eb020000000100ffffffff041e351703000000000351ac004ff53e050000000003ab53636c1460010000000000cb55f701000000000651520051ab0000000000", "acac636a6aac5300", 0, 406448919, "793a3d3c37f6494fab79ff10c16702de002f63e34be25dd8561f424b0ea938c4"],
+    ["c47d5ad60485cb2f7a825587b95ea665a593769191382852f3514a486d7a7a11d220b62c54000000000663655253acab8c3cf32b0285b040e50dcf6987ddf7c385b3665048ad2f9317b9e0c5ba0405d8fde4129b00000000095251ab00ac65635300ffffffff549fe963ee410d6435bb2ed3042a7c294d0c7382a83edefba8582a2064af3265000000000152fffffffff7737a85e0e94c2d19cd1cde47328ece04b3e33cd60f24a8a345da7f2a96a6d0000000000865ab6a0051656aab28ff30d5049613ea020000000005ac51000063f06df1050000000008ac63516aabac5153afef5901000000000700656500655253688bc00000000000086aab5352526a53521ff1d5ff", "51ac52", 2, -1296011911, "0c1fd44476ff28bf603ad4f306e8b6c7f0135a441dc3194a6f227cb54598642a"],
+    ["0b43f122032f182366541e7ee18562eb5f39bc7a8e5e0d3c398f7e306e551cdef773941918030000000863006351ac51acabffffffffae586660c8ff43355b685dfa8676a370799865fbc4b641c5a962f0849a13d8250100000005abab63acabffffffff0b2b6b800d8e77807cf130de6286b237717957658443674df047a2ab18e413860100000008ab6aac655200ab63ffffffff04f1dbca03000000000800635253ab656a52a6eefd0300000000036365655d8ca90200000000005a0d530400000000015300000000", "65ac65acac", 0, 351448685, "86f26e23822afd1bdfc9fff92840fc1e60089f12f54439e3ab9e5167d0361dcf"],
+    ["af1c4ab301ec462f76ee69ba419b1b2557b7ded639f3442a3522d4f9170b2d6859765c3df402000000016affffffff01a5ca6c000000000008ab52536aab00005300000000", "6a6351", 0, 110304602, "e88ed2eea9143f2517b15c03db00767eb01a5ce12193b99b964a35700607e5f4"],
+    ["0bfd34210451c92cdfa02125a62ba365448e11ff1db3fb8bc84f1c7e5615da40233a8cd368010000000252ac9a070cd88dec5cf9aed1eab10d19529720e12c52d3a21b92c6fdb589d056908e43ea910e0200000009ac516a52656a6a5165ffffffffc3edcca8d2f61f34a5296c405c5f6bc58276416c720c956ff277f1fb81541ddd00000000030063abffffffff811247905cdfc973d179c03014c01e37d44e78f087233444dfdce1d1389d97c302000000065163000063ab1724a26e02ca37c902000000000851ab53525352ac529012a90100000000085200525253535353fa32575b", "5352ac6351", 1, -1087700448, "b8f1e1f35e3e1368bd17008c756e59cced216b3c699bcd7bebdb5b6c8eec4697"],
+    ["467a3e7602e6d1a7a531106791845ec3908a29b833598e41f610ef83d02a7da3a1900bf2960000000005ab6a636353ffffffff031db6dac6f0bafafe723b9199420217ad2c94221b6880654f2b35114f44b1df010000000965ab52636a63ac6352ffffffff02b3b95c0100000000026300703216030000000001ab3261c0aa", "6a", 0, 2110869267, "3078b1d1a7713c6d101c64afe35adfae0977a5ab4c7e07a0b170b041258adbf2"],
+    ["8713bc4f01b411149d575ebae575f5dd7e456198d61d238695df459dd9b86c4e3b2734b62e0300000004abac6363ffffffff03b58049050000000002ac653c714c04000000000953656a005151526a527b5a9e03000000000652ac5100525300000000", "52", 0, -647281251, "0e0bed1bf2ff255aef6e5c587f879ae0be6222ab33bd75ee365ec6fbb8acbe38"],
+    ["b5a7df6102107beded33ae7f1dec0531d4829dff7477260925aa2cba54119b7a07d92d5a1d02000000046a516a52803b625c334c1d2107a326538a3db92c6c6ae3f7c3516cd90a09b619ec6f58d10e77bd6703000000056563006a63ffffffff0117484b03000000000853acab52526a65abc1b548a1", "ac006a525100", 0, 2074359913, "680336db57347d8183b8898cd27a83f1ba5884155aeae5ce20b4840b75e12871"],
+    ["49eb2178020a04fca08612c34959fd41447319c190fb7ffed9f71c235aa77bec28703aa1820200000003ac6353abaff326071f07ec6b77fb651af06e8e8bd171068ec96b52ed584de1d71437fed186aecf0300000001acffffffff03da3dbe02000000000652ac63ac6aab8f3b680400000000096a536a65636a53516a5175470100000000016500000000", "6a536365", 0, 1283691249, "c670219a93234929f662ecb9aa148a85a2d281e83f4e53d10509461cdea47979"],
+    ["0f96cea9019b4b3233c0485d5b1bad770c246fe8d4a58fb24c3b7dfdb3b0fd90ea4e8e947f0300000006006a5163515303571e1e01906956030000000005ab635353abadc0fbbe", "acac", 0, -1491469027, "716a8180e417228f769dcb49e0491e3fda63badf3d5ea0ceeac7970d483dd7e2"],
+    ["148e68480196eb52529af8e83e14127cbfdbd4a174e60a86ac2d86eac9665f46f4447cf7aa01000000045200ac538f8f871401cf240c0300000000065252ab52656a5266cf61", "", 0, -344314825, "eacc47c5a53734d6ae3aedbc6a7c0a75a1565310851b29ef0342dc4745ceb607"],
+    ["6c7913f902aa3f5f939dd1615114ce961beda7c1e0dd195be36a2f0d9d047c28ac62738c3a020000000453abac00ffffffff477bf2c5b5c6733881447ac1ecaff3a6f80d7016eee3513f382ad7f554015b970100000007ab6563acab5152ffffffff04e58fe1040000000009ab00526aabab526553e59790010000000002ab525a834b03000000000035fdaf0200000000086551ac65515200ab00000000", "63ac53", 1, 1285478169, "1536da582a0b6de017862445e91ba14181bd6bf953f4de2f46b040d351a747c9"],
+    ["3320f6730132f830c4681d0cae542188e4177cad5d526fae84565c60ceb5c0118e844f90bd030000000163ffffffff0257ec5a040000000005525251ac6538344d000000000002515200000000", "5352656a53ac516a65", 0, 788050308, "3afacaca0ef6be9d39e71d7b1b118994f99e4ea5973c9107ca687d28d8eba485"],
+    ["c13aa4b702eedd7cde09d0416e649a890d40e675aa9b5b6d6912686e20e9b9e10dbd40abb1000000000863ab6353515351ac11d24dc4cc22ded7cdbc13edd3f87bd4b226eda3e4408853a57bcd1becf2df2a1671fd1600000000045165516affffffff01baea300100000000076aab52ab53005300000000", "0065", 0, -1195908377, "241a23e7b1982d5f78917ed97a8678087acbbffe7f624b81df78a5fe5e41e754"],
+    ["a2692fff03b2387f5bacd5640c86ba7df574a0ee9ed7f66f22c73cccaef3907eae791cbd230200000004536363abffffffff4d9fe7e5b375de88ba48925d9b2005447a69ea2e00495a96eafb2f144ad475b40000000008000053000052636537259bee3cedd3dcc07c8f423739690c590dc195274a7d398fa196af37f3e9b4a1413f810000000006ac63acac52abffffffff04c65fe60200000000075151536365ab657236fc020000000009005263ab00656a6a5195b8b6030000000007ac5165636aac6a7d7b66010000000002acab00000000", "51", 2, -826546582, "925037c7dc7625f3f12dc83904755a37016560de8e1cdd153c88270a7201cf15"],
+    ["2c5b003201b88654ac2d02ff6762446cb5a4af77586f05e65ee5d54680cea13291efcf930d0100000005ab536a006a37423d2504100367000000000004536a515335149800000000000152166aeb03000000000452510063226c8e03000000000000000000", "635251", 0, 1060344799, "7e058ca5dd07640e4aae7dea731cfb7d7fef1bfd0d6d7b6ce109d041f4ca2a31"],
+    ["f981b9e104acb93b9a7e2375080f3ea0e7a94ce54cd8fb25c57992fa8042bdf4378572859f0100000002630008604febba7e4837da77084d5d1b81965e0ea0deb6d61278b6be8627b0d9a2ecd7aeb06a0300000005ac5353536a42af3ef15ce7a2cd60482fc0d191c4236e66b4b48c9018d7dbe4db820f5925aad0e8b52a0300000008ab0063510052516301863715efc8608bf69c0343f18fb81a8b0c720898a3563eca8fe630736c0440a179129d03000000086aac6a52ac6a63ac44fec4c00408320a03000000000062c21c030000000007ac6a655263006553835f0100000000015303cd60000000000005535263536558b596e0", "00", 0, -2140385880, "49870a961263354c9baf108c6979b28261f99b374e97605baa532d9fa3848797"],
+    ["c4b702e502f1a54f235224f0e6de961d2e53b506ab45b9a40805d1dacd35148f0acf24ca5e00000000085200ac65ac53acabf34ba6099135658460de9d9b433b84a8562032723635baf21ca1db561dce1c13a06f4407000000000851ac006a63516aabffffffff02a853a603000000000163d17a67030000000005ab63006a5200000000", "ac5363515153", 1, 480734903, "5c46f7ac3d6460af0da28468fcc5b3c87f2b9093d0f837954b7c8174b4d7b6e7"],
+    ["9b83f78704f492b9b353a3faad8d93f688e885030c274856e4037818848b99e490afef27770200000000ffffffff36b60675a5888c0ef4d9e11744ecd90d9fe9e6d8abb4cff5666c898fdce98d9e00000000056aab656352596370fca7a7c139752971e169a1af3e67d7656fc4fc7fd3b98408e607c2f2c836c9f27c030000000653ac51ab6300a0761de7e158947f401b3595b7dc0fe7b75fa9c833d13f1af57b9206e4012de0c41b8124030000000953656a53ab53510052242e5f5601bf83b301000000000465516a6300000000", "63515200ac656365", 3, -150879312, "9cf05990421ea853782e4a2c67118e03434629e7d52ab3f1d55c37cf7d72cdc4"],
+    ["f492a9da04f80b679708c01224f68203d5ea2668b1f442ebba16b1aa4301d2fe5b4e2568f3010000000953005351525263ab65ffffffff93b34c3f37d4a66df255b514419105b56d7d60c24bf395415eda3d3d8aa5cd0101000000020065ffffffff9dba34dabdc4f1643b372b6b77fdf2b482b33ed425914bb4b1a61e4fad33cf390000000002ab52ffffffffbbf3dc82f397ef3ee902c5146c8a80d9a1344fa6e38b7abce0f157be7adaefae0000000009515351005365006a51ffffffff021359ba010000000000403fea0200000000095200ac6353abac635300000000", "00ac51acacac", 0, -2115078404, "fd44fc98639ca32c927929196fc3f3594578f4c4bd248156a25c04a65bf3a9f3"],
+    ["2f73e0b304f154d3a00fde2fdd40e791295e28d6cb76af9c0fd8547acf3771a02e3a92ba37030000000852ac6351ab6565639aa95467b065cec61b6e7dc4d6192b5536a7c569315fb43f470078b31ed22a55dab8265f02000000080065636a6aab6a53ffffffff9e3addbff52b2aaf9fe49c67017395198a9b71f0aa668c5cb354d06c295a691a0100000000ffffffff45c2b4019abaf05c5e484df982a4a07459204d1343a6ee5badade358141f8f990300000007ac516a6aacac6308655cd601f3bc2f0000000000015200000000", "", 0, -2082053939, "9a95e692e1f78efd3e46bb98f178a1e3a0ef60bd0301d9f064c0e5703dc879c2"],
+    ["5a60b9b503553f3c099f775db56af3456330f1e44e67355c4ab290d22764b9144a7b5f959003000000030052acbd63e0564decc8659aa53868be48c1bfcda0a8c9857b0db32a217bc8b46d9e7323fe9649020000000553ac6551abd0ecf806211db989bead96c09c7f3ec5f73c1411d3329d47d12f9e46678f09bac0dc383e0200000000ffffffff01494bb202000000000500516551ac00000000", "ac", 0, 1169947809, "62a36c6e8da037202fa8aeae03e533665376d5a4e0a854fc4624a75ec52e4eb1"],
+    ["e3649aa40405e6ffe377dbb1bbbb672a40d8424c430fa6512c6165273a2b9b6afa9949ec430200000007630052ab655153a365f62f2792fa90c784efe3f0981134d72aac0b1e1578097132c7f0406671457c332b84020000000353ab6ad780f40cf51be22bb4ff755434779c7f1def4999e4f289d2bd23d142f36b66fbe5cfbb4b01000000076a5252abac52ab1430ffdc67127c9c0fc97dcd4b578dab64f4fb9550d2b59d599773962077a563e8b6732c02000000016affffffff04cb2687000000000002ab636e320904000000000252acf70e9401000000000100dc3393050000000006ab0063536aacbc231765", "65520053", 3, -2016196547, "f64f805f0ff7f237359fa6b0e58085f3c766d1859003332223444fd29144112a"],
+    ["4c4be7540344050e3044f0f1d628039a334a7c1f7b4573469cfea46101d6888bb6161fe9710200000000ffffffffac85a4fdad641d8e28523f78cf5b0f4dc74e6c5d903c10b358dd13a5a1fd8a06000000000163e0ae75d05616b72467b691dc207fe2e65ea35e2eadb7e06ea442b2adb9715f212c0924f10200000000ffffffff0194ddfe02000000000265ac00000000", "00006500", 1, -479922562, "d66924d49f03a6960d3ca479f3415d638c45889ce9ab05e25b65ac260b51d634"],
+    ["202c18eb012bc0a987e69e205aea63f0f0c089f96dd8f0e9fcde199f2f37892b1d4e6da90302000000055352ac6565ffffffff0257e5450100000000025300ad257203000000000000000000", "520052ac6a005265", 0, 168054797, "502967a6f999f7ee25610a443caf8653dda288e6d644a77537bcc115a8a29894"],
+    ["32fa0b0804e6ea101e137665a041cc2350b794e59bf42d9b09088b01cde806ec1bbea077df0200000008515153650000006506a11c55904258fa418e57b88b12724b81153260d3f4c9f080439789a391ab147aabb0fa0000000007000052ac51ab510986f2a15c0d5e05d20dc876dd2dafa435276d53da7b47c393f20900e55f163b97ce0b800000000008ab526a520065636a8087df7d4d9c985fb42308fb09dce704650719140aa6050e8955fa5d2ea46b464a333f870000000009636300636a6565006affffffff01994a0d040000000002536500000000", "516563530065", 2, -163068286, "f58637277d2bc42e18358dc55f7e87e7043f5e33f4ce1fc974e715ef0d3d1c2a"],
+    ["ae23424d040cd884ebfb9a815d8f17176980ab8015285e03fdde899449f4ae71e04275e9a80100000007ab006553530053ffffffff018e06db6af519dadc5280c07791c0fd33251500955e43fe4ac747a4df5c54df020000000251ac330e977c0fec6149a1768e0d312fdb53ed9953a3737d7b5d06aad4d86e9970346a4feeb5030000000951ab51ac6563ab526a67cabc431ee3d8111224d5ecdbb7d717aa8fe82ce4a63842c9bd1aa848f111910e5ae1eb0100000004ac515300bfb7e0d7048acddc030000000009636a5253636a655363a3428e040000000001525b99c6050000000004655265ab717e6e020000000000d99011eb", "ac6a6a516565", 1, -716251549, "b098eb9aff1bbd375c70a0cbb9497882ab51f3abfebbf4e1f8d74c0739dc7717"],
+    ["030f44fc01b4a9267335a95677bd190c1c12655e64df74addc53b753641259af1a54146baa020000000152e004b56c04ba11780300000000026a53f125f001000000000251acd2cc7c03000000000763536563655363c9b9e50500000000015200000000", "ac", 0, -1351818298, "19dd32190ed2a37be22f0224a9b55b91e37290577c6c346d36d32774db0219a3"],
+    ["c05f448f02817740b30652c5681a3b128322f9dc97d166bd4402d39c37c0b14506d8adb5890300000003536353ffffffffa188b430357055ba291c648f951cd2f9b28a2e76353bef391b71a889ba68d5fc02000000056565526a6affffffff02745f73010000000001ab3ec34c0400000000036aac5200000000", "516551510053", 0, -267877178, "3a1c6742d4c374f061b1ebe330b1e169a113a19792a1fdde979b53e094cc4a3c"],
+    ["163ba45703dd8c2c5a1c1f8b806afdc710a2a8fc40c0138e2d83e329e0e02a9b6c837ff6b8000000000700655151ab6a522b48b8f134eb1a7e6f5a6fa319ce9d11b36327ba427b7d65ead3b4a6a69f85cda8bbcd22030000000563656552acffffffffdbcf4955232bd11eef0cc6954f3f6279675b2956b9bcc24f08c360894027a60201000000066500006500abffffffff04d0ce9d0200000000008380650000000000015233f360040000000003006aabedcf0801000000000000000000", "000065006500ac", 0, 216965323, "9afe3f4978df6a86e9a8ebd62ef6a9d48a2203f02629349f1864ef2b8b92fd55"],
+    ["fe647f950311bf8f3a4d90afd7517df306e04a344d2b2a2fea368935faf11fa6882505890d0000000005ab5100516affffffff43c140947d9778718919c49c0535667fc6cc727f5876851cb8f7b6460710c7f60100000000ffffffffce4aa5d90d7ab93cbec2e9626a435afcf2a68dd693c15b0e1ece81a9fcbe025e0300000000ffffffff02f34806020000000002515262e54403000000000965635151ac655363636de5ce24", "6a005100ac516351", 2, 989643518, "818a7ceaf963f52b5c48a7f01681ac6653c26b63a9f491856f090d9d60f2ffe3"],
+    ["cef7316804c3e77fe67fc6207a1ea6ae6eb06b3bf1b3a4010a45ae5c7ad677bb8a4ebd16d90200000009ac536a5152ac5263005301ab8a0da2b3e0654d31a30264f9356ba1851c820a403be2948d35cafc7f9fe67a06960300000006526a63636a53ffffffffbada0d85465199fa4232c6e4222df790470c5b7afd54704595a48eedd7a4916b030000000865ab63ac006a006ab28dba4ad55e58b5375053f78b8cdf4879f723ea4068aed3dd4138766cb4d80aab0aff3d0300000003ac6a00ffffffff010f5dd6010000000006ab006aab51ab00000000", "", 1, 889284257, "d0f32a6db43378af84b063a6706d614e2d647031cf066997c48c04de3b493a94"],
+    ["7b3ff28004ba3c7590ed6e36f45453ebb3f16636fe716acb2418bb2963df596a50ed954d2e03000000065251515265abffffffff706ee16e32e22179400c9841013971645dabf63a3a6d2d5feb42f83aa468983e030000000653ac51ac5152ffffffffa03a16e5e5de65dfa848b9a64ee8bf8656cc1f96b06a15d35bd5f3d32629876e020000000043c1a3965448b3b46f0f0689f1368f3b2981208a368ec5c30defb35595ef9cf95ffd10e902000000036aac65253a5bbe042e907204000000000800006565656352634203b4020000000002656336b3b7010000000001ab7a063f0100000000026500a233cb76", "006551636a53ac5251", 1, -1144216171, "68c7bd717b399b1ee33a6562a916825a2fed3019cdf4920418bb72ffd7403c8c"],
+    ["1be8ee5604a9937ebecffc832155d9ba7860d0ca451eaced58ca3688945a31d93420c27c460100000006abac5300535288b65458af2f17cbbf7c5fbcdcfb334ffd84c1510d5500dc7d25a43c36679b702e850f7c0200000003005300ffffffff7c237281cb859653eb5bb0a66dbb7aeb2ac11d99ba9ed0f12c766a8ae2a2157203000000086aabac526365acabfffffffff09d3d6639849f442a6a52ad10a5d0e4cb1f4a6b22a98a8f442f60280c9e5be80200000007ab00ab6565ab52ffffffff0398fe83030000000005526aababacbdd6ec010000000005535252ab6a82c1e6040000000001652b71c40c", "6563526353656351", 2, -853634888, "0d936cceda2f56c7bb87d90a7b508f6208577014ff280910a710580357df25f3"],
+    ["9e0f99c504fbca858c209c6d9371ddd78985be1ab52845db0720af9ae5e2664d352f5037d4010000000552ac53636affffffff0e0ce866bc3f5b0a49748f597c18fa47a2483b8a94cef1d7295d9a5d36d31ae7030000000663515263ac635bb5d1698325164cdd3f7f3f7831635a3588f26d47cc30bf0fefd56cd87dc4e84f162ab702000000036a6365ffffffff85c2b1a61de4bcbd1d5332d5f59f338dd5e8accbc466fd860f96eef1f54c28ec030000000165ffffffff04f5cabd010000000007000052ac526563c18f1502000000000465510051dc9157050000000008655363ac525253ac506bb600000000000865656a53ab63006a00000000", "006a6a0052", 0, 1186324483, "2f9b7348600336512686e7271c53015d1cb096ab1a5e0bce49acd35bceb42bc8"],
+    ["11ce51f90164b4b54b9278f0337d95c50d16f6828fcb641df9c7a041a2b274aa70b1250f2b0000000008ab6a6a65006551524c9fe7f604af44be050000000005525365006521f79a0300000000015306bb4e04000000000265ac99611a05000000000765acab656500006dc866d0", "", 0, -1710478768, "cfa4b7573559b3b199478880c8013fa713ca81ca8754a3fd68a6d7ee6147dc5a"],
+    ["86bc233e02ba3c647e356558e7252481a7769491fb46e883dd547a4ce9898fc9a1ca1b77790000000006ab5351abab51f0c1d09c37696d5c7c257788f5dff5583f4700687bcb7d4acfb48521dc953659e325fa390300000003acac5280f29523027225af03000000000963abac0065ab65acab7e59d90400000000016549dac846", "53006aac52acac", 0, 711159875, "880330ccde00991503ea598a6dfd81135c6cda9d317820352781417f89134d85"],
+    ["beac155d03a853bf18cd5c490bb2a245b3b2a501a3ce5967945b0bf388fec2ba9f04c03d68030000000012fe96283aec4d3aafed8f888b0f1534bd903f9cd1af86a7e64006a2fa0d2d30711af770010000000163ffffffffd963a19d19a292104b9021c535d3e302925543fb3b5ed39fb2124ee23a9db00302000000056500ac63acffffffff01ad67f503000000000300ac5189f78db2", "53536a636500", 2, 748992863, "bde3dd0575164d7ece3b5783ce0783ffddb7df98f178fe6468683230314f285a"],
+    ["489ebbf10478e260ba88c0168bd7509a651b36aaee983e400c7063da39c93bf28100011f280100000004abab63ab2fc856f05f59b257a4445253e0d91b6dffe32302d520ac8e7f6f2467f7f6b4b65f2f59e903000000096353abacab6351656affffffff0122d9480db6c45a2c6fd68b7bc57246edffbf6330c39ccd36aa3aa45ec108fc030000000265ab9a7e78a69aadd6b030b12602dff0739bbc346b466c7c0129b34f50ae1f61e634e11e9f3d0000000006516a53525100ffffffff011271070000000000086563ab6353536352c4dd0e2c", "", 0, -293358504, "4eba3055bc2b58765593ec6e11775cea4b6493d8f785e28d01e2d5470ea71575"],
+    ["6911195d04f449e8eade3bc49fd09b6fb4b7b7ec86529918b8593a9f6c34c2f2d301ec378b000000000263ab49162266af054643505b572c24ff6f8e4c920e601b23b3c42095881857d00caf56b28acd030000000565525200ac3ac4d24cb59ee8cfec0950312dcdcc14d1b360ab343e834004a5628d629642422f3c5acc02000000035100accf99b663e3c74787aba1272129a34130668a877cc6516bfb7574af9fa6d07f9b4197303400000000085351ab5152635252ffffffff042b3c95000000000000ff92330200000000046a5252ab884a2402000000000853530065520063000d78be03000000000953abab52ab53ac65aba72cb34b", "6a", 2, -637739405, "6b80d74eb0e7ee59d14f06f30ba7d72a48d3a8ff2d68d3b99e770dec23e9284f"],
+    ["746347cf03faa548f4c0b9d2bd96504d2e780292730f690bf0475b188493fb67ca58dcca4f0000000002005336e3521bfb94c254058e852a32fc4cf50d99f9cc7215f7c632b251922104f638aa0b9d080100000008656aac5351635251ffffffff4da22a678bb5bb3ad1a29f97f6f7e5b5de11bb80bcf2f7bb96b67b9f1ac44d09030000000365ababffffffff036f02b30000000000076353ab6aac63ac50b72a050000000002acaba8abf804000000000663006a6a6353797eb999", "acac5100", 1, -1484493812, "164c32a263f357e385bd744619b91c3f9e3ce6c256d6a827d6defcbdff38fa75"],
+    ["e17149010239dd33f847bf1f57896db60e955117d8cf013e7553fae6baa9acd3d0f1412ad90200000006516500516500cb7b32a8a67d58dddfb6ceb5897e75ef1c1ff812d8cd73875856487826dec4a4e2d2422a0100000004ac525365196dbb69039229270400000000070000535351636a8b7596020000000006ab51ac52655131e99d040000000003516551ee437f5c", "ac656a53", 1, 1102662601, "8858bb47a042243f369f27d9ab4a9cd6216adeac1c1ac413ed0890e46f23d3f3"],
+    ["144971940223597a2d1dec49c7d4ec557e4f4bd207428618bafa3c96c411752d494249e1fb0100000004526a5151ffffffff340a545b1080d4f7e2225ff1c9831f283a7d4ca4d3d0a29d12e07d86d6826f7f0200000003006553ffffffff03c36965000000000000dfa9af00000000000451636aac7f7d140300000000016300000000", "", 1, -108117779, "c84fcaf9d779df736a26cc3cabd04d0e61150d4d5472dd5358d6626e610be57f"],
+    ["2aee6b9a02172a8288e02fac654520c9dd9ab93cf514d73163701f4788b4caeeb9297d2e250300000004ab6363008fb36695528d7482710ea2926412f877a3b20acae31e9d3091406bfa6b62ebf9d9d2a6470100000009535165536a63520065ffffffff03f7b560050000000003acab6a9a8338050000000000206ce90000000000056552516a5100000000", "5252", 1, -1102319963, "fa4676c374ae3a417124b4c970d1ed3319dc3ac91fb36efca1aa9ed981a8aa1b"],
+    ["9554595203ad5d687f34474685425c1919e3d2cd05cf2dac89d5f33cd3963e5bb43f8706480100000000ffffffff9de2539c2fe3000d59afbd376cb46cefa8bd01dbc43938ff6089b63d68acdc2b02000000096553655251536a6500fffffffff9695e4016cd4dfeb5f7dadf00968e6a409ef048f81922cec231efed4ac78f5d010000000763abab6a5365006caaf0070162cc640200000000045163ab5100000000", "", 0, -1105256289, "e8e10ed162b1a43bfd23bd06b74a6c2f138b8dc1ab094ffb2fa11d5b22869bee"],
+    ["04f51f2a0484cba53d63de1cb0efdcb222999cdf2dd9d19b3542a896ca96e23a643dfc45f00200000007acac53510063002b091fd0bfc0cfb386edf7b9e694f1927d7a3cf4e1d2ce937c1e01610313729ef6419ae7030000000165a3372a913c59b8b3da458335dc1714805c0db98992fd0d93f16a7f28c55dc747fe66a5b503000000095351ab65ab52536351ffffffff5650b318b3e236802a4e41ed9bc0a19c32b7aa3f9b2cda1178f84499963a0cde000000000165ffffffff0383954f04000000000553ac536363a8fc90030000000000a2e315000000000005acab00ab5100000000", "0053", 2, -1424653648, "a5bc0356f56b2b41a2314ec05bee7b91ef57f1074bcd2efc4da442222269d1a3"],
+    ["53dc1a88046531c7b57a35f4d9adf101d068bf8d63fbbedaf4741dba8bc5e92c8725def571030000000453655251fcdf116a226b3ec240739c4c7493800e4edfe67275234e371a227721eac43d3d9ecaf1b50300000003ac0052ffffffff2c9279ffeea4718d167e9499bd067600715c14484e373ef93ae4a31d2f5671ab0000000009516553ac636a6a65001977752eeba95a8f16b88c571a459c2f2a204e23d48cc7090e4f4cc35846ca7fc0a455ce00000000055165ac0063188143f80205972902000000000765ac63ac516353c7b6a50000000000036a510000000000", "655351536a", 0, 103806788, "b276584d3514e5b4e058167c41dc02915b9d97f6795936a51f40e894ed8508bc"],
+    ["5a06cb4602dcfc85f49b8d14513f33c48f67146f2ee44959bbca092788e6823b2719f3160b0200000001ab3c013f2518035b9ea635f9a1c74ec1a3fb7496a160f46aae2e09bfc5cd5111a0f20969e003000000015158c89ab7049f20d6010000000008ac6a52abac53515349765e00000000000300ab638292630100000000045351ab0086da09010000000006656a6365525300000000", "526a63", 1, 1502936586, "bdfaff8a4e775379c5dc26e024968efa805f923de53fa8272dd53ec582afa0c5"],
+    ["ca9d84fa0129011e1bf27d7cb71819650b59fb292b053d625c6f02b0339249b498ff7fd4b601000000025352ffffffff032173a0040000000008525253abab5152639473bb030000000009005153526a53535151d085bd0000000000086a5365ab5165655300000000", "005152ac51", 0, 580353445, "c629d93b02037f40aa110e46d903edb34107f64806aa0c418d435926feef68b8"],
+    ["e3cdbfb4014d90ae6a4401e85f7ac717adc2c035858bf6ff48979dd399d155bce1f150daea0300000002ac51a67a0d39017f6c71040000000005535200535200000000", "", 0, -1899950911, "c1c7df8206e661d593f6455db1d61a364a249407f88e99ecad05346e495b38d7"],
+    ["b2b6b9ab0283d9d73eeae3d847f41439cd88279c166aa805e44f8243adeb3b09e584efb1df00000000026300ffffffff7dfe653bd67ca094f8dab51007c6adaced09de2af745e175b9714ca1f5c68d050000000003ac6500aa8e596903fd3f3204000000000553ac6a6a533a2e210500000000075253acabab526392d0ee020000000008520065635200ab5200000000", "65acacac65005365", 0, 28298553, "39c2aaa2496212b3ab120ab7d7f37c5e852bfe38d20f5226413a2268663eeae8"],
+    ["4314339e01de40faabcb1b970245a7f19eedbc17c507dac86cf986c2973715035cf95736ae0200000007abababababab65bde67b900151510b04000000000853ac00655200535300000000", "52", 0, 399070095, "47585dc25469d04ff3a60939d0a03779e3e81a411bf0ca18b91bb925ebd30718"],
+    ["f063171b03e1830fdc1d685a30a377537363ccafdc68b42bf2e3acb908dac61ee24b37595c020000000765ac5100ab6aacf447bc8e037b89d6cadd62d960cc442d5ced901d188867b5122b42a862929ce45e7b628d010000000253aba009a1ba42b00f1490b0b857052820976c675f335491cda838fb7934d5eea0257684a2a202000000001e83cf2401a7f777030000000008ab6553526a53526a00000000", "", 2, 1984790332, "c19caada8e71535e29a86fa29cfd9b74a0c7412003fc722a121005e461e01636"],
+    ["cf7bdc250249e22cbe23baf6b648328d31773ea0e771b3b76a48b4748d7fbd390e88a004d30000000003ac536a4ab8cce0e097136c90b2037f231b7fde2063017facd40ed4e5896da7ad00e9c71dd70ae600000000096a0063516352525365ffffffff01b71e3e00000000000300536a00000000", "", 1, 546970113, "6a815ba155270af102322c882f26d22da11c5330a751f520807936b320b9af5d"],
+    ["ac7a125a0269d35f5dbdab9948c48674616e7507413cd10e1acebeaf85b369cd8c88301b7c030000000963656aac6a530053abffffffffed94c39a582e1a46ce4c6bffda2ccdb16cda485f3a0d94b06206066da12aecfe010000000752abab63536363ef71dcfb02ee07fa0400000000016a6908c802000000000751656a6551abac688c2c2d", "6a6351526551", 0, 858400684, "552ff97d7924f51cda6d1b94be53483153ef725cc0a3a107adbef220c753f9a6"],
+    ["3a1f454a03a4591e46cf1f7605a3a130b631bf4dfd81bd2443dc4fac1e0a224e74112884fe0000000005516aac6a53a87e78b55548601ffc941f91d75eab263aa79cd498c88c37fdf275a64feff89fc1710efe03000000016a39d7ef6f2a52c00378b4f8f8301853b61c54792c0f1c4e2cd18a08cb97a7668caa008d970200000002656affffffff017642b20100000000096a63535253abac6a6528271998", "51", 2, 1459585400, "e9a7f21fc2d38be7be47095fbc8f1bf8923660aa4d71df6d797ae0ba5ca4d5b0"],
+    ["6269e0fa0173e76e89657ca495913f1b86af5b8f1c1586bcd6c960aede9bc759718dfd5044000000000352ac530e2c7bd90219849b000000000007ab00ab6a53006319f281000000000007ab00515165ac5200000000", "6a", 0, -2039568300, "62094f98234a05bf1b9c7078c5275ed085656856fb5bdfd1b48090e86b53dd85"],
+    ["eb2bc00604815b9ced1c604960d54beea4a3a74b5c0035d4a8b6bfec5d0c9108f143c0e99a0000000000ffffffff22645b6e8da5f11d90e5130fd0a0df8cf79829b2647957471d881c2372c527d8010000000263acffffffff1179dbaf17404109f706ae27ad7ba61e860346f63f0c81cb235d2b05d14f2c1003000000025300264cb23aaffdc4d6fa8ec0bb94eff3a2e50a83418a8e9473a16aaa4ef8b855625ed77ef40100000003ac51acf8414ad404dd328901000000000652526500006ab6261c000000000002526a72a4c9020000000006ac526500656586d2e7000000000006656aac00ac5279cd8908", "51", 1, -399279379, "d37532e7b2b8e7db5c7c534197600397ebcc15a750e3af07a3e2d2e4f84b024f"],
+    ["eba8b0de04ac276293c272d0d3636e81400b1aaa60db5f11561480592f99e6f6fa13ad387002000000070053acab536563bebb23d66fd17d98271b182019864a90e60a54f5a615e40b643a54f8408fa8512cfac927030000000963ac6a6aabac65ababffffffff890a72192bc01255058314f376bab1dc72b5fea104c154a15d6faee75dfa5dba020000000100592b3559b0085387ac7575c05b29b1f35d9a2c26a0c27903cc0f43e7e6e37d5a60d8305a030000000252abffffffff0126518f05000000000000000000", "005300635252635351", 1, 664344756, "26dc2cba4bd5334e5c0b3a520b44cc1640c6b923d10e576062f1197171724097"],
+    ["185cda1a01ecf7a8a8c28466725b60431545fc7a3367ab68e34d486e8ea85ee3128e0d8384000000000465ac63abec88b7bb031c56eb04000000000965636a51005252006a7c78d5040000000007acac63abac51ac3024a40500000000086300526a51abac51464c0e8c", "0065535265515352", 0, 1594558917, "b5280b9610c0625a65b36a8c2402a95019a7bbb9dd3de77f7c3cb1d82c3263ba"],
+    ["92c9fb780138abc472e589d5b59489303f234acc838ca66ffcdf0164517a8679bb622a4267020000000153468e373d04de03fa020000000009ac006a5265ab5163006af649050000000007515153006a00658ceb59030000000001ac36afa0020000000009ab53006351ab51000000000000", "6a", 0, 2059357502, "e2358dfb51831ee81d7b0bc602a65287d6cd2dbfacf55106e2bf597e22a4b573"],
+    ["6f62138301436f33a00b84a26a0457ccbfc0f82403288b9cbae39986b34357cb2ff9b889b302000000045253655335a7ff6701bac9960400000000086552ab656352635200000000", "6aac51", 0, 1444414211, "502a2435fd02898d2ff3ab08a3c19078414b32ec9b73d64a944834efc9dae10c"],
+    ["9981143a040a88c2484ac3abe053849e72d04862120f424f373753161997dd40505dcb4783030000000700536365536565a2e10da3f4b1c1ad049d97b33f0ae0ea48c5d7c30cc8810e144ad93be97789706a5ead180100000003636a00ffffffffbdcbac84c4bcc87f03d0ad83fbe13b369d7e42ddb3aecf40870a37e814ad8bb5010000000963536a5100636a53abffffffff883609905a80e34202101544f69b58a0b4576fb7391e12a769f890eef90ffb72020000000651656352526affffffff04243660000000000004ab5352534a9ce001000000000863656363ab6a53652df19d030000000003ac65acedc51700000000000000000000", "ac6300acac", 2, 293672388, "7ba99b289c04718a7283f150d831175ed6303081e191a0608ea81f78926c5bdf"],
+    ["49f7d0b6037bba276e910ad3cd74966c7b3bc197ffbcfefd6108d6587006947e97789835ea0300000008526a52006a650053ffffffff8d7b6c07cd10f4c4010eac7946f61aff7fb5f3920bdf3467e939e58a1d4100ab03000000076aac63ac535351ffffffff8f48c3ba2d52ad67fbcdc90d8778f3c8a3894e3c35b9730562d7176b81af23c80100000003ab5265ffffffff0301e3ef0300000000046a525353e899ac0500000000075153ab6a65abac259bea0400000000007b739972", "53516aacac6aac", 1, 955403557, "5d366a7f4346ae18aeb7c9fc4dab5af71173184aa20ed22fcb4ea8511ad25449"],
+    ["58a4fed801fbd8d92db9dfcb2e26b6ff10b120204243fee954d7dcb3b4b9b53380e7bb8fb60100000003006351ffffffff02a0795b050000000006536351ac6aac2718d00200000000075151acabac515354d21ba1", "005363515351", 0, -1322430665, "bbee941bbad950424bf40e3623457db47f60ed29deaa43c99dec702317cb3326"],
+    ["17fad0d303da0d764fedf9f2887a91ea625331b28704940f41e39adf3903d8e75683ef6d46020000000151ffffffffff376eea4e880bcf0f03d33999104aafed2b3daf4907950bb06496af6b51720a020000000900636a63525253525196521684f3b08497bad2c660b00b43a6a517edc58217876eb5e478aa3b5fda0f29ee1bea00000000046aacab6affffffff03dde8e2050000000007ac5365ac51516a14772e000000000005630000abacbbb360010000000006ab5251ab656a50f180f0", "0053", 0, -1043701251, "a3bdf8771c8990971bff9b4e7d59b7829b067ed0b8d3ac1ec203429811384668"],
+    ["5a2257df03554550b774e677f348939b37f8e765a212e566ce6b60b4ea8fed4c9504b7f7d1000000000653655265ab5258b67bb931df15b041177cf9599b0604160b79e30f3d7a594e7826bae2c29700f6d8f8f40300000005515300ac6a159cf8808a41f504eb5c2e0e8a9279f3801a5b5d7bc6a70515fbf1c5edc875bb4c9ffac500000000050063510052ffffffff0422a90105000000000965006a650000516a006417d2020000000006526363ab00524d969d0100000000035153acc4f077040000000005ac5200636500000000", "6a52", 1, -1482463464, "37b794b05d0687c9b93d5917ab068f6b2f0e38406ff04e7154d104fc1fb14cdc"],
+    ["e0032ad601269154b3fa72d3888a3151da0aed32fb2e1a15b3ae7bee57c3ddcffff76a1321010000000100110d93ae03f5bd080100000000075263516a6551002871e60100000000046a005252eaa753040000000004ab6aab526e325c71", "630052", 0, -1857873018, "ea117348e94de86381bb8ad1c7f93b8c623f0272104341701bb54e6cb433596c"],
+    ["014b2a5304d46764817aca180dca50f5ab25f2e0d5749f21bb74a2f8bf6b8b7b3fa8189cb7030000000965ac5165ab6a51ac6360ecd91e8abc7e700a4c36c1a708a494c94bb20cbe695c408543146566ab22be43beae9103000000045163ab00ffffffffffa48066012829629a9ec06ccd4905a05df0e2b745b966f6a269c9c8e13451fc00000000026565ffffffffc40ccadc21e65fe8a4b1e072f4994738ccaf4881ae6fede2a2844d7da4d199ab02000000065152ab536aabffffffff01b6e054030000000004515352ab3e063432", "", 0, 1056459916, "a7aff48f3b8aeb7a4bfe2e6017c80a84168487a69b69e46681e0d0d8e63a84b6"],
+    ["1201ab5d04f89f07c0077abd009762e59db4bb0d86048383ba9e1dad2c9c2ad96ef660e6d00200000007ab6a65ac5200652466fa5143ab13d55886b6cdc3d0f226f47ec1c3020c1c6e32602cd3428aceab544ef43e00000000086a6a6a526a6a5263ffffffffd5be0b0be13ab75001243749c839d779716f46687e2e9978bd6c9e2fe457ee48020000000365abab1e1bac0f72005cf638f71a3df2e3bbc0fa35bf00f32d9c7dc9c39a5e8909f7d53170c8ae0200000008ab6a51516363516affffffff02f0a6210500000000036300ac867356010000000009acab65ac6353536a659356d367", "ac53535252", 0, 917543338, "418acc156c2bc76a5d7baa58db29f1b4cf6c266c9222ed167ef5b4d47f0e0f41"],
+    ["344fa11e01c19c4dd232c77742f0dd0aeb3695f18f76da627628741d0ee362b0ea1fb3a2180200000007635151005100529bab25af01937c1f0500000000055153ab53656e7630af", "6351005163ac51", 0, -629732125, "228ca52a0a376fe0527a61cfa8da6d7baf87486bba92d49dfd3899cac8a1034f"],
+    ["b2fda1950191358a2b855f5626a0ebc830ab625bea7480f09f9cd3b388102e35c0f303124c030000000565ac65ab53ffffffff03f9c5ec04000000000765ab51516551650e2b9f0500000000045365525284e8f6040000000001ac00000000", "ac51655253", 0, 1433027632, "d2fa7e13c34cecda5105156bd2424c9b84ee0a07162642b0706f83243ff811a8"],
+    ["a4a6bbd201aa5d882957ac94f2c74d4747ae32d69fdc765add4acc2b68abd1bdb8ee333d6e0300000008516a6552515152abffffffff02c353cb040000000007ac6351ab51536588bd320500000000066552525253ac00000000", "", 0, 1702060459, "499da7d74032388f820645191ac3c8d20f9dba8e8ded7fa3a5401ea2942392a1"],
+    ["83a583d204d926f2ee587a83dd526cf1e25a44bb668e45370798f91a2907d184f7cddcbbc7030000000700ab6565536a539f71d3776300dffdfa0cdd1c3784c9a1f773e34041ca400193612341a9c42df64e3f550e01000000050052515251ffffffff52dab2034ab0648553a1bb8fc4e924b2c89ed97c18dfc8a63e248b454035564b01000000015139ab54708c7d4d2c2886290f08a5221cf69592a810fd1979d7b63d35c271961e710424fd0300000005ac65ac5251ffffffff01168f7c030000000000a85e5fb0", "6a536353656a00", 0, 179595345, "5350a31ac954a0b49931239d0ecafbf34d035a537fd0c545816b8fdc355e9961"],
+    ["ffd35d51042f290108fcb6ea49a560ba0a6560f9181da7453a55dfdbdfe672dc800b39e7320200000006630065516a65f2166db2e3827f44457e86dddfd27a8af3a19074e216348daa0204717d61825f198ec0030100000006ab51abab00abffffffffdf41807adb7dff7db9f14d95fd6dc4e65f8402c002d009a3f1ddedf6f4895fc8030000000500ab006a65a5a848345052f860620abd5fcd074195548ce3bd0839fa9ad8642ed80627bf43a0d47dbd010000000765ab006a656a53b38cdd6502a186da05000000000765ab00ab006a53527c0e0100000000085365ab51acacac52534bd1b1", "6a635253ac0000", 0, 1095082149, "3c05473a816621a3613f0e903faa1a1e44891dd40862b029e41fc520776350fa"],
+    ["6c9a4b98013c8f1cae1b1df9f0f2de518d0c50206a0ab871603ac682155504c0e0ce946f460100000000ffffffff04e9266305000000000753535100ac6aacded39e04000000000365ac6ab93ccd010000000002515397bf3d050000000003ab636300000000", "63520052ac656353", 0, -352633155, "936eff8cdfd771be24124da87c7b24feb48da7cbc2c25fb5ba13d1a23255d902"],
+    ["c4b80f850323022205b3e1582f1ed097911a81be593471a8dce93d5c3a7bded92ef6c7c1260100000002006affffffff70294d62f37c3da7c5eae5d67dce6e1b28fedd7316d03f4f48e1829f78a88ae801000000096a5200530000516351f6b7b544f7c39189d3a2106ca58ce4130605328ce7795204be592a90acd81bef517d6f170200000000ffffffff012ab8080000000000075100006365006335454c1e", "53ac6a536aacac", 0, -1124103895, "06277201504e6bf8b8c94136fad81b6e3dadacb9d4a2c21a8e10017bfa929e0e"],
+    ["8ab69ed50351b47b6e04ac05e12320984a63801716739ed7a940b3429c9c9fed44d3398ad40300000006536a516a52638171ef3a46a2adb8025a4884b453889bc457d63499971307a7e834b0e76eec69c943038a0300000000ffffffff566bb96f94904ed8d43d9d44a4a6301073cef2c011bf5a12a89bedbaa03e4724030000000265acb606affd01edea38050000000008515252516aacac6300000000", "65000000006365ac53", 0, -1338942849, "7912573937824058103cb921a59a7f910a854bf2682f4116a393a2045045a8c3"],
+    ["2484991e047f1cf3cfe38eab071f915fe86ebd45d111463b315217bf9481daf0e0d10902a402000000006e71a424eb1347ffa638363604c0d5eccbc90447ff371e000bf52fc743ec832851bb564a0100000001abffffffffef7d014fad3ae7927948edbbb3afe247c1bcbe7c4c8f5d6cf97c799696412612020000000851536a5353006a001dfee0d7a0dd46ada63b925709e141863f7338f34f7aebde85d39268ae21b77c3068c01d0000000008535151ab00636563ffffffff018478070200000000095200635365ac52ab5341b08cd3", "", 3, 265623923, "24cb420a53b4f8bb477f7cbb293caabfd2fc47cc400ce37dbbab07f92d3a9575"],
+    ["54839ef9026f65db30fc9cfcb71f5f84d7bb3c48731ab9d63351a1b3c7bc1e7da22bbd508e0300000000442ad138f170e446d427d1f64040016032f36d8325c3b2f7a4078766bdd8fb106e52e8d20000000003656500ffffffff02219aa101000000000851ababac52ab00659646bd02000000000552acacabac24c394a5", "ac", 0, 906807497, "69264faadcd1a581f7000570a239a0a26b82f2ad40374c5b9c1f58730514de96"],
+    ["5036d7080434eb4eef93efda86b9131b0b4c6a0c421e1e5feb099a28ff9dd8477728639f77030000000951516aab535152ab5391429be9cce85d9f3d358c5605cf8c3666f034af42740e94d495e28b9aaa1001ba0c87580300000008006552ab00ab006affffffffd838978e10c0c78f1cd0a0830d6815f38cdcc631408649c32a25170099669daa0000000002acab8984227e804ad268b5b367285edcdf102d382d027789250a2c0641892b480c21bf84e3fb0100000000b518041e023d8653010000000001004040fb0100000000080051ac5200636a6300000000", "52ac", 0, 366357656, "bd0e88829afa6bdc1e192bb8b2d9d14db69298a4d81d464cbd34df0302c634c6"],
+    ["9ad5ccf503fa4facf6a27b538bc910cce83c118d6dfd82f3fb1b8ae364a1aff4dcefabd38f03000000096365655263ac655300807c48130c5937190a996105a69a8eba585e0bd32fadfc57d24029cbed6446d30ebc1f100100000004000053650f0ccfca1356768df7f9210cbf078a53c72e0712736d9a7a238e0115faac0ca383f219d0010000000600ab536552002799982b0221b8280000000000000c41320000000000086552ac6365636a6595f233a3", "6a5152", 2, 553208588, "f99c29a79f1d73d2a69c59abbb5798e987639e36d4c44125d8dc78a94ddcfb13"],
+    ["669538a204047214ce058aed6a07ca5ad4866c821c41ac1642c7d63ed0054f84677077a84f030000000853abacab6a655353ffffffff70c2a071c115282924e3cb678b13800c1d29b6a028b3c989a598c491bc7c76c5030000000752ac52ac5163ac80420e8a6e43d39af0163271580df6b936237f15de998e9589ec39fe717553d415ac02a4030000000463635153184ad8a5a4e69a8969f71288c331aff3c2b7d1b677d2ebafad47234840454b624bf7ac1d03000000056a63abab63df38c24a02fbc63a040000000002ab535ec3dc050000000002536500000000", "635153", 3, -190399351, "9615541884dfb1feeb08073a6a6aa73ef694bc5076e52187fdf4138a369f94d9"],
+    ["972128b904e7b673517e96e98d80c0c8ceceae76e2f5c126d63da77ffd7893fb53308bb2da0300000006ac6552ab52acffffffff4cac767c797d297c079a93d06dc8569f016b4bf7a7d79b605c526e1d36a40e2202000000095365ab636aac6a6a6a69928d2eddc836133a690cfb72ec2d3115bf50fb3b0d10708fa5d2ebb09b4810c426a1db01000000060052526300001e8e89585da7e77b2dd2e30625887f0660accdf29e53a614d23cf698e6fc8ab03310e87700000000076a520051acac6555231ddb0330ec2d03000000000200abfaf457040000000004ab6a6352bdc42400000000000153d6dd2f04", "", 0, 209234698, "4a92fec1eb03f5bd754ee9bfd70707dc4420cc13737374f4675f48529be518e4"],
+    ["5374f0c603d727f63006078bd6c3dce48bd5d0a4b6ea00a47e5832292d86af258ea0825c260000000009655353636352526a6af2221067297d42a9f8933dfe07f61a574048ff9d3a44a3535cd8eb7de79fb7c45b6f47320200000003ac006affffffff153d917c447d367e75693c5591e0abf4c94bbdd88a98ab8ad7f75bfe69a08c470200000005ac65516365ffffffff037b5b7b000000000001515dc4d904000000000004bb26010000000004536a6aac00000000", "516552516352ac", 2, 328538756, "8bb7a0129eaf4b8fc23e911c531b9b7637a21ab11a246352c6c053ff6e93fcb6"],
+    ["c441132102cc82101b6f31c1025066ab089f28108c95f18fa67db179610247086350c163bd010000000651525263ab00ffffffff9b8d56b1f16746f075249b215bdb3516cbbe190fef6292c75b1ad8a8988897c3000000000751ab6553abab00ffffffff02f9078b000000000009ab0053ac51ac00ab51c0422105000000000651006563525200000000", "ac51", 0, -197051790, "55acd8293ed0be6792150a3d7ced6c5ccd153ca7daf09cee035c1b0dac92bb96"],
+    ["8bff9d170419fa6d556c65fa227a185fe066efc1decf8a1c490bc5cbb9f742d68da2ab7f320100000007ab000053525365a7a43a80ab9593b9e8b6130a7849603b14b5c9397a190008d89d362250c3a2257504eb810200000007acabacac00ab51ee141be418f003e75b127fd3883dbf4e8c3f6cd05ca4afcaac52edd25dd3027ae70a62a00000000008ac52526a5200536affffffffb8058f4e1d7f220a1d1fa17e96d81dfb9a304a2de4e004250c9a576963a586ae0300000005abacac5363b9bc856c039c01d804000000000951656aac53005365acb0724e00000000000565abab63acea7c7a0000000000036a00ac00000000", "6565", 1, -1349282084, "2b822737c2affeefae13451d7c9db22ff98e06490005aba57013f6b9bbc97250"],
+    ["0e1633b4041c50f656e882a53fde964e7f0c853b0ada0964fc89ae124a2b7ffc5bc97ea6230100000006ac6aacacabacffffffff2e35f4dfcad2d53ea1c8ada8041d13ea6c65880860d96a14835b025f76b1fbd9000000000351515121270867ef6bf63a91adbaf790a43465c61a096acc5a776b8e5215d4e5cd1492e611f761000000000600ac6aab5265ffffffff63b5fc39bcac83ca80ac36124abafc5caee608f9f63a12479b68473bd4bae769000000000965ac52acac5263acabffffffff0163153e020000000008ab005165ab65515300000000", "6a6aac00", 0, -968477862, "20732d5073805419f275c53784e78db45e53332ee618a9fcf60a3417a6e2ca69"],
+    ["2b052c24022369e956a8d318e38780ef73b487ba6a8f674a56bdb80a9a63634c6110fb5154010000000251acffffffff48fe138fb7fdaa014d67044bc05940f4127e70c113c6744fbd13f8d51d45143e01000000005710db3804e01aa9030000000008acac6a516a5152abfd55aa01000000000751ab510000ac636d6026010000000000b97da9000000000000fddf3b53", "006552", 0, 595461670, "685d67d84755906d67a007a7d4fa311519467b9bdc6a351913246a41e082a29f"],
+    ["7888b71403f6d522e414d4ca2e12786247acf3e78f1918f6d727d081a79813d129ee8befce0100000009ab516a6353ab6365abffffffff4a882791bf6400fda7a8209fb2c83c6eef51831bdf0f5dacde648859090797ec030000000153ffffffffbb08957d59fa15303b681bad19ccf670d7d913697a2f4f51584bf85fcf91f1f30200000008526565ac52ac63acffffffff0227c0e8050000000001ac361dc801000000000800515165ab00ab0000000000", "656a", 2, 1869281295, "f43378a0b7822ad672773944884e866d7a46579ee34f9afc17b20afc1f6cf197"],
+    ["cc4dda57047bd0ca6806243a6a4b108f7ced43d8042a1acaa28083c9160911cf47eab910c40200000007526a0000ab6a63e4154e581fcf52567836c9a455e8b41b162a78c85906ccc1c2b2b300b4c69caaaa2ba0230300000008ab5152ac5100ab65ffffffff69696b523ed4bd41ecd4d65b4af73c9cf77edf0e066138712a8e60a04614ea1c0300000004ab6a000016c9045c7df7836e05ac4b2e397e2dd72a5708f4a8bf6d2bc36adc5af3cacefcf074b8b403000000065352ac5252acffffffff01d7e380050000000000cf4e699a", "525163656351", 1, -776533694, "ff18c5bffd086e00917c2234f880034d24e7ea2d1e1933a28973d134ca9e35d2"],
+    ["b7877f82019c832707a60cf14fba44cfa254d787501fdd676bd58c744f6e951dbba0b3b77f0200000009ac515263ac53525300a5a36e500148f89c0500000000085265ac6a6a65acab00000000", "6563", 0, -1785108415, "cb6e4322955af12eb29613c70e1a00ddbb559c887ba844df0bcdebed736dffbd"],
+    ["aeb14046045a28cc59f244c2347134d3434faaf980961019a084f7547218785a2bd03916f3000000000165f852e6104304955bda5fa0b75826ee176211acc4a78209816bbb4419feff984377b2352200000000003a94a5032df1e0d60390715b4b188c330e4bb7b995f07cdef11ced9d17ee0f60bb7ffc8e0100000002516513e343a5c1dc1c80cd4561e9dddad22391a2dbf9c8d2b6048e519343ca1925a9c6f0800a020000000665516365ac513180144a0290db27000000000006ab655151ab5138b187010000000007ab5363abac516a9e5cd98a", "53ac", 0, 478591320, "e8d89a302ae626898d4775d103867a8d9e81f4fd387af07212adab99946311ef"],
+    ["57a5a04c0278c8c8e243d2df4bb716f81d41ac41e2df153e7096f5682380c4f441888d9d260300000004ab63ab6afdbe4203525dff42a7b1e628fe22bccaa5edbb34d8ab02faff198e085580ea5fcdb0c61b0000000002ac6affffffff03375e6c05000000000663ab516a6a513cb6260400000000007ca328020000000006516a636a52ab94701cc7", "0053ac5152", 0, -550925626, "b7ca991ab2e20d0158168df2d3dd842a57ab4a3b67cca8f45b07c4b7d1d11126"],
+    ["7e27c42d0279c1a05eeb9b9faedcc9be0cab6303bde351a19e5cbb26dd0d594b9d74f40d2b020000000200518c8689a08a01e862d5c4dcb294a2331912ff11c13785be7dce3092f154a005624970f84e0200000000500cf5a601e74c1f0000000000076aab52636a6a5200000000", "6500006a5351", 0, 449533391, "535ba819d74770d4d613ee19369001576f98837e18e1777b8246238ff2381dd0"],
+    ["2b3470dd028083910117f86614cdcfb459ee56d876572510be4df24c72e8f58c70d5f5948b03000000066aab65635265da2c3aac9d42c9baafd4b655c2f3efc181784d8cba5418e053482132ee798408ba43ccf90300000000ffffffff047dda4703000000000765516a52ac53009384a603000000000651636a63ab6a8cf57a03000000000352ab6a8cf6a405000000000952636a6a6565525100661e09cb", "ac520063ac6a6a52", 1, 1405647183, "9b360c3310d55c845ef537125662b9fe56840c72136891274e9fedfef56f9bb5"],
+    ["3a5644a9010f199f253f858d65782d3caec0ac64c3262b56893022b9796086275c9d4d097b02000000009d168f7603a67b30050000000007ac51536a0053acd9d88a050000000007655363535263ab3cf1f403000000000352ac6a00000000", "005363536565acac6a", 0, -1383947195, "6390ab0963cf611e0cea35a71dc958b494b084e6fd71d22217fdc5524787ade6"],
+    ["bda1ff6804a3c228b7a12799a4c20917301dd501c67847d35da497533a606701ad31bf9d5e0300000001ac16a6c5d03cf516cd7364e4cbbf5aeccd62f8fd03cb6675883a0636a7daeb650423cb1291010000000500656553ac4a63c30b6a835606909c9efbae1b2597e9db020c5ecfc0642da6dc583fba4e84167539a8020000000865525353515200acffffffff990807720a5803c305b7da08a9f24b92abe343c42ac9e917a84e1f335aad785d00000000026a52ffffffff04981f20030000000001ab8c762200000000000253ab690b9605000000000151ce88b301000000000753526a6a51006500000000", "000052ac52530000", 1, -1809193140, "5299b0fb7fc16f40a5d6b337e71fcd1eb04d2600aefd22c06fe9c71fe0b0ba54"],
+    ["db4904e6026b6dd8d898f278c6428a176410d1ffbde75a4fa37cda12263108ccd4ca6137440100000007656a0000515263ffffffff1db7d5005c1c40da0ed17b74cf6b2a6ee2c33c9e0bacda76c0da2017dcac2fc70200000004abab6a53ffffffff0454cf2103000000000153463aef000000000009ab6a630065ab52636387e0ed050000000000e8d16f05000000000352ac63e4521b22", "", 1, 1027042424, "48315a95e49277ab6a2d561ee4626820b7bab919eea372b6bf4e9931ab221d04"],
+    ["dca31ad10461ead74751e83d9a81dcee08db778d3d79ad9a6d079cfdb93919ac1b0b61871102000000086500525365ab51ac7f7e9aed78e1ef8d213d40a1c50145403d196019985c837ffe83836222fe3e5955e177e70100000006525152525300ffffffff5e98482883cc08a6fe946f674cca479822f0576a43bf4113de9cbf414ca628060100000006ac53516a5253ffffffff07490b0b898198ec16c23b75d606e14fa16aa3107ef9818594f72d5776805ec502000000036a0052ffffffff01932a2803000000000865ab6551ac6a516a2687aa06", "635300ac", 2, -1880362326, "74d6a2fa7866fd8b74b2e34693e2d6fd690410384b7afdcd6461b1ae71d265ce"],
+    ["e14e1a9f0442ab44dfc5f6d945ad1ff8a376bc966aad5515421e96ddbe49e529614995cafc03000000055165515165fffffffff97582b8290e5a5cfeb2b0f018882dbe1b43f60b7f45e4dd21dbd3a8b0cfca3b0200000000daa267726fe075db282d694b9fee7d6216d17a8c1f00b2229085495c5dc5b260c8f8cd5d000000000363ac6affffffffaab083d22d0465471c896a438c6ac3abf4d383ae79420617a8e0ba8b9baa872b010000000963526563ac5363ababd948b5ce022113440200000000076a636552006a53229017040000000000e6f62ac8", "526353636a65", 3, -485265025, "1bc8ad76f9b7c366c5d052dc479d6a8a2015566d3a42e93ab12f727692c89d65"],
+    ["69df842a04c1410bfca10896467ce664cfa31c681a5dac10106b34d4b9d4d6d0dc1eac01c1000000000551536a5165269835ca4ad7268667b16d0a2df154ec81e304290d5ed69e0069b43f8c89e673328005e200000000076a5153006aacabffffffffc9314bd80b176488f3d634360fcba90c3a659e74a52e100ac91d3897072e3509010000000765abac51636363ffffffff0e0768b13f10f0fbd2fa3f68e4b4841809b3b5ba0e53987c3aaffcf09eee12bf0300000008ac535263526a53ac514f4c2402da8fab0400000000001ef15201000000000451526a52d0ec9aca", "525365ac52", 1, 313967049, "a72a760b361af41832d2c667c7488dc9702091918d11e344afc234a4aea3ec44"],
+    ["e4fec9f10378a95199c1dd23c6228732c9de0d7997bf1c83918a5cfd36012476c0c3cba24002000000085165536500ac0000ad08ab93fb49d77d12a7ccdbb596bc5110876451b53a79fdce43104ff1c316ad63501de801000000046a6352ab76af9908463444aeecd32516a04dd5803e02680ed7f16307242a794024d93287595250f4000000000089807279041a82e603000000000200521429100200000000055253636a63f20b940400000000004049ed04000000000500ab5265ab43dfaf7d", "6563526aac", 2, -1923470368, "32f3c012eca9a823bebb9b282240aec40ca65df9f38da43b1dcfa0cac0c0df7e"],
+    ["4000d3600100b7a3ff5b41ec8d6ccdc8b2775ad034765bad505192f05d1f55d2bc39d0cbe10100000007ab5165ac6a5163ffffffff034949150100000000026a6a92c9f6000000000008ab6553ab6aab635200e697040000000007636a5353525365237ae7d2", "52000063", 0, -880046683, "c76146f68f43037289aaeb2bacf47408cddc0fb326b350eb4f5ef6f0f8564793"],
+    ["eabc0aa701fe489c0e4e6222d72b52f083166b49d63ad1410fb98caed027b6a71c02ab830c03000000075253ab63530065ffffffff01a5dc0b05000000000253533e820177", "", 0, 954499283, "1d849b92eedb9bf26bd4ced52ce9cb0595164295b0526842ab1096001fcd31b1"],
+    ["d48d55d304aad0139783b44789a771539d052db565379f668def5084daba0dfd348f7dcf6b00000000006826f59e5ffba0dd0ccbac89c1e2d69a346531d7f995dea2ca6d7e6d9225d81aec257c6003000000096a655200ac656552acffffffffa188ffbd5365cae844c8e0dea6213c4d1b2407274ae287b769ab0bf293e049eb0300000005ac6a6aab51ad1c407c5b116ca8f65ed496b476183f85f072c5f8a0193a4273e2015b1cc288bf03e9e2030000000252abffffffff04076f44040000000006655353abab53be6500050000000003ac65ac3c15040500000000095100ab536353516a52ed3aba04000000000900ac53ab53636aabac00000000", "5253526563acac", 2, -1506108646, "bbee17c8582514744bab5df50012c94b0db4aff5984d2e13a8d09421674404e2"],
+    ["9746f45b039bfe723258fdb6be77eb85917af808211eb9d43b15475ee0b01253d33fc3bfc502000000065163006a655312b12562dc9c54e11299210266428632a7d0ee31d04dfc7375dcad2da6e9c11947ced0e000000000009074095a5ac4df057554566dd04740c61490e1d3826000ad9d8f777a93373c8dddc4918a00000000025351ffffffff01287564030000000004636a00ab00000000", "52", 2, -1380411075, "84af1623366c4db68d81f452b86346832344734492b9c23fbb89015e516c60b2"],
+    ["df0a32ae01c4672fd1abd0b2623aae0a1a8256028df57e532f9a472d1a9ceb194267b6ee190200000009536a6a51516a525251b545f9e803469a2302000000000465526500810631040000000000441f5b050000000006530051006aaceb183c76", "536a635252ac6a", 0, 1601138113, "9a0435996cc58bdba09643927fe48c1fc908d491a050abbef8daec87f323c58f"],
+    ["b1c0b71804dff30812b92eefb533ac77c4b9fdb9ab2f77120a76128d7da43ad70c20bbfb990200000002536392693e6001bc59411aebf15a3dc62a6566ec71a302141b0c730a3ecc8de5d76538b30f55010000000665535252ac514b740c6271fb9fe69fdf82bf98b459a7faa8a3b62f3af34943ad55df4881e0d93d3ce0ac0200000000c4158866eb9fb73da252102d1e64a3ce611b52e873533be43e6883137d0aaa0f63966f060000000001abffffffff04a605b604000000000851006a656a630052f49a0300000000000252515a94e1050000000009abac65ab0052abab00fd8dd002000000000651535163526a2566852d", "ac5363", 0, -1718831517, "b0dc030661783dd9939e4bf1a6dfcba809da2017e1b315a6312e5942d714cf05"],
+    ["3657e4260304ccdc19936e47bdf058d36167ee3d4eb145c52b224eff04c9eb5d1b4e434dfc0000000001ab58aefe57707c66328d3cceef2e6f56ab6b7465e587410c5f73555a513ace2b232793a74400000000036a006522e69d3a785b61ad41a635d59b3a06b2780a92173f85f8ed428491d0aaa436619baa9c4501000000046351abab2609629902eb7793050000000000a1b967040000000003525353a34d6192", "516a", 0, -1761874713, "0a2ff41f6d155d8d0e37cd9438f3b270df9f9214cda8e95c76d5a239ca189df2"],
+    ["a0eb6dc402994e493c787b45d1f946d267b09c596c5edde043e620ce3d59e95b2b5b93d43002000000096a5252526aac63ab6555694287a279e29ee491c177a801cd685b8744a2eab83824255a3bcd08fc0e3ea13fb8820000000009abab6365ab52ab0063ffffffff029e424a040000000008acab53ab516a636a23830f0400000000016adf49c1f9", "ac0065ac6500005252", 1, 669294500, "e05e3d383631a7ed1b78210c13c2eb26564e5577db7ddfcea2583c7c014091d4"],
+    ["6e67c0d3027701ef71082204c85ed63c700ef1400c65efb62ce3580d187fb348376a23e9710200000001655b91369d3155ba916a0bc6fe4f5d94cad461d899bb8aaac3699a755838bfc229d6828920010000000765536353526a52ffffffff04c0c792000000000005650052535372f79e000000000001527fc0ee010000000005ac5300ab65d1b3e902000000000251aba942b278", "6a5151", 0, 1741407676, "e657e2c8ec4ebc769ddd3198a83267b47d4f2a419fc737e813812acefad92ff7"],
+    ["8f53639901f1d643e01fc631f632b7a16e831d846a0184cdcda289b8fa7767f0c292eb221a00000000046a53abacffffffff037a2daa01000000000553ac6a6a51eac349020000000005ac526552638421b3040000000007006a005100ac63048a1492", "ac65", 0, 1033685559, "da86c260d42a692358f46893d6f91563985d86eeb9ea9e21cd38c2d8ffcfcc4d"],
+    ["b3cad3a7041c2c17d90a2cd994f6c37307753fa3635e9ef05ab8b1ff121ca11239a0902e700300000009ab635300006aac5163ffffffffcec91722c7468156dce4664f3c783afef147f0e6f80739c83b5f09d5a09a57040200000004516a6552ffffffff969d1c6daf8ef53a70b7cdf1b4102fb3240055a8eaeaed2489617cd84cfd56cf020000000352ab53ffffffff46598b6579494a77b593681c33422a99559b9993d77ca2fa97833508b0c169f80200000009655300655365516351ffffffff04d7ddf800000000000853536a65ac6351ab09f3420300000000056aab65abac33589d04000000000952656a65655151acac944d6f0400000000006a8004ba", "005165", 1, 1035865506, "fe1dc9e8554deecf8f50c417c670b839cc9d650722ebaaf36572418756075d58"],
+    ["cf781855040a755f5ba85eef93837236b34a5d3daeb2dbbdcf58bb811828d806ed05754ab8010000000351ac53ffffffffda1e264727cf55c67f06ebcc56dfe7fa12ac2a994fecd0180ce09ee15c480f7d00000000096351516a51acac00ab53dd49ff9f334befd6d6f87f1a832cddfd826a90b78fd8cf19a52cb8287788af94e939d6020000000700525251ac526310d54a7e8900ed633f0f6f0841145aae7ee0cbbb1e2a0cae724ee4558dbabfdc58ba6855010000000552536a53abfd1b101102c51f910500000000096300656a525252656a300bee010000000009ac52005263635151abe19235c9", "53005365", 2, 1422854188, "d5981bd4467817c1330da72ddb8760d6c2556cd809264b2d85e6d274609fc3a3"]
+]
diff --git a/tapyrus/tests/data/lex_combine_psbt_hex b/tapyrus/tests/data/lex_combine_psbt_hex
new file mode 100644
index 00000000..9ee710b6
--- /dev/null
+++ b/tapyrus/tests/data/lex_combine_psbt_hex
@@ -0,0 +1 @@
+70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a0100000000000af00102030405060708090f0102030405060708090a0b0c0d0e0f0af00102030405060708100f0102030405060708090a0b0c0d0e0f000af00102030405060708090f0102030405060708090a0b0c0d0e0f0af00102030405060708100f0102030405060708090a0b0c0d0e0f000af00102030405060708090f0102030405060708090a0b0c0d0e0f0af00102030405060708100f0102030405060708090a0b0c0d0e0f00
\ No newline at end of file
diff --git a/tapyrus/tests/data/lex_psbt_1_hex b/tapyrus/tests/data/lex_psbt_1_hex
new file mode 100644
index 00000000..a125c529
--- /dev/null
+++ b/tapyrus/tests/data/lex_psbt_1_hex
@@ -0,0 +1 @@
+70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a0100000000000af00102030405060708090f0102030405060708090a0b0c0d0e0f000af00102030405060708090f0102030405060708090a0b0c0d0e0f000af00102030405060708090f0102030405060708090a0b0c0d0e0f00
\ No newline at end of file
diff --git a/tapyrus/tests/data/lex_psbt_2_hex b/tapyrus/tests/data/lex_psbt_2_hex
new file mode 100644
index 00000000..766c7eee
--- /dev/null
+++ b/tapyrus/tests/data/lex_psbt_2_hex
@@ -0,0 +1 @@
+70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a0100000000000af00102030405060708100f0102030405060708090a0b0c0d0e0f000af00102030405060708100f0102030405060708090a0b0c0d0e0f000af00102030405060708100f0102030405060708090a0b0c0d0e0f00
\ No newline at end of file
diff --git a/tapyrus/tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw b/tapyrus/tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw
new file mode 100644
index 00000000..f195623c
Binary files /dev/null and b/tapyrus/tests/data/mainnet_block_000000000000000000000c835b2adcaedc20fdf6ee440009c249452c726dafae.raw differ
diff --git a/tapyrus/tests/data/merkle_block.hex b/tapyrus/tests/data/merkle_block.hex
new file mode 100644
index 00000000..9844ad3b
--- /dev/null
+++ b/tapyrus/tests/data/merkle_block.hex
@@ -0,0 +1 @@
+0100000096574bdcf9fca26560e5ddf07812c8e64841cb56e6453bf689277e47e0de40d4acd63fe13a8e957e37396beb969a3c54169ba154085ac6933d92c048b8ac01d139b453897c252f18b1258327ff99e923acabe1ce5c8340d19e1098445c1b8cb7a7b57c62004020fd9cd7dc16bedcba8925e358485db06b915c97b3ebfffde128ff5739a01955d21db9f1f4a92f94c77433f01d4b94247902724d70a342a90b5f44d7d0ee70880900000005b5c5945cc9908afb0a0cb2910b6623857e46d04df470e5a1ab482d2b7a119bc902bff69aa3707c3317d35beb0f9bbfbca793bdf57869ec16b142880489fa025b431bbc09b76450aa051845747dafb19876528d23814abef113fd032765be4d721ba6f4b8499fec71f8950a0e4fd22c9b623fb8c14106fec037f498f3f628bc04f541d68b460a5247b1e1ecacff7b66aaa11b66c0ede3d0c58a835d6ca100c4d6022f0f
\ No newline at end of file
diff --git a/tapyrus/tests/data/previous_tx_0_hex b/tapyrus/tests/data/previous_tx_0_hex
new file mode 100644
index 00000000..ce208945
--- /dev/null
+++ b/tapyrus/tests/data/previous_tx_0_hex
@@ -0,0 +1 @@
+0200000000010158e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd7501000000171600145f275f436b09a8cc9a2eb2a2f528485c68a56323feffffff02d8231f1b0100000017a914aed962d6654f9a2b36608eb9d64d2b260db4f1118700c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88702483045022100a22edcc6e5bc511af4cc4ae0de0fcd75c7e04d8c1c3a8aa9d820ed4b967384ec02200642963597b9b1bc22c75e9f3e117284a962188bf5e8a74c895089046a20ad770121035509a48eb623e10aace8bfd0212fdb8a8e5af3c94b0b133b95e114cab89e4f7965000000
\ No newline at end of file
diff --git a/tapyrus/tests/data/previous_tx_1_hex b/tapyrus/tests/data/previous_tx_1_hex
new file mode 100644
index 00000000..9297523e
--- /dev/null
+++ b/tapyrus/tests/data/previous_tx_1_hex
@@ -0,0 +1 @@
+0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f618765000000
\ No newline at end of file
diff --git a/tapyrus/tests/data/psbt1.hex b/tapyrus/tests/data/psbt1.hex
new file mode 100644
index 00000000..3bcb9179
--- /dev/null
+++ b/tapyrus/tests/data/psbt1.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tapyrus/tests/data/psbt2.hex b/tapyrus/tests/data/psbt2.hex
new file mode 100644
index 00000000..47f38701
--- /dev/null
+++ b/tapyrus/tests/data/psbt2.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tapyrus/tests/data/psbt_combined.hex b/tapyrus/tests/data/psbt_combined.hex
new file mode 100644
index 00000000..47f38701
--- /dev/null
+++ b/tapyrus/tests/data/psbt_combined.hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tapyrus/tests/data/serde/README.md b/tapyrus/tests/data/serde/README.md
new file mode 100644
index 00000000..a12793ba
--- /dev/null
+++ b/tapyrus/tests/data/serde/README.md
@@ -0,0 +1,12 @@
+Serialization input/output
+==========================
+
+Files here contain hex strings and binary data representing types used for
+regression testing.
+
+- *_hex: consensus encoded types represented as hex strings
+- *_ser: consensus encoded types represented as binary data
+- *_bincode: types serialized with serde as bincode
+
+We consensus deserialize, serde serialize, then check against the expected data
+to verify no serde regressions have been introduced.
diff --git a/tapyrus/tests/data/serde/absolute_lock_time_blocks_bincode b/tapyrus/tests/data/serde/absolute_lock_time_blocks_bincode
new file mode 100644
index 00000000..ab7c85f5
Binary files /dev/null and b/tapyrus/tests/data/serde/absolute_lock_time_blocks_bincode differ
diff --git a/tapyrus/tests/data/serde/absolute_lock_time_seconds_bincode b/tapyrus/tests/data/serde/absolute_lock_time_seconds_bincode
new file mode 100644
index 00000000..0d59b0c9
--- /dev/null
+++ b/tapyrus/tests/data/serde/absolute_lock_time_seconds_bincode
@@ -0,0 +1 @@
+PÉb
\ No newline at end of file
diff --git a/tapyrus/tests/data/serde/address_bincode b/tapyrus/tests/data/serde/address_bincode
new file mode 100644
index 00000000..5a1c100d
Binary files /dev/null and b/tapyrus/tests/data/serde/address_bincode differ
diff --git a/tapyrus/tests/data/serde/block_bincode b/tapyrus/tests/data/serde/block_bincode
new file mode 100644
index 00000000..0bd56c8d
Binary files /dev/null and b/tapyrus/tests/data/serde/block_bincode differ
diff --git a/tapyrus/tests/data/serde/child_number_bincode b/tapyrus/tests/data/serde/child_number_bincode
new file mode 100644
index 00000000..c9902e4a
--- /dev/null
+++ b/tapyrus/tests/data/serde/child_number_bincode
@@ -0,0 +1 @@
+ﾭ�
\ No newline at end of file
diff --git a/tapyrus/tests/data/serde/control_block_bincode b/tapyrus/tests/data/serde/control_block_bincode
new file mode 100644
index 00000000..02f9b8ca
Binary files /dev/null and b/tapyrus/tests/data/serde/control_block_bincode differ
diff --git a/tapyrus/tests/data/serde/control_block_hex b/tapyrus/tests/data/serde/control_block_hex
new file mode 100644
index 00000000..b1ddcda5
--- /dev/null
+++ b/tapyrus/tests/data/serde/control_block_hex
@@ -0,0 +1 @@
+c1a9d6f66cd4b25004f526bfa873e56942f98e8e492bd79ed6532b966104817c2bda584e7d32612381cf88edc1c02e28a296e807c16ad22f591ee113946e48a71e0641e660d1e5392fb79d64838c2b84faf04b7f5f283c9d8bf83e39e177b64372a0cd22eeab7e093873e851e247714eff762d8a30be699ba4456cfe6491b282e193a071350ae099005a5950d74f73ba13077a57bc478007fb0e4d1099ce9cf3d4
diff --git a/tapyrus/tests/data/serde/ecdsa_sig_bincode b/tapyrus/tests/data/serde/ecdsa_sig_bincode
new file mode 100644
index 00000000..3136dc70
Binary files /dev/null and b/tapyrus/tests/data/serde/ecdsa_sig_bincode differ
diff --git a/tapyrus/tests/data/serde/ecdsa_sig_hex b/tapyrus/tests/data/serde/ecdsa_sig_hex
new file mode 100644
index 00000000..a435e3df
--- /dev/null
+++ b/tapyrus/tests/data/serde/ecdsa_sig_hex
@@ -0,0 +1 @@
+3046022100839c1fbc5304de944f697c9f4b1d01d1faeba32d751c0f7acb21ac8a0f436a72022100e89bd46bb3a5a62adc679f659b7ce876d83ee297c7a5587b2011c4fcc72eab45
diff --git a/tapyrus/tests/data/serde/extended_priv_key b/tapyrus/tests/data/serde/extended_priv_key
new file mode 100644
index 00000000..7e84345f
--- /dev/null
+++ b/tapyrus/tests/data/serde/extended_priv_key
@@ -0,0 +1 @@
+xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi
diff --git a/tapyrus/tests/data/serde/extended_priv_key_bincode b/tapyrus/tests/data/serde/extended_priv_key_bincode
new file mode 100644
index 00000000..a4331025
Binary files /dev/null and b/tapyrus/tests/data/serde/extended_priv_key_bincode differ
diff --git a/tapyrus/tests/data/serde/extended_pub_key b/tapyrus/tests/data/serde/extended_pub_key
new file mode 100644
index 00000000..da226876
--- /dev/null
+++ b/tapyrus/tests/data/serde/extended_pub_key
@@ -0,0 +1 @@
+xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8
diff --git a/tapyrus/tests/data/serde/extended_pub_key_bincode b/tapyrus/tests/data/serde/extended_pub_key_bincode
new file mode 100644
index 00000000..096623fd
Binary files /dev/null and b/tapyrus/tests/data/serde/extended_pub_key_bincode differ
diff --git a/tapyrus/tests/data/serde/private_key_bincode b/tapyrus/tests/data/serde/private_key_bincode
new file mode 100644
index 00000000..827f5d7f
Binary files /dev/null and b/tapyrus/tests/data/serde/private_key_bincode differ
diff --git a/tapyrus/tests/data/serde/proprietary_key_bincode b/tapyrus/tests/data/serde/proprietary_key_bincode
new file mode 100644
index 00000000..24310775
Binary files /dev/null and b/tapyrus/tests/data/serde/proprietary_key_bincode differ
diff --git a/tapyrus/tests/data/serde/psbt_bincode b/tapyrus/tests/data/serde/psbt_bincode
new file mode 100644
index 00000000..c7fb60da
Binary files /dev/null and b/tapyrus/tests/data/serde/psbt_bincode differ
diff --git a/tapyrus/tests/data/serde/public_key_bincode b/tapyrus/tests/data/serde/public_key_bincode
new file mode 100644
index 00000000..472a282c
Binary files /dev/null and b/tapyrus/tests/data/serde/public_key_bincode differ
diff --git a/tapyrus/tests/data/serde/public_key_hex b/tapyrus/tests/data/serde/public_key_hex
new file mode 100644
index 00000000..4c6541bc
--- /dev/null
+++ b/tapyrus/tests/data/serde/public_key_hex
@@ -0,0 +1 @@
+042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133
diff --git a/tapyrus/tests/data/serde/raw_pair_bincode b/tapyrus/tests/data/serde/raw_pair_bincode
new file mode 100644
index 00000000..415afa7d
Binary files /dev/null and b/tapyrus/tests/data/serde/raw_pair_bincode differ
diff --git a/tapyrus/tests/data/serde/relative_lock_time_blocks_bincode b/tapyrus/tests/data/serde/relative_lock_time_blocks_bincode
new file mode 100644
index 00000000..4eb84bb4
Binary files /dev/null and b/tapyrus/tests/data/serde/relative_lock_time_blocks_bincode differ
diff --git a/tapyrus/tests/data/serde/relative_lock_time_seconds_bincode b/tapyrus/tests/data/serde/relative_lock_time_seconds_bincode
new file mode 100644
index 00000000..b6ed9a62
Binary files /dev/null and b/tapyrus/tests/data/serde/relative_lock_time_seconds_bincode differ
diff --git a/tapyrus/tests/data/serde/script_bincode b/tapyrus/tests/data/serde/script_bincode
new file mode 100644
index 00000000..5bf932f6
Binary files /dev/null and b/tapyrus/tests/data/serde/script_bincode differ
diff --git a/tapyrus/tests/data/serde/taproot_sig_bincode b/tapyrus/tests/data/serde/taproot_sig_bincode
new file mode 100644
index 00000000..01f28cee
Binary files /dev/null and b/tapyrus/tests/data/serde/taproot_sig_bincode differ
diff --git a/tapyrus/tests/data/serde/taproot_sig_hex b/tapyrus/tests/data/serde/taproot_sig_hex
new file mode 100644
index 00000000..9ab24dd5
--- /dev/null
+++ b/tapyrus/tests/data/serde/taproot_sig_hex
@@ -0,0 +1 @@
+6470FD1303DDA4FDA717B9837153C24A6EAB377183FC438F939E0ED2B620E9EE5077C4A8B8DCA28963D772A94F5F0DDF598E1C47C137F91933274C7C3EDADCE8
diff --git a/tapyrus/tests/data/serde/taptree_bincode b/tapyrus/tests/data/serde/taptree_bincode
new file mode 100644
index 00000000..51979bfa
Binary files /dev/null and b/tapyrus/tests/data/serde/taptree_bincode differ
diff --git a/tapyrus/tests/data/serde/transaction_bincode b/tapyrus/tests/data/serde/transaction_bincode
new file mode 100644
index 00000000..a3ec014a
Binary files /dev/null and b/tapyrus/tests/data/serde/transaction_bincode differ
diff --git a/tapyrus/tests/data/serde/transaction_ser b/tapyrus/tests/data/serde/transaction_ser
new file mode 100644
index 00000000..54226f70
Binary files /dev/null and b/tapyrus/tests/data/serde/transaction_ser differ
diff --git a/tapyrus/tests/data/serde/txin_bincode b/tapyrus/tests/data/serde/txin_bincode
new file mode 100644
index 00000000..92a61a1a
Binary files /dev/null and b/tapyrus/tests/data/serde/txin_bincode differ
diff --git a/tapyrus/tests/data/serde/txin_ser b/tapyrus/tests/data/serde/txin_ser
new file mode 100644
index 00000000..f2c5f3a6
Binary files /dev/null and b/tapyrus/tests/data/serde/txin_ser differ
diff --git a/tapyrus/tests/data/serde/txout_bincode b/tapyrus/tests/data/serde/txout_bincode
new file mode 100644
index 00000000..2c3d2077
Binary files /dev/null and b/tapyrus/tests/data/serde/txout_bincode differ
diff --git a/tapyrus/tests/data/serde/u256_bincode b/tapyrus/tests/data/serde/u256_bincode
new file mode 100644
index 00000000..e91e8a92
Binary files /dev/null and b/tapyrus/tests/data/serde/u256_bincode differ
diff --git a/tapyrus/tests/data/serde/uint128_bincode b/tapyrus/tests/data/serde/uint128_bincode
new file mode 100644
index 00000000..24087dd3
Binary files /dev/null and b/tapyrus/tests/data/serde/uint128_bincode differ
diff --git a/tapyrus/tests/data/serde/uint256_bincode b/tapyrus/tests/data/serde/uint256_bincode
new file mode 100644
index 00000000..6fe1e032
Binary files /dev/null and b/tapyrus/tests/data/serde/uint256_bincode differ
diff --git a/tapyrus/tests/data/serde/witness_bincode b/tapyrus/tests/data/serde/witness_bincode
new file mode 100644
index 00000000..e7d43be0
Binary files /dev/null and b/tapyrus/tests/data/serde/witness_bincode differ
diff --git a/tapyrus/tests/data/sign_1_psbt_hex b/tapyrus/tests/data/sign_1_psbt_hex
new file mode 100644
index 00000000..3bcb9179
--- /dev/null
+++ b/tapyrus/tests/data/sign_1_psbt_hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tapyrus/tests/data/sign_2_psbt_hex b/tapyrus/tests/data/sign_2_psbt_hex
new file mode 100644
index 00000000..70231338
--- /dev/null
+++ b/tapyrus/tests/data/sign_2_psbt_hex
@@ -0,0 +1 @@
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
\ No newline at end of file
diff --git a/tapyrus/tests/data/testnet_block_000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b.raw b/tapyrus/tests/data/testnet_block_000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b.raw
new file mode 100644
index 00000000..45376bad
Binary files /dev/null and b/tapyrus/tests/data/testnet_block_000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b.raw differ
diff --git a/tapyrus/tests/data/update_1_psbt_hex b/tapyrus/tests/data/update_1_psbt_hex
new file mode 100644
index 00000000..705d70d0
--- /dev/null
+++ b/tapyrus/tests/data/update_1_psbt_hex
@@ -0,0 +1 @@
+70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d90c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d710d90c6a4f0000008000000080010000800001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88701042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc10d90c6a4f00000080000000800200008000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000
\ No newline at end of file
diff --git a/tapyrus/tests/data/update_2_psbt_hex b/tapyrus/tests/data/update_2_psbt_hex
new file mode 100644
index 00000000..31fbd54f
--- /dev/null
+++ b/tapyrus/tests/data/update_2_psbt_hex
@@ -0,0 +1 @@
+70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f618765000000010304010000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d90c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d710d90c6a4f0000008000000080010000800001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e8870103040100000001042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc10d90c6a4f00000080000000800200008000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000
\ No newline at end of file
diff --git a/tapyrus/tests/psbt.rs b/tapyrus/tests/psbt.rs
new file mode 100644
index 00000000..61e95502
--- /dev/null
+++ b/tapyrus/tests/psbt.rs
@@ -0,0 +1,476 @@
+//! Tests PSBT integration vectors from BIP 174
+//! defined at <https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#test-vectors>
+
+use core::convert::TryFrom;
+use std::collections::BTreeMap;
+use std::str::FromStr;
+
+use tapyrus::bip32::{Fingerprint, IntoDerivationPath, KeySource, Xpriv, Xpub};
+use tapyrus::blockdata::opcodes::OP_0;
+use tapyrus::blockdata::{script, transaction};
+use tapyrus::consensus::encode::{deserialize, serialize_hex};
+use tapyrus::hex::FromHex;
+use tapyrus::psbt::{Psbt, PsbtSighashType};
+use tapyrus::script::PushBytes;
+use tapyrus::secp256k1::{self, Secp256k1};
+use tapyrus::{
+    absolute, Amount, Denomination, Network, OutPoint, PrivateKey, PublicKey, ScriptBuf, Sequence,
+    Transaction, TxIn, TxOut, Witness,
+};
+
+const NETWORK: Network = Network::Dev;
+
+#[track_caller]
+fn hex_psbt(s: &str) -> Psbt {
+    let v: Vec<u8> = Vec::from_hex(s).expect("valid hex digits");
+    Psbt::deserialize(&v).expect("valid magic and valid separators")
+}
+
+#[track_caller]
+fn hex_script(s: &str) -> ScriptBuf { ScriptBuf::from_hex(s).expect("valid hex digits") }
+
+#[test]
+#[ignore] // TODO: Re-enable after modified PSBT for tapyrus
+fn bip174_psbt_workflow() {
+    let secp = Secp256k1::new();
+
+    //
+    // Step 0: Create the extended private key from the test vector data.
+    //
+
+    let ext_priv = build_extended_private_key();
+    let ext_pub = Xpub::from_priv(&secp, &ext_priv);
+    let parent_fingerprint = ext_pub.fingerprint();
+
+    //
+    // Step 1: The creator.
+    //
+
+    let tx = create_transaction();
+    let psbt = create_psbt(tx);
+
+    //
+    // Step 2: The first updater.
+    //
+
+    let psbt = update_psbt(psbt, parent_fingerprint);
+
+    //
+    // Step 3: The second updater.
+    //
+
+    let psbt = update_psbt_with_sighash_all(psbt);
+
+    //
+    // Step 4: The first signer.
+    //
+
+    // Strings from BIP 174 test vector.
+    let test_vector = vec![
+        ("cP53pDbR5WtAD8dYAW9hhTjuvvTVaEiQBdrz9XPrgLBeRFiyCbQr", "m/0h/0h/0h"), // from_priv, into_derivation_path?
+        ("cR6SXDoyfQrcp4piaiHE97Rsgta9mNhGTen9XeonVgwsh4iSgw6d", "m/0h/0h/2h"),
+    ];
+
+    // We pass the keys to the signer after doing verification to make explicit
+    // that signer is only using these two keys.
+    let keys = parse_and_verify_keys(&ext_priv, &test_vector);
+    let psbt_1 = signer_one_sign(psbt.clone(), keys);
+
+    //
+    // Step 5: The second signer.
+    //
+
+    // Strings from BIP 174 test vector.
+    let test_vector = vec![
+        ("cT7J9YpCwY3AVRFSjN6ukeEeWY6mhpbJPxRaDaP5QTdygQRxP9Au", "m/0h/0h/1h"),
+        ("cNBc3SWUip9PPm1GjRoLEJT6T41iNzCYtD7qro84FMnM5zEqeJsE", "m/0h/0h/3h"),
+    ];
+
+    let keys = parse_and_verify_keys(&ext_priv, &test_vector);
+    let psbt_2 = signer_two_sign(psbt, keys);
+
+    //
+    // Step 6: Combiner the two signed PSBTs.
+    //
+
+    let combined = combine(psbt_1, psbt_2);
+
+    //
+    // Step 7: Finalize the PSBT.
+    //
+
+    let finalized = finalize(combined);
+
+    //
+    // Step 8: Extract the transaction.
+    //
+
+    let _tx = extract_transaction(finalized);
+
+    //
+    // Step 9: Test lexicographical PSBT combiner.
+    //
+    // Combine would be done earlier, at Step 6, in typical workflow.
+    // We define it here to reflect the order of test vectors in BIP 174.
+    //
+
+    combine_lexicographically();
+}
+
+/// Attempts to build an extended private key from seed and also directly from a string.
+fn build_extended_private_key() -> Xpriv {
+    // Strings from BIP 174 test vector.
+    let extended_private_key = "tprv8ZgxMBicQKsPd9TeAdPADNnSyH9SSUUbTVeFszDE23Ki6TBB5nCefAdHkK8Fm3qMQR6sHwA56zqRmKmxnHk37JkiFzvncDqoKmPWubu7hDF";
+    let seed = "cUkG8i1RFfWGWy5ziR11zJ5V4U4W3viSFCfyJmZnvQaUsd1xuF3T";
+
+    let xpriv = Xpriv::from_str(extended_private_key).unwrap();
+
+    let sk = PrivateKey::from_wif(seed).unwrap();
+    let seeded = Xpriv::new_master(NETWORK, &sk.inner.secret_bytes()).unwrap();
+    assert_eq!(xpriv, seeded);
+
+    xpriv
+}
+
+/// Creates the initial transaction, called by the PSBT Creator.
+fn create_transaction() -> Transaction {
+    // Strings from BIP 174 test vector.
+    let output_0 = TvOutput {
+        amount: "1.49990000",
+        script_pubkey: "0014d85c2b71d0060b09c9886aeb815e50991dda124d",
+    };
+    let output_1 = TvOutput {
+        amount: "1.00000000",
+        script_pubkey: "001400aea9a2e5f0f876a588df5546e8742d1d87008f",
+    };
+    let input_0 = TvInput {
+        txid: "75ddabb27b8845f5247975c8a5ba7c6f336c4570708ebe230caf6db5217ae858",
+        index: 0,
+    };
+    let input_1 = TvInput {
+        txid: "1dea7cd05979072a3578cab271c02244ea8a090bbb46aa680a65ecd027048d83",
+        index: 1,
+    };
+    struct TvOutput {
+        amount: &'static str,
+        script_pubkey: &'static str,
+    }
+    struct TvInput {
+        txid: &'static str,
+        index: u32,
+    }
+
+    Transaction {
+        version: transaction::Version::TWO,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![
+            TxIn {
+                previous_output: OutPoint {
+                    txid: input_0.txid.parse().expect("failed to parse txid"),
+                    vout: input_0.index,
+                },
+                script_sig: ScriptBuf::new(),
+                sequence: Sequence::MAX, // Disable nSequence.
+                witness: Witness::default(),
+            },
+            TxIn {
+                previous_output: OutPoint {
+                    txid: input_1.txid.parse().expect("failed to parse txid"),
+                    vout: input_1.index,
+                },
+                script_sig: ScriptBuf::new(),
+                sequence: Sequence::MAX,
+                witness: Witness::default(),
+            },
+        ],
+        output: vec![
+            TxOut {
+                value: Amount::from_str_in(output_0.amount, Denomination::TPC)
+                    .expect("failed to parse amount"),
+                script_pubkey: ScriptBuf::from_hex(output_0.script_pubkey)
+                    .expect("failed to parse script"),
+            },
+            TxOut {
+                value: Amount::from_str_in(output_1.amount, Denomination::TPC)
+                    .expect("failed to parse amount"),
+                script_pubkey: ScriptBuf::from_hex(output_1.script_pubkey)
+                    .expect("failed to parse script"),
+            },
+        ],
+    }
+}
+
+/// Creates the initial PSBT, called by the Creator. Verifies against BIP 174 test vector.
+#[track_caller]
+fn create_psbt(tx: Transaction) -> Psbt {
+    // String from BIP 174 test vector.
+    let expected_psbt_hex = include_str!("data/create_psbt_hex");
+    let expected_psbt: Psbt = hex_psbt(expected_psbt_hex);
+    let psbt = Psbt::from_unsigned_tx(tx).unwrap();
+
+    assert_eq!(psbt, expected_psbt);
+    psbt
+}
+
+/// Updates `psbt` according to the BIP, returns the newly updated PSBT. Verifies against BIP 174 test vector.
+#[track_caller]
+fn update_psbt(mut psbt: Psbt, fingerprint: Fingerprint) -> Psbt {
+    // Strings from BIP 174 test vector.
+    let previous_tx_0 = include_str!("data/previous_tx_0_hex");
+    let previous_tx_1 = include_str!("data/previous_tx_1_hex");
+
+    let redeem_script_0 = "5221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae";
+    let redeem_script_1 = "00208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903";
+    let witness_script = "522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae";
+
+    // Public key and its derivation path (these are the child pubkeys for our `Xpriv`,
+    // can be verified by deriving the key using this derivation path).
+    let pk_path = vec![
+        ("029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f", "m/0h/0h/0h"),
+        ("02dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d7", "m/0h/0h/1h"),
+        ("03089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc", "m/0h/0h/2h"),
+        ("023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e73", "m/0h/0h/3h"),
+        ("03a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca58771", "m/0h/0h/4h"),
+        ("027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b50051096", "m/0h/0h/5h"),
+    ];
+
+    let expected_psbt_hex = include_str!("data/update_1_psbt_hex");
+    let expected_psbt: Psbt = hex_psbt(expected_psbt_hex);
+
+    let mut input_0 = psbt.inputs[0].clone();
+
+    let v = Vec::from_hex(previous_tx_1).unwrap();
+    let tx: Transaction = deserialize(&v).unwrap();
+    input_0.non_witness_utxo = Some(tx);
+    input_0.redeem_script = Some(hex_script(redeem_script_0));
+    input_0.bip32_derivation = bip32_derivation(fingerprint, &pk_path, vec![0, 1]);
+
+    let mut input_1 = psbt.inputs[1].clone();
+
+    let v = Vec::from_hex(previous_tx_0).unwrap();
+    let tx: Transaction = deserialize(&v).unwrap();
+    input_1.witness_utxo = Some(tx.output[1].clone());
+
+    input_1.redeem_script = Some(hex_script(redeem_script_1));
+    input_1.witness_script = Some(hex_script(witness_script));
+    input_1.bip32_derivation = bip32_derivation(fingerprint, &pk_path, vec![2, 3]);
+
+    psbt.inputs = vec![input_0, input_1];
+
+    let mut output_0 = psbt.outputs[0].clone();
+    output_0.bip32_derivation = bip32_derivation(fingerprint, &pk_path, vec![4]);
+
+    let mut output_1 = psbt.outputs[1].clone();
+    output_1.bip32_derivation = bip32_derivation(fingerprint, &pk_path, vec![5]);
+
+    psbt.outputs = vec![output_0, output_1];
+
+    assert_eq!(psbt, expected_psbt);
+    psbt
+}
+
+/// `pk_path` holds tuples of `(public_key, derivation_path)`. `indecies` is used to access the
+/// `pk_path` vector. `fingerprint` is from the parent extended public key.
+fn bip32_derivation(
+    fingerprint: Fingerprint,
+    pk_path: &[(&str, &str)],
+    indecies: Vec<usize>,
+) -> BTreeMap<secp256k1::PublicKey, KeySource> {
+    let mut tree = BTreeMap::new();
+    for i in indecies {
+        let pk = pk_path[i].0;
+        let path = pk_path[i].1;
+
+        let pk = PublicKey::from_str(pk).unwrap();
+        let path = path.into_derivation_path().unwrap();
+
+        tree.insert(pk.inner, (fingerprint, path));
+    }
+    tree
+}
+
+/// Does the second update according to the BIP, returns the newly updated PSBT. Verifies against BIP 174 test vector.
+#[track_caller]
+fn update_psbt_with_sighash_all(mut psbt: Psbt) -> Psbt {
+    let expected_psbt_hex = include_str!("data/update_2_psbt_hex");
+    let expected_psbt: Psbt = hex_psbt(expected_psbt_hex);
+
+    let ty = PsbtSighashType::from_str("SIGHASH_ALL").unwrap();
+
+    let mut input_0 = psbt.inputs[0].clone();
+    input_0.sighash_type = Some(ty);
+    let mut input_1 = psbt.inputs[1].clone();
+    input_1.sighash_type = Some(ty);
+
+    psbt.inputs = vec![input_0, input_1];
+
+    assert_eq!(psbt, expected_psbt);
+    psbt
+}
+
+/// Verifies the keys in the test vector are valid for the extended private key and derivation path.
+fn parse_and_verify_keys(
+    ext_priv: &Xpriv,
+    sk_path: &[(&str, &str)],
+) -> BTreeMap<PublicKey, PrivateKey> {
+    let secp = &Secp256k1::new();
+
+    let mut key_map = BTreeMap::new();
+    for (secret_key, derivation_path) in sk_path.iter() {
+        let wif_priv = PrivateKey::from_wif(secret_key).expect("failed to parse key");
+
+        let path =
+            derivation_path.into_derivation_path().expect("failed to convert derivation path");
+        let derived_priv =
+            ext_priv.derive_priv(secp, &path).expect("failed to derive ext priv key").to_priv();
+        assert_eq!(wif_priv, derived_priv);
+        let derived_pub = derived_priv.public_key(secp);
+        key_map.insert(derived_pub, derived_priv);
+    }
+    key_map
+}
+
+/// Does the first signing according to the BIP, returns the signed PSBT. Verifies against BIP 174 test vector.
+#[track_caller]
+fn signer_one_sign(psbt: Psbt, key_map: BTreeMap<tapyrus::PublicKey, PrivateKey>) -> Psbt {
+    let expected_psbt_hex = include_str!("data/sign_1_psbt_hex");
+    let expected_psbt: Psbt = hex_psbt(expected_psbt_hex);
+
+    let psbt = sign(psbt, key_map);
+
+    assert_eq!(psbt, expected_psbt);
+    psbt
+}
+
+/// Does the second signing according to the BIP, returns the signed PSBT. Verifies against BIP 174 test vector.
+#[track_caller]
+fn signer_two_sign(psbt: Psbt, key_map: BTreeMap<tapyrus::PublicKey, PrivateKey>) -> Psbt {
+    let expected_psbt_hex = include_str!("data/sign_2_psbt_hex");
+    let expected_psbt: Psbt = hex_psbt(expected_psbt_hex);
+
+    let psbt = sign(psbt, key_map);
+
+    assert_eq!(psbt, expected_psbt);
+    psbt
+}
+
+/// Does the combine according to the BIP, returns the combined PSBT. Verifies against BIP 174 test vector.
+#[track_caller]
+fn combine(mut this: Psbt, that: Psbt) -> Psbt {
+    let expected_psbt_hex = include_str!("data/combine_psbt_hex");
+    let expected_psbt: Psbt = hex_psbt(expected_psbt_hex);
+
+    this.combine(that).expect("failed to combine PSBTs");
+
+    assert_eq!(this, expected_psbt);
+    this
+}
+
+/// Does the finalize step according to the BIP, returns the combined PSBT. Verifies against BIP 174
+/// test vector.
+#[track_caller]
+fn finalize(psbt: Psbt) -> Psbt {
+    let expected_psbt_hex = include_str!("data/finalize_psbt_hex");
+    let expected_psbt: Psbt = hex_psbt(expected_psbt_hex);
+
+    let psbt = finalize_psbt(psbt);
+
+    assert_eq!(psbt, expected_psbt);
+    psbt
+}
+
+/// Does the transaction extractor step according to the BIP, returns the combined PSBT. Verifies
+/// against BIP 174 test vector.
+fn extract_transaction(psbt: Psbt) -> Transaction {
+    let expected_tx_hex = include_str!("data/extract_tx_hex");
+
+    let tx = psbt.extract_tx_unchecked_fee_rate();
+
+    let got = serialize_hex(&tx);
+    assert_eq!(got, expected_tx_hex);
+
+    tx
+}
+
+/// Combines two PSBTs lexicographically according to the BIP. Verifies against BIP 174 test vector.
+#[track_caller]
+fn combine_lexicographically() {
+    let psbt_1_hex = include_str!("data/lex_psbt_1_hex");
+    let psbt_2_hex = include_str!("data/lex_psbt_2_hex");
+
+    let expected_psbt_hex = include_str!("data/lex_combine_psbt_hex");
+    let expected_psbt: Psbt = hex_psbt(expected_psbt_hex);
+
+    let v = Vec::from_hex(psbt_1_hex).unwrap();
+    let mut psbt_1 = Psbt::deserialize(&v).expect("failed to deserialize psbt 1");
+
+    let v = Vec::from_hex(psbt_2_hex).unwrap();
+    let psbt_2 = Psbt::deserialize(&v).expect("failed to deserialize psbt 2");
+
+    psbt_1.combine(psbt_2).expect("failed to combine PSBTs");
+
+    assert_eq!(psbt_1, expected_psbt);
+}
+
+/// Signs `psbt` with `keys` if required.
+fn sign(mut psbt: Psbt, keys: BTreeMap<tapyrus::PublicKey, PrivateKey>) -> Psbt {
+    let secp = Secp256k1::new();
+    psbt.sign(&keys, &secp).unwrap();
+    psbt
+}
+
+/// Finalizes a PSBT accord to the Input Finalizer role described in BIP 174.
+/// This is just a test. For a production-ready PSBT Finalizer, use [rust-miniscript](https://docs.rs/miniscript/latest/miniscript/psbt/trait.PsbtExt.html#tymethod.finalize)
+fn finalize_psbt(mut psbt: Psbt) -> Psbt {
+    // Input 0: legacy UTXO
+
+    let sigs: Vec<_> = psbt.inputs[0].partial_sigs.values().collect();
+    let script_sig = script::Builder::new()
+        .push_opcode(OP_0) // OP_CHECKMULTISIG bug pops +1 value when evaluating so push OP_0.
+        .push_slice(sigs[0].serialize())
+        .push_slice(sigs[1].serialize())
+        .push_slice(
+            <&PushBytes>::try_from(psbt.inputs[0].redeem_script.as_ref().unwrap().as_bytes())
+                .unwrap(),
+        )
+        .into_script();
+
+    psbt.inputs[0].final_script_sig = Some(script_sig);
+
+    psbt.inputs[0].partial_sigs = BTreeMap::new();
+    psbt.inputs[0].sighash_type = None;
+    psbt.inputs[0].redeem_script = None;
+    psbt.inputs[0].bip32_derivation = BTreeMap::new();
+
+    // Input 1: SegWit UTXO
+
+    let script_sig = script::Builder::new()
+        .push_slice(
+            <&PushBytes>::try_from(psbt.inputs[1].redeem_script.as_ref().unwrap().as_bytes())
+                .unwrap(),
+        )
+        .into_script();
+
+    psbt.inputs[1].final_script_sig = Some(script_sig);
+
+    let script_witness = {
+        let sigs: Vec<_> = psbt.inputs[1].partial_sigs.values().collect();
+        let mut script_witness = Witness::new();
+        script_witness.push([]); // Push 0x00 to the stack.
+        script_witness.push(sigs[1].to_vec());
+        script_witness.push(sigs[0].to_vec());
+        script_witness.push(psbt.inputs[1].witness_script.clone().unwrap().as_bytes());
+
+        script_witness
+    };
+
+    psbt.inputs[1].final_script_witness = Some(script_witness);
+
+    psbt.inputs[1].partial_sigs = BTreeMap::new();
+    psbt.inputs[1].sighash_type = None;
+    psbt.inputs[1].redeem_script = None;
+    psbt.inputs[1].witness_script = None;
+    psbt.inputs[1].bip32_derivation = BTreeMap::new();
+
+    psbt
+}
diff --git a/tapyrus/tests/serde.rs b/tapyrus/tests/serde.rs
new file mode 100644
index 00000000..2b68dc68
--- /dev/null
+++ b/tapyrus/tests/serde.rs
@@ -0,0 +1,372 @@
+//! Regression tests for _most_ types that implement `serde::Serialize`.
+//!
+//! For remaining types see: ./serde_opcodes.rs
+//!
+//! If you find a type defined in `rust-tapyrus` that implements `Serialize` and does _not_ have a
+//! regression test please add it.
+//!
+//! Types/tests were found using, and are ordered by, the output of: `git grep -l Serialize`.
+//!
+
+// In tests below `deserialize` is consensus deserialize while `serialize` is serde serialize, that
+// is why we have two different serialized data files for tests that use binary serialized input.
+//
+// To create a file with the expected serialized data do something like:
+//
+//  use std::fs::File;
+//  use std::io::Write;
+//  let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
+//  let got = serialize(&script).unwrap();
+//  let mut file = File::create("/tmp/script_bincode").unwrap();
+//  file.write_all(&got).unwrap();
+
+#![cfg(feature = "serde")]
+
+use std::collections::BTreeMap;
+use std::convert::TryFrom;
+use std::str::FromStr;
+
+use bincode::serialize;
+use tapyrus::bip32::{ChildNumber, KeySource, Xpriv, Xpub};
+use tapyrus::blockdata::locktime::{absolute, relative};
+use tapyrus::blockdata::witness::Witness;
+use tapyrus::consensus::encode::deserialize;
+use tapyrus::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
+use tapyrus::hex::FromHex;
+use tapyrus::psbt::raw::{self, Key, Pair, ProprietaryKey};
+use tapyrus::psbt::{Input, Output, Psbt, PsbtSighashType};
+use tapyrus::sighash::{EcdsaSighashType, TapSighashType};
+use tapyrus::taproot::{self, ControlBlock, LeafVersion, TapTree, TaprootBuilder};
+use tapyrus::{
+    ecdsa, transaction, Address, Amount, Block, Network, OutPoint, PrivateKey, PublicKey,
+    ScriptBuf, Sequence, Transaction, TxIn, TxOut, MalFixTxid,
+};
+
+/// Implicitly does regression test for `BlockHeader` also.
+#[test]
+#[ignore]
+fn serde_regression_block() {
+    let segwit = include_bytes!(
+        "data/testnet_block_000000000000045e0b1660b6445b5e5c5ab63c9a4f956be7e1e69be04fa4497b.raw"
+    );
+    let block: Block = deserialize(segwit).unwrap();
+    let got = serialize(&block).unwrap();
+    let want = include_bytes!("data/serde/block_bincode");
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_absolute_lock_time_height() {
+    let t = absolute::LockTime::from_height(741521).expect("valid height");
+    let got = serialize(&t).unwrap();
+    let want = include_bytes!("data/serde/absolute_lock_time_blocks_bincode") as &[_];
+    assert_eq!(got, want);
+}
+
+#[test]
+fn serde_regression_absolute_lock_time_time() {
+    let seconds: u32 = 1653195600; // May 22nd, 5am UTC.
+    let t = absolute::LockTime::from_time(seconds).expect("valid time");
+    let got = serialize(&t).unwrap();
+
+    let want = include_bytes!("data/serde/absolute_lock_time_seconds_bincode") as &[_];
+    assert_eq!(got, want);
+}
+
+#[test]
+fn serde_regression_relative_lock_time_height() {
+    let t = relative::LockTime::from(relative::Height::from(0xCAFE_u16));
+    let got = serialize(&t).unwrap();
+
+    let want = include_bytes!("data/serde/relative_lock_time_blocks_bincode") as &[_];
+    assert_eq!(got, want);
+}
+
+#[test]
+fn serde_regression_relative_lock_time_time() {
+    let t = relative::LockTime::from(relative::Time::from_512_second_intervals(0xFACE_u16));
+    let got = serialize(&t).unwrap();
+
+    let want = include_bytes!("data/serde/relative_lock_time_seconds_bincode") as &[_];
+    assert_eq!(got, want);
+}
+
+#[test]
+fn serde_regression_script() {
+    let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
+    let got = serialize(&script).unwrap();
+    let want = include_bytes!("data/serde/script_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_txin() {
+    let ser = include_bytes!("data/serde/txin_ser");
+    let txin: TxIn = deserialize(ser).unwrap();
+
+    let got = serialize(&txin).unwrap();
+    let want = include_bytes!("data/serde/txin_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_txout() {
+    let txout = TxOut {
+        value: Amount::from_tap(0xDEADBEEFCAFEBABE),
+        script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]),
+    };
+    let got = serialize(&txout).unwrap();
+    let want = include_bytes!("data/serde/txout_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_transaction() {
+    let ser = include_bytes!("data/serde/transaction_ser");
+    let tx: Transaction = deserialize(ser).unwrap();
+    let got = serialize(&tx).unwrap();
+    let want = include_bytes!("data/serde/transaction_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_witness() {
+    let w0 = Vec::from_hex("03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105")
+        .unwrap();
+    let w1 = Vec::from_hex("000000").unwrap();
+    let vec = vec![w0, w1];
+    let witness = Witness::from_slice(&vec);
+
+    let got = serialize(&witness).unwrap();
+    let want = include_bytes!("data/serde/witness_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_address() {
+    let s = include_str!("data/serde/public_key_hex");
+    let pk = PublicKey::from_str(s.trim()).unwrap();
+    let addr = Address::p2pkh(&pk, Network::Prod);
+
+    let got = serialize(&addr).unwrap();
+    let want = include_bytes!("data/serde/address_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_extended_priv_key() {
+    let s = include_str!("data/serde/extended_priv_key");
+    let key = Xpriv::from_str(s.trim()).unwrap();
+    let got = serialize(&key).unwrap();
+    let want = include_bytes!("data/serde/extended_priv_key_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_extended_pub_key() {
+    let s = include_str!("data/serde/extended_pub_key");
+    let key = Xpub::from_str(s.trim()).unwrap();
+    let got = serialize(&key).unwrap();
+    let want = include_bytes!("data/serde/extended_pub_key_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_ecdsa_sig() {
+    let s = include_str!("data/serde/ecdsa_sig_hex");
+    let sig = ecdsa::Signature {
+        sig: secp256k1::ecdsa::Signature::from_str(s.trim()).unwrap(),
+        hash_ty: EcdsaSighashType::All,
+    };
+
+    let got = serialize(&sig).unwrap();
+    let want = include_bytes!("data/serde/ecdsa_sig_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_control_block() {
+    let s = include_str!("data/serde/control_block_hex");
+    let block = ControlBlock::decode(&Vec::<u8>::from_hex(s.trim()).unwrap()).unwrap();
+    let got = serialize(&block).unwrap();
+
+    let want = include_bytes!("data/serde/control_block_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_child_number() {
+    let num = ChildNumber::Normal { index: 0xDEADBEEF };
+    let got = serialize(&num).unwrap();
+    let want = include_bytes!("data/serde/child_number_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_private_key() {
+    let sk = PrivateKey::from_wif("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
+    let got = serialize(&sk).unwrap();
+    let want = include_bytes!("data/serde/private_key_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_public_key() {
+    let s = include_str!("data/serde/public_key_hex");
+    let pk = PublicKey::from_str(s.trim()).unwrap();
+    let got = serialize(&pk).unwrap();
+    let want = include_bytes!("data/serde/public_key_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_psbt() {
+    let tx = Transaction {
+        version: transaction::Version::ONE,
+        lock_time: absolute::LockTime::ZERO,
+        input: vec![TxIn {
+            previous_output: OutPoint {
+                txid: "e567952fb6cc33857f392efa3a46c995a28f69cca4bb1b37e0204dab1ec7a389"
+                    .parse::<MalFixTxid>()
+                    .unwrap(),
+                vout: 1,
+            },
+            script_sig: ScriptBuf::from_hex("160014be18d152a9b012039daf3da7de4f53349eecb985")
+                .unwrap(),
+            sequence: Sequence::from_consensus(4294967295),
+            witness: Witness::from_slice(&[Vec::from_hex(
+                "03d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f2105",
+            )
+            .unwrap()]),
+        }],
+        output: vec![TxOut {
+            value: Amount::from_tap(190_303_501_938),
+            script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587")
+                .unwrap(),
+        }],
+    };
+    let unknown: BTreeMap<raw::Key, Vec<u8>> =
+        vec![(raw::Key { type_value: 9, key: vec![0, 1] }, vec![3, 4, 5])].into_iter().collect();
+    let key_source = ("deadbeef".parse().unwrap(), "m/0'/1".parse().unwrap());
+    let keypaths: BTreeMap<secp256k1::PublicKey, KeySource> = vec![(
+        "0339880dc92394b7355e3d0439fa283c31de7590812ea011c4245c0674a685e883".parse().unwrap(),
+        key_source.clone(),
+    )]
+    .into_iter()
+    .collect();
+
+    let proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>> = vec![(
+        raw::ProprietaryKey {
+            prefix: "prefx".as_bytes().to_vec(),
+            subtype: 42,
+            key: "test_key".as_bytes().to_vec(),
+        },
+        vec![5, 6, 7],
+    )]
+    .into_iter()
+    .collect();
+
+    let psbt = Psbt {
+        version: 0,
+        xpub: {
+            let s = include_str!("data/serde/extended_pub_key");
+            let xpub = Xpub::from_str(s.trim()).unwrap();
+            vec![(xpub, key_source)].into_iter().collect()
+        },
+        unsigned_tx: {
+            let mut unsigned = tx.clone();
+            unsigned.input[0].script_sig = ScriptBuf::new();
+            unsigned.input[0].witness = Witness::default();
+            unsigned
+        },
+        proprietary: proprietary.clone(),
+        unknown: unknown.clone(),
+
+        inputs: vec![Input {
+            non_witness_utxo: Some(tx),
+            witness_utxo: Some(TxOut {
+                value: Amount::from_tap(190_303_501_938),
+                script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
+            }),
+            sighash_type: Some(PsbtSighashType::from(EcdsaSighashType::from_str("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY").unwrap())),
+            redeem_script: Some(vec![0x51].into()),
+            witness_script: None,
+            partial_sigs: vec![(
+                "0339880dc92394b7355e3d0439fa283c31de7590812ea011c4245c0674a685e883".parse().unwrap(),
+                "304402204f67e2afb76142d44fae58a2495d33a3419daa26cd0db8d04f3452b63289ac0f022010762a9fb67e94cc5cad9026f6dc99ff7f070f4278d30fbc7d0c869dd38c7fe701".parse().unwrap(),
+            )].into_iter().collect(),
+            bip32_derivation: keypaths.clone().into_iter().collect(),
+            final_script_witness: Some(Witness::from_slice(&[vec![1, 3], vec![5]])),
+            ripemd160_preimages: vec![(ripemd160::Hash::hash(&[1, 2]), vec![1, 2])].into_iter().collect(),
+            sha256_preimages: vec![(sha256::Hash::hash(&[1, 2]), vec![1, 2])].into_iter().collect(),
+            hash160_preimages: vec![(hash160::Hash::hash(&[1, 2]), vec![1, 2])].into_iter().collect(),
+            hash256_preimages: vec![(sha256d::Hash::hash(&[1, 2]), vec![1, 2])].into_iter().collect(),
+            proprietary: proprietary.clone(),
+            unknown: unknown.clone(),
+            ..Default::default()
+        }],
+        outputs: vec![Output {
+            bip32_derivation: keypaths.into_iter().collect(),
+            proprietary,
+            unknown,
+            ..Default::default()
+        }],
+    };
+
+    // Sanity, check we can roundtrip BIP-174 serialize.
+    let serialized = psbt.serialize();
+    Psbt::deserialize(&serialized).unwrap();
+
+    let got = serialize(&psbt).unwrap();
+    let want = include_bytes!("data/serde/psbt_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_raw_pair() {
+    let pair = Pair {
+        key: Key { type_value: 1u8, key: vec![0u8, 1u8, 2u8, 3u8] },
+        value: vec![0u8, 1u8, 2u8, 3u8],
+    };
+    let got = serialize(&pair).unwrap();
+    let want = include_bytes!("data/serde/raw_pair_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_proprietary_key() {
+    let key = ProprietaryKey {
+        prefix: vec![0u8, 1u8, 2u8, 3u8],
+        subtype: 1u8,
+        key: vec![0u8, 1u8, 2u8, 3u8],
+    };
+    let got = serialize(&key).unwrap();
+    let want = include_bytes!("data/serde/proprietary_key_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_taproot_sig() {
+    let s = include_str!("data/serde/taproot_sig_hex");
+    let sig = taproot::Signature {
+        sig: secp256k1::schnorr::Signature::from_str(s.trim()).unwrap(),
+        hash_ty: TapSighashType::All,
+    };
+
+    let got = serialize(&sig).unwrap();
+    let want = include_bytes!("data/serde/taproot_sig_bincode") as &[_];
+    assert_eq!(got, want)
+}
+
+#[test]
+fn serde_regression_taptree() {
+    let ver = LeafVersion::from_consensus(0).unwrap();
+    let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
+    let mut builder = TaprootBuilder::new().add_leaf_with_ver(1, script.clone(), ver).unwrap();
+    builder = builder.add_leaf(1, script).unwrap();
+    let tree = TapTree::try_from(builder).unwrap();
+
+    let got = serialize(&tree).unwrap();
+    let want = include_bytes!("data/serde/taptree_bincode") as &[_];
+    assert_eq!(got, want)
+}
diff --git a/tapyrus/tests/serde_opcodes.rs b/tapyrus/tests/serde_opcodes.rs
new file mode 100644
index 00000000..c583990a
--- /dev/null
+++ b/tapyrus/tests/serde_opcodes.rs
@@ -0,0 +1,280 @@
+//! serde regression tests for blockdata::opcodes module.
+//!
+
+#![cfg(feature = "serde")]
+
+extern crate serde_json;
+extern crate tapyrus;
+
+macro_rules! test_opcodes {
+    ($($op:ident),* $(,)+) => {
+        $(
+            let op = tapyrus::blockdata::opcodes::all::$op;
+            let want = concat!("\"", stringify!($op), "\"");
+            let got = ::serde_json::to_string(&op).unwrap();
+            assert_eq!(got, want);
+        )*
+    }
+}
+
+#[test]
+fn serde_regression_opcodes() {
+    test_opcodes! {
+        OP_PUSHBYTES_0,
+        OP_PUSHBYTES_1,
+        OP_PUSHBYTES_2,
+        OP_PUSHBYTES_3,
+        OP_PUSHBYTES_4,
+        OP_PUSHBYTES_5,
+        OP_PUSHBYTES_6,
+        OP_PUSHBYTES_7,
+        OP_PUSHBYTES_8,
+        OP_PUSHBYTES_9,
+        OP_PUSHBYTES_10,
+        OP_PUSHBYTES_11,
+        OP_PUSHBYTES_12,
+        OP_PUSHBYTES_13,
+        OP_PUSHBYTES_14,
+        OP_PUSHBYTES_15,
+        OP_PUSHBYTES_16,
+        OP_PUSHBYTES_17,
+        OP_PUSHBYTES_18,
+        OP_PUSHBYTES_19,
+        OP_PUSHBYTES_20,
+        OP_PUSHBYTES_21,
+        OP_PUSHBYTES_22,
+        OP_PUSHBYTES_23,
+        OP_PUSHBYTES_24,
+        OP_PUSHBYTES_25,
+        OP_PUSHBYTES_26,
+        OP_PUSHBYTES_27,
+        OP_PUSHBYTES_28,
+        OP_PUSHBYTES_29,
+        OP_PUSHBYTES_30,
+        OP_PUSHBYTES_31,
+        OP_PUSHBYTES_32,
+        OP_PUSHBYTES_33,
+        OP_PUSHBYTES_34,
+        OP_PUSHBYTES_35,
+        OP_PUSHBYTES_36,
+        OP_PUSHBYTES_37,
+        OP_PUSHBYTES_38,
+        OP_PUSHBYTES_39,
+        OP_PUSHBYTES_40,
+        OP_PUSHBYTES_41,
+        OP_PUSHBYTES_42,
+        OP_PUSHBYTES_43,
+        OP_PUSHBYTES_44,
+        OP_PUSHBYTES_45,
+        OP_PUSHBYTES_46,
+        OP_PUSHBYTES_47,
+        OP_PUSHBYTES_48,
+        OP_PUSHBYTES_49,
+        OP_PUSHBYTES_50,
+        OP_PUSHBYTES_51,
+        OP_PUSHBYTES_52,
+        OP_PUSHBYTES_53,
+        OP_PUSHBYTES_54,
+        OP_PUSHBYTES_55,
+        OP_PUSHBYTES_56,
+        OP_PUSHBYTES_57,
+        OP_PUSHBYTES_58,
+        OP_PUSHBYTES_59,
+        OP_PUSHBYTES_60,
+        OP_PUSHBYTES_61,
+        OP_PUSHBYTES_62,
+        OP_PUSHBYTES_63,
+        OP_PUSHBYTES_64,
+        OP_PUSHBYTES_65,
+        OP_PUSHBYTES_66,
+        OP_PUSHBYTES_67,
+        OP_PUSHBYTES_68,
+        OP_PUSHBYTES_69,
+        OP_PUSHBYTES_70,
+        OP_PUSHBYTES_71,
+        OP_PUSHBYTES_72,
+        OP_PUSHBYTES_73,
+        OP_PUSHBYTES_74,
+        OP_PUSHBYTES_75,
+        OP_PUSHDATA1,
+        OP_PUSHDATA2,
+        OP_PUSHDATA4,
+        OP_PUSHNUM_NEG1,
+        OP_RESERVED,
+        OP_PUSHNUM_1,
+        OP_PUSHNUM_2,
+        OP_PUSHNUM_3,
+        OP_PUSHNUM_4,
+        OP_PUSHNUM_5,
+        OP_PUSHNUM_6,
+        OP_PUSHNUM_7,
+        OP_PUSHNUM_8,
+        OP_PUSHNUM_9,
+        OP_PUSHNUM_10,
+        OP_PUSHNUM_11,
+        OP_PUSHNUM_12,
+        OP_PUSHNUM_13,
+        OP_PUSHNUM_14,
+        OP_PUSHNUM_15,
+        OP_PUSHNUM_16,
+        OP_NOP,
+        OP_VER,
+        OP_IF,
+        OP_NOTIF,
+        OP_VERIF,
+        OP_VERNOTIF,
+        OP_ELSE,
+        OP_ENDIF,
+        OP_VERIFY,
+        OP_RETURN,
+        OP_TOALTSTACK,
+        OP_FROMALTSTACK,
+        OP_2DROP,
+        OP_2DUP,
+        OP_3DUP,
+        OP_2OVER,
+        OP_2ROT,
+        OP_2SWAP,
+        OP_IFDUP,
+        OP_DEPTH,
+        OP_DROP,
+        OP_DUP,
+        OP_NIP,
+        OP_OVER,
+        OP_PICK,
+        OP_ROLL,
+        OP_ROT,
+        OP_SWAP,
+        OP_TUCK,
+        OP_CAT,
+        OP_SUBSTR,
+        OP_LEFT,
+        OP_RIGHT,
+        OP_SIZE,
+        OP_INVERT,
+        OP_AND,
+        OP_OR,
+        OP_XOR,
+        OP_EQUAL,
+        OP_EQUALVERIFY,
+        OP_RESERVED1,
+        OP_RESERVED2,
+        OP_1ADD,
+        OP_1SUB,
+        OP_2MUL,
+        OP_2DIV,
+        OP_NEGATE,
+        OP_ABS,
+        OP_NOT,
+        OP_0NOTEQUAL,
+        OP_ADD,
+        OP_SUB,
+        OP_MUL,
+        OP_DIV,
+        OP_MOD,
+        OP_LSHIFT,
+        OP_RSHIFT,
+        OP_BOOLAND,
+        OP_BOOLOR,
+        OP_NUMEQUAL,
+        OP_NUMEQUALVERIFY,
+        OP_NUMNOTEQUAL,
+        OP_LESSTHAN ,
+        OP_GREATERTHAN ,
+        OP_LESSTHANOREQUAL ,
+        OP_GREATERTHANOREQUAL ,
+        OP_MIN,
+        OP_MAX,
+        OP_WITHIN,
+        OP_RIPEMD160,
+        OP_SHA1,
+        OP_SHA256,
+        OP_HASH160,
+        OP_HASH256,
+        OP_CODESEPARATOR,
+        OP_CHECKSIG,
+        OP_CHECKSIGVERIFY,
+        OP_CHECKMULTISIG,
+        OP_CHECKMULTISIGVERIFY,
+        OP_NOP1,
+        OP_CLTV,
+        OP_CSV,
+        OP_NOP4,
+        OP_NOP5,
+        OP_NOP6,
+        OP_NOP7,
+        OP_NOP8,
+        OP_NOP9,
+        OP_NOP10,
+        OP_CHECKSIGADD,
+        OP_RETURN_187,
+        OP_COLOR,
+        OP_RETURN_189,
+        OP_RETURN_190,
+        OP_RETURN_191,
+        OP_RETURN_192,
+        OP_RETURN_193,
+        OP_RETURN_194,
+        OP_RETURN_195,
+        OP_RETURN_196,
+        OP_RETURN_197,
+        OP_RETURN_198,
+        OP_RETURN_199,
+        OP_RETURN_200,
+        OP_RETURN_201,
+        OP_RETURN_202,
+        OP_RETURN_203,
+        OP_RETURN_204,
+        OP_RETURN_205,
+        OP_RETURN_206,
+        OP_RETURN_207,
+        OP_RETURN_208,
+        OP_RETURN_209,
+        OP_RETURN_210,
+        OP_RETURN_211,
+        OP_RETURN_212,
+        OP_RETURN_213,
+        OP_RETURN_214,
+        OP_RETURN_215,
+        OP_RETURN_216,
+        OP_RETURN_217,
+        OP_RETURN_218,
+        OP_RETURN_219,
+        OP_RETURN_220,
+        OP_RETURN_221,
+        OP_RETURN_222,
+        OP_RETURN_223,
+        OP_RETURN_224,
+        OP_RETURN_225,
+        OP_RETURN_226,
+        OP_RETURN_227,
+        OP_RETURN_228,
+        OP_RETURN_229,
+        OP_RETURN_230,
+        OP_RETURN_231,
+        OP_RETURN_232,
+        OP_RETURN_233,
+        OP_RETURN_234,
+        OP_RETURN_235,
+        OP_RETURN_236,
+        OP_RETURN_237,
+        OP_RETURN_238,
+        OP_RETURN_239,
+        OP_RETURN_240,
+        OP_RETURN_241,
+        OP_RETURN_242,
+        OP_RETURN_243,
+        OP_RETURN_244,
+        OP_RETURN_245,
+        OP_RETURN_246,
+        OP_RETURN_247,
+        OP_RETURN_248,
+        OP_RETURN_249,
+        OP_RETURN_250,
+        OP_RETURN_251,
+        OP_RETURN_252,
+        OP_RETURN_253,
+        OP_RETURN_254,
+        OP_INVALIDOPCODE,
+    }
+}