From fe10ff2eb7c68fd0e092b6c94e59d0de7229935a Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 18 Nov 2024 10:24:20 +0000
Subject: [PATCH 001/554] Mark functions `const` in `units`

Mark `checked_` functions const. Replace `map()` and `?` operators,
which are not allowed in const context, with match statements.
Use descriptive variable names in ceiling division to make
it easier to follow.
---
 units/src/amount/signed.rs   | 48 +++++++++++++++++++------
 units/src/amount/unsigned.rs | 69 ++++++++++++++++++++++++++++--------
 2 files changed, 91 insertions(+), 26 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index c98d11898e..0bcdb48964 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -217,27 +217,45 @@ impl SignedAmount {
     /// Consider using `unsigned_abs` which is often more practical.
     ///
     /// Returns [`None`] if overflow occurred. (`self == MIN`)
-    pub fn checked_abs(self) -> Option<SignedAmount> { self.0.checked_abs().map(SignedAmount) }
+    pub const fn checked_abs(self) -> Option<SignedAmount> {
+        // No `map()` in const context.
+        match self.0.checked_abs() {
+            Some(res) => Some(SignedAmount(res)),
+            None => None,
+        }
+    }
 
     /// Checked addition.
     ///
     /// Returns [`None`] if overflow occurred.
-    pub fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
-        self.0.checked_add(rhs.0).map(SignedAmount)
+    pub const fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
+        // No `map()` in const context.
+        match self.0.checked_add(rhs.0) {
+            Some(res) => Some(SignedAmount(res)),
+            None => None,
+        }
     }
 
     /// Checked subtraction.
     ///
     /// Returns [`None`] if overflow occurred.
-    pub fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
-        self.0.checked_sub(rhs.0).map(SignedAmount)
+    pub const fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
+        // No `map()` in const context.
+        match self.0.checked_sub(rhs.0) {
+            Some(res) => Some(SignedAmount(res)),
+            None => None,
+        }
     }
 
     /// Checked multiplication.
     ///
     /// Returns [`None`] if overflow occurred.
-    pub fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
-        self.0.checked_mul(rhs).map(SignedAmount)
+    pub const fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
+        // No `map()` in const context.
+        match self.0.checked_mul(rhs) {
+            Some(res) => Some(SignedAmount(res)),
+            None => None,
+        }
     }
 
     /// Checked integer division.
@@ -245,15 +263,23 @@ impl SignedAmount {
     /// 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)
+    pub const fn checked_div(self, rhs: i64) -> Option<SignedAmount> {
+        // No `map()` in const context.
+        match self.0.checked_div(rhs) {
+            Some(res) => Some(SignedAmount(res)),
+            None => None,
+        }
     }
 
     /// Checked remainder.
     ///
     /// Returns [`None`] if overflow occurred.
-    pub fn checked_rem(self, rhs: i64) -> Option<SignedAmount> {
-        self.0.checked_rem(rhs).map(SignedAmount)
+    pub const fn checked_rem(self, rhs: i64) -> Option<SignedAmount> {
+        // No `map()` in const context.
+        match self.0.checked_rem(rhs) {
+            Some(res) => Some(SignedAmount(res)),
+            None => None,
+        }
     }
 
     /// Unchecked addition.
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index cb2f49f08f..e5597269f2 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -196,28 +196,48 @@ impl Amount {
     /// Checked addition.
     ///
     /// Returns [`None`] if overflow occurred.
-    pub fn checked_add(self, rhs: Amount) -> Option<Amount> {
-        self.0.checked_add(rhs.0).map(Amount)
+    pub const fn checked_add(self, rhs: Amount) -> Option<Amount> {
+        // No `map()` in const context.
+        match self.0.checked_add(rhs.0) {
+            Some(res) => Some(Amount(res)),
+            None => None,
+        }
     }
 
     /// Checked subtraction.
     ///
     /// Returns [`None`] if overflow occurred.
-    pub fn checked_sub(self, rhs: Amount) -> Option<Amount> {
-        self.0.checked_sub(rhs.0).map(Amount)
+    pub const fn checked_sub(self, rhs: Amount) -> Option<Amount> {
+        // No `map()` in const context.
+        match self.0.checked_sub(rhs.0) {
+            Some(res) => Some(Amount(res)),
+            None => None,
+        }
     }
 
     /// Checked multiplication.
     ///
     /// Returns [`None`] if overflow occurred.
-    pub fn checked_mul(self, rhs: u64) -> Option<Amount> { self.0.checked_mul(rhs).map(Amount) }
+    pub const fn checked_mul(self, rhs: u64) -> Option<Amount> {
+        // No `map()` in const context.
+        match self.0.checked_mul(rhs) {
+            Some(res) => Some(Amount(res)),
+            None => None,
+        }
+    }
 
     /// 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) }
+    pub const fn checked_div(self, rhs: u64) -> Option<Amount> {
+        // No `map()` in const context.
+        match self.0.checked_div(rhs) {
+            Some(res) => Some(Amount(res)),
+            None => None,
+        }
+    }
 
     /// Checked weight ceiling division.
     ///
@@ -227,12 +247,19 @@ impl Amount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[cfg(feature = "alloc")]
-    pub fn checked_div_by_weight_ceil(self, rhs: Weight) -> Option<FeeRate> {
-        let sats = self.0.checked_mul(1_000)?;
+    pub const fn checked_div_by_weight_ceil(self, rhs: Weight) -> Option<FeeRate> {
         let wu = rhs.to_wu();
-
-        let fee_rate = sats.checked_add(wu.checked_sub(1)?)?.checked_div(wu)?;
-        Some(FeeRate::from_sat_per_kwu(fee_rate))
+        // No `?` operator in const context.
+        if let Some(sats) = self.0.checked_mul(1_000) {
+            if let Some(wu_minus_one) = wu.checked_sub(1) {
+                if let Some(sats_plus_wu_minus_one) = sats.checked_add(wu_minus_one) {
+                    if let Some(fee_rate) = sats_plus_wu_minus_one.checked_div(wu) {
+                        return Some(FeeRate::from_sat_per_kwu(fee_rate));
+                    }
+                }
+            }
+        }
+        None
     }
 
     /// Checked weight floor division.
@@ -242,15 +269,27 @@ impl Amount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[cfg(feature = "alloc")]
-    pub fn checked_div_by_weight_floor(self, rhs: Weight) -> Option<FeeRate> {
-        let fee_rate = self.0.checked_mul(1_000)?.checked_div(rhs.to_wu())?;
-        Some(FeeRate::from_sat_per_kwu(fee_rate))
+    pub const fn checked_div_by_weight_floor(self, rhs: Weight) -> Option<FeeRate> {
+        // No `?` operator in const context.
+        match self.0.checked_mul(1_000) {
+            Some(res) => match res.checked_div(rhs.to_wu()) {
+                Some(fee_rate) => Some(FeeRate::from_sat_per_kwu(fee_rate)),
+                None => None,
+            },
+            None => None,
+        }
     }
 
     /// Checked remainder.
     ///
     /// Returns [`None`] if overflow occurred.
-    pub fn checked_rem(self, rhs: u64) -> Option<Amount> { self.0.checked_rem(rhs).map(Amount) }
+    pub const fn checked_rem(self, rhs: u64) -> Option<Amount> {
+        // No `map()` in const context.
+        match self.0.checked_rem(rhs) {
+            Some(res) => Some(Amount(res)),
+            None => None,
+        }
+    }
 
     /// Unchecked addition.
     ///

From a8379bf0053e66cf5984ce449d19e54e529b6b70 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 18 Nov 2024 10:50:26 +0000
Subject: [PATCH 002/554] Mark `checked_` functions const in bitcoin.

Replace `?` operators, which are not allowed in const context, with
match statements.
---
 bitcoin/src/psbt/mod.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index c9eac7165b..5adc816540 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -627,8 +627,11 @@ impl Psbt {
 
     /// 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])
+        // No `?` operator in const context.
+        match self.check_index_is_within_bounds(input_index) {
+            Ok(_) => Ok(&self.inputs[input_index]),
+            Err(e) => Err(e),
+        }
     }
 
     /// Checks `input_index` is within bounds for the PSBT `inputs` array and

From 434e131660e82e06efd97981c1d975c04de2d010 Mon Sep 17 00:00:00 2001
From: LLFourn <lloyd.fourn@gmail.com>
Date: Tue, 19 Nov 2024 15:32:30 +1100
Subject: [PATCH 003/554] Fix documentation of Xpub::identifier

---
 bitcoin/src/bip32.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 8f11e67b83..34d93833a8 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -880,7 +880,7 @@ impl Xpub {
         ret
     }
 
-    /// Returns the HASH160 of the chaincode
+    /// Returns the HASH160 of the public key component of the xpub
     pub fn identifier(&self) -> XKeyIdentifier {
         XKeyIdentifier(hash160::Hash::hash(&self.public_key.serialize()))
     }

From a0c79735c79ab067f2518ecae1c533e75d194ab0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=20=5Ctimes=203=20=F0=9F=97=BF?= <sonkaos999@gmail.com>
Date: Tue, 19 Nov 2024 10:08:06 +0100
Subject: [PATCH 004/554] README: Fix Kani badge and update `no-std` details

---
 README.md | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index a841d5122e..bf66bc65fc 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@
     <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/2021/11/01/Rust-1.63.0.html"><img alt="Rustc Version 1.63.0+" src="https://img.shields.io/badge/rustc-1.63.0%2B-lightgrey.svg"/></a>
     <a href="https://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>
+    <a href="https://github.com/model-checking/kani"><img alt="kani" src="https://github.com/rust-bitcoin/rust-bitcoin/workflows/Kani%20CI/badge.svg"></a>
   </p>
 </div>
 
@@ -49,7 +49,7 @@ are no plans to do so. Of course, patches to fix specific consensus incompatibil
 
 ### 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
+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.
 
 ### Semver compliance
@@ -103,13 +103,6 @@ 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/):
 
 ```
@@ -127,6 +120,15 @@ cargo test
 Please refer to the [`cargo` documentation](https://doc.rust-lang.org/stable/cargo/) for more
 detailed instructions.
 
+### No-std support
+
+The `std` cargo feature is enabled by default. To build this project without the Rust standard
+library, use the `--no-default-features` flag or set `default-features = false` in your dependency
+declaration when adding it to your project.
+
+For embedded device examples, see [`bitcoin/embedded`](https://github.com/rust-bitcoin/rust-bitcoin/tree/master/bitcoin/embedded)
+or [`hashes/embedded`](https://github.com/rust-bitcoin/rust-bitcoin/tree/master/hashes/embedded).
+
 ### Just
 
 We support [`just`](https://just.systems/man/en/) for running dev workflow commands. Run `just` from

From e4cf8ebc208068ef2888e6e9e6f27f12cd07570f Mon Sep 17 00:00:00 2001
From: Max Fang <protonmail.com@maxfa.ng>
Date: Mon, 18 Nov 2024 17:46:35 -0800
Subject: [PATCH 005/554] address: Add `Address::into_unchecked`

Adds an ergonomic way to convert any `Address` (network can be checked
or unchecked) into an `Address<NetworkUnchecked>` without cloning, which
I've found useful in several contexts.
---
 bitcoin/src/address/mod.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index c7053f6674..cc948ad1e0 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -383,6 +383,9 @@ impl<V: NetworkValidation> Address<V> {
     pub fn as_unchecked(&self) -> &Address<NetworkUnchecked> {
         unsafe { &*(self as *const Address<V> as *const Address<NetworkUnchecked>) }
     }
+
+    /// Marks the network of this address as unchecked.
+    pub fn into_unchecked(self) -> Address<NetworkUnchecked> { Address(self.0, PhantomData) }
 }
 
 /// Methods and functions that can be called only on `Address<NetworkChecked>`.

From 073ff81536e7a24883d6470ecf3054f4b7263186 Mon Sep 17 00:00:00 2001
From: Max Fang <protonmail.com@maxfa.ng>
Date: Mon, 18 Nov 2024 17:52:11 -0800
Subject: [PATCH 006/554] address: Simplify `Address::assume_checked` impl

Removes an unnecessary `match`.
---
 bitcoin/src/address/mod.rs | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index cc948ad1e0..1169e631a8 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -795,16 +795,7 @@ impl Address<NetworkUnchecked> {
     /// For details about this mechanism, see section [*Parsing addresses*](Address#parsing-addresses)
     /// on [`Address`].
     #[inline]
-    pub fn assume_checked(self) -> Address {
-        use AddressInner::*;
-
-        let inner = match self.0 {
-            P2pkh { hash, network } => P2pkh { hash, network },
-            P2sh { hash, network } => P2sh { hash, network },
-            Segwit { program, hrp } => Segwit { program, hrp },
-        };
-        Address(inner, PhantomData)
-    }
+    pub fn assume_checked(self) -> Address { Address(self.0, PhantomData) }
 
     /// Parse a bech32 Address string
     pub fn from_bech32_str(s: &str) -> Result<Address<NetworkUnchecked>, Bech32Error> {

From 571ba0c77c84de47180103557a58bce63c12e73a Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Thu, 21 Nov 2024 01:52:28 +0000
Subject: [PATCH 007/554] Automated update to Github CI to rustc
 nightly-2024-11-20

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 403284ecea..b5c32f9dde 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2024-11-17
+nightly-2024-11-20

From 17ca5018ebb28d5d392d61aee62170fb3e4f2a5b Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 22 Nov 2024 10:42:17 +1100
Subject: [PATCH 008/554] units: Comment alloc feature

Add a comment to the `serde` module about why we have all the `alloc`
feature gating.

Done as part of #3556 - auditing the whole crate for use of `alloc`
feature.
---
 units/src/amount/serde.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index 038b530ef9..a485994b71 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -24,7 +24,7 @@ use core::fmt;
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-#[cfg(feature = "alloc")]
+#[cfg(feature = "alloc")] // This is because `to_float_in` uses `to_string`.
 use super::Denomination;
 use super::{Amount, ParseAmountError, SignedAmount};
 

From 3002a3c2f24e23b33a7f4a7cfc9bdca5027f1063 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Mon, 25 Nov 2024 01:55:40 +0000
Subject: [PATCH 009/554] Automated update to Github CI to rustc
 nightly-2024-11-22

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index b5c32f9dde..c3f22bff65 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2024-11-20
+nightly-2024-11-22

From 7b8369f381c3f3fc15ed536d5316e86e02914b4e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 19 Nov 2024 11:12:23 +1100
Subject: [PATCH 010/554] units: Add integration test of API surface

In an effort to check off items in the Rust API guidelines
checklist (#3632) add an integration test file that tests:

- The location of re-exports for various typical usage styles.
- Regressions in the API surface (things being accidentally moved).
- All public types implement Debug (C-DEBUG).
- For all non-error types:
    - `Debug` representation is never empty (C-DEBUG-NONEMPTY)
- For all error types:
    - Derive standard traits as defined by `rust-bitcoin` policy.

I used the `cargo check-api` script we have laying around from ages
ago (#2986) to parse `units` and get a list of the public types.
---
 units/tests/api.rs | 217 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 217 insertions(+)
 create mode 100644 units/tests/api.rs

diff --git a/units/tests/api.rs b/units/tests/api.rs
new file mode 100644
index 0000000000..c69e20bb5c
--- /dev/null
+++ b/units/tests/api.rs
@@ -0,0 +1,217 @@
+//! Test the API surface of `units`.
+//!
+//! The point of these tests are to check the API surface as opposed to test the API functionality.
+//!
+//! What this module tests:
+//!
+//! - The location of re-exports for various typical usage styles.
+//! - Regressions in the API surface (things being accidentally moved).
+//! - All public types implement Debug (C-DEBUG).
+//! - For all non-error types:
+//!     - `Debug` representation is never empty (C-DEBUG-NONEMPTY)
+//! - For all error types:
+//!     - Derive standard traits as defined by `rust-bitcoin` policy.
+//!
+//! This file was created by referring to the output of `cargo check-api`.
+//!
+//! ref: <https://rust-lang.github.io/api-guidelines/about.html>
+
+#![allow(dead_code)]
+#![allow(unused_imports)]
+
+// These imports test "typical" usage by user code.
+use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::Height`.
+use bitcoin_units::{
+    amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, FeeRate,
+    SignedAmount, Weight,
+};
+
+/// A struct that includes all public non-error enums.
+#[derive(Debug)] // All public types implement Debug (C-DEBUG).
+struct Enums {
+    a: amount::Denomination,
+}
+
+impl Enums {
+    fn new() -> Self { Self { a: amount::Denomination::Bitcoin } }
+}
+
+/// A struct that includes all public non-error structs.
+#[derive(Debug)] // All public types implement Debug (C-DEBUG).
+struct Structs {
+    a: Amount,
+    b: amount::Display,
+    c: SignedAmount,
+    d: BlockHeight,
+    e: BlockInterval,
+    f: FeeRate,
+    g: absolute::Height,
+    h: absolute::Time,
+    i: relative::Height,
+    j: relative::Time,
+    k: Weight,
+}
+
+impl Structs {
+    fn max() -> Self {
+        Self {
+            a: Amount::MAX,
+            b: Amount::MAX.display_in(amount::Denomination::Bitcoin),
+            c: SignedAmount::MAX,
+            d: BlockHeight::MAX,
+            e: BlockInterval::MAX,
+            f: FeeRate::MAX,
+            g: absolute::Height::MAX,
+            h: absolute::Time::MAX,
+            i: relative::Height::MAX,
+            j: relative::Time::MAX,
+            k: Weight::MAX,
+        }
+    }
+}
+
+/// A struct that includes all public non-error types.
+#[derive(Debug)] // All public types implement Debug (C-DEBUG).
+struct Types {
+    a: Enums,
+    b: Structs,
+}
+
+impl Types {
+    fn new() -> Self { Self { a: Enums::new(), b: Structs::max() } }
+}
+
+/// A struct that includes all public error types.
+// These derives are the policy of `rust-bitcoin` not Rust API guidelines.
+#[derive(Debug, Clone, PartialEq, Eq)] // All public types implement Debug (C-DEBUG).
+struct Errors {
+    a: amount::InputTooLargeError,
+    b: amount::InvalidCharacterError,
+    c: amount::MissingDenominationError,
+    d: amount::MissingDigitsError,
+    e: amount::OutOfRangeError,
+    f: amount::ParseAmountError,
+    g: amount::ParseDenominationError,
+    h: amount::ParseError,
+    i: amount::PossiblyConfusingDenominationError,
+    j: amount::TooPreciseError,
+    k: amount::UnknownDenominationError,
+    l: amount::error::InputTooLargeError,
+    m: amount::error::InvalidCharacterError,
+    n: amount::error::MissingDenominationError,
+    o: amount::error::MissingDigitsError,
+    p: amount::error::OutOfRangeError,
+    q: amount::error::ParseAmountError,
+    r: amount::error::ParseDenominationError,
+    s: amount::error::ParseError,
+    t: amount::error::PossiblyConfusingDenominationError,
+    u: amount::error::TooPreciseError,
+    v: amount::error::UnknownDenominationError,
+    w: block::TooBigForRelativeBlockHeightError,
+    x: locktime::absolute::ConversionError,
+    y: locktime::absolute::Height,
+    z: locktime::absolute::ParseHeightError,
+    _a: locktime::absolute::ParseTimeError,
+    _b: locktime::relative::TimeOverflowError,
+    _c: parse::ContainsPrefixError,
+    _d: parse::MissingPrefixError,
+    _e: parse::ParseIntError,
+    _f: parse::PrefixedHexError,
+    _g: parse::UnprefixedHexError,
+}
+
+#[test]
+fn api_can_use_modules_from_crate_root() {
+    use bitcoin_units::{amount, block, fee_rate, locktime, parse, weight};
+}
+
+#[test]
+fn api_can_use_types_from_crate_root() {
+    use bitcoin_units::{Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Weight};
+}
+
+#[test]
+fn api_can_use_all_types_from_module_amount() {
+    use bitcoin_units::amount::{
+        Amount, Denomination, Display, InputTooLargeError, InvalidCharacterError,
+        MissingDenominationError, MissingDigitsError, OutOfRangeError, ParseAmountError,
+        ParseDenominationError, ParseError, PossiblyConfusingDenominationError, SignedAmount,
+        TooPreciseError, UnknownDenominationError,
+    };
+}
+
+#[test]
+fn api_can_use_all_types_from_module_amount_error() {
+    use bitcoin_units::amount::error::{
+        InputTooLargeError, InvalidCharacterError, MissingDenominationError, MissingDigitsError,
+        OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError,
+        PossiblyConfusingDenominationError, TooPreciseError, UnknownDenominationError,
+    };
+}
+
+#[test]
+fn api_can_use_all_types_from_module_block() {
+    use bitcoin_units::block::{BlockHeight, BlockInterval, TooBigForRelativeBlockHeightError};
+}
+
+#[test]
+fn api_can_use_all_types_from_module_fee_rate() {
+    use bitcoin_units::fee_rate::FeeRate;
+}
+
+#[test]
+fn api_can_use_all_types_from_module_locktime_absolute() {
+    use bitcoin_units::locktime::absolute::{
+        ConversionError, Height, ParseHeightError, ParseTimeError, Time,
+    };
+}
+
+#[test]
+fn api_can_use_all_types_from_module_locktime_relative() {
+    use bitcoin_units::locktime::relative::{Height, Time, TimeOverflowError};
+}
+
+#[test]
+fn api_can_use_all_types_from_module_parse() {
+    use bitcoin_units::parse::{
+        ContainsPrefixError, MissingPrefixError, ParseIntError, PrefixedHexError,
+        UnprefixedHexError,
+    };
+}
+
+#[test]
+fn api_can_use_all_types_from_module_weight() {
+    use bitcoin_units::weight::Weight;
+}
+
+// `Debug` representation is never empty (C-DEBUG-NONEMPTY).
+#[test]
+fn api_all_non_error_types_have_non_empty_debug() {
+    let t = Types::new();
+
+    let debug = format!("{:?}", t.a.a);
+    assert!(!debug.is_empty());
+
+    let debug = format!("{:?}", t.b.a);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.b);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.c);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.d);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.e);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.f);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.g);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.h);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.i);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.j);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.k);
+    assert!(!debug.is_empty());
+}

From cc4c36e8ac8ae5ed701d524cfe6cdc32451f4884 Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Mon, 25 Nov 2024 11:06:45 -0600
Subject: [PATCH 011/554] Deprecate weight

The name weight is misleading since it is actually only the segwit parts
of the weight calculation
---
 bitcoin/src/blockdata/transaction.rs | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 0dd69f1c7c..b8526d0724 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -863,7 +863,7 @@ where
         |(count, partial_input_weight, inputs_with_witnesses), prediction| {
             (
                 count + 1,
-                partial_input_weight + prediction.weight().to_wu() as usize,
+                partial_input_weight + prediction.witness_weight().to_wu() as usize,
                 inputs_with_witnesses + (prediction.witness_size > 0) as usize,
             )
         },
@@ -937,7 +937,7 @@ pub const fn predict_weight_from_slices(
     let mut i = 0;
     while i < inputs.len() {
         let prediction = inputs[i];
-        partial_input_weight += prediction.weight().to_wu() as usize;
+        partial_input_weight += prediction.witness_weight().to_wu() as usize;
         inputs_with_witnesses += (prediction.witness_size > 0) as usize;
         i += 1;
     }
@@ -1142,7 +1142,16 @@ impl InputWeightPrediction {
 
     /// Computes the **signature weight** added to a transaction by an input with this weight prediction,
     /// not counting the prevout (txid, index), sequence, potential witness flag bytes or the witness count varint.
+    #[deprecated(since = "TBD", note = "use `InputWeightPrediction::witness_weight()` instead")]
     pub const fn weight(&self) -> Weight {
+        Self::witness_weight(self)
+    }
+
+    /// Computes the **signature weight** added to a transaction by an input with this weight prediction,
+    /// not counting the prevout (txid, index), sequence, potential witness flag bytes or the witness count varint.
+    ///
+    /// See also [`InputWeightPrediction::total_weight`]
+    pub const fn witness_weight(&self) -> Weight {
         Weight::from_wu_usize(self.script_size * 4 + self.witness_size)
     }
 }
@@ -1941,16 +1950,16 @@ mod tests {
 
         // Confirm signature grinding input weight predictions are aligned with constants.
         assert_eq!(
-            InputWeightPrediction::ground_p2wpkh(0).weight(),
-            InputWeightPrediction::P2WPKH_MAX.weight()
+            InputWeightPrediction::ground_p2wpkh(0).witness_weight(),
+            InputWeightPrediction::P2WPKH_MAX.witness_weight()
         );
         assert_eq!(
-            InputWeightPrediction::ground_nested_p2wpkh(0).weight(),
-            InputWeightPrediction::NESTED_P2WPKH_MAX.weight()
+            InputWeightPrediction::ground_nested_p2wpkh(0).witness_weight(),
+            InputWeightPrediction::NESTED_P2WPKH_MAX.witness_weight()
         );
         assert_eq!(
-            InputWeightPrediction::ground_p2pkh_compressed(0).weight(),
-            InputWeightPrediction::P2PKH_COMPRESSED_MAX.weight()
+            InputWeightPrediction::ground_p2pkh_compressed(0).witness_weight(),
+            InputWeightPrediction::P2PKH_COMPRESSED_MAX.witness_weight()
         );
     }
 

From d9ccb60a2f9e89c8bb1979f032e8a222ab9b025a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 26 Nov 2024 10:06:58 +1100
Subject: [PATCH 012/554] Fix typo in hash tag type

In commit: `39f7dcb Reduce API surface of tagged wrapped hash types` I
introduced a typo in the tagged hash tag type. Fortunately it has no
effect because the tag type controls how an engine  is created (when the
tag is input into the engine) and has no effect on the call to
`from_engine`. However the typo makes the code confusing.

This bug is currently unreleased.

Fix: #3649
---
 bitcoin/src/taproot/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index b8bd003423..dbcb65193a 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -68,7 +68,7 @@ crate::internal_macros::define_extension_trait! {
             let mut eng = sha256t::Hash::<TapLeafTag>::engine();
             ver.to_consensus().consensus_encode(&mut eng).expect("engines don't error");
             script.consensus_encode(&mut eng).expect("engines don't error");
-            let inner = sha256t::Hash::<TapTweakTag>::from_engine(eng);
+            let inner = sha256t::Hash::<TapLeafTag>::from_engine(eng);
             TapLeafHash::from_byte_array(inner.to_byte_array())
         }
     }

From f9ab3aea8abb0bf17d0a03be29d510049a85d0a9 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 26 Nov 2024 10:13:19 +1100
Subject: [PATCH 013/554] Re-export bech32 crate

`rust-bitcoin` is a lot further from 1.0 than `bech32` is. We previously
removed the re-export of `bech32` because we thought it might hold us up
releasing `rust-bitcoin 1.0` but in hindsite this was incorrect.

Having a public re-export of dependencies helps users keep their deps in
sync with those in `rust-bitcoin` and is thus useful.

Close: #3650
---
 bitcoin/src/lib.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index 7a73dc2243..9727d4db87 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -68,6 +68,9 @@ pub extern crate base64;
 /// Bitcoin base58 encoding and decoding.
 pub extern crate base58;
 
+/// Re-export the `bech32` crate.
+pub extern crate bech32;
+
 /// Rust implementation of cryptographic hash function algorithms.
 pub extern crate hashes;
 

From 261c8d8ae659d98fd3f63228f16d8f2eb4010b7e Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Mon, 25 Nov 2024 11:07:24 -0600
Subject: [PATCH 014/554] Add total_weight to Input Weight Prediction

---
 bitcoin/src/blockdata/transaction.rs | 33 ++++++++++++++--------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index b8526d0724..0ed381ef4a 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -851,19 +851,13 @@ 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(
+    // sum input_weights, input_count and count of inputs with witness data
+    let (input_count, input_weight, inputs_with_witnesses) = inputs.into_iter().fold(
         (0, 0, 0),
-        |(count, partial_input_weight, inputs_with_witnesses), prediction| {
+        |(count, input_weight, inputs_with_witnesses), prediction| {
             (
                 count + 1,
-                partial_input_weight + prediction.witness_weight().to_wu() as usize,
+                input_weight + prediction.total_weight().to_wu() as usize,
                 inputs_with_witnesses + (prediction.witness_size > 0) as usize,
             )
         },
@@ -882,7 +876,7 @@ where
     );
     predict_weight_internal(
         input_count,
-        partial_input_weight,
+        input_weight,
         inputs_with_witnesses,
         output_count,
         output_scripts_size,
@@ -891,15 +885,11 @@ where
 
 const fn predict_weight_internal(
     input_count: usize,
-    partial_input_weight: usize,
+    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 =
@@ -1147,6 +1137,17 @@ impl InputWeightPrediction {
         Self::witness_weight(self)
     }
 
+    /// Computes the signature, prevout (txid, index), and sequence weights of this weight
+    /// prediction.
+    ///
+    /// See also [`InputWeightPrediction::witness_weight`]
+    pub const fn total_weight(&self) -> Weight {
+        // `impl const Trait` is currently unavailable: rust/issues/67792
+        // Convert to u64s because we can't use `Add` in const context.
+        let weight = TX_IN_BASE_WEIGHT.to_wu() + Self::witness_weight(self).to_wu();
+        Weight::from_wu(weight)
+    }
+
     /// Computes the **signature weight** added to a transaction by an input with this weight prediction,
     /// not counting the prevout (txid, index), sequence, potential witness flag bytes or the witness count varint.
     ///

From 335203289201b2e34cb57a6a107547f946475109 Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Tue, 26 Nov 2024 14:29:38 -0600
Subject: [PATCH 015/554] Fix internal weight calculation

This function calls helper function predict_weight_internal and that
function was refactored.  The refactor changed the interface to accept
the input_weight instead of partial input_weight, however this function
was not updated with the refactor and was still passing a partial input
weight.  This commit is a followup that fixes the internal calculation
error by pass input_weight instead of partial_weight to the helper
function predict_weight_internal.
---
 bitcoin/src/blockdata/transaction.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 0ed381ef4a..9e2038096d 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -920,14 +920,14 @@ pub const fn predict_weight_from_slices(
     inputs: &[InputWeightPrediction],
     output_script_lens: &[usize],
 ) -> Weight {
-    let mut partial_input_weight = 0;
+    let mut 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.witness_weight().to_wu() as usize;
+        input_weight += prediction.total_weight().to_wu() as usize;
         inputs_with_witnesses += (prediction.witness_size > 0) as usize;
         i += 1;
     }
@@ -943,7 +943,7 @@ pub const fn predict_weight_from_slices(
 
     predict_weight_internal(
         inputs.len(),
-        partial_input_weight,
+        input_weight,
         inputs_with_witnesses,
         output_script_lens.len(),
         output_scripts_size,

From f961f3c0eca4e9b175761756f48699012b63d70a Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Tue, 26 Nov 2024 14:55:49 -0600
Subject: [PATCH 016/554] Add test

Test that behavior of this function as it interacts with predict_weight_internal
---
 bitcoin/src/blockdata/transaction.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 9e2038096d..137110f4f9 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -1964,6 +1964,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn weight_prediction_const_from_slices() {
+        let predict = [
+            InputWeightPrediction::P2WPKH_MAX,
+            InputWeightPrediction::NESTED_P2WPKH_MAX,
+            InputWeightPrediction::P2PKH_COMPRESSED_MAX,
+            InputWeightPrediction::P2PKH_UNCOMPRESSED_MAX,
+            InputWeightPrediction::P2TR_KEY_DEFAULT_SIGHASH,
+            InputWeightPrediction::P2TR_KEY_NON_DEFAULT_SIGHASH
+        ];
+
+        let weight = predict_weight_from_slices(&predict, &[1]);
+        assert_eq!(weight, Weight::from_wu(2493));
+    }
+
     #[test]
     fn sequence_debug_output() {
         let seq = Sequence::from_seconds_floor(1000);

From 7e17eaf21c479338d5161b493f02578ef4186e62 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 26 Nov 2024 12:08:25 +1100
Subject: [PATCH 017/554] units: Add stringy regression tests

Add regression tests for `Display` and `FromStr` impls.

Exclude error types and helper types (`amount::Display`).
---
 units/tests/str.rs | 49 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 units/tests/str.rs

diff --git a/units/tests/str.rs b/units/tests/str.rs
new file mode 100644
index 0000000000..89068bf9b3
--- /dev/null
+++ b/units/tests/str.rs
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Do basic regression tests on the `Display` and `FromStr` impls.
+
+use bitcoin_units::locktime::{absolute, relative};
+use bitcoin_units::{Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Weight};
+
+macro_rules! check {
+    ($($test_name:ident, $ty:path, $val:path, $str:literal);* $(;)?) => {
+        $(
+            #[test]
+            fn $test_name() {
+                let got = format!("{}", $val);
+                assert_eq!(got, $str);
+
+                let got = $str.parse::<$ty>().unwrap();
+                assert_eq!(got, $val)
+            }
+        )*
+    }
+}
+
+check! {
+    amount_unsigned_one_sat, Amount, Amount::ONE_SAT, "0.00000001 BTC";
+    amount_unsigned_max_money, Amount, Amount::MAX_MONEY, "21000000 BTC";
+
+    amount_signed_one_sat, SignedAmount, SignedAmount::ONE_SAT, "0.00000001 BTC";
+    amount_signed_max_money, SignedAmount, SignedAmount::MAX_MONEY, "21000000 BTC";
+
+    block_height_min, BlockHeight, BlockHeight::MIN, "0";
+    block_height_max, BlockHeight, BlockHeight::MAX, "4294967295";
+
+    block_interval_min, BlockInterval, BlockInterval::MIN, "0";
+    block_interval_max, BlockInterval, BlockInterval::MAX, "4294967295";
+
+    fee_rate_min, FeeRate, FeeRate::MIN, "0";
+    fee_rate_max, FeeRate, FeeRate::MAX, "18446744073709551615";
+    fee_rate_dust, FeeRate, FeeRate::DUST, "750";
+
+    lock_time_absolute_min, absolute::Height, absolute::Height::MIN, "0";
+    lock_time_absolute_max, absolute::Height, absolute::Height::MAX, "499999999";
+
+    lock_time_relative_min, relative::Height, relative::Height::MIN, "0";
+    lock_time_relative_max, relative::Height, relative::Height::MAX, "65535";
+
+    weight_min, Weight, Weight::MIN, "0";
+    weight_max, Weight, Weight::MAX, "18446744073709551615";
+    weight_max_block, Weight, Weight::MAX_BLOCK, "4000000";
+}

From 9aebb96fb99e8e9e019663659c6eff851a62f2ce Mon Sep 17 00:00:00 2001
From: Sanket Kanjalkar <sanketk@squareup.com>
Date: Tue, 26 Nov 2024 21:35:14 -0800
Subject: [PATCH 018/554] Fix psbt fuzz crash

Fixes: https://github.com/rust-bitcoin/rust-bitcoin/issues/3628

This occurs when combining two PSBTs with different xpub key sources. Added a length check before indexing into slices to prevent out-of-bounds access.
---
 bitcoin/src/psbt/mod.rs           | 15 +++++++++++++--
 bitcoin/tests/data/psbt_fuzz1.hex |  1 +
 bitcoin/tests/data/psbt_fuzz2.hex |  1 +
 3 files changed, 15 insertions(+), 2 deletions(-)
 create mode 100644 bitcoin/tests/data/psbt_fuzz1.hex
 create mode 100644 bitcoin/tests/data/psbt_fuzz2.hex

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index c9eac7165b..bfbb2853d0 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -255,8 +255,9 @@ impl Psbt {
                                 == derivation2[derivation2.len() - derivation1.len()..])
                     {
                         continue;
-                    } else if derivation2[..]
-                        == derivation1[derivation1.len() - derivation2.len()..]
+                    } else if derivation2.len() <= derivation1.len()
+                        && derivation2[..]
+                                == derivation1[derivation1.len() - derivation2.len()..]
                     {
                         entry.insert((fingerprint1, derivation1));
                         continue;
@@ -2113,6 +2114,16 @@ mod tests {
         assert_eq!(psbt1, psbt2);
     }
 
+
+    // https://github.com/rust-bitcoin/rust-bitcoin/issues/3628
+    #[test]
+    fn test_combine_psbt_fuzz_3628() {
+        let mut psbt1 = hex_psbt(include_str!("../../tests/data/psbt_fuzz1.hex")).unwrap();
+        let psbt2 = hex_psbt(include_str!("../../tests/data/psbt_fuzz2.hex")).unwrap();
+
+        assert!(matches!(psbt1.combine(psbt2).unwrap_err(), Error::CombineInconsistentKeySources(_)));
+    }
+
     #[cfg(feature = "rand-std")]
     fn gen_keys() -> (PrivateKey, PublicKey, Secp256k1<All>) {
         use secp256k1::rand::thread_rng;
diff --git a/bitcoin/tests/data/psbt_fuzz1.hex b/bitcoin/tests/data/psbt_fuzz1.hex
new file mode 100644
index 0000000000..dd3c9b7ed9
--- /dev/null
+++ b/bitcoin/tests/data/psbt_fuzz1.hex
@@ -0,0 +1 @@
+70736274ff01000a000000ff0000000074ff4f010488b21eff02000001004a92244992244902030203030303030303030303030303030303030303030303030303030303030303f4000000000000000a000208ffffffff08080804000000000000000c080808000b0000000000010000
\ No newline at end of file
diff --git a/bitcoin/tests/data/psbt_fuzz2.hex b/bitcoin/tests/data/psbt_fuzz2.hex
new file mode 100644
index 0000000000..8a33cf01c8
--- /dev/null
+++ b/bitcoin/tests/data/psbt_fuzz2.hex
@@ -0,0 +1 @@
+70736274ff01000a000000ff0000000074ff4f010488b21eff02000001004a92244992244902030203030303030303030303030303030303030303030303030303030303030303f4000000000000000a000208ffffffff080808040000000000000008000000000000001000
\ No newline at end of file

From 5e47c4123d5cdd768d7f8523ce81e1b2069edaae Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Wed, 27 Nov 2024 07:34:47 -0600
Subject: [PATCH 019/554] Update CompactTarget::from_next_work_required to take
 timespan as i64

Bitcoin Core's consensus rules allow this timespan interval to be
negative. This commit also updates Params::pow_target_timespan to be a
u32. This field is almost compared to u64 and i64s, so changing this to
a u32 will allow users to use `.into()` for converstions
---
 bitcoin/src/network/params.rs |  4 ++--
 bitcoin/src/pow.rs            | 33 +++++++++++++++++++++++----------
 2 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/bitcoin/src/network/params.rs b/bitcoin/src/network/params.rs
index eecc42cb86..e322009be9 100644
--- a/bitcoin/src/network/params.rs
+++ b/bitcoin/src/network/params.rs
@@ -113,7 +113,7 @@ pub struct Params {
     /// Expected amount of time to mine one block.
     pub pow_target_spacing: u64,
     /// Difficulty recalculation interval.
-    pub pow_target_timespan: u64,
+    pub pow_target_timespan: u32,
     /// 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.
@@ -261,7 +261,7 @@ impl Params {
 
     /// Calculates the number of blocks between difficulty adjustments.
     pub fn difficulty_adjustment_interval(&self) -> u64 {
-        self.pow_target_timespan / self.pow_target_spacing
+        u64::from(self.pow_target_timespan) / self.pow_target_spacing
     }
 }
 
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index 7566e73b2f..243da4a3c2 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -371,12 +371,14 @@ define_extension_trait! {
         /// Take the example of the first difficulty adjustment. Block 2016 introduces a new [`CompactTarget`],
         /// which takes the net timespan between Block 2015 and Block 0, and recomputes the difficulty.
         ///
+        /// To calculate the timespan, users should first convert their u32 timestamps to i64s before subtracting them
+        ///
         /// # Returns
         ///
         /// The expected [`CompactTarget`] recalculation.
         fn from_next_work_required(
             last: CompactTarget,
-            timespan: u64,
+            timespan: i64,
             params: impl AsRef<Params>,
         ) -> CompactTarget {
             let params = params.as_ref();
@@ -387,11 +389,11 @@ define_extension_trait! {
             // ref: <https://github.com/bitcoin/bitcoin/blob/0503cbea9aab47ec0a87d34611e5453158727169/src/pow.cpp>
             let min_timespan = params.pow_target_timespan >> 2; // Lines 56/57
             let max_timespan = params.pow_target_timespan << 2; // Lines 58/59
-            let actual_timespan = timespan.clamp(min_timespan, max_timespan);
+            let actual_timespan = timespan.clamp(min_timespan.into(), max_timespan.into());
             let prev_target: Target = last.into();
             let maximum_retarget = prev_target.max_transition_threshold(params); // bnPowLimit
             let retarget = prev_target.0; // bnNew
-            let retarget = retarget.mul(actual_timespan.into());
+            let retarget = retarget.mul(u128::try_from(actual_timespan).expect("clamped value won't be negative").into());
             let retarget = retarget.div(params.pow_target_timespan.into());
             let retarget = Target(retarget);
             if retarget.ge(&maximum_retarget) {
@@ -1750,8 +1752,8 @@ mod tests {
     fn compact_target_from_upwards_difficulty_adjustment() {
         let params = Params::new(crate::Network::Signet);
         let starting_bits = CompactTarget::from_consensus(503543726); // Genesis compact target on Signet
-        let start_time: u64 = 1598918400; // Genesis block unix time
-        let end_time: u64 = 1599332177; // Block 2015 unix time
+        let start_time: i64 = 1598918400; // Genesis block unix time
+        let end_time: i64 = 1599332177; // Block 2015 unix time
         let timespan = end_time - start_time; // Faster than expected
         let adjustment = CompactTarget::from_next_work_required(starting_bits, timespan, &params);
         let adjustment_bits = CompactTarget::from_consensus(503394215); // Block 2016 compact target
@@ -1762,8 +1764,8 @@ mod tests {
     fn compact_target_from_downwards_difficulty_adjustment() {
         let params = Params::new(crate::Network::Signet);
         let starting_bits = CompactTarget::from_consensus(503394215); // Block 2016 compact target
-        let start_time: u64 = 1599332844; // Block 2016 unix time
-        let end_time: u64 = 1600591200; // Block 4031 unix time
+        let start_time: i64 = 1599332844; // Block 2016 unix time
+        let end_time: i64 = 1600591200; // Block 4031 unix time
         let timespan = end_time - start_time; // Slower than expected
         let adjustment = CompactTarget::from_next_work_required(starting_bits, timespan, &params);
         let adjustment_bits = CompactTarget::from_consensus(503397348); // Block 4032 compact target
@@ -1829,7 +1831,18 @@ mod tests {
     fn compact_target_from_maximum_upward_difficulty_adjustment() {
         let params = Params::new(crate::Network::Signet);
         let starting_bits = CompactTarget::from_consensus(503403001);
-        let timespan = (0.2 * params.pow_target_timespan as f64) as u64;
+        let timespan = params.pow_target_timespan / 5;
+        let got = CompactTarget::from_next_work_required(starting_bits, timespan.into(), params);
+        let want =
+            Target::from_compact(starting_bits).min_transition_threshold().to_compact_lossy();
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn compact_target_from_maximum_upward_difficulty_adjustment_with_negative_timespan() {
+        let params = Params::new(crate::Network::Signet);
+        let starting_bits = CompactTarget::from_consensus(503403001);
+        let timespan: i64 = -i64::from(params.pow_target_timespan);
         let got = CompactTarget::from_next_work_required(starting_bits, timespan, params);
         let want =
             Target::from_compact(starting_bits).min_transition_threshold().to_compact_lossy();
@@ -1841,7 +1854,7 @@ mod tests {
         let params = Params::new(crate::Network::Signet);
         let starting_bits = CompactTarget::from_consensus(403403001); // High difficulty for Signet
         let timespan = 5 * params.pow_target_timespan; // Really slow.
-        let got = CompactTarget::from_next_work_required(starting_bits, timespan, &params);
+        let got = CompactTarget::from_next_work_required(starting_bits, timespan.into(), &params);
         let want =
             Target::from_compact(starting_bits).max_transition_threshold(params).to_compact_lossy();
         assert_eq!(got, want);
@@ -1852,7 +1865,7 @@ mod tests {
         let params = Params::new(crate::Network::Signet);
         let starting_bits = CompactTarget::from_consensus(503543726); // Genesis compact target on Signet
         let timespan = 5 * params.pow_target_timespan; // Really slow.
-        let got = CompactTarget::from_next_work_required(starting_bits, timespan, &params);
+        let got = CompactTarget::from_next_work_required(starting_bits, timespan.into(), &params);
         let want = params.max_attainable_target.to_compact_lossy();
         assert_eq!(got, want);
     }

From 4d0d78a3af2ca300c6b40348724e806bd51ef27a Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Wed, 27 Nov 2024 07:45:57 -0600
Subject: [PATCH 020/554] Fix typo in from_next_work_required documentation

---
 bitcoin/src/pow.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index 243da4a3c2..b6d531cb24 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -357,7 +357,7 @@ define_extension_trait! {
         /// ref: <https://github.com/bitcoin/bitcoin/blob/0503cbea9aab47ec0a87d34611e5453158727169/src/pow.cpp>
         ///
         /// Given the previous Target, represented as a [`CompactTarget`], the difficulty is adjusted
-        /// by taking the timespan between them, and multipling the current [`CompactTarget`] by a factor
+        /// by taking the timespan between them, and multiplying the current [`CompactTarget`] by a factor
         /// of the net timespan and expected timespan. The [`CompactTarget`] may not adjust by more than
         /// a factor of 4, or adjust beyond the maximum threshold for the network.
         ///

From e0442782c8c04bdc48c2743e70f46e41c507e5f4 Mon Sep 17 00:00:00 2001
From: Rob N <rob.netzke@gmail.com>
Date: Tue, 19 Nov 2024 12:42:55 -1000
Subject: [PATCH 021/554] fix(script): account for data pushing opcodes in
 `is_standard_op_return`

While I believe the original commit used 80 bytes for the entire script as the limit,
Bitcoin Core as of [this commit](https://github.com/bitcoin/bitcoin/blame/7a172c76d2361fc3cdf6345590e26c79a7821672/src/policy/policy.h)
will relay OP_RETURN outputs as long as the data itself is not above 80 bytes, meaning a script of maximum size 83 bytes should be standard.
---
 bitcoin/src/blockdata/script/borrowed.rs | 4 ++--
 bitcoin/src/blockdata/script/tests.rs    | 6 ++++--
 bitcoin/src/policy.rs                    | 3 +++
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs
index e1fe91b781..a922d7313d 100644
--- a/bitcoin/src/blockdata/script/borrowed.rs
+++ b/bitcoin/src/blockdata/script/borrowed.rs
@@ -12,7 +12,7 @@ use super::{
 use crate::consensus::Encodable;
 use crate::opcodes::all::*;
 use crate::opcodes::{self, Opcode};
-use crate::policy::DUST_RELAY_TX_FEE;
+use crate::policy::{DUST_RELAY_TX_FEE, MAX_OP_RETURN_RELAY};
 use crate::prelude::{sink, DisplayHex, String, ToString};
 use crate::taproot::{LeafVersion, TapLeafHash, TapLeafHashExt as _};
 use crate::FeeRate;
@@ -217,7 +217,7 @@ crate::internal_macros::define_extension_trait! {
         /// What this function considers to be standard may change without warning pending Bitcoin Core
         /// changes.
         #[inline]
-        fn is_standard_op_return(&self) -> bool { self.is_op_return() && self.len() <= 80 }
+        fn is_standard_op_return(&self) -> bool { self.is_op_return() && self.len() <= MAX_OP_RETURN_RELAY }
 
         /// Checks whether a script is trivially known to have no satisfying input.
         ///
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 5a3409af6c..7010bb19b9 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -416,8 +416,10 @@ fn standard_op_return() {
     assert!(ScriptBuf::from_hex("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e")
         .unwrap()
         .is_standard_op_return());
-
-    assert!(!ScriptBuf::from_hex("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e21")
+    assert!(ScriptBuf::from_hex("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e21")
+        .unwrap()
+        .is_standard_op_return());
+    assert!(!ScriptBuf::from_hex("6a48656c6c6f2c2074686973206973206d7920666972737420636f6e747269627574696f6e20746f207275737420626974636f696e2e20506c6561736520617070726f7665206d79205052206672656e21524f42")
         .unwrap()
         .is_standard_op_return());
 }
diff --git a/bitcoin/src/policy.rs b/bitcoin/src/policy.rs
index 35c2dda8b5..89eb08261e 100644
--- a/bitcoin/src/policy.rs
+++ b/bitcoin/src/policy.rs
@@ -43,6 +43,9 @@ pub const DEFAULT_MIN_RELAY_TX_FEE: u32 = 1_000;
 /// mempools.
 pub const DEFAULT_MEMPOOL_EXPIRY: u32 = 336;
 
+// 80 bytes of data, +1 for OP_RETURN, +2 for the pushdata opcodes.
+pub(crate) const MAX_OP_RETURN_RELAY: usize = 83;
+
 /// 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)

From d9b48cc2ce68b065640caa22da6fbcb1f3ad85f8 Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Tue, 19 Nov 2024 16:05:38 -0600
Subject: [PATCH 022/554] Add p2wpkh address creation example

---
 bitcoin/Cargo.toml                        |  4 ++++
 bitcoin/examples/create-p2wpkh-address.rs | 24 +++++++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 bitcoin/examples/create-p2wpkh-address.rs

diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index c4ba294c44..ee854c75b9 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -71,6 +71,10 @@ required-features = ["std", "bitcoinconsensus"]
 name = "ecdsa-psbt-simple"
 required-features = ["rand-std"]
 
+[[example]]
+name = "create-p2wpkh-address"
+required-features = ["rand-std"]
+
 [[example]]
 name = "sign-tx-segwit-v0"
 required-features = ["rand-std"]
diff --git a/bitcoin/examples/create-p2wpkh-address.rs b/bitcoin/examples/create-p2wpkh-address.rs
new file mode 100644
index 0000000000..b8ec758f82
--- /dev/null
+++ b/bitcoin/examples/create-p2wpkh-address.rs
@@ -0,0 +1,24 @@
+use bitcoin::secp256k1::{rand, Secp256k1};
+use bitcoin::{Address, CompressedPublicKey, Network, PrivateKey};
+
+/// Generate a P2WPKH (pay-to-witness-public-key-hash) address and print it
+/// along with the associated private key needed to transact.
+fn main() {
+    // Create new secp256k1 instance.
+    let secp = Secp256k1::new();
+
+    // Generate secp256k1 public and private key pair.
+    let (secret_key, public_key) = secp.generate_keypair(&mut rand::thread_rng());
+
+    // Create a Bitcoin private key to be used on the Bitcoin mainnet.
+    let private_key = PrivateKey::new(secret_key, Network::Bitcoin);
+
+    // Create a compressed Bitcoin public key from the secp256k1 public key.
+    let public_key = CompressedPublicKey(public_key);
+
+    // Create a Bitcoin P2WPKH address.
+    let address = Address::p2wpkh(public_key, Network::Bitcoin);
+
+    println!("Private Key: {}", private_key);
+    println!("Address: {}", address);
+}

From 60f43a893d67c221f61e289cab6394418411cf55 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 11:48:38 +1100
Subject: [PATCH 023/554] Remove duplicate test case

In commit:

 `a10d5e15b3 Extract the Script assembly creator from fmt::Debug`

A test case was refactored and where there used to be two test case, one
for `Debug` and one for `Display`, two identical test cases were left.

Remove duplicate test case.
---
 bitcoin/src/blockdata/script/tests.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 5a3409af6c..591b4d01e9 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -483,10 +483,6 @@ fn script_json_serialize() {
 
 #[test]
 fn script_asm() {
-    assert_eq!(
-        ScriptBuf::from_hex("6363636363686868686800").unwrap().to_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_string(),
         "OP_IF OP_IF OP_IF OP_IF OP_IF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_ENDIF OP_0"

From 987e31a188672b65fc3505b813cba3d3abd28165 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Thu, 28 Nov 2024 01:55:33 +0000
Subject: [PATCH 024/554] Automated update to Github CI to rustc
 nightly-2024-11-27

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index c3f22bff65..fa09b09916 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2024-11-22
+nightly-2024-11-27

From 77085a1fa1f39e7358202e49189282e48a965747 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 27 Nov 2024 14:09:56 +1100
Subject: [PATCH 025/554] units: Remove serde from amounts

The `Amount` and `SignedAmount` were not supposed to implement `serde`
traits by design because doing so implicitly uses sats. We provide two
modules `as_sat` and `as_btc` to allow users to explicitly serialize in
their preferred format.

In commit: `d57ec019d5 Use Amount type for TxOut value field` derives
were added for `serde` and we did not notice it during review.
---
 bitcoin/src/crypto/sighash.rs |  1 +
 primitives/src/transaction.rs |  1 +
 units/src/amount/signed.rs    | 21 ++++++++++++++++++---
 units/src/amount/unsigned.rs  | 24 ++++++++++++++++++------
 4 files changed, 38 insertions(+), 9 deletions(-)

diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index d5651de35f..ccbac973e5 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1862,6 +1862,7 @@ mod tests {
             #[serde(rename = "scriptPubKey")]
             script_pubkey: ScriptBuf,
             #[serde(rename = "amountSats")]
+            #[serde(with = "crate::amount::serde::as_sat")]
             value: Amount,
         }
 
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 639f0c52a0..4a4c6f6687 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -343,6 +343,7 @@ impl TxIn {
 #[cfg(feature = "alloc")]
 pub struct TxOut {
     /// The value of the output, in satoshis.
+    #[cfg_attr(feature = "serde", serde(with = "crate::amount::serde::as_sat"))]
     pub value: Amount,
     /// The script which must be satisfied for the output to be spent.
     pub script_pubkey: ScriptBuf,
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index b90fdd5e71..266a5d32a8 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -17,9 +17,9 @@ use super::{
 
 /// A signed amount.
 ///
-/// The [`SignedAmount`] type can be used to express Bitcoin amounts that support
-/// arithmetic and conversion to various denominations.
-///
+/// The [`SignedAmount`] type can be used to express Bitcoin amounts that support arithmetic and
+/// conversion to various denominations. The `Amount` type does not implement `serde` traits but we
+/// do provide modules for serializing as satoshis or bitcoin.
 ///
 /// Warning!
 ///
@@ -29,6 +29,21 @@ use super::{
 /// start with `checked_`.  The operations from [`core::ops`] that [`Amount`]
 /// implements will panic when overflow or underflow occurs.
 ///
+/// # Examples
+///
+/// ```
+/// # #[cfg(feature = "serde")] {
+/// use serde::{Serialize, Deserialize};
+/// use bitcoin_units::SignedAmount;
+///
+/// #[derive(Serialize, Deserialize)]
+/// struct Foo {
+///     // If you are using `rust-bitcoin` then `bitcoin::amount::serde::as_sat` also works.
+///     #[serde(with = "bitcoin_units::amount::serde::as_sat")]  // Also `serde::as_btc`.
+///     amount: SignedAmount,
+/// }
+/// # }
+/// ```
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct SignedAmount(i64);
 
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index a682623853..c2e6de9a92 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -7,8 +7,6 @@ use alloc::string::{String, ToString};
 use core::str::FromStr;
 use core::{default, fmt, ops};
 
-#[cfg(feature = "serde")]
-use ::serde::{Deserialize, Serialize};
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 
@@ -21,9 +19,9 @@ use crate::{FeeRate, Weight};
 
 /// An amount.
 ///
-/// The [`Amount`] type can be used to express Bitcoin amounts that support
-/// arithmetic and conversion to various denominations.
-///
+/// The [`Amount`] type can be used to express Bitcoin amounts that support arithmetic and
+/// conversion to various denominations. The `Amount` type does not implement `serde` traits but we
+/// do provide modules for serializing as satoshis or bitcoin.
 ///
 /// Warning!
 ///
@@ -36,8 +34,22 @@ use crate::{FeeRate, Weight};
 /// zero is considered an underflow and will cause a panic if you're not using
 /// the checked arithmetic methods.
 ///
+/// # Examples
+///
+/// ```
+/// # #[cfg(feature = "serde")] {
+/// use serde::{Serialize, Deserialize};
+/// use bitcoin_units::Amount;
+///
+/// #[derive(Serialize, Deserialize)]
+/// struct Foo {
+///     // If you are using `rust-bitcoin` then `bitcoin::amount::serde::as_sat` also works.
+///     #[serde(with = "bitcoin_units::amount::serde::as_sat")]  // Also `serde::as_btc`.
+///     amount: Amount,
+/// }
+/// # }
+/// ```
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Amount(u64);
 
 impl Amount {

From 22769268f34b45c0bd86c548eb13cfe1e290f0d7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 13:36:09 +1100
Subject: [PATCH 026/554] units: Close the hex parse errors

As part of the 1.0 effort close the errors in the `units::parse` module.
---
 bitcoin/src/lib.rs |  4 ++--
 units/src/parse.rs | 53 ++++++++++++++++++++++++++++++++--------------
 units/tests/api.rs |  5 +----
 3 files changed, 40 insertions(+), 22 deletions(-)

diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index 9727d4db87..c17350b1ea 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -237,8 +237,8 @@ pub mod parse {
     #[doc(inline)]
     pub use units::parse::{
         hex_check_unprefixed, hex_remove_prefix, hex_u128, hex_u128_unchecked, hex_u128_unprefixed,
-        hex_u32, hex_u32_unchecked, hex_u32_unprefixed, int, ContainsPrefixError,
-        MissingPrefixError, ParseIntError, PrefixedHexError, UnprefixedHexError,
+        hex_u32, hex_u32_unchecked, hex_u32_unprefixed, int,
+        ParseIntError, PrefixedHexError, UnprefixedHexError,
     };
 }
 
diff --git a/units/src/parse.rs b/units/src/parse.rs
index 84917406dc..a78e6eb408 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -293,18 +293,25 @@ pub(crate) fn hex_remove_optional_prefix(s: &str) -> &str {
 
 /// Error returned when parsing an integer from a hex string that is supposed to contain a prefix.
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub enum PrefixedHexError {
+pub struct PrefixedHexError(PrefixedHexErrorInner);
+
+/// Error returned when parsing an integer from a hex string that is supposed to contain a prefix.
+#[derive(Debug, Clone, Eq, PartialEq)]
+enum PrefixedHexErrorInner {
     /// Hex string is missing prefix.
     MissingPrefix(MissingPrefixError),
     /// Error parsing integer from hex string.
     ParseInt(ParseIntError),
 }
 
+internals::impl_from_infallible!(PrefixedHexError);
+internals::impl_from_infallible!(PrefixedHexErrorInner);
+
 impl fmt::Display for PrefixedHexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use PrefixedHexError::*;
+        use PrefixedHexErrorInner::*;
 
-        match *self {
+        match self.0 {
             MissingPrefix(ref e) => write_err!(f, "hex string is missing prefix"; e),
             ParseInt(ref e) => write_err!(f, "prefixed hex string invalid int"; e),
         }
@@ -314,9 +321,9 @@ impl fmt::Display for PrefixedHexError {
 #[cfg(feature = "std")]
 impl std::error::Error for PrefixedHexError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use PrefixedHexError::*;
+        use PrefixedHexErrorInner::*;
 
-        match *self {
+        match self.0 {
             MissingPrefix(ref e) => Some(e),
             ParseInt(ref e) => Some(e),
         }
@@ -324,27 +331,37 @@ impl std::error::Error for PrefixedHexError {
 }
 
 impl From<MissingPrefixError> for PrefixedHexError {
-    fn from(e: MissingPrefixError) -> Self { Self::MissingPrefix(e) }
+    fn from(e: MissingPrefixError) -> Self {
+        Self(PrefixedHexErrorInner::MissingPrefix(e))
+    }
 }
 
 impl From<ParseIntError> for PrefixedHexError {
-    fn from(e: ParseIntError) -> Self { Self::ParseInt(e) }
+    fn from(e: ParseIntError) -> Self {
+        Self(PrefixedHexErrorInner::ParseInt(e))
+    }
 }
 
 /// Error returned when parsing an integer from a hex string that is not supposed to contain a prefix.
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub enum UnprefixedHexError {
+pub struct UnprefixedHexError(UnprefixedHexErrorInner);
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+enum UnprefixedHexErrorInner {
     /// Hex string contains prefix.
     ContainsPrefix(ContainsPrefixError),
     /// Error parsing integer from string.
     ParseInt(ParseIntError),
 }
 
+internals::impl_from_infallible!(UnprefixedHexError);
+internals::impl_from_infallible!(UnprefixedHexErrorInner);
+
 impl fmt::Display for UnprefixedHexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use UnprefixedHexError::*;
+        use UnprefixedHexErrorInner::*;
 
-        match *self {
+        match self.0 {
             ContainsPrefix(ref e) => write_err!(f, "hex string is contains prefix"; e),
             ParseInt(ref e) => write_err!(f, "hex string parse int"; e),
         }
@@ -354,9 +371,9 @@ impl fmt::Display for UnprefixedHexError {
 #[cfg(feature = "std")]
 impl std::error::Error for UnprefixedHexError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use UnprefixedHexError::*;
+        use UnprefixedHexErrorInner::*;
 
-        match *self {
+        match self.0 {
             ContainsPrefix(ref e) => Some(e),
             ParseInt(ref e) => Some(e),
         }
@@ -364,16 +381,20 @@ impl std::error::Error for UnprefixedHexError {
 }
 
 impl From<ContainsPrefixError> for UnprefixedHexError {
-    fn from(e: ContainsPrefixError) -> Self { Self::ContainsPrefix(e) }
+    fn from(e: ContainsPrefixError) -> Self {
+        Self(UnprefixedHexErrorInner::ContainsPrefix(e))
+    }
 }
 
 impl From<ParseIntError> for UnprefixedHexError {
-    fn from(e: ParseIntError) -> Self { Self::ParseInt(e) }
+    fn from(e: ParseIntError) -> Self {
+        Self(UnprefixedHexErrorInner::ParseInt(e))
+    }
 }
 
 /// Error returned when a hex string is missing a prefix (e.g. `0x`).
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct MissingPrefixError {
+struct MissingPrefixError {
     hex: InputString,
 }
 
@@ -393,7 +414,7 @@ impl std::error::Error for MissingPrefixError {}
 
 /// Error when hex string contains a prefix (e.g. 0x).
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub struct ContainsPrefixError {
+struct ContainsPrefixError {
     hex: InputString,
 }
 
diff --git a/units/tests/api.rs b/units/tests/api.rs
index c69e20bb5c..209eaca120 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -113,8 +113,6 @@ struct Errors {
     z: locktime::absolute::ParseHeightError,
     _a: locktime::absolute::ParseTimeError,
     _b: locktime::relative::TimeOverflowError,
-    _c: parse::ContainsPrefixError,
-    _d: parse::MissingPrefixError,
     _e: parse::ParseIntError,
     _f: parse::PrefixedHexError,
     _g: parse::UnprefixedHexError,
@@ -174,8 +172,7 @@ fn api_can_use_all_types_from_module_locktime_relative() {
 #[test]
 fn api_can_use_all_types_from_module_parse() {
     use bitcoin_units::parse::{
-        ContainsPrefixError, MissingPrefixError, ParseIntError, PrefixedHexError,
-        UnprefixedHexError,
+        ParseIntError, PrefixedHexError, UnprefixedHexError,
     };
 }
 

From d595f421c67390c13d896a93df2ddfdaf354e1b4 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 13:45:01 +1100
Subject: [PATCH 027/554] Remove whitespace between enum variants

We don't tend to put whitespace between enum variants.
---
 units/src/amount/error.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/units/src/amount/error.rs b/units/src/amount/error.rs
index 8c0e79fad8..81f3c3b315 100644
--- a/units/src/amount/error.rs
+++ b/units/src/amount/error.rs
@@ -15,10 +15,8 @@ use super::INPUT_STRING_LEN_LIMIT;
 pub enum ParseError {
     /// Invalid amount.
     Amount(ParseAmountError),
-
     /// Invalid denomination.
     Denomination(ParseDenominationError),
-
     /// The denomination was not identified.
     MissingDenomination(MissingDenominationError),
 }

From 31f883ac00e9d6887791fb41ac35d3e10b387d58 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 15:49:01 +1100
Subject: [PATCH 028/554] Implement iter::Sum for FeeRate

The `FeeRate` implements `ops::Add`, no reason not to enable summing an
iterator of fee rates.
---
 units/src/fee_rate.rs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index 4ed19f685b..c6f3f76fb1 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -267,6 +267,24 @@ impl SubAssign<&FeeRate> for FeeRate {
     fn sub_assign(&mut self, rhs: &FeeRate) { self.0 -= rhs.0 }
 }
 
+impl core::iter::Sum for FeeRate {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = Self>,
+    {
+        FeeRate::from_sat_per_kwu(iter.map(FeeRate::to_sat_per_kwu).sum())
+    }
+}
+
+impl<'a> core::iter::Sum<&'a FeeRate> for FeeRate {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = &'a FeeRate>,
+    {
+        FeeRate::from_sat_per_kwu(iter.map(|f| FeeRate::to_sat_per_kwu(*f)).sum())
+    }
+}
+
 crate::impl_parse_str_from_int_infallible!(FeeRate, u64, from_sat_per_kwu);
 
 #[cfg(test)]

From 0369e64b56346f04aaaea60c159761651424f336 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 15:51:29 +1100
Subject: [PATCH 029/554] Implement Sum for an iterator of references to
 amounts

We have `iter::Sum` already for `Amount` and `SignedAmount`. Add
an implementation for each to support iterators that yield references.
---
 units/src/amount/signed.rs   | 10 ++++++++++
 units/src/amount/tests.rs    |  4 ++--
 units/src/amount/unsigned.rs | 10 ++++++++++
 3 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index b90fdd5e71..841b270714 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -442,6 +442,16 @@ impl core::iter::Sum for SignedAmount {
     }
 }
 
+impl<'a> core::iter::Sum<&'a SignedAmount> for SignedAmount {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = &'a SignedAmount>,
+    {
+        let sats: i64 = iter.map(|amt| amt.0).sum();
+        SignedAmount::from_sat(sats)
+    }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for SignedAmount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index e695a443bd..00d54d7268 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -825,8 +825,8 @@ fn serde_as_sat_opt() {
 
 #[test]
 fn sum_amounts() {
-    assert_eq!(Amount::from_sat(0), [].into_iter().sum::<Amount>());
-    assert_eq!(SignedAmount::from_sat(0), [].into_iter().sum::<SignedAmount>());
+    assert_eq!(Amount::from_sat(0), [].iter().sum::<Amount>());
+    assert_eq!(SignedAmount::from_sat(0), [].iter().sum::<SignedAmount>());
 
     let amounts = [Amount::from_sat(42), Amount::from_sat(1337), Amount::from_sat(21)];
     let sum = amounts.into_iter().sum::<Amount>();
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index a682623853..143c94e57f 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -432,6 +432,16 @@ impl core::iter::Sum for Amount {
     }
 }
 
+impl<'a> core::iter::Sum<&'a Amount> for Amount {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = &'a Amount>,
+    {
+        let sats: u64 = iter.map(|amt| amt.0).sum();
+        Amount::from_sat(sats)
+    }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Amount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {

From 433f70939c3ecc10702ab6502e3f9bcd94dab739 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 15:56:07 +1100
Subject: [PATCH 030/554] Implement iter::Sum for BlockInterval

We support adding two intervals; no obvious reason not to support
summing an iterator of intervals.
---
 units/src/block.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/units/src/block.rs b/units/src/block.rs
index 7b407e33cf..aabb4c2ccb 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -231,6 +231,23 @@ impl ops::SubAssign<BlockInterval> for BlockInterval {
     fn sub_assign(&mut self, rhs: BlockInterval) { self.0 = self.to_u32() - rhs.to_u32(); }
 }
 
+impl core::iter::Sum for BlockInterval {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        let sum = iter.map(|interval| interval.0).sum();
+        BlockInterval::from_u32(sum)
+    }
+}
+
+impl<'a> core::iter::Sum<&'a BlockInterval> for BlockInterval {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = &'a BlockInterval>,
+    {
+        let sum = iter.map(|interval| interval.0).sum();
+        BlockInterval::from_u32(sum)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

From 667b7f1010bc0745d3e39181e15ec795aeca68dc Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Wed, 27 Nov 2024 22:57:51 -0600
Subject: [PATCH 031/554] Remove unused extern statement

extern crate keywords are no longer needed to import a crate
---
 bitcoin/examples/bip32.rs     | 2 --
 bitcoin/examples/handshake.rs | 2 --
 2 files changed, 4 deletions(-)

diff --git a/bitcoin/examples/bip32.rs b/bitcoin/examples/bip32.rs
index f2f36d4099..eec8eccac2 100644
--- a/bitcoin/examples/bip32.rs
+++ b/bitcoin/examples/bip32.rs
@@ -1,5 +1,3 @@
-extern crate bitcoin;
-
 use std::{env, process};
 
 use bitcoin::address::{Address, KnownHrp};
diff --git a/bitcoin/examples/handshake.rs b/bitcoin/examples/handshake.rs
index 8cfa6a9e22..db5a4fb171 100644
--- a/bitcoin/examples/handshake.rs
+++ b/bitcoin/examples/handshake.rs
@@ -1,5 +1,3 @@
-extern crate bitcoin;
-
 use std::io::{BufReader, Write};
 use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr, TcpStream};
 use std::time::{SystemTime, UNIX_EPOCH};

From c49f40fd9af1b9446a7c9a35aefdc02b30801275 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 16:59:00 +1100
Subject: [PATCH 032/554] units: Test C-COMMON-TRAITS

Add structs to the `api` integration test file that verify the set of
common traits.
---
 units/tests/api.rs | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/units/tests/api.rs b/units/tests/api.rs
index c69e20bb5c..539359b897 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -81,6 +81,31 @@ impl Types {
     fn new() -> Self { Self { a: Enums::new(), b: Structs::max() } }
 }
 
+/// A struct that includes all public non-error non-helper structs.
+// C-COMMON-TRAITS excluding `Default` and `Display`. `Display` is done in `./str.rs`.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct CommonTraits {
+    a: Amount,
+    c: SignedAmount,
+    d: BlockHeight,
+    e: BlockInterval,
+    f: FeeRate,
+    g: absolute::Height,
+    h: absolute::Time,
+    i: relative::Height,
+    j: relative::Time,
+    k: Weight,
+}
+
+/// A struct that includes all types that implement `Default`.
+#[derive(Default)]              // C-COMMON-TRAITS: `Default`
+struct Default {
+    a: Amount,
+    b: SignedAmount,
+    c: relative::Height,
+    d: relative::Time,
+}
+
 /// A struct that includes all public error types.
 // These derives are the policy of `rust-bitcoin` not Rust API guidelines.
 #[derive(Debug, Clone, PartialEq, Eq)] // All public types implement Debug (C-DEBUG).

From 91268bba672d7dea9e29cccfa83f3b34df27fe91 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 28 Nov 2024 22:20:57 +0000
Subject: [PATCH 033/554] Examples use ?, not try!, not unwrap

To conform to Rust API guidelines examples should Examples use ?, not
try!, not unwrap (C-QUESTION-MARK).

Label the examples as `# Examples`.
Replace one `unwrap()` with `expect()` .  The others don't technically
conform to the guidelines but are warranted.
---
 hashes/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index bc6206d305..44b13523d1 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -5,7 +5,7 @@
 //! This library implements the hash functions needed by Bitcoin. As an ancillary thing, it exposes
 //! hexadecimal serialization and deserialization, since these are needed to display hashes.
 //!
-//! ## Commonly used operations
+//! # Examples
 //!
 //! Hashing a single byte slice or a string:
 //!
@@ -26,7 +26,7 @@
 //!
 //! let mut reader: &[u8] = b"hello"; // In real code, this could be a `File` or `TcpStream`.
 //! let mut engine = Sha256::engine();
-//! std::io::copy(&mut reader, &mut engine).unwrap();
+//! std::io::copy(&mut reader, &mut engine).expect("engine writes don't error");
 //! let _hash = Sha256::from_engine(engine);
 //! # }
 //! ```

From a1260b06edb120eedd45b64ea9a8701b83bd0e0b Mon Sep 17 00:00:00 2001
From: Update Stable Rustc Bot <bot@example.com>
Date: Fri, 29 Nov 2024 00:59:16 +0000
Subject: [PATCH 034/554] Automated update to Github CI to rustc stable-1.83.0

---
 .github/workflows/stable-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stable-version b/.github/workflows/stable-version
index 71fae54fb2..6b4de0a42b 100644
--- a/.github/workflows/stable-version
+++ b/.github/workflows/stable-version
@@ -1 +1 @@
-1.82.0
+1.83.0

From b5a0731a23f945f7e4cc7d8f3c0f1d3f83875272 Mon Sep 17 00:00:00 2001
From: Chris Hyunhum Cho <c.hyunhum@gmail.com>
Date: Fri, 29 Nov 2024 08:06:51 +0000
Subject: [PATCH 035/554] refactor: remove unnecessary if block

---
 bitcoin/src/crypto/taproot.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/bitcoin/src/crypto/taproot.rs b/bitcoin/src/crypto/taproot.rs
index bfa857aa03..f050a9ec33 100644
--- a/bitcoin/src/crypto/taproot.rs
+++ b/bitcoin/src/crypto/taproot.rs
@@ -49,9 +49,8 @@ impl Signature {
     /// Note: this allocates on the heap, prefer [`serialize`](Self::serialize) if vec is not needed.
     pub fn to_vec(self) -> Vec<u8> {
         let mut ser_sig = self.signature.as_ref().to_vec();
-        if self.sighash_type == TapSighashType::Default {
-            // default sighash type, don't add extra sighash byte
-        } else {
+        // If default sighash type, don't add extra sighash byte
+        if self.sighash_type != TapSighashType::Default {
             ser_sig.push(self.sighash_type as u8);
         }
         ser_sig

From 0990b30035a01e6e75aa5e82412d79bd1eb9e267 Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 1 Dec 2024 01:41:12 +0000
Subject: [PATCH 036/554] 2024-12-01 automated rustfmt nightly

---
 bitcoin/src/blockdata/transaction.rs |  6 ++----
 bitcoin/src/lib.rs                   |  4 ++--
 bitcoin/src/psbt/mod.rs              |  9 +++++----
 units/src/parse.rs                   | 16 ++++------------
 units/tests/api.rs                   |  6 ++----
 5 files changed, 15 insertions(+), 26 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 137110f4f9..6a91bcc512 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -1133,9 +1133,7 @@ impl InputWeightPrediction {
     /// Computes the **signature weight** added to a transaction by an input with this weight prediction,
     /// not counting the prevout (txid, index), sequence, potential witness flag bytes or the witness count varint.
     #[deprecated(since = "TBD", note = "use `InputWeightPrediction::witness_weight()` instead")]
-    pub const fn weight(&self) -> Weight {
-        Self::witness_weight(self)
-    }
+    pub const fn weight(&self) -> Weight { Self::witness_weight(self) }
 
     /// Computes the signature, prevout (txid, index), and sequence weights of this weight
     /// prediction.
@@ -1972,7 +1970,7 @@ mod tests {
             InputWeightPrediction::P2PKH_COMPRESSED_MAX,
             InputWeightPrediction::P2PKH_UNCOMPRESSED_MAX,
             InputWeightPrediction::P2TR_KEY_DEFAULT_SIGHASH,
-            InputWeightPrediction::P2TR_KEY_NON_DEFAULT_SIGHASH
+            InputWeightPrediction::P2TR_KEY_NON_DEFAULT_SIGHASH,
         ];
 
         let weight = predict_weight_from_slices(&predict, &[1]);
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index c17350b1ea..bb0e1f1c00 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -237,8 +237,8 @@ pub mod parse {
     #[doc(inline)]
     pub use units::parse::{
         hex_check_unprefixed, hex_remove_prefix, hex_u128, hex_u128_unchecked, hex_u128_unprefixed,
-        hex_u32, hex_u32_unchecked, hex_u32_unprefixed, int,
-        ParseIntError, PrefixedHexError, UnprefixedHexError,
+        hex_u32, hex_u32_unchecked, hex_u32_unprefixed, int, ParseIntError, PrefixedHexError,
+        UnprefixedHexError,
     };
 }
 
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 7bf5791f0d..e1e64dde0c 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -256,8 +256,7 @@ impl Psbt {
                     {
                         continue;
                     } else if derivation2.len() <= derivation1.len()
-                        && derivation2[..]
-                                == derivation1[derivation1.len() - derivation2.len()..]
+                        && derivation2[..] == derivation1[derivation1.len() - derivation2.len()..]
                     {
                         entry.insert((fingerprint1, derivation1));
                         continue;
@@ -2117,14 +2116,16 @@ mod tests {
         assert_eq!(psbt1, psbt2);
     }
 
-
     // https://github.com/rust-bitcoin/rust-bitcoin/issues/3628
     #[test]
     fn test_combine_psbt_fuzz_3628() {
         let mut psbt1 = hex_psbt(include_str!("../../tests/data/psbt_fuzz1.hex")).unwrap();
         let psbt2 = hex_psbt(include_str!("../../tests/data/psbt_fuzz2.hex")).unwrap();
 
-        assert!(matches!(psbt1.combine(psbt2).unwrap_err(), Error::CombineInconsistentKeySources(_)));
+        assert!(matches!(
+            psbt1.combine(psbt2).unwrap_err(),
+            Error::CombineInconsistentKeySources(_)
+        ));
     }
 
     #[cfg(feature = "rand-std")]
diff --git a/units/src/parse.rs b/units/src/parse.rs
index a78e6eb408..a08fd56923 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -331,15 +331,11 @@ impl std::error::Error for PrefixedHexError {
 }
 
 impl From<MissingPrefixError> for PrefixedHexError {
-    fn from(e: MissingPrefixError) -> Self {
-        Self(PrefixedHexErrorInner::MissingPrefix(e))
-    }
+    fn from(e: MissingPrefixError) -> Self { Self(PrefixedHexErrorInner::MissingPrefix(e)) }
 }
 
 impl From<ParseIntError> for PrefixedHexError {
-    fn from(e: ParseIntError) -> Self {
-        Self(PrefixedHexErrorInner::ParseInt(e))
-    }
+    fn from(e: ParseIntError) -> Self { Self(PrefixedHexErrorInner::ParseInt(e)) }
 }
 
 /// Error returned when parsing an integer from a hex string that is not supposed to contain a prefix.
@@ -381,15 +377,11 @@ impl std::error::Error for UnprefixedHexError {
 }
 
 impl From<ContainsPrefixError> for UnprefixedHexError {
-    fn from(e: ContainsPrefixError) -> Self {
-        Self(UnprefixedHexErrorInner::ContainsPrefix(e))
-    }
+    fn from(e: ContainsPrefixError) -> Self { Self(UnprefixedHexErrorInner::ContainsPrefix(e)) }
 }
 
 impl From<ParseIntError> for UnprefixedHexError {
-    fn from(e: ParseIntError) -> Self {
-        Self(UnprefixedHexErrorInner::ParseInt(e))
-    }
+    fn from(e: ParseIntError) -> Self { Self(UnprefixedHexErrorInner::ParseInt(e)) }
 }
 
 /// Error returned when a hex string is missing a prefix (e.g. `0x`).
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 477cc825c9..8649e7397d 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -98,7 +98,7 @@ struct CommonTraits {
 }
 
 /// A struct that includes all types that implement `Default`.
-#[derive(Default)]              // C-COMMON-TRAITS: `Default`
+#[derive(Default)] // C-COMMON-TRAITS: `Default`
 struct Default {
     a: Amount,
     b: SignedAmount,
@@ -196,9 +196,7 @@ fn api_can_use_all_types_from_module_locktime_relative() {
 
 #[test]
 fn api_can_use_all_types_from_module_parse() {
-    use bitcoin_units::parse::{
-        ParseIntError, PrefixedHexError, UnprefixedHexError,
-    };
+    use bitcoin_units::parse::{ParseIntError, PrefixedHexError, UnprefixedHexError};
 }
 
 #[test]

From 23c77275b1ce9b9a8ff69efb8c87cad297b9e506 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 13:57:28 +1100
Subject: [PATCH 037/554] Reduce code comment lines

Make the comment more terse by using 'info' instead of 'information' and
reduce the line count by 2.
---
 units/src/amount/error.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/units/src/amount/error.rs b/units/src/amount/error.rs
index 81f3c3b315..083e87969a 100644
--- a/units/src/amount/error.rs
+++ b/units/src/amount/error.rs
@@ -56,8 +56,7 @@ impl fmt::Display for ParseError {
         match self {
             ParseError::Amount(error) => write_err!(f, "invalid amount"; error),
             ParseError::Denomination(error) => write_err!(f, "invalid denomination"; error),
-            // We consider this to not be a source because it currently doesn't contain useful
-            // information
+            // We consider this to not be a source because it currently doesn't contain useful info.
             ParseError::MissingDenomination(_) =>
                 f.write_str("the input doesn't contain a denomination"),
         }
@@ -70,8 +69,7 @@ impl std::error::Error for ParseError {
         match self {
             ParseError::Amount(error) => Some(error),
             ParseError::Denomination(error) => Some(error),
-            // We consider this to not be a source because it currently doesn't contain useful
-            // information
+            // We consider this to not be a source because it currently doesn't contain useful info.
             ParseError::MissingDenomination(_) => None,
         }
     }

From fd2a5c1ec79f337fb3695c030c9fb6b4671468f2 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 14:17:39 +1100
Subject: [PATCH 038/554] Close amounts error types

Close the two pubic enum error types in `units::amounts`. All the other
structs are closed already because they either have private fields or
marked `non_exhaustive`.
---
 units/src/amount/error.rs    | 66 +++++++++++++++++++++---------------
 units/src/amount/mod.rs      | 14 ++++----
 units/src/amount/signed.rs   | 13 ++++---
 units/src/amount/tests.rs    | 14 ++++----
 units/src/amount/unsigned.rs |  7 ++--
 5 files changed, 67 insertions(+), 47 deletions(-)

diff --git a/units/src/amount/error.rs b/units/src/amount/error.rs
index 083e87969a..55939b5ae5 100644
--- a/units/src/amount/error.rs
+++ b/units/src/amount/error.rs
@@ -11,8 +11,10 @@ use super::INPUT_STRING_LEN_LIMIT;
 
 /// An error during amount parsing amount with denomination.
 #[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum ParseError {
+pub struct ParseError(pub(crate) ParseErrorInner);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ParseErrorInner {
     /// Invalid amount.
     Amount(ParseAmountError),
     /// Invalid denomination.
@@ -22,42 +24,43 @@ pub enum ParseError {
 }
 
 internals::impl_from_infallible!(ParseError);
+internals::impl_from_infallible!(ParseErrorInner);
 
 impl From<ParseAmountError> for ParseError {
-    fn from(e: ParseAmountError) -> Self { Self::Amount(e) }
+    fn from(e: ParseAmountError) -> Self { Self(ParseErrorInner::Amount(e)) }
 }
 
 impl From<ParseDenominationError> for ParseError {
-    fn from(e: ParseDenominationError) -> Self { Self::Denomination(e) }
+    fn from(e: ParseDenominationError) -> Self { Self(ParseErrorInner::Denomination(e)) }
 }
 
 impl From<OutOfRangeError> for ParseError {
-    fn from(e: OutOfRangeError) -> Self { Self::Amount(e.into()) }
+    fn from(e: OutOfRangeError) -> Self { Self(ParseErrorInner::Amount(e.into())) }
 }
 
 impl From<TooPreciseError> for ParseError {
-    fn from(e: TooPreciseError) -> Self { Self::Amount(e.into()) }
+    fn from(e: TooPreciseError) -> Self { Self(ParseErrorInner::Amount(e.into())) }
 }
 
 impl From<MissingDigitsError> for ParseError {
-    fn from(e: MissingDigitsError) -> Self { Self::Amount(e.into()) }
+    fn from(e: MissingDigitsError) -> Self { Self(ParseErrorInner::Amount(e.into())) }
 }
 
 impl From<InputTooLargeError> for ParseError {
-    fn from(e: InputTooLargeError) -> Self { Self::Amount(e.into()) }
+    fn from(e: InputTooLargeError) -> Self { Self(ParseErrorInner::Amount(e.into())) }
 }
 
 impl From<InvalidCharacterError> for ParseError {
-    fn from(e: InvalidCharacterError) -> Self { Self::Amount(e.into()) }
+    fn from(e: InvalidCharacterError) -> Self { Self(ParseErrorInner::Amount(e.into())) }
 }
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ParseError::Amount(error) => write_err!(f, "invalid amount"; error),
-            ParseError::Denomination(error) => write_err!(f, "invalid denomination"; error),
+        match self.0 {
+            ParseErrorInner::Amount(ref e) => write_err!(f, "invalid amount"; e),
+            ParseErrorInner::Denomination(ref e) => write_err!(f, "invalid denomination"; e),
             // We consider this to not be a source because it currently doesn't contain useful info.
-            ParseError::MissingDenomination(_) =>
+            ParseErrorInner::MissingDenomination(_) =>
                 f.write_str("the input doesn't contain a denomination"),
         }
     }
@@ -66,19 +69,21 @@ impl fmt::Display for ParseError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match self {
-            ParseError::Amount(error) => Some(error),
-            ParseError::Denomination(error) => Some(error),
+        match self.0 {
+            ParseErrorInner::Amount(ref e) => Some(e),
+            ParseErrorInner::Denomination(ref e) => Some(e),
             // We consider this to not be a source because it currently doesn't contain useful info.
-            ParseError::MissingDenomination(_) => None,
+            ParseErrorInner::MissingDenomination(_) => None,
         }
     }
 }
 
 /// An error during amount parsing.
 #[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum ParseAmountError {
+pub struct ParseAmountError(pub(crate) ParseAmountErrorInner);
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ParseAmountErrorInner {
     /// The amount is too big or too small.
     OutOfRange(OutOfRangeError),
     /// Amount has higher precision than supported by the type.
@@ -92,28 +97,31 @@ pub enum ParseAmountError {
 }
 
 impl From<TooPreciseError> for ParseAmountError {
-    fn from(value: TooPreciseError) -> Self { Self::TooPrecise(value) }
+    fn from(value: TooPreciseError) -> Self { Self(ParseAmountErrorInner::TooPrecise(value)) }
 }
 
 impl From<MissingDigitsError> for ParseAmountError {
-    fn from(value: MissingDigitsError) -> Self { Self::MissingDigits(value) }
+    fn from(value: MissingDigitsError) -> Self { Self(ParseAmountErrorInner::MissingDigits(value)) }
 }
 
 impl From<InputTooLargeError> for ParseAmountError {
-    fn from(value: InputTooLargeError) -> Self { Self::InputTooLarge(value) }
+    fn from(value: InputTooLargeError) -> Self { Self(ParseAmountErrorInner::InputTooLarge(value)) }
 }
 
 impl From<InvalidCharacterError> for ParseAmountError {
-    fn from(value: InvalidCharacterError) -> Self { Self::InvalidCharacter(value) }
+    fn from(value: InvalidCharacterError) -> Self {
+        Self(ParseAmountErrorInner::InvalidCharacter(value))
+    }
 }
 
 internals::impl_from_infallible!(ParseAmountError);
+internals::impl_from_infallible!(ParseAmountErrorInner);
 
 impl fmt::Display for ParseAmountError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseAmountError::*;
+        use ParseAmountErrorInner::*;
 
-        match *self {
+        match self.0 {
             OutOfRange(ref error) => write_err!(f, "amount out of range"; error),
             TooPrecise(ref error) => write_err!(f, "amount has a too high precision"; error),
             MissingDigits(ref error) => write_err!(f, "the input has too few digits"; error),
@@ -126,9 +134,9 @@ impl fmt::Display for ParseAmountError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseAmountError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseAmountError::*;
+        use ParseAmountErrorInner::*;
 
-        match *self {
+        match self.0 {
             TooPrecise(ref error) => Some(error),
             InputTooLarge(ref error) => Some(error),
             OutOfRange(ref error) => Some(error),
@@ -195,7 +203,9 @@ impl fmt::Display for OutOfRangeError {
 impl std::error::Error for OutOfRangeError {}
 
 impl From<OutOfRangeError> for ParseAmountError {
-    fn from(value: OutOfRangeError) -> Self { ParseAmountError::OutOfRange(value) }
+    fn from(value: OutOfRangeError) -> Self {
+        ParseAmountError(ParseAmountErrorInner::OutOfRange(value))
+    }
 }
 
 /// Error returned when the input string has higher precision than satoshis.
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index f78b5c3787..21eb9ed8c8 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -20,7 +20,7 @@ use core::cmp::Ordering;
 use core::fmt;
 use core::str::FromStr;
 
-use self::error::MissingDigitsKind;
+use self::error::{MissingDigitsKind, ParseAmountErrorInner, ParseErrorInner};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
@@ -297,10 +297,12 @@ impl InnerParseError {
         match self {
             Self::Overflow { is_negative } =>
                 OutOfRangeError { is_signed, is_greater_than_max: !is_negative }.into(),
-            Self::TooPrecise(error) => ParseAmountError::TooPrecise(error),
-            Self::MissingDigits(error) => ParseAmountError::MissingDigits(error),
-            Self::InputTooLarge(len) => ParseAmountError::InputTooLarge(InputTooLargeError { len }),
-            Self::InvalidCharacter(error) => ParseAmountError::InvalidCharacter(error),
+            Self::TooPrecise(e) => ParseAmountError(ParseAmountErrorInner::TooPrecise(e)),
+            Self::MissingDigits(e) => ParseAmountError(ParseAmountErrorInner::MissingDigits(e)),
+            Self::InputTooLarge(len) =>
+                ParseAmountError(ParseAmountErrorInner::InputTooLarge(InputTooLargeError { len })),
+            Self::InvalidCharacter(e) =>
+                ParseAmountError(ParseAmountErrorInner::InvalidCharacter(e)),
         }
     }
 }
@@ -311,7 +313,7 @@ fn split_amount_and_denomination(s: &str) -> Result<(&str, Denomination), ParseE
     } else {
         let i = s
             .find(|c: char| c.is_alphabetic())
-            .ok_or(ParseError::MissingDenomination(MissingDenominationError))?;
+            .ok_or(ParseError(ParseErrorInner::MissingDenomination(MissingDenominationError)))?;
         (i, i)
     };
     Ok((&s[..i], s[j..].parse()?))
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index b90fdd5e71..632a562675 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -10,6 +10,7 @@ use core::{default, fmt, ops};
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 
+use super::error::{ParseAmountErrorInner, ParseErrorInner};
 use super::{
     parse_signed_to_satoshi, split_amount_and_denomination, Amount, Denomination, Display,
     DisplayStyle, OutOfRangeError, ParseAmountError, ParseError,
@@ -92,12 +93,14 @@ impl SignedAmount {
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
         match parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(true))? {
             // (negative, amount)
-            (false, sat) if sat > i64::MAX as u64 =>
-                Err(ParseAmountError::OutOfRange(OutOfRangeError::too_big(true))),
+            (false, sat) if sat > i64::MAX as u64 => Err(ParseAmountError(
+                ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_big(true)),
+            )),
             (false, sat) => Ok(SignedAmount(sat as i64)),
             (true, sat) if sat == i64::MIN.unsigned_abs() => Ok(SignedAmount(i64::MIN)),
-            (true, sat) if sat > i64::MIN.unsigned_abs() =>
-                Err(ParseAmountError::OutOfRange(OutOfRangeError::too_small())),
+            (true, sat) if sat > i64::MIN.unsigned_abs() => Err(ParseAmountError(
+                ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_small()),
+            )),
             (true, sat) => Ok(SignedAmount(-(sat as i64))),
         }
     }
@@ -415,7 +418,7 @@ impl FromStr for SignedAmount {
         let result = SignedAmount::from_str_with_denomination(s);
 
         match result {
-            Err(ParseError::MissingDenomination(_)) => {
+            Err(ParseError(ParseErrorInner::MissingDenomination(_))) => {
                 let d = SignedAmount::from_str_in(s, Denomination::Satoshi);
 
                 if d == Ok(SignedAmount::ZERO) {
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index e695a443bd..24e0675459 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -33,7 +33,9 @@ fn from_str_zero() {
         match s.parse::<Amount>() {
             Err(e) => assert_eq!(
                 e,
-                ParseError::Amount(ParseAmountError::OutOfRange(OutOfRangeError::negative()))
+                ParseError(ParseErrorInner::Amount(ParseAmountError(
+                    ParseAmountErrorInner::OutOfRange(OutOfRangeError::negative())
+                )))
             ),
             Ok(_) => panic!("unsigned amount from {}", s),
         }
@@ -321,7 +323,7 @@ fn parsing() {
     // more than 50 chars.
     assert_eq!(
         p("100000000000000.00000000000000000000000000000000000", Denomination::Bitcoin),
-        Err(E::InputTooLarge(InputTooLargeError { len: 51 }))
+        Err(E(ParseAmountErrorInner::InputTooLarge(InputTooLargeError { len: 51 })))
     );
 }
 
@@ -731,10 +733,10 @@ fn serde_as_btc() {
     // 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(TooPreciseError { position: 16 }).to_string()));
+    assert!(t.unwrap_err().to_string().contains(
+        &ParseAmountError(ParseAmountErrorInner::TooPrecise(TooPreciseError { position: 16 }))
+            .to_string()
+    ));
     let t: Result<T, serde_json::Error> = serde_json::from_str("{\"amt\": -1, \"samt\": 1}");
     assert!(t.unwrap_err().to_string().contains(&OutOfRangeError::negative().to_string()));
 }
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index a682623853..37845c1cee 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -12,6 +12,7 @@ use ::serde::{Deserialize, Serialize};
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 
+use super::error::{ParseAmountErrorInner, ParseErrorInner};
 use super::{
     parse_signed_to_satoshi, split_amount_and_denomination, Denomination, Display, DisplayStyle,
     OutOfRangeError, ParseAmountError, ParseError, SignedAmount,
@@ -103,7 +104,9 @@ impl Amount {
         let (negative, satoshi) =
             parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(false))?;
         if negative {
-            return Err(ParseAmountError::OutOfRange(OutOfRangeError::negative()));
+            return Err(ParseAmountError(ParseAmountErrorInner::OutOfRange(
+                OutOfRangeError::negative(),
+            )));
         }
         Ok(Amount::from_sat(satoshi))
     }
@@ -405,7 +408,7 @@ impl FromStr for Amount {
         let result = Amount::from_str_with_denomination(s);
 
         match result {
-            Err(ParseError::MissingDenomination(_)) => {
+            Err(ParseError(ParseErrorInner::MissingDenomination(_))) => {
                 let d = Amount::from_str_in(s, Denomination::Satoshi);
 
                 if d == Ok(Amount::ZERO) {

From f428833bdd89229ef9323a14ba4efdda53834c11 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 2 Dec 2024 09:44:35 +1100
Subject: [PATCH 039/554] Only update nightly once a week

Merging the nightly update PRs is boring and annoying. We can just do it
once a week without too much risk of falling behind.

This does mean that I (Tobin) can't be lazy and skip merging the bot's
PRs (which I find myself doing when its twice a week).
---
 .github/workflows/cron-semi-weekly-update-nightly.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/cron-semi-weekly-update-nightly.yml b/.github/workflows/cron-semi-weekly-update-nightly.yml
index 8cfb698854..ea9c4f434d 100644
--- a/.github/workflows/cron-semi-weekly-update-nightly.yml
+++ b/.github/workflows/cron-semi-weekly-update-nightly.yml
@@ -1,7 +1,7 @@
 name: Update Nightly rustc
 on:
   schedule:
-    - cron: "5 0 * * 1,4" # runs every Monday and Thursday at 00:05
+    - cron: "5 0 * * 6" # Saturday at 00:05
   workflow_dispatch: # allows manual triggering
 jobs:
   format:

From 01ec48cfb83389759c1c83ec85d008533ddef74d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 2 Dec 2024 09:47:11 +1100
Subject: [PATCH 040/554] Re-name cron nightly update jobs

We just changed the cron nightly update job to be once a week instead of
twice - re-name the file appropriately.
---
 ...i-weekly-update-nightly.yml => cron-weekly-update-nightly.yml} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename .github/workflows/{cron-semi-weekly-update-nightly.yml => cron-weekly-update-nightly.yml} (100%)

diff --git a/.github/workflows/cron-semi-weekly-update-nightly.yml b/.github/workflows/cron-weekly-update-nightly.yml
similarity index 100%
rename from .github/workflows/cron-semi-weekly-update-nightly.yml
rename to .github/workflows/cron-weekly-update-nightly.yml

From 75297a68f60eb8e779a56f76ac5377c5d7c87559 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Mon, 2 Dec 2024 01:59:35 +0000
Subject: [PATCH 041/554] Automated update to Github CI to rustc
 nightly-2024-12-01

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index fa09b09916..67380bdf06 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2024-11-27
+nightly-2024-12-01

From 8b41ecb4270585652259277e7f132c8fbdcae953 Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Sun, 1 Dec 2024 20:59:46 -0600
Subject: [PATCH 042/554] Fix typo in re-export

---
 bitcoin/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index bb0e1f1c00..2c4c76ae12 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -123,7 +123,7 @@ pub mod taproot;
 pub use primitives::{
     block::{
         Block, BlockHash, Checked as BlockChecked, Header as BlockHeader,
-        Unchecked as BockUnchecked, Validation as BlockValidation, WitnessCommitment,
+        Unchecked as BlockUnchecked, Validation as BlockValidation, WitnessCommitment,
     },
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
     opcodes::Opcode,

From 22530f6a2b484d2cb7974250bca5b28b9f26d85d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 16:39:32 +1100
Subject: [PATCH 043/554] Support serde serializing Amount as string

Sometimes JSON parsers may munge floats. Instead of using `f64` we can
serialize BTC amounts as strings.

Includes addition of `alloc` feature gate to `DisplayFullError` to
remove lint warnings when building with `--no-default-features`.

Close: #894
---
 units/Cargo.toml          |   2 +-
 units/src/amount/serde.rs | 115 +++++++++++++++++++++++++++++++++++++-
 units/src/amount/tests.rs |  68 ++++++++++++++++++++++
 3 files changed, 183 insertions(+), 2 deletions(-)

diff --git a/units/Cargo.toml b/units/Cargo.toml
index 61acb6613c..682307dde2 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -15,7 +15,7 @@ exclude = ["tests", "contrib"]
 [features]
 default = ["std"]
 std = ["alloc", "internals/std"]
-alloc = ["internals/alloc"]
+alloc = ["internals/alloc","serde?/alloc"]
 
 [dependencies]
 internals = { package = "bitcoin-internals", version = "0.4.0" }
diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index a485994b71..f5ddc595f8 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -20,13 +20,16 @@
 //! }
 //! ```
 
+#[cfg(feature = "alloc")]
 use core::fmt;
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[cfg(feature = "alloc")] // This is because `to_float_in` uses `to_string`.
 use super::Denomination;
-use super::{Amount, ParseAmountError, SignedAmount};
+#[cfg(feature = "alloc")]
+use super::ParseAmountError;
+use super::{Amount, SignedAmount};
 
 /// This trait is used only to avoid code duplication and naming collisions
 /// of the different serde serialization crates.
@@ -37,6 +40,10 @@ pub trait SerdeAmount: Copy + Sized {
     fn ser_btc<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
     #[cfg(feature = "alloc")]
     fn des_btc<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error>;
+    #[cfg(feature = "alloc")]
+    fn ser_str<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
+    #[cfg(feature = "alloc")]
+    fn des_str<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error>;
 }
 
 mod private {
@@ -50,8 +57,11 @@ pub trait SerdeAmountForOpt: Copy + Sized + SerdeAmount {
     fn ser_sat_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
     #[cfg(feature = "alloc")]
     fn ser_btc_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
+    #[cfg(feature = "alloc")]
+    fn ser_str_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error>;
 }
 
+#[cfg(feature = "alloc")]
 struct DisplayFullError(ParseAmountError);
 
 #[cfg(feature = "std")]
@@ -70,6 +80,7 @@ impl fmt::Display for DisplayFullError {
 }
 
 #[cfg(not(feature = "std"))]
+#[cfg(feature = "alloc")]
 impl fmt::Display for DisplayFullError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
@@ -90,6 +101,18 @@ impl SerdeAmount for Amount {
         use serde::de::Error;
         Amount::from_btc(f64::deserialize(d)?).map_err(DisplayFullError).map_err(D::Error::custom)
     }
+    #[cfg(feature = "alloc")]
+    fn ser_str<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
+        s.serialize_str(&self.to_string_in(Denomination::Bitcoin))
+    }
+    #[cfg(feature = "alloc")]
+    fn des_str<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
+        use serde::de::Error;
+        let s: alloc::string::String = Deserialize::deserialize(d)?;
+        Amount::from_str_in(&s, Denomination::Bitcoin)
+            .map_err(DisplayFullError)
+            .map_err(D::Error::custom)
+    }
 }
 
 impl SerdeAmountForOpt for Amount {
@@ -101,6 +124,10 @@ impl SerdeAmountForOpt for Amount {
     fn ser_btc_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
         s.serialize_some(&self.to_btc())
     }
+    #[cfg(feature = "alloc")]
+    fn ser_str_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
+        s.serialize_some(&self.to_string_in(Denomination::Bitcoin))
+    }
 }
 
 impl SerdeAmount for SignedAmount {
@@ -121,6 +148,18 @@ impl SerdeAmount for SignedAmount {
             .map_err(DisplayFullError)
             .map_err(D::Error::custom)
     }
+    #[cfg(feature = "alloc")]
+    fn ser_str<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
+        s.serialize_str(self.to_string_in(Denomination::Bitcoin).as_str())
+    }
+    #[cfg(feature = "alloc")]
+    fn des_str<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
+        use serde::de::Error;
+        let s: alloc::string::String = Deserialize::deserialize(d)?;
+        SignedAmount::from_str_in(&s, Denomination::Bitcoin)
+            .map_err(DisplayFullError)
+            .map_err(D::Error::custom)
+    }
 }
 
 impl SerdeAmountForOpt for SignedAmount {
@@ -132,6 +171,10 @@ impl SerdeAmountForOpt for SignedAmount {
     fn ser_btc_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
         s.serialize_some(&self.to_btc())
     }
+    #[cfg(feature = "alloc")]
+    fn ser_str_opt<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
+        s.serialize_some(&self.to_string_in(Denomination::Bitcoin))
+    }
 }
 
 pub mod as_sat {
@@ -272,3 +315,73 @@ pub mod as_btc {
         }
     }
 }
+
+#[cfg(feature = "alloc")]
+pub mod as_str {
+    //! Serialize and deserialize [`Amount`](crate::Amount) as a JSON string denominated in BTC.
+    //! Use with `#[serde(with = "amount::serde::as_str")]`.
+
+    use serde::{Deserializer, Serializer};
+
+    use super::private;
+    use crate::amount::serde::SerdeAmount;
+
+    pub fn serialize<A: SerdeAmount, S: Serializer>(a: &A, s: S) -> Result<S::Ok, S::Error> {
+        a.ser_str(s, private::Token)
+    }
+
+    pub fn deserialize<'d, A: SerdeAmount, D: Deserializer<'d>>(d: D) -> Result<A, D::Error> {
+        A::des_str(d, private::Token)
+    }
+
+    pub mod opt {
+        //! Serialize and deserialize `Option<Amount>` as a JSON string denominated in BTC.
+        //! Use with `#[serde(default, with = "amount::serde::as_str::opt")]`.
+
+        use core::fmt;
+        use core::marker::PhantomData;
+
+        use serde::{de, Deserializer, Serializer};
+
+        use super::private;
+        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_str_opt(s, private::Token),
+                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<String>")
+                }
+
+                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_str(d, private::Token)?))
+                }
+            }
+            d.deserialize_option(VisitOptAmt::<A>(PhantomData))
+        }
+    }
+}
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 0b22ea2ff8..1213e888ca 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -741,6 +741,31 @@ fn serde_as_btc() {
     assert!(t.unwrap_err().to_string().contains(&OutOfRangeError::negative().to_string()));
 }
 
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+#[test]
+fn serde_as_str() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct T {
+        #[serde(with = "crate::amount::serde::as_str")]
+        pub amt: Amount,
+        #[serde(with = "crate::amount::serde::as_str")]
+        pub samt: SignedAmount,
+    }
+
+    serde_test::assert_tokens(
+        &T { amt: Amount::from_sat(123456789), samt: SignedAmount::from_sat(-123456789) },
+        &[
+            serde_test::Token::Struct { name: "T", len: 2 },
+            serde_test::Token::String("amt"),
+            serde_test::Token::String("1.23456789"),
+            serde_test::Token::String("samt"),
+            serde_test::Token::String("-1.23456789"),
+            serde_test::Token::StructEnd,
+        ],
+    );
+}
+
 #[cfg(feature = "serde")]
 #[cfg(feature = "alloc")]
 #[test]
@@ -825,6 +850,49 @@ fn serde_as_sat_opt() {
     assert_eq!(without, serde_json::from_value(value_without).unwrap());
 }
 
+#[cfg(feature = "serde")]
+#[cfg(feature = "alloc")]
+#[test]
+#[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
+fn serde_as_str_opt() {
+    use serde_json;
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug, Eq)]
+    struct T {
+        #[serde(default, with = "crate::amount::serde::as_str::opt")]
+        pub amt: Option<Amount>,
+        #[serde(default, with = "crate::amount::serde::as_str::opt")]
+        pub samt: Option<SignedAmount>,
+    }
+
+    let with = T {
+        amt: Some(Amount::from_sat(123456789)),
+        samt: Some(SignedAmount::from_sat(-123456789)),
+    };
+    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\": \"1.23456789\", \"samt\": \"-1.23456789\"}").unwrap();
+    assert_eq!(t, with);
+
+    let t: T = serde_json::from_str("{}").unwrap();
+    assert_eq!(t, without);
+
+    let value_with: serde_json::Value =
+        serde_json::from_str("{\"amt\": \"1.23456789\", \"samt\": \"-1.23456789\"}").unwrap();
+    assert_eq!(with, serde_json::from_value(value_with).unwrap());
+
+    let value_without: serde_json::Value = serde_json::from_str("{}").unwrap();
+    assert_eq!(without, serde_json::from_value(value_without).unwrap());
+}
+
 #[test]
 fn sum_amounts() {
     assert_eq!(Amount::from_sat(0), [].iter().sum::<Amount>());

From c27f4435208cc3ca7b98580fd7e2784e089b545e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 2 Dec 2024 14:25:55 +1100
Subject: [PATCH 044/554] Add basic unit tests for Amount serde

Add a test each for serializing `Amount` as sat, as BTC, and as str.
---
 units/src/amount/serde.rs | 67 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index f5ddc595f8..2caa8c74e7 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -385,3 +385,70 @@ pub mod as_str {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn can_serde_as_sat() {
+        #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+        pub struct HasAmount {
+            #[serde(with = "crate::amount::serde::as_sat")]
+            pub amount: Amount,
+        }
+
+        let orig = HasAmount {
+            amount: Amount::ONE_BTC,
+        };
+
+        let json = serde_json::to_string(&orig).expect("failed to ser");
+        let want = "{\"amount\":100000000}";
+        assert_eq!(json, want);
+
+        let rinsed: HasAmount = serde_json::from_str(&json).expect("failed to deser");
+        assert_eq!(rinsed, orig)
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn can_serde_as_btc() {
+        #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+        pub struct HasAmount {
+            #[serde(with = "crate::amount::serde::as_btc")]
+            pub amount: Amount,
+        }
+
+        let orig = HasAmount {
+            amount: Amount::ONE_BTC,
+        };
+
+        let json = serde_json::to_string(&orig).expect("failed to ser");
+        let want = "{\"amount\":1.0}";
+        assert_eq!(json, want);
+
+        let rinsed: HasAmount = serde_json::from_str(&json).expect("failed to deser");
+        assert_eq!(rinsed, orig)
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn can_serde_as_str() {
+        #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+        pub struct HasAmount {
+            #[serde(with = "crate::amount::serde::as_str")]
+            pub amount: Amount,
+        }
+
+        let orig = HasAmount {
+            amount: Amount::ONE_BTC,
+        };
+
+        let json = serde_json::to_string(&orig).expect("failed to ser");
+        let want = "{\"amount\":\"1\"}";
+        assert_eq!(json, want);
+
+        let rinsed: HasAmount = serde_json::from_str(&json).expect("failed to deser");
+        assert_eq!(rinsed, orig);
+    }
+}

From edab380ac096babf3d12f27d373d0900d10bc065 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 18 Nov 2024 09:44:49 +1100
Subject: [PATCH 045/554] bitcoin: Bump version to v0.33.0-alpha.0

Needs release notes but there are 20 pages of them, that feels like too
many to go through manually.

Includes a missing changelog entry in `units` for an already released
change that is included in this `bitcoin` release.
---
 Cargo-minimal.lock   |   2 +-
 Cargo-recent.lock    |   2 +-
 bitcoin/CHANGELOG.md | 107 +++++++++++++++++++++++++++++++++++++++++--
 bitcoin/Cargo.toml   |   2 +-
 units/CHANGELOG.md   |   1 +
 5 files changed, 108 insertions(+), 6 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 5ec37a0166..4277d220f5 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -53,7 +53,7 @@ dependencies = [
 
 [[package]]
 name = "bitcoin"
-version = "0.33.0-alpha"
+version = "0.33.0-alpha.0"
 dependencies = [
  "arbitrary",
  "base58ck",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index ed3d594ec8..1f12e5e504 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -52,7 +52,7 @@ dependencies = [
 
 [[package]]
 name = "bitcoin"
-version = "0.33.0-alpha"
+version = "0.33.0-alpha.0"
 dependencies = [
  "arbitrary",
  "base58ck",
diff --git a/bitcoin/CHANGELOG.md b/bitcoin/CHANGELOG.md
index c6c779bd37..203e3967bc 100644
--- a/bitcoin/CHANGELOG.md
+++ b/bitcoin/CHANGELOG.md
@@ -1,6 +1,107 @@
-# 0.33.0-alpha - TODO: Set date
-
-- Enforce script size limit when hashing scripts [#2794](https://github.com/rust-bitcoin/rust-bitcoin/pull/2794)
+# 0.33.0-alpha.0 - 2024-11-18
+
+This series of alpha releases is meant for two things:
+
+1. To facilitate testing of `primitives 0.101`.
+2. To allow testing of upcoming `1.0` releases of:
+
+   - `bitcoin_hashes`
+   - `hex`
+   - `bitcoin-io`
+   - `primitives`
+   - `units`
+   - `ordered`
+
+You likely want to explicitly set the version if doing testing. `cargo` can be surprising when there
+is a `-` in the version number.
+
+We do not currently intend on releasing `bitcoin 0.33.0` until the `1.0` releases above are done.
+
+For changes to our dependencies included in this release see:
+
+- `bitcoin_hashes 0.15`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/hashes/CHANGELOG.md)
+- `hex-conservative 0.3`: [changelog](https://github.com/rust-bitcoin/hex-conservative/blob/master/CHANGELOG.md)
+- `bitcoin-io 0.2`: [changelog](https://github.com/rust-bitcoin/rust-bitcoin/blob/master/io/CHANGELOG.md)
+- `bitcoin-primitives: 0.101`: [changelog]((https://github.com/rust-bitcoin/rust-bitcoin/blob/master/primitives/CHANGELOG.md))
+- `bitcoin-units 0.2`: [changelog]((https://github.com/rust-bitcoin/rust-bitcoin/blob/master/units/CHANGELOG.md))
+- `bitcoinconsensus: 0.106.0+26`: [changelog](https://github.com/rust-bitcoin/rust-bitcoinconsensus/blob/master/CHANGELOG.md)
+
+## Changes
+
+- Fix psbt fuzz crash [#3667](https://github.com/rust-bitcoin/rust-bitcoin/pull/3667)
+- Update `from_next_work_required` to take an `i64` for timespan [#3660](https://github.com/rust-bitcoin/rust-bitcoin/pull/3660)
+- Account for data pushing opcodes in `is_standard_op_return` [#3643](https://github.com/rust-bitcoin/rust-bitcoin/pull/3643)
+- Add p2wpkh address creation example [#3642](https://github.com/rust-bitcoin/rust-bitcoin/pull/3642)
+- Add `Address::into_unchecked` [#3640](https://github.com/rust-bitcoin/rust-bitcoin/pull/3640)
+- Mark `checked_` functions as const [#3636](https://github.com/rust-bitcoin/rust-bitcoin/pull/3636)
+- Mark functions const in `fee_rate` [#3627](https://github.com/rust-bitcoin/rust-bitcoin/pull/3627)
+- Mark funtions const [#3608](https://github.com/rust-bitcoin/rust-bitcoin/pull/3608)
+- Add constructor to `FeeRate` [#3604](https://github.com/rust-bitcoin/rust-bitcoin/pull/3604)
+- Fix bug in witness stack getters [#3601](https://github.com/rust-bitcoin/rust-bitcoin/pull/3601)
+- Split `checked_div_by_weight` into floor and ceiling version [#3587](https://github.com/rust-bitcoin/rust-bitcoin/pull/3587)
+- script: remove `unsafe` marker from slice-to-script conversions [#3569](https://github.com/rust-bitcoin/rust-bitcoin/pull/3569)
+- io: Bump version to `0.1.3` [#3566](https://github.com/rust-bitcoin/rust-bitcoin/pull/3566)
+- Re-export `block::Header` as `BlockHeader` [#3562](https://github.com/rust-bitcoin/rust-bitcoin/pull/3562)
+- Bump `hex-conservative` to `0.3.0` [#3543](https://github.com/rust-bitcoin/rust-bitcoin/pull/3543)
+- Re-organise the `amount` module [#3541](https://github.com/rust-bitcoin/rust-bitcoin/pull/3541)
+- Improve the `amount` module [#3539](https://github.com/rust-bitcoin/rust-bitcoin/pull/3539)
+- base58: Close all errors [#3533](https://github.com/rust-bitcoin/rust-bitcoin/pull/3533)
+- psbt: Fix bug in `Subtype` consensus_encode [#3519](https://github.com/rust-bitcoin/rust-bitcoin/pull/3519)
+- Explicitly re-export stuff from crates down the stack [#3497](https://github.com/rust-bitcoin/rust-bitcoin/pull/3497)
+- Expose `units::amount::ParseError` [#3496](https://github.com/rust-bitcoin/rust-bitcoin/pull/3496)
+- Make `Amount::to_sat and SignedAmount::to_sat` const [#3493](https://github.com/rust-bitcoin/rust-bitcoin/pull/3493)
+- Decode an address string based on prefix [#3481](https://github.com/rust-bitcoin/rust-bitcoin/pull/3481)
+- Replace `ENABLE_RBF_NO_LOCKTIME` with `ENABLE_LOCKTIME_AND_RBF` [#3459](https://github.com/rust-bitcoin/rust-bitcoin/pull/3459)
+- Add version three variant to transaction version [#3450](https://github.com/rust-bitcoin/rust-bitcoin/pull/3450)
+- Input weight prediction helpers for nested P2WPKH [#3443](https://github.com/rust-bitcoin/rust-bitcoin/pull/3443)
+- Clarify sequence constant name and add `FINAL` [#3439](https://github.com/rust-bitcoin/rust-bitcoin/pull/3439)
+- Add checked div by weight to amount [#3430](https://github.com/rust-bitcoin/rust-bitcoin/pull/3430)
+- Rename `Midstate::into_parts` to `Midstate::to_parts` since it derives `Copy` [#3429](https://github.com/rust-bitcoin/rust-bitcoin/pull/3429)
+- Const locktime constructors [#3421](https://github.com/rust-bitcoin/rust-bitcoin/pull/3421)
+- Fix script number overflow check for `push_int` [#3392](https://github.com/rust-bitcoin/rust-bitcoin/pull/3392)
+- transaction: Remove `Default` implementations [#3386](https://github.com/rust-bitcoin/rust-bitcoin/pull/3386)
+- Add `FeeRate` addition and subtraction traits [#3381](https://github.com/rust-bitcoin/rust-bitcoin/pull/3381)
+- Add `Xpriv::to_xpub` and improve related method names [#3358](https://github.com/rust-bitcoin/rust-bitcoin/pull/3358)
+- Support `impl AsRef<[#u8]>` in `signed_msg_hash` [3357](https://github.com/rust-bitcoin/rust-bitcoin/pull/u8)
+- Fix `GetKey` for sets (plus some related changes) [#3356](https://github.com/rust-bitcoin/rust-bitcoin/pull/3356)
+- Add a condition for parsing zero from string when not denominated [#3346](https://github.com/rust-bitcoin/rust-bitcoin/pull/3346)
+- Add basic `miri` checks [#3328](https://github.com/rust-bitcoin/rust-bitcoin/pull/3328)
+- Add coinbase associated consts [#3308](https://github.com/rust-bitcoin/rust-bitcoin/pull/3308)
+- Fix bug in `ArrayVec::extend_from_slice` [#3272](https://github.com/rust-bitcoin/rust-bitcoin/pull/3272)
+- Change `T::from_str(s)` to `s.parse::<T>()` in examples, docs and tests [#3262](https://github.com/rust-bitcoin/rust-bitcoin/pull/3262)
+- Add `Arbitrary` to `Weight` [#3257](https://github.com/rust-bitcoin/rust-bitcoin/pull/3257)
+- Bump `units` version [#3248](https://github.com/rust-bitcoin/rust-bitcoin/pull/3248)
+- Rename key field in Key to key_data [#3048](https://github.com/rust-bitcoin/rust-bitcoin/pull/3048)
+- Optimize `base58` on small inputs [#3002](https://github.com/rust-bitcoin/rust-bitcoin/pull/3002)
+- Add `TxIdentifier` trait [#2987](https://github.com/rust-bitcoin/rust-bitcoin/pull/2987)
+- Fix `Amount` decimals handling [#2951](https://github.com/rust-bitcoin/rust-bitcoin/pull/2951)
+- `OP_RETURN` standardness check [#2949](https://github.com/rust-bitcoin/rust-bitcoin/pull/2949)
+- Support Testnet4 Network [#2945](https://github.com/rust-bitcoin/rust-bitcoin/pull/2945)
+- Remove `VarInt` and use `ReadExt` and `WriteExt` trait methods instead [#2931](https://github.com/rust-bitcoin/rust-bitcoin/pull/2931)
+- bip32: Add `From<&'a [#u32]>` for `DerivationPath` [2909](https://github.com/rust-bitcoin/rust-bitcoin/pull/u32)
+- psbt: Encode keytype as a compact size unsigned integer [#2906](https://github.com/rust-bitcoin/rust-bitcoin/pull/2906)
+- Pass sigs and associated types by value [#2899](https://github.com/rust-bitcoin/rust-bitcoin/pull/2899)
+- Re-export `UnprefixedHexError` in the bitcoin crate root [#2895](https://github.com/rust-bitcoin/rust-bitcoin/pull/2895)
+- taproot: Split errors up [#2886](https://github.com/rust-bitcoin/rust-bitcoin/pull/2886)
+- Remove usage of `blockdata` from paths [#2885](https://github.com/rust-bitcoin/rust-bitcoin/pull/2885)
+- Update `PushBytes::read_scriptint(x)` to `x.read_scriptint()` [#2872](https://github.com/rust-bitcoin/rust-bitcoin/pull/2872)
+- Remove `Denomination::MilliSatoshi` [#2870](https://github.com/rust-bitcoin/rust-bitcoin/pull/2870)
+- Pass keys by value [#2868](https://github.com/rust-bitcoin/rust-bitcoin/pull/2868)
+- Clarify the meaning of `Height` & `Time` based locktime [#2858](https://github.com/rust-bitcoin/rust-bitcoin/pull/2858)
+- Add API for extracting the inner payload of `RawNetworkMessage` [#2839](https://github.com/rust-bitcoin/rust-bitcoin/pull/2839)
+- Update `bitcoinconsensus` version to `0.106.0+26` [#2833] (https://github.com/rust-bitcoin/rust-bitcoin/pull/2833)
+- Make `difficulty_float` general to all networks [#2816](https://github.com/rust-bitcoin/rust-bitcoin/pull/2816)
+- Add const modifier to `Magic::from_bytes` [#2815](https://github.com/rust-bitcoin/rust-bitcoin/pull/2815)
+- Add an `AddressData` type [#2808](https://github.com/rust-bitcoin/rust-bitcoin/pull/2808)
+- Make `Address:p2sh_from_hash` public [#2795](https://github.com/rust-bitcoin/rust-bitcoin/pull/2795)
+- Enable getting the witness program from an address [#2796](https://github.com/rust-bitcoin/rust-bitcoin/pull/2796)
+- Enforce script size limit when hashing scripts [##2794](https://github.com/rust-bitcoin/rust-bitcoin/pull/2794https://github.com/rust-bitcoin/rust-bitcoin/pull/#2794)
+- Deprecate `to_vec` in favour of `to_bytes` [#2768](https://github.com/rust-bitcoin/rust-bitcoin/pull/2768)
+- Flesh out hex unit parsing API [#2765](https://github.com/rust-bitcoin/rust-bitcoin/pull/2765)
+- Bench `base58` encoding and remove `SmallVec` to improve perf [#2759](https://github.com/rust-bitcoin/rust-bitcoin/pull/2759)
+- Add difficulty adjustment calculation [#2740](https://github.com/rust-bitcoin/rust-bitcoin/pull/2740)
+- Upgrade `base64` dependency [#2721](https://github.com/rust-bitcoin/rust-bitcoin/pull/2721)
+- Some additional inspectors on `Script` and `Witness` [#2646](https://github.com/rust-bitcoin/rust-bitcoin/pull/2646)
 
 ## Upgrade notes
 
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index ee854c75b9..d17b7a7054 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bitcoin"
-version = "0.33.0-alpha"
+version = "0.33.0-alpha.0"
 authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
diff --git a/units/CHANGELOG.md b/units/CHANGELOG.md
index fd6a4e6e81..dbb1bab813 100644
--- a/units/CHANGELOG.md
+++ b/units/CHANGELOG.md
@@ -12,6 +12,7 @@
 * Error instead of panic when `Time::from_second_ceil` input is too large [#3052](https://github.com/rust-bitcoin/rust-bitcoin/pull/3052)
 * Remove re-export of `ParseIntError` [#3069](https://github.com/rust-bitcoin/rust-bitcoin/pull/3069)
 * Add `FeeRate` addition and subtraction traits [#3381](https://github.com/rust-bitcoin/rust-bitcoin/pull/3381)
+* Add `BlockHeight` and `BlockInterval` types [#2615](https://github.com/rust-bitcoin/rust-bitcoin/pull/2615)
 
 ## Additional test infrastructure:`Arbitrary`
 

From 6950c0a7b507f9d70c1ebdab540634482f73b247 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 4 Dec 2024 12:32:46 +0000
Subject: [PATCH 046/554] Change `Amount::MAX` to equal `MAX_MONEY`

To prevent rounding errors converting to and from f64 change
`Amount::MAX` to `MAX_MONEY` which is below the limit in f64 that has
issues.

Add checks to `from_str_in`, `checked_add` and `checked_mul` that the
result is below MAX, where previously a u64 overflow was relied on.

Change tests to account for new lower MAX that is within the range of
SignedAmount and does not overflow so easily

Remove overflow tests

`Amount::MAX` is now below `u64::MAX` and within the range of values for
`SignedAmount`.   These tests therefore do not overflow.
In effective_value there is no error with `Amount::MAX` and the correct
value is returned.
In psbt the removed test is effectively the same as the previous test.

Modify `Amount` tests to work with new `MAX`

Tests need to be changed that checked values above the new `MAX` or
`Amount::MAX` was out of range for `SignedAmount` which it isn't anymore
---
 bitcoin/src/blockdata/transaction.rs |  6 ----
 bitcoin/src/psbt/mod.rs              |  9 +----
 units/src/amount/tests.rs            | 50 ++++++++--------------------
 units/src/amount/unsigned.rs         | 20 +++++++++--
 4 files changed, 31 insertions(+), 54 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 6a91bcc512..35c0ff6066 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -1709,12 +1709,6 @@ mod tests {
         assert!(eff_value.is_none());
     }
 
-    #[test]
-    fn effective_value_value_does_not_overflow() {
-        let eff_value = effective_value(FeeRate::ZERO, Weight::ZERO, Amount::MAX);
-        assert!(eff_value.is_none());
-    }
-
     #[test]
     fn txin_txout_weight() {
         // [(is_segwit, tx_hex, expected_weight)]
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index e1e64dde0c..6de326a1dc 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -2159,7 +2159,7 @@ mod tests {
         let output_1_val = Amount::from_sat(100_000_000);
         let prev_output_val = Amount::from_sat(200_000_000);
 
-        let mut t = Psbt {
+        let t = Psbt {
             unsigned_tx: Transaction {
                 version: transaction::Version::TWO,
                 lock_time: absolute::LockTime::from_consensus(1257139),
@@ -2253,13 +2253,6 @@ mod tests {
             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]
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 0b22ea2ff8..dd4eb2e164 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -80,10 +80,6 @@ fn test_signed_amount_try_from_amount() {
     let ua_positive = Amount::from_sat(123);
     let sa_positive = SignedAmount::try_from(ua_positive).unwrap();
     assert_eq!(sa_positive, SignedAmount::from_sat(123));
-
-    let ua_max = Amount::MAX;
-    let result = SignedAmount::try_from(ua_max);
-    assert_eq!(result, Err(OutOfRangeError { is_signed: true, is_greater_than_max: true }));
 }
 
 #[test]
@@ -154,9 +150,6 @@ fn amount_checked_div_by_weight_ceil() {
     // round up to 864
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(864));
 
-    let fee_rate = Amount::MAX.checked_div_by_weight_ceil(weight);
-    assert!(fee_rate.is_none());
-
     let fee_rate = Amount::ONE_SAT.checked_div_by_weight_ceil(Weight::ZERO);
     assert!(fee_rate.is_none());
 }
@@ -175,9 +168,6 @@ fn amount_checked_div_by_weight_floor() {
     // round down to 863
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
 
-    let fee_rate = Amount::MAX.checked_div_by_weight_floor(weight);
-    assert!(fee_rate.is_none());
-
     let fee_rate = Amount::ONE_SAT.checked_div_by_weight_floor(Weight::ZERO);
     assert!(fee_rate.is_none());
 }
@@ -230,9 +220,6 @@ fn floating_point() {
     assert_eq!(sf(-184467440738.0, D::Bitcoin), Err(OutOfRangeError::too_small().into()));
     assert_eq!(f(18446744073709551617.0, D::Satoshi), Err(OutOfRangeError::too_big(false).into()));
 
-    // Amount can be grater than the max SignedAmount.
-    assert!(f(SignedAmount::MAX.to_float_in(D::Satoshi) + 1.0, D::Satoshi).is_ok());
-
     assert_eq!(
         f(Amount::MAX.to_float_in(D::Satoshi) + 1.0, D::Satoshi),
         Err(OutOfRangeError::too_big(false).into())
@@ -283,7 +270,7 @@ fn parsing() {
         Err(E::from(InvalidCharacterError { invalid_char: '.', position: 5 }))
     );
     #[cfg(feature = "alloc")]
-    let more_than_max = format!("1{}", Amount::MAX);
+    let more_than_max = format!("{}", Amount::MAX.to_sat() + 1);
     #[cfg(feature = "alloc")]
     assert_eq!(p(&more_than_max, btc), Err(OutOfRangeError::too_big(false).into()));
     assert_eq!(p("0.000000042", btc), Err(TooPreciseError { position: 10 }.into()));
@@ -300,20 +287,9 @@ fn parsing() {
     assert_eq!(p("1.1", btc), Ok(Amount::from_sat(1_100_000_00)));
     assert_eq!(p("100", sat), Ok(Amount::from_sat(100)));
     assert_eq!(p("55", sat), Ok(Amount::from_sat(55)));
-    assert_eq!(p("5500000000000000000", sat), Ok(Amount::from_sat(55_000_000_000_000_000_00)));
-    // Should this even pass?
-    assert_eq!(p("5500000000000000000.", sat), Ok(Amount::from_sat(55_000_000_000_000_000_00)));
-    assert_eq!(p("12345678901.12345678", btc), Ok(Amount::from_sat(12_345_678_901__123_456_78)));
-
-    // make sure satoshi > i64::MAX is checked.
-    #[cfg(feature = "alloc")]
-    {
-        let amount = Amount::from_sat(i64::MAX as u64);
-        assert_eq!(Amount::from_str_in(&amount.to_string_in(sat), sat), Ok(amount));
-        assert!(SignedAmount::from_str_in(&(amount + Amount::from_sat(1)).to_string_in(sat), sat)
-            .is_err());
-        assert!(Amount::from_str_in(&(amount + Amount::from_sat(1)).to_string_in(sat), sat).is_ok());
-    }
+    assert_eq!(p("2100000000000000", sat), Ok(Amount::from_sat(21_000_000__000_000_00)));
+    assert_eq!(p("2100000000000000.", sat), Ok(Amount::from_sat(21_000_000__000_000_00)));
+    assert_eq!(p("21000000", btc), Ok(Amount::from_sat(21_000_000__000_000_00)));
 
     // exactly 50 chars.
     assert_eq!(
@@ -523,14 +499,14 @@ check_format_non_negative_show_denom! {
 fn test_unsigned_signed_conversion() {
     let sa = SignedAmount::from_sat;
     let ua = Amount::from_sat;
+    let max_sats: u64 = Amount::MAX.to_sat();
 
-    assert_eq!(Amount::MAX.to_signed(), Err(OutOfRangeError::too_big(true)));
-    assert_eq!(ua(i64::MAX as u64).to_signed(), Ok(sa(i64::MAX)));
+    assert_eq!(ua(max_sats).to_signed(), Ok(sa(max_sats as i64)));
     assert_eq!(ua(i64::MAX as u64 + 1).to_signed(), Err(OutOfRangeError::too_big(true)));
 
-    assert_eq!(sa(i64::MAX).to_unsigned(), Ok(ua(i64::MAX as u64)));
+    assert_eq!(sa(max_sats as i64).to_unsigned(), Ok(ua(max_sats)));
 
-    assert_eq!(sa(i64::MAX).to_unsigned().unwrap().to_signed(), Ok(sa(i64::MAX)));
+    assert_eq!(sa(max_sats as i64).to_unsigned().unwrap().to_signed(), Ok(sa(max_sats as i64)));
 }
 
 #[test]
@@ -638,7 +614,7 @@ fn to_from_string_in() {
         ua_str(&ua_sat(1_000_000_000_000).to_string_in(D::MilliBitcoin), D::MilliBitcoin),
         Ok(ua_sat(1_000_000_000_000))
     );
-    assert!(ua_str(&ua_sat(u64::MAX).to_string_in(D::MilliBitcoin), D::MilliBitcoin).is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MilliBitcoin), D::MilliBitcoin).is_ok());
 
     assert_eq!(sa_str(&sa_sat(-1).to_string_in(D::MicroBitcoin), D::MicroBitcoin), Ok(sa_sat(-1)));
 
@@ -718,12 +694,12 @@ fn serde_as_btc() {
     }
 
     let orig = T {
-        amt: Amount::from_sat(21_000_000__000_000_01),
-        samt: SignedAmount::from_sat(-21_000_000__000_000_01),
+        amt: Amount::from_sat(20_000_000__000_000_01),
+        samt: SignedAmount::from_sat(-20_000_000__000_000_01),
     };
 
-    let json = "{\"amt\": 21000000.00000001, \
-                \"samt\": -21000000.00000001}";
+    let json = "{\"amt\": 20000000.00000001, \
+                \"samt\": -20000000.00000001}";
     let t: T = serde_json::from_str(json).unwrap();
     assert_eq!(t, orig);
 
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index fd5b0613f6..9b96c4d510 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -65,7 +65,7 @@ impl Amount {
     /// 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);
+    pub const MAX: Amount = Amount::MAX_MONEY;
     /// The number of bytes that an amount contributes to the size of a transaction.
     pub const SIZE: usize = 8; // Serialized length of a u64.
 
@@ -120,6 +120,11 @@ impl Amount {
                 OutOfRangeError::negative(),
             )));
         }
+        if satoshi > Self::MAX.0 {
+            return Err(ParseAmountError(ParseAmountErrorInner::OutOfRange(
+                OutOfRangeError::too_big(false),
+            )));
+        }
         Ok(Amount::from_sat(satoshi))
     }
 
@@ -214,7 +219,7 @@ impl Amount {
     pub const fn checked_add(self, rhs: Amount) -> Option<Amount> {
         // No `map()` in const context.
         match self.0.checked_add(rhs.0) {
-            Some(res) => Some(Amount(res)),
+            Some(res) => Amount(res).check_max(),
             None => None,
         }
     }
@@ -236,7 +241,7 @@ impl Amount {
     pub const fn checked_mul(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
         match self.0.checked_mul(rhs) {
-            Some(res) => Some(Amount(res)),
+            Some(res) => Amount(res).check_max(),
             None => None,
         }
     }
@@ -332,6 +337,15 @@ impl Amount {
             Ok(SignedAmount::from_sat(self.to_sat() as i64))
         }
     }
+
+    /// Checks if the amount is below the maximum value.  Returns `None` if it is above.
+    const fn check_max(self) -> Option<Amount> {
+        if self.0 > Self::MAX.0 {
+            None
+        } else {
+            Some(self)
+        }
+    }
 }
 
 impl default::Default for Amount {

From 219ecd54980f28d02953fd5158ec8c3d6a034dc1 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 6 Dec 2024 15:20:52 +1100
Subject: [PATCH 047/554] Add api text files

We are about to introduce a script that generates text files for the
public API surface of various crates.

Run the soon-to-be-introduced script and commit the changes. Covers:

- `hashes`
- `io`
- `primitives`
- `units`

The script and CI setup will be done in the next patch, this is just to
make review easier.
---
 api/README.md                   |   12 +
 api/hashes/all-features.txt     | 1094 ++++++++++++++++++
 api/hashes/alloc-only.txt       |  945 ++++++++++++++++
 api/hashes/no-features.txt      |  882 +++++++++++++++
 api/io/all-features.txt         |  377 +++++++
 api/io/alloc-only.txt           |  135 +++
 api/io/no-features.txt          |  127 +++
 api/primitives/all-features.txt | 1873 +++++++++++++++++++++++++++++++
 api/primitives/alloc-only.txt   | 1740 ++++++++++++++++++++++++++++
 api/primitives/no-features.txt  | 1098 ++++++++++++++++++
 api/units/all-features.txt      | 1218 ++++++++++++++++++++
 api/units/alloc-only.txt        | 1109 ++++++++++++++++++
 api/units/no-features.txt       | 1063 ++++++++++++++++++
 13 files changed, 11673 insertions(+)
 create mode 100644 api/README.md
 create mode 100644 api/hashes/all-features.txt
 create mode 100644 api/hashes/alloc-only.txt
 create mode 100644 api/hashes/no-features.txt
 create mode 100644 api/io/all-features.txt
 create mode 100644 api/io/alloc-only.txt
 create mode 100644 api/io/no-features.txt
 create mode 100644 api/primitives/all-features.txt
 create mode 100644 api/primitives/alloc-only.txt
 create mode 100644 api/primitives/no-features.txt
 create mode 100644 api/units/all-features.txt
 create mode 100644 api/units/alloc-only.txt
 create mode 100644 api/units/no-features.txt

diff --git a/api/README.md b/api/README.md
new file mode 100644
index 0000000000..8979cd542d
--- /dev/null
+++ b/api/README.md
@@ -0,0 +1,12 @@
+# API text files
+
+Each file here lists the public API when built with some set of features
+enabled. To create these files run `../contrib/check-for-api-changes.sh`:
+
+Requires `cargo-public-api`, install with:
+
+```
+cargo +stable install cargo-public-api --locked
+```
+
+ref: https://github.com/enselic/cargo-public-api
diff --git a/api/hashes/all-features.txt b/api/hashes/all-features.txt
new file mode 100644
index 0000000000..1f85ee2724
--- /dev/null
+++ b/api/hashes/all-features.txt
@@ -0,0 +1,1094 @@
+#[repr(transparent)] pub struct bitcoin_hashes::Hash160(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Hmac<T: bitcoin_hashes::GeneralHash>(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Ripemd160(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha1(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha256(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha256d(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha384(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha512(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha512_256(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Siphash24(_)
+#[repr(transparent)] pub struct bitcoin_hashes::hash160::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::hmac::Hmac<T: bitcoin_hashes::GeneralHash>(_)
+#[repr(transparent)] pub struct bitcoin_hashes::ripemd160::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha1::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256d::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256t::Hash<T>(_, _)
+#[repr(transparent)] pub struct bitcoin_hashes::sha384::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha512::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha512_256::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::siphash24::Hash(_)
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::hash160::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::ripemd160::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha1::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256d::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha384::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512_256::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::siphash24::HashEngine
+impl bitcoin_hashes::error::FromSliceError
+impl bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::hash160::HashEngine
+impl bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::ripemd160::HashEngine
+impl bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::sha1::HashEngine
+impl bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::sha256::HashEngine
+impl bitcoin_hashes::sha256::Midstate
+impl bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::sha256d::HashEngine
+impl bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::sha384::HashEngine
+impl bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::sha512::HashEngine
+impl bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::sha512_256::HashEngine
+impl bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::siphash24::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::hash160::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::ripemd160::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::sha1::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::sha256::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::sha256d::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::sha384::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::sha512::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::sha512_256::HashEngine
+impl bitcoin_io::Write for bitcoin_hashes::siphash24::HashEngine
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::hash160::Hash
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::sha1::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256d::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
+impl core::borrow::Borrow<[u8; 48]> for bitcoin_hashes::sha384::Hash
+impl core::borrow::Borrow<[u8; 64]> for bitcoin_hashes::sha512::Hash
+impl core::borrow::Borrow<[u8; 8]> for bitcoin_hashes::siphash24::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::hash160::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::ripemd160::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha1::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256d::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha384::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512_256::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::siphash24::Hash
+impl core::clone::Clone for bitcoin_hashes::error::FromSliceError
+impl core::clone::Clone for bitcoin_hashes::hash160::Hash
+impl core::clone::Clone for bitcoin_hashes::hash160::HashEngine
+impl core::clone::Clone for bitcoin_hashes::hkdf::MaxLengthError
+impl core::clone::Clone for bitcoin_hashes::ripemd160::Hash
+impl core::clone::Clone for bitcoin_hashes::ripemd160::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha1::Hash
+impl core::clone::Clone for bitcoin_hashes::sha1::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha256::Hash
+impl core::clone::Clone for bitcoin_hashes::sha256::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha256::Midstate
+impl core::clone::Clone for bitcoin_hashes::sha256::MidstateError
+impl core::clone::Clone for bitcoin_hashes::sha256d::Hash
+impl core::clone::Clone for bitcoin_hashes::sha256d::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha384::Hash
+impl core::clone::Clone for bitcoin_hashes::sha384::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha512::Hash
+impl core::clone::Clone for bitcoin_hashes::sha512::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha512_256::Hash
+impl core::clone::Clone for bitcoin_hashes::sha512_256::HashEngine
+impl core::clone::Clone for bitcoin_hashes::siphash24::Hash
+impl core::clone::Clone for bitcoin_hashes::siphash24::HashEngine
+impl core::clone::Clone for bitcoin_hashes::siphash24::State
+impl core::cmp::Eq for bitcoin_hashes::error::FromSliceError
+impl core::cmp::Eq for bitcoin_hashes::hash160::Hash
+impl core::cmp::Eq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::cmp::Eq for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha1::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha256::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha256::Midstate
+impl core::cmp::Eq for bitcoin_hashes::sha256::MidstateError
+impl core::cmp::Eq for bitcoin_hashes::sha256d::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha384::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha512::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::Eq for bitcoin_hashes::siphash24::Hash
+impl core::cmp::Ord for bitcoin_hashes::hash160::Hash
+impl core::cmp::Ord for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha1::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha256::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha256::Midstate
+impl core::cmp::Ord for bitcoin_hashes::sha256d::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha384::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha512::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::Ord for bitcoin_hashes::siphash24::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::error::FromSliceError
+impl core::cmp::PartialEq for bitcoin_hashes::hash160::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::cmp::PartialEq for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha1::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::Midstate
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::MidstateError
+impl core::cmp::PartialEq for bitcoin_hashes::sha256d::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha384::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha512::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::siphash24::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::hash160::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha1::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Midstate
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256d::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha384::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha512::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::siphash24::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::hash160::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::sha1::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256d::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
+impl core::convert::AsRef<[u8; 48]> for bitcoin_hashes::sha384::Hash
+impl core::convert::AsRef<[u8; 64]> for bitcoin_hashes::sha512::Hash
+impl core::convert::AsRef<[u8; 8]> for bitcoin_hashes::siphash24::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::hash160::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::ripemd160::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha1::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Midstate
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256d::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha384::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512_256::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::siphash24::Hash
+impl core::convert::From<core::convert::Infallible> for bitcoin_hashes::error::FromSliceError
+impl core::default::Default for bitcoin_hashes::hash160::HashEngine
+impl core::default::Default for bitcoin_hashes::ripemd160::HashEngine
+impl core::default::Default for bitcoin_hashes::sha1::HashEngine
+impl core::default::Default for bitcoin_hashes::sha256::HashEngine
+impl core::default::Default for bitcoin_hashes::sha256::Midstate
+impl core::default::Default for bitcoin_hashes::sha256d::HashEngine
+impl core::default::Default for bitcoin_hashes::sha384::HashEngine
+impl core::default::Default for bitcoin_hashes::sha512::HashEngine
+impl core::default::Default for bitcoin_hashes::sha512_256::HashEngine
+impl core::error::Error for bitcoin_hashes::error::FromSliceError
+impl core::error::Error for bitcoin_hashes::hkdf::MaxLengthError
+impl core::error::Error for bitcoin_hashes::sha256::MidstateError
+impl core::fmt::Debug for bitcoin_hashes::error::FromSliceError
+impl core::fmt::Debug for bitcoin_hashes::hash160::Hash
+impl core::fmt::Debug for bitcoin_hashes::hkdf::MaxLengthError
+impl core::fmt::Debug for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha1::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha256::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha256::Midstate
+impl core::fmt::Debug for bitcoin_hashes::sha256::MidstateError
+impl core::fmt::Debug for bitcoin_hashes::sha256d::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha384::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha512::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::Debug for bitcoin_hashes::siphash24::Hash
+impl core::fmt::Debug for bitcoin_hashes::siphash24::HashEngine
+impl core::fmt::Debug for bitcoin_hashes::siphash24::State
+impl core::fmt::Display for bitcoin_hashes::error::FromSliceError
+impl core::fmt::Display for bitcoin_hashes::hash160::Hash
+impl core::fmt::Display for bitcoin_hashes::hkdf::MaxLengthError
+impl core::fmt::Display for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::Display for bitcoin_hashes::sha1::Hash
+impl core::fmt::Display for bitcoin_hashes::sha256::Hash
+impl core::fmt::Display for bitcoin_hashes::sha256::MidstateError
+impl core::fmt::Display for bitcoin_hashes::sha256d::Hash
+impl core::fmt::Display for bitcoin_hashes::sha384::Hash
+impl core::fmt::Display for bitcoin_hashes::sha512::Hash
+impl core::fmt::Display for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::Display for bitcoin_hashes::siphash24::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::hash160::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha1::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha256::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha256d::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha384::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha512::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::siphash24::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::hash160::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha1::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha256::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha256d::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha384::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha512::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::siphash24::Hash
+impl core::hash::Hash for bitcoin_hashes::hash160::Hash
+impl core::hash::Hash for bitcoin_hashes::ripemd160::Hash
+impl core::hash::Hash for bitcoin_hashes::sha1::Hash
+impl core::hash::Hash for bitcoin_hashes::sha256::Hash
+impl core::hash::Hash for bitcoin_hashes::sha256::Midstate
+impl core::hash::Hash for bitcoin_hashes::sha256d::Hash
+impl core::hash::Hash for bitcoin_hashes::sha384::Hash
+impl core::hash::Hash for bitcoin_hashes::sha512::Hash
+impl core::hash::Hash for bitcoin_hashes::sha512_256::Hash
+impl core::hash::Hash for bitcoin_hashes::siphash24::Hash
+impl core::marker::Copy for bitcoin_hashes::hash160::Hash
+impl core::marker::Copy for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Copy for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Copy for bitcoin_hashes::sha1::Hash
+impl core::marker::Copy for bitcoin_hashes::sha256::Hash
+impl core::marker::Copy for bitcoin_hashes::sha256::Midstate
+impl core::marker::Copy for bitcoin_hashes::sha256d::Hash
+impl core::marker::Copy for bitcoin_hashes::sha384::Hash
+impl core::marker::Copy for bitcoin_hashes::sha512::Hash
+impl core::marker::Copy for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Copy for bitcoin_hashes::siphash24::Hash
+impl core::marker::Freeze for bitcoin_hashes::error::FromSliceError
+impl core::marker::Freeze for bitcoin_hashes::hash160::Hash
+impl core::marker::Freeze for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Freeze for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Freeze for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha1::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha256::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha256::Midstate
+impl core::marker::Freeze for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Freeze for bitcoin_hashes::sha256d::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha384::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha512::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::siphash24::Hash
+impl core::marker::Freeze for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::siphash24::State
+impl core::marker::Send for bitcoin_hashes::error::FromSliceError
+impl core::marker::Send for bitcoin_hashes::hash160::Hash
+impl core::marker::Send for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Send for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Send for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Send for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha1::Hash
+impl core::marker::Send for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha256::Hash
+impl core::marker::Send for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha256::Midstate
+impl core::marker::Send for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Send for bitcoin_hashes::sha256d::Hash
+impl core::marker::Send for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha384::Hash
+impl core::marker::Send for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha512::Hash
+impl core::marker::Send for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Send for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Send for bitcoin_hashes::siphash24::Hash
+impl core::marker::Send for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Send for bitcoin_hashes::siphash24::State
+impl core::marker::StructuralPartialEq for bitcoin_hashes::error::FromSliceError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::hash160::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::ripemd160::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha1::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Midstate
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::MidstateError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256d::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha384::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512_256::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::siphash24::Hash
+impl core::marker::Sync for bitcoin_hashes::error::FromSliceError
+impl core::marker::Sync for bitcoin_hashes::hash160::Hash
+impl core::marker::Sync for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Sync for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Sync for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Sync for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha1::Hash
+impl core::marker::Sync for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha256::Hash
+impl core::marker::Sync for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha256::Midstate
+impl core::marker::Sync for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Sync for bitcoin_hashes::sha256d::Hash
+impl core::marker::Sync for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha384::Hash
+impl core::marker::Sync for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha512::Hash
+impl core::marker::Sync for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Sync for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Sync for bitcoin_hashes::siphash24::Hash
+impl core::marker::Sync for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Sync for bitcoin_hashes::siphash24::State
+impl core::marker::Unpin for bitcoin_hashes::error::FromSliceError
+impl core::marker::Unpin for bitcoin_hashes::hash160::Hash
+impl core::marker::Unpin for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Unpin for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Unpin for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha1::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha256::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha256::Midstate
+impl core::marker::Unpin for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Unpin for bitcoin_hashes::sha256d::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha384::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha512::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::siphash24::Hash
+impl core::marker::Unpin for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::siphash24::State
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::error::FromSliceError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Midstate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::MidstateError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::State
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::error::FromSliceError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Midstate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::MidstateError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::State
+impl core::str::traits::FromStr for bitcoin_hashes::hash160::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::ripemd160::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha1::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha256::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha256d::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha384::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha512::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha512_256::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::siphash24::Hash
+impl serde::ser::Serialize for bitcoin_hashes::hash160::Hash
+impl serde::ser::Serialize for bitcoin_hashes::ripemd160::Hash
+impl serde::ser::Serialize for bitcoin_hashes::sha1::Hash
+impl serde::ser::Serialize for bitcoin_hashes::sha256::Hash
+impl serde::ser::Serialize for bitcoin_hashes::sha256d::Hash
+impl serde::ser::Serialize for bitcoin_hashes::sha384::Hash
+impl serde::ser::Serialize for bitcoin_hashes::sha512::Hash
+impl serde::ser::Serialize for bitcoin_hashes::sha512_256::Hash
+impl serde::ser::Serialize for bitcoin_hashes::siphash24::Hash
+impl std::io::Write for bitcoin_hashes::hash160::HashEngine
+impl std::io::Write for bitcoin_hashes::ripemd160::HashEngine
+impl std::io::Write for bitcoin_hashes::sha1::HashEngine
+impl std::io::Write for bitcoin_hashes::sha256::HashEngine
+impl std::io::Write for bitcoin_hashes::sha256d::HashEngine
+impl std::io::Write for bitcoin_hashes::sha384::HashEngine
+impl std::io::Write for bitcoin_hashes::sha512::HashEngine
+impl std::io::Write for bitcoin_hashes::sha512_256::HashEngine
+impl std::io::Write for bitcoin_hashes::siphash24::HashEngine
+impl<'de, T: bitcoin_hashes::GeneralHash + serde::de::Deserialize<'de>> serde::de::Deserialize<'de> for bitcoin_hashes::hmac::Hmac<T>
+impl<'de, T: bitcoin_hashes::sha256t::Tag> serde::de::Deserialize<'de> for bitcoin_hashes::sha256t::Hash<T>
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::hash160::Hash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::ripemd160::Hash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha1::Hash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha256::Hash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha256d::Hash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha384::Hash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha512::Hash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha512_256::Hash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::siphash24::Hash
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::Debug> core::fmt::Debug for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::Display> core::fmt::Display for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::LowerHex> core::fmt::LowerHex for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::str::traits::FromStr> core::str::traits::FromStr for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + serde::ser::Serialize> serde::ser::Serialize for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_io::Write for bitcoin_hashes::hmac::HmacEngine<T>
+impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> core::default::Default for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> std::io::Write for bitcoin_hashes::hmac::HmacEngine<T>
+impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::Hash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::clone::Clone for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Eq for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Ord for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::default::Default for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Display for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::LowerHex for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::UpperHex for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::hash::Hash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::marker::Copy for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::str::traits::FromStr for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> serde::ser::Serialize for bitcoin_hashes::sha256t::Hash<T>
+impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::clone::Clone
+impl<T: core::cmp::Eq + bitcoin_hashes::GeneralHash> core::cmp::Eq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::Ord + bitcoin_hashes::GeneralHash> core::cmp::Ord for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::PartialEq + bitcoin_hashes::GeneralHash> core::cmp::PartialEq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::PartialOrd + bitcoin_hashes::GeneralHash> core::cmp::PartialOrd for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::hash::Hash + bitcoin_hashes::GeneralHash> core::hash::Hash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::marker::Copy + bitcoin_hashes::GeneralHash> core::marker::Copy for bitcoin_hashes::hmac::Hmac<T>
+impl<T> bitcoin_hashes::sha256t::Hash<T> where T: bitcoin_hashes::sha256t::Tag
+impl<T> core::marker::Freeze for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::sha256t::Hash<T>
+impl<T> core::marker::Send for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Send
+impl<T> core::marker::Sync for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Unpin
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<ValueT, const N: usize> core::default::Default for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>
+impl<ValueT, const N: usize> core::marker::Freeze for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>
+impl<ValueT, const N: usize> core::marker::Send for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::marker::Send
+impl<ValueT, const N: usize> core::marker::Sync for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::marker::Sync
+impl<ValueT, const N: usize> core::marker::Unpin for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::marker::Unpin
+impl<ValueT, const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::panic::unwind_safe::RefUnwindSafe
+impl<ValueT, const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::panic::unwind_safe::UnwindSafe
+impl<ValueT, const N: usize> serde::de::Visitor<'_> for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: bitcoin_hashes::Hash + bitcoin_hashes::Hash<Bytes = [u8; N]>
+impl<ValueT> core::default::Default for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>
+impl<ValueT> core::marker::Freeze for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>
+impl<ValueT> core::marker::Send for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::marker::Send
+impl<ValueT> core::marker::Sync for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::marker::Sync
+impl<ValueT> core::marker::Unpin for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::marker::Unpin
+impl<ValueT> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::panic::unwind_safe::RefUnwindSafe
+impl<ValueT> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::panic::unwind_safe::UnwindSafe
+impl<ValueT> serde::de::Visitor<'_> for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::str::traits::FromStr, <ValueT as core::str::traits::FromStr>::Err: core::fmt::Display
+impl<const N: usize> bitcoin_hashes::IsByteArray for [u8; N]
+pub const [u8; N]::LEN: usize
+pub const bitcoin_hashes::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::Hash::LEN: usize
+pub const bitcoin_hashes::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::IsByteArray::LEN: usize
+pub const bitcoin_hashes::hash160::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::hash160::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::hmac::HmacEngine<T>::BLOCK_SIZE: usize
+pub const bitcoin_hashes::ripemd160::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::ripemd160::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha1::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha1::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha256::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256d::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha256d::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256t::Hash<T>::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha384::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha384::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha512::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha512::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha512_256::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha512_256::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize
+pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::hash160::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::ripemd160::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::sha1::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::hash_unoptimized(bytes: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha256::HashEngine::can_extract_midstate(&self) -> bool
+pub const fn bitcoin_hashes::sha256::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::as_parts(&self) -> (&[u8; 32], u64)
+pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::new(state: [u8; 32], bytes_hashed: u64) -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::to_parts(self) -> ([u8; 32], u64)
+pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha256d::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48]
+pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self
+pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48]
+pub const fn bitcoin_hashes::sha384::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64]
+pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self
+pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64]
+pub const fn bitcoin_hashes::sha512::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha512_256::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8]
+pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self
+pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8]
+pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
+pub extern crate bitcoin_hashes::hex
+pub extern crate bitcoin_hashes::serde
+pub fn bitcoin_hashes::GeneralHash::engine() -> Self::Engine where Self::Engine: core::default::Default
+pub fn bitcoin_hashes::GeneralHash::from_engine(e: Self::Engine) -> Self
+pub fn bitcoin_hashes::GeneralHash::hash(data: &[u8]) -> Self where Self::Engine: core::default::Default
+pub fn bitcoin_hashes::GeneralHash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>, Self::Engine: core::default::Default
+pub fn bitcoin_hashes::GeneralHash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error> where Self::Engine: core::default::Default
+pub fn bitcoin_hashes::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::Hash::from_slice(sl: &[u8]) -> core::result::Result<Self, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::cmp::fixed_time_eq(a: &[u8], b: &[u8]) -> bool
+pub fn bitcoin_hashes::debug_hex(bytes: &[u8], f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::error::FromSliceError::clone(&self) -> bitcoin_hashes::error::FromSliceError
+pub fn bitcoin_hashes::error::FromSliceError::eq(&self, other: &bitcoin_hashes::error::FromSliceError) -> bool
+pub fn bitcoin_hashes::error::FromSliceError::expected_length(&self) -> usize
+pub fn bitcoin_hashes::error::FromSliceError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::error::FromSliceError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_hashes::error::FromSliceError::invalid_length(&self) -> usize
+pub fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash
+pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::hash160::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::hash160::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::hash160::HashEngine
+pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool
+pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::hash160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::hash160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::hash160::HashEngine) -> bitcoin_hashes::hash160::Hash
+pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hash160::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::hash160::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::hash160::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::hash160::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::hash160::HashEngine::clone(&self) -> bitcoin_hashes::hash160::HashEngine
+pub fn bitcoin_hashes::hash160::HashEngine::default() -> Self
+pub fn bitcoin_hashes::hash160::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::hash160::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::hash160::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::hash160::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::hash160::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::hash160::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand(&self, info: &[u8], okm: &mut [u8]) -> core::result::Result<(), bitcoin_hashes::hkdf::MaxLengthError>
+pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand_to_len(&self, info: &[u8], len: usize) -> core::result::Result<alloc::vec::Vec<u8>, bitcoin_hashes::hkdf::MaxLengthError>
+pub fn bitcoin_hashes::hkdf::Hkdf<T>::new(salt: &[u8], ikm: &[u8]) -> Self
+pub fn bitcoin_hashes::hkdf::MaxLengthError::clone(&self) -> bitcoin_hashes::hkdf::MaxLengthError
+pub fn bitcoin_hashes::hkdf::MaxLengthError::eq(&self, other: &bitcoin_hashes::hkdf::MaxLengthError) -> bool
+pub fn bitcoin_hashes::hkdf::MaxLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hmac::Hmac<T>::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
+pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
+pub fn bitcoin_hashes::hmac::Hmac<T>::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
+pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_engine(e: bitcoin_hashes::hmac::HmacEngine<T>) -> bitcoin_hashes::hmac::Hmac<T>
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::hmac::Hmac<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::hmac::Hmac<T>::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::default() -> Self
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::input(&mut self, buf: &[u8])
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::new(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>::default() -> Self
+pub fn bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>::expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>::visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E> where E: serde::de::Error
+pub fn bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::default() -> Self
+pub fn bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E> where E: serde::de::Error
+pub fn bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E> where E: serde::de::Error
+pub fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash
+pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::ripemd160::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::ripemd160::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine
+pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool
+pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160::HashEngine) -> bitcoin_hashes::ripemd160::Hash
+pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::ripemd160::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::ripemd160::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::ripemd160::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::ripemd160::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::ripemd160::HashEngine::clone(&self) -> bitcoin_hashes::ripemd160::HashEngine
+pub fn bitcoin_hashes::ripemd160::HashEngine::default() -> Self
+pub fn bitcoin_hashes::ripemd160::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::ripemd160::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::ripemd160::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::ripemd160::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::ripemd160::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::ripemd160::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash
+pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha1::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha1::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine
+pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool
+pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha1::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::sha1::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngine) -> bitcoin_hashes::sha1::Hash
+pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha1::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha1::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha1::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha1::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha1::HashEngine::clone(&self) -> bitcoin_hashes::sha1::HashEngine
+pub fn bitcoin_hashes::sha1::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha1::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::sha1::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::sha1::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha1::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha1::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::sha1::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash
+pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha256::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool
+pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256::Hash
+pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256::HashEngine::clone(&self) -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha256::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::sha256::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::sha256::HashEngine::from_midstate(midstate: bitcoin_hashes::sha256::Midstate) -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha256::HashEngine::midstate(&self) -> core::result::Result<bitcoin_hashes::sha256::Midstate, bitcoin_hashes::sha256::MidstateError>
+pub fn bitcoin_hashes::sha256::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha256::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::sha256::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::sha256::Midstate::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Midstate::clone(&self) -> bitcoin_hashes::sha256::Midstate
+pub fn bitcoin_hashes::sha256::Midstate::cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256::Midstate::default() -> bitcoin_hashes::sha256::Midstate
+pub fn bitcoin_hashes::sha256::Midstate::eq(&self, other: &bitcoin_hashes::sha256::Midstate) -> bool
+pub fn bitcoin_hashes::sha256::Midstate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256::MidstateError::clone(&self) -> bitcoin_hashes::sha256::MidstateError
+pub fn bitcoin_hashes::sha256::MidstateError::eq(&self, other: &bitcoin_hashes::sha256::MidstateError) -> bool
+pub fn bitcoin_hashes::sha256::MidstateError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256d::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha256d::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256d::HashEngine
+pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool
+pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256d::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256d::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256d::HashEngine) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256d::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256d::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256d::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256d::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256d::HashEngine::clone(&self) -> bitcoin_hashes::sha256d::HashEngine
+pub fn bitcoin_hashes::sha256d::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha256d::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::sha256d::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::sha256d::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::sha256d::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha256d::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::sha256d::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256t::Hash<T>::default() -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
+pub fn bitcoin_hashes::sha256t::Hash<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash<T>
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash<H: core::hash::Hasher>(&self, h: &mut H)
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::sha256t::Hash<T>::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256t::Hash<T>::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8; 48]
+pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8; 48]
+pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash
+pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha384::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha384::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine
+pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool
+pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha384::Hash::from_bytes_mut(bytes: &mut [u8; 48]) -> &mut Self
+pub fn bitcoin_hashes::sha384::Hash::from_bytes_ref(bytes: &[u8; 48]) -> &Self
+pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::HashEngine) -> bitcoin_hashes::sha384::Hash
+pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha384::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha384::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha384::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha384::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha384::HashEngine::clone(&self) -> bitcoin_hashes::sha384::HashEngine
+pub fn bitcoin_hashes::sha384::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha384::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::sha384::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::sha384::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha384::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha384::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::sha384::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8; 64]
+pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8; 64]
+pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash
+pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha512::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha512::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine
+pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool
+pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha512::Hash::from_bytes_mut(bytes: &mut [u8; 64]) -> &mut Self
+pub fn bitcoin_hashes::sha512::Hash::from_bytes_ref(bytes: &[u8; 64]) -> &Self
+pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::HashEngine) -> bitcoin_hashes::sha512::Hash
+pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha512::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha512::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha512::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha512::HashEngine::clone(&self) -> bitcoin_hashes::sha512::HashEngine
+pub fn bitcoin_hashes::sha512::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha512::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::sha512::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::sha512::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha512::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha512::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::sha512::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash
+pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha512_256::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha512_256::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine
+pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool
+pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_256::HashEngine) -> bitcoin_hashes::sha512_256::Hash
+pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512_256::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha512_256::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha512_256::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
+pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha512_256::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha512_256::HashEngine::clone(&self) -> bitcoin_hashes::sha512_256::HashEngine
+pub fn bitcoin_hashes::sha512_256::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha512_256::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::sha512_256::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::sha512_256::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha512_256::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha512_256::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::sha512_256::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8; 8]
+pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::siphash24::Hash::as_u64(&self) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8; 8]
+pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::siphash24::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::siphash24::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
+pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::siphash24::Hash::from_bytes_mut(bytes: &mut [u8; 8]) -> &mut Self
+pub fn bitcoin_hashes::siphash24::Hash::from_bytes_ref(bytes: &[u8; 8]) -> &Self
+pub fn bitcoin_hashes::siphash24::Hash::from_engine(e: bitcoin_hashes::siphash24::HashEngine) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::from_engine_to_u64(e: bitcoin_hashes::siphash24::HashEngine) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::siphash24::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::siphash24::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::partial_cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::siphash24::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::siphash24::Hash::to_u64(self) -> u64
+pub fn bitcoin_hashes::siphash24::HashEngine::clone(&self) -> bitcoin_hashes::siphash24::HashEngine
+pub fn bitcoin_hashes::siphash24::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_hashes::siphash24::HashEngine::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_hashes::siphash24::HashEngine::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::siphash24::HashEngine::input(&mut self, msg: &[u8])
+pub fn bitcoin_hashes::siphash24::HashEngine::keys(&self) -> (u64, u64)
+pub fn bitcoin_hashes::siphash24::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::siphash24::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_hashes::siphash24::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_hashes::siphash24::State::clone(&self) -> bitcoin_hashes::siphash24::State
+pub fn bitcoin_hashes::siphash24::State::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub macro bitcoin_hashes::hash_newtype!
+pub macro bitcoin_hashes::impl_debug_only_for_newtype!
+pub macro bitcoin_hashes::impl_hex_for_newtype!
+pub macro bitcoin_hashes::impl_serde_for_newtype!
+pub macro bitcoin_hashes::sha256t_hash_newtype!
+pub macro bitcoin_hashes::sha256t_tag!
+pub mod bitcoin_hashes
+pub mod bitcoin_hashes::cmp
+pub mod bitcoin_hashes::error
+pub mod bitcoin_hashes::hash160
+pub mod bitcoin_hashes::hkdf
+pub mod bitcoin_hashes::hmac
+pub mod bitcoin_hashes::macros
+pub mod bitcoin_hashes::macros::serde_details
+pub mod bitcoin_hashes::ripemd160
+pub mod bitcoin_hashes::serde_macros
+pub mod bitcoin_hashes::serde_macros::serde_details
+pub mod bitcoin_hashes::sha1
+pub mod bitcoin_hashes::sha256
+pub mod bitcoin_hashes::sha256d
+pub mod bitcoin_hashes::sha256t
+pub mod bitcoin_hashes::sha384
+pub mod bitcoin_hashes::sha512
+pub mod bitcoin_hashes::sha512_256
+pub mod bitcoin_hashes::siphash24
+pub struct bitcoin_hashes::FromSliceError(_)
+pub struct bitcoin_hashes::Hkdf<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::HmacEngine<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::error::FromSliceError(_)
+pub struct bitcoin_hashes::hash160::HashEngine(_)
+pub struct bitcoin_hashes::hkdf::Hkdf<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::hkdf::MaxLengthError
+pub struct bitcoin_hashes::hmac::HmacEngine<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, const N: usize>(_)
+pub struct bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>(_)
+pub struct bitcoin_hashes::ripemd160::HashEngine
+pub struct bitcoin_hashes::serde_macros::serde_details::BytesVisitor<ValueT, const N: usize>(_)
+pub struct bitcoin_hashes::serde_macros::serde_details::HexVisitor<ValueT>(_)
+pub struct bitcoin_hashes::sha1::HashEngine
+pub struct bitcoin_hashes::sha256::HashEngine
+pub struct bitcoin_hashes::sha256::Midstate
+pub struct bitcoin_hashes::sha256::MidstateError
+pub struct bitcoin_hashes::sha256d::HashEngine(_)
+pub struct bitcoin_hashes::sha384::HashEngine(_)
+pub struct bitcoin_hashes::sha512::HashEngine
+pub struct bitcoin_hashes::sha512_256::HashEngine(_)
+pub struct bitcoin_hashes::siphash24::HashEngine
+pub struct bitcoin_hashes::siphash24::State
+pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
+pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
+pub trait bitcoin_hashes::HashEngine: core::clone::Clone
+pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + sealed::IsByteArray
+pub trait bitcoin_hashes::sha256t::Tag
+pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
+pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
+pub type bitcoin_hashes::HkdfSha256 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha256::Hash>
+pub type bitcoin_hashes::HkdfSha512 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha512::Hash>
+pub type bitcoin_hashes::HmacSha256 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha256::Hash>
+pub type bitcoin_hashes::HmacSha512 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha512::Hash>
+pub type bitcoin_hashes::Sha256t<T> = bitcoin_hashes::sha256t::Hash<T>
+pub type bitcoin_hashes::hash160::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::hash160::Hash::Engine = bitcoin_hashes::hash160::HashEngine
+pub type bitcoin_hashes::hash160::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::hmac::Hmac<T>::Bytes = <T as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_hashes::hmac::Hmac<T>::Engine = bitcoin_hashes::hmac::HmacEngine<T>
+pub type bitcoin_hashes::hmac::Hmac<T>::Err = <T as core::str::traits::FromStr>::Err
+pub type bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>::Value = ValueT
+pub type bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::Value = ValueT
+pub type bitcoin_hashes::ripemd160::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::ripemd160::Hash::Engine = bitcoin_hashes::ripemd160::HashEngine
+pub type bitcoin_hashes::ripemd160::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha1::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::sha1::Hash::Engine = bitcoin_hashes::sha1::HashEngine
+pub type bitcoin_hashes::sha1::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha256::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256::Hash::Engine = bitcoin_hashes::sha256::HashEngine
+pub type bitcoin_hashes::sha256::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha256d::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256d::Hash::Engine = bitcoin_hashes::sha256d::HashEngine
+pub type bitcoin_hashes::sha256d::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha256t::Hash<T>::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256t::Hash<T>::Engine = bitcoin_hashes::sha256::HashEngine
+pub type bitcoin_hashes::sha256t::Hash<T>::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha384::Hash::Bytes = [u8; 48]
+pub type bitcoin_hashes::sha384::Hash::Engine = bitcoin_hashes::sha384::HashEngine
+pub type bitcoin_hashes::sha384::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha512::Hash::Bytes = [u8; 64]
+pub type bitcoin_hashes::sha512::Hash::Engine = bitcoin_hashes::sha512::HashEngine
+pub type bitcoin_hashes::sha512::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha512_256::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha512_256::Hash::Engine = bitcoin_hashes::sha512_256::HashEngine
+pub type bitcoin_hashes::sha512_256::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::siphash24::Hash::Bytes = [u8; 8]
+pub type bitcoin_hashes::siphash24::Hash::Engine = bitcoin_hashes::siphash24::HashEngine
+pub type bitcoin_hashes::siphash24::Hash::Err = hex_conservative::error::HexToArrayError
diff --git a/api/hashes/alloc-only.txt b/api/hashes/alloc-only.txt
new file mode 100644
index 0000000000..50246e2d43
--- /dev/null
+++ b/api/hashes/alloc-only.txt
@@ -0,0 +1,945 @@
+#[repr(transparent)] pub struct bitcoin_hashes::Hash160(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Hmac<T: bitcoin_hashes::GeneralHash>(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Ripemd160(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha1(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha256(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha256d(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha384(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha512(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha512_256(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Siphash24(_)
+#[repr(transparent)] pub struct bitcoin_hashes::hash160::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::hmac::Hmac<T: bitcoin_hashes::GeneralHash>(_)
+#[repr(transparent)] pub struct bitcoin_hashes::ripemd160::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha1::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256d::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256t::Hash<T>(_, _)
+#[repr(transparent)] pub struct bitcoin_hashes::sha384::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha512::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha512_256::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::siphash24::Hash(_)
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::hash160::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::ripemd160::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha1::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256d::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha384::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512_256::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::siphash24::HashEngine
+impl bitcoin_hashes::error::FromSliceError
+impl bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::hash160::HashEngine
+impl bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::ripemd160::HashEngine
+impl bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::sha1::HashEngine
+impl bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::sha256::HashEngine
+impl bitcoin_hashes::sha256::Midstate
+impl bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::sha256d::HashEngine
+impl bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::sha384::HashEngine
+impl bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::sha512::HashEngine
+impl bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::sha512_256::HashEngine
+impl bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::siphash24::HashEngine
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::hash160::Hash
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::sha1::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256d::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
+impl core::borrow::Borrow<[u8; 48]> for bitcoin_hashes::sha384::Hash
+impl core::borrow::Borrow<[u8; 64]> for bitcoin_hashes::sha512::Hash
+impl core::borrow::Borrow<[u8; 8]> for bitcoin_hashes::siphash24::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::hash160::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::ripemd160::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha1::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256d::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha384::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512_256::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::siphash24::Hash
+impl core::clone::Clone for bitcoin_hashes::error::FromSliceError
+impl core::clone::Clone for bitcoin_hashes::hash160::Hash
+impl core::clone::Clone for bitcoin_hashes::hash160::HashEngine
+impl core::clone::Clone for bitcoin_hashes::hkdf::MaxLengthError
+impl core::clone::Clone for bitcoin_hashes::ripemd160::Hash
+impl core::clone::Clone for bitcoin_hashes::ripemd160::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha1::Hash
+impl core::clone::Clone for bitcoin_hashes::sha1::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha256::Hash
+impl core::clone::Clone for bitcoin_hashes::sha256::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha256::Midstate
+impl core::clone::Clone for bitcoin_hashes::sha256::MidstateError
+impl core::clone::Clone for bitcoin_hashes::sha256d::Hash
+impl core::clone::Clone for bitcoin_hashes::sha256d::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha384::Hash
+impl core::clone::Clone for bitcoin_hashes::sha384::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha512::Hash
+impl core::clone::Clone for bitcoin_hashes::sha512::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha512_256::Hash
+impl core::clone::Clone for bitcoin_hashes::sha512_256::HashEngine
+impl core::clone::Clone for bitcoin_hashes::siphash24::Hash
+impl core::clone::Clone for bitcoin_hashes::siphash24::HashEngine
+impl core::clone::Clone for bitcoin_hashes::siphash24::State
+impl core::cmp::Eq for bitcoin_hashes::error::FromSliceError
+impl core::cmp::Eq for bitcoin_hashes::hash160::Hash
+impl core::cmp::Eq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::cmp::Eq for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha1::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha256::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha256::Midstate
+impl core::cmp::Eq for bitcoin_hashes::sha256::MidstateError
+impl core::cmp::Eq for bitcoin_hashes::sha256d::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha384::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha512::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::Eq for bitcoin_hashes::siphash24::Hash
+impl core::cmp::Ord for bitcoin_hashes::hash160::Hash
+impl core::cmp::Ord for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha1::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha256::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha256::Midstate
+impl core::cmp::Ord for bitcoin_hashes::sha256d::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha384::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha512::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::Ord for bitcoin_hashes::siphash24::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::error::FromSliceError
+impl core::cmp::PartialEq for bitcoin_hashes::hash160::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::cmp::PartialEq for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha1::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::Midstate
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::MidstateError
+impl core::cmp::PartialEq for bitcoin_hashes::sha256d::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha384::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha512::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::siphash24::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::hash160::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha1::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Midstate
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256d::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha384::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha512::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::siphash24::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::hash160::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::sha1::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256d::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
+impl core::convert::AsRef<[u8; 48]> for bitcoin_hashes::sha384::Hash
+impl core::convert::AsRef<[u8; 64]> for bitcoin_hashes::sha512::Hash
+impl core::convert::AsRef<[u8; 8]> for bitcoin_hashes::siphash24::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::hash160::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::ripemd160::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha1::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Midstate
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256d::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha384::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512_256::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::siphash24::Hash
+impl core::convert::From<core::convert::Infallible> for bitcoin_hashes::error::FromSliceError
+impl core::default::Default for bitcoin_hashes::hash160::HashEngine
+impl core::default::Default for bitcoin_hashes::ripemd160::HashEngine
+impl core::default::Default for bitcoin_hashes::sha1::HashEngine
+impl core::default::Default for bitcoin_hashes::sha256::HashEngine
+impl core::default::Default for bitcoin_hashes::sha256::Midstate
+impl core::default::Default for bitcoin_hashes::sha256d::HashEngine
+impl core::default::Default for bitcoin_hashes::sha384::HashEngine
+impl core::default::Default for bitcoin_hashes::sha512::HashEngine
+impl core::default::Default for bitcoin_hashes::sha512_256::HashEngine
+impl core::fmt::Debug for bitcoin_hashes::error::FromSliceError
+impl core::fmt::Debug for bitcoin_hashes::hash160::Hash
+impl core::fmt::Debug for bitcoin_hashes::hkdf::MaxLengthError
+impl core::fmt::Debug for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha1::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha256::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha256::Midstate
+impl core::fmt::Debug for bitcoin_hashes::sha256::MidstateError
+impl core::fmt::Debug for bitcoin_hashes::sha256d::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha384::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha512::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::Debug for bitcoin_hashes::siphash24::Hash
+impl core::fmt::Debug for bitcoin_hashes::siphash24::HashEngine
+impl core::fmt::Debug for bitcoin_hashes::siphash24::State
+impl core::fmt::Display for bitcoin_hashes::error::FromSliceError
+impl core::fmt::Display for bitcoin_hashes::hash160::Hash
+impl core::fmt::Display for bitcoin_hashes::hkdf::MaxLengthError
+impl core::fmt::Display for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::Display for bitcoin_hashes::sha1::Hash
+impl core::fmt::Display for bitcoin_hashes::sha256::Hash
+impl core::fmt::Display for bitcoin_hashes::sha256::MidstateError
+impl core::fmt::Display for bitcoin_hashes::sha256d::Hash
+impl core::fmt::Display for bitcoin_hashes::sha384::Hash
+impl core::fmt::Display for bitcoin_hashes::sha512::Hash
+impl core::fmt::Display for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::Display for bitcoin_hashes::siphash24::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::hash160::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha1::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha256::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha256d::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha384::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha512::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::LowerHex for bitcoin_hashes::siphash24::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::hash160::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha1::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha256::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha256d::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha384::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha512::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::UpperHex for bitcoin_hashes::siphash24::Hash
+impl core::hash::Hash for bitcoin_hashes::hash160::Hash
+impl core::hash::Hash for bitcoin_hashes::ripemd160::Hash
+impl core::hash::Hash for bitcoin_hashes::sha1::Hash
+impl core::hash::Hash for bitcoin_hashes::sha256::Hash
+impl core::hash::Hash for bitcoin_hashes::sha256::Midstate
+impl core::hash::Hash for bitcoin_hashes::sha256d::Hash
+impl core::hash::Hash for bitcoin_hashes::sha384::Hash
+impl core::hash::Hash for bitcoin_hashes::sha512::Hash
+impl core::hash::Hash for bitcoin_hashes::sha512_256::Hash
+impl core::hash::Hash for bitcoin_hashes::siphash24::Hash
+impl core::marker::Copy for bitcoin_hashes::hash160::Hash
+impl core::marker::Copy for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Copy for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Copy for bitcoin_hashes::sha1::Hash
+impl core::marker::Copy for bitcoin_hashes::sha256::Hash
+impl core::marker::Copy for bitcoin_hashes::sha256::Midstate
+impl core::marker::Copy for bitcoin_hashes::sha256d::Hash
+impl core::marker::Copy for bitcoin_hashes::sha384::Hash
+impl core::marker::Copy for bitcoin_hashes::sha512::Hash
+impl core::marker::Copy for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Copy for bitcoin_hashes::siphash24::Hash
+impl core::marker::Freeze for bitcoin_hashes::error::FromSliceError
+impl core::marker::Freeze for bitcoin_hashes::hash160::Hash
+impl core::marker::Freeze for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Freeze for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Freeze for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha1::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha256::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha256::Midstate
+impl core::marker::Freeze for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Freeze for bitcoin_hashes::sha256d::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha384::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha512::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::siphash24::Hash
+impl core::marker::Freeze for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::siphash24::State
+impl core::marker::Send for bitcoin_hashes::error::FromSliceError
+impl core::marker::Send for bitcoin_hashes::hash160::Hash
+impl core::marker::Send for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Send for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Send for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Send for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha1::Hash
+impl core::marker::Send for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha256::Hash
+impl core::marker::Send for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha256::Midstate
+impl core::marker::Send for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Send for bitcoin_hashes::sha256d::Hash
+impl core::marker::Send for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha384::Hash
+impl core::marker::Send for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha512::Hash
+impl core::marker::Send for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Send for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Send for bitcoin_hashes::siphash24::Hash
+impl core::marker::Send for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Send for bitcoin_hashes::siphash24::State
+impl core::marker::StructuralPartialEq for bitcoin_hashes::error::FromSliceError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::hash160::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::ripemd160::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha1::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Midstate
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::MidstateError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256d::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha384::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512_256::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::siphash24::Hash
+impl core::marker::Sync for bitcoin_hashes::error::FromSliceError
+impl core::marker::Sync for bitcoin_hashes::hash160::Hash
+impl core::marker::Sync for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Sync for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Sync for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Sync for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha1::Hash
+impl core::marker::Sync for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha256::Hash
+impl core::marker::Sync for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha256::Midstate
+impl core::marker::Sync for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Sync for bitcoin_hashes::sha256d::Hash
+impl core::marker::Sync for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha384::Hash
+impl core::marker::Sync for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha512::Hash
+impl core::marker::Sync for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Sync for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Sync for bitcoin_hashes::siphash24::Hash
+impl core::marker::Sync for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Sync for bitcoin_hashes::siphash24::State
+impl core::marker::Unpin for bitcoin_hashes::error::FromSliceError
+impl core::marker::Unpin for bitcoin_hashes::hash160::Hash
+impl core::marker::Unpin for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Unpin for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Unpin for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha1::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha256::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha256::Midstate
+impl core::marker::Unpin for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Unpin for bitcoin_hashes::sha256d::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha384::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha512::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::siphash24::Hash
+impl core::marker::Unpin for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::siphash24::State
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::error::FromSliceError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Midstate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::MidstateError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::State
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::error::FromSliceError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Midstate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::MidstateError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::State
+impl core::str::traits::FromStr for bitcoin_hashes::hash160::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::ripemd160::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha1::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha256::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha256d::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha384::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha512::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::sha512_256::Hash
+impl core::str::traits::FromStr for bitcoin_hashes::siphash24::Hash
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::Debug> core::fmt::Debug for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::Display> core::fmt::Display for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::LowerHex> core::fmt::LowerHex for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::str::traits::FromStr> core::str::traits::FromStr for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
+impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> core::default::Default for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::Hash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::clone::Clone for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Eq for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Ord for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::default::Default for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Display for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::LowerHex for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::UpperHex for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::hash::Hash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::marker::Copy for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::str::traits::FromStr for bitcoin_hashes::sha256t::Hash<T>
+impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::clone::Clone
+impl<T: core::cmp::Eq + bitcoin_hashes::GeneralHash> core::cmp::Eq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::Ord + bitcoin_hashes::GeneralHash> core::cmp::Ord for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::PartialEq + bitcoin_hashes::GeneralHash> core::cmp::PartialEq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::PartialOrd + bitcoin_hashes::GeneralHash> core::cmp::PartialOrd for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::hash::Hash + bitcoin_hashes::GeneralHash> core::hash::Hash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::marker::Copy + bitcoin_hashes::GeneralHash> core::marker::Copy for bitcoin_hashes::hmac::Hmac<T>
+impl<T> bitcoin_hashes::sha256t::Hash<T> where T: bitcoin_hashes::sha256t::Tag
+impl<T> core::marker::Freeze for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::sha256t::Hash<T>
+impl<T> core::marker::Send for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Send
+impl<T> core::marker::Sync for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Unpin
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<const N: usize> bitcoin_hashes::IsByteArray for [u8; N]
+pub const [u8; N]::LEN: usize
+pub const bitcoin_hashes::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::Hash::LEN: usize
+pub const bitcoin_hashes::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::IsByteArray::LEN: usize
+pub const bitcoin_hashes::hash160::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::hash160::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::hmac::HmacEngine<T>::BLOCK_SIZE: usize
+pub const bitcoin_hashes::ripemd160::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::ripemd160::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha1::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha1::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha256::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256d::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha256d::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256t::Hash<T>::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha384::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha384::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha512::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha512::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha512_256::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha512_256::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize
+pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::hash160::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::ripemd160::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::sha1::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::hash_unoptimized(bytes: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha256::HashEngine::can_extract_midstate(&self) -> bool
+pub const fn bitcoin_hashes::sha256::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::as_parts(&self) -> (&[u8; 32], u64)
+pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::new(state: [u8; 32], bytes_hashed: u64) -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::to_parts(self) -> ([u8; 32], u64)
+pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha256d::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48]
+pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self
+pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48]
+pub const fn bitcoin_hashes::sha384::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64]
+pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self
+pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64]
+pub const fn bitcoin_hashes::sha512::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha512_256::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8]
+pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self
+pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8]
+pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
+pub extern crate bitcoin_hashes::hex
+pub fn bitcoin_hashes::GeneralHash::engine() -> Self::Engine where Self::Engine: core::default::Default
+pub fn bitcoin_hashes::GeneralHash::from_engine(e: Self::Engine) -> Self
+pub fn bitcoin_hashes::GeneralHash::hash(data: &[u8]) -> Self where Self::Engine: core::default::Default
+pub fn bitcoin_hashes::GeneralHash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>, Self::Engine: core::default::Default
+pub fn bitcoin_hashes::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::Hash::from_slice(sl: &[u8]) -> core::result::Result<Self, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::cmp::fixed_time_eq(a: &[u8], b: &[u8]) -> bool
+pub fn bitcoin_hashes::debug_hex(bytes: &[u8], f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::error::FromSliceError::clone(&self) -> bitcoin_hashes::error::FromSliceError
+pub fn bitcoin_hashes::error::FromSliceError::eq(&self, other: &bitcoin_hashes::error::FromSliceError) -> bool
+pub fn bitcoin_hashes::error::FromSliceError::expected_length(&self) -> usize
+pub fn bitcoin_hashes::error::FromSliceError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::error::FromSliceError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_hashes::error::FromSliceError::invalid_length(&self) -> usize
+pub fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash
+pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::hash160::HashEngine
+pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool
+pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::hash160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::hash160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::hash160::HashEngine) -> bitcoin_hashes::hash160::Hash
+pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hash160::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::hash160::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::hash160::HashEngine::clone(&self) -> bitcoin_hashes::hash160::HashEngine
+pub fn bitcoin_hashes::hash160::HashEngine::default() -> Self
+pub fn bitcoin_hashes::hash160::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::hash160::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand(&self, info: &[u8], okm: &mut [u8]) -> core::result::Result<(), bitcoin_hashes::hkdf::MaxLengthError>
+pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand_to_len(&self, info: &[u8], len: usize) -> core::result::Result<alloc::vec::Vec<u8>, bitcoin_hashes::hkdf::MaxLengthError>
+pub fn bitcoin_hashes::hkdf::Hkdf<T>::new(salt: &[u8], ikm: &[u8]) -> Self
+pub fn bitcoin_hashes::hkdf::MaxLengthError::clone(&self) -> bitcoin_hashes::hkdf::MaxLengthError
+pub fn bitcoin_hashes::hkdf::MaxLengthError::eq(&self, other: &bitcoin_hashes::hkdf::MaxLengthError) -> bool
+pub fn bitcoin_hashes::hkdf::MaxLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hmac::Hmac<T>::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
+pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
+pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
+pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_engine(e: bitcoin_hashes::hmac::HmacEngine<T>) -> bitcoin_hashes::hmac::Hmac<T>
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::hmac::Hmac<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::default() -> Self
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::input(&mut self, buf: &[u8])
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::new(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+pub fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash
+pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine
+pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool
+pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160::HashEngine) -> bitcoin_hashes::ripemd160::Hash
+pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::ripemd160::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::ripemd160::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::ripemd160::HashEngine::clone(&self) -> bitcoin_hashes::ripemd160::HashEngine
+pub fn bitcoin_hashes::ripemd160::HashEngine::default() -> Self
+pub fn bitcoin_hashes::ripemd160::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::ripemd160::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash
+pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine
+pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool
+pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha1::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::sha1::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngine) -> bitcoin_hashes::sha1::Hash
+pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha1::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha1::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha1::HashEngine::clone(&self) -> bitcoin_hashes::sha1::HashEngine
+pub fn bitcoin_hashes::sha1::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha1::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha1::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash
+pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool
+pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256::Hash
+pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256::HashEngine::clone(&self) -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha256::HashEngine::from_midstate(midstate: bitcoin_hashes::sha256::Midstate) -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha256::HashEngine::midstate(&self) -> core::result::Result<bitcoin_hashes::sha256::Midstate, bitcoin_hashes::sha256::MidstateError>
+pub fn bitcoin_hashes::sha256::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha256::Midstate::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Midstate::clone(&self) -> bitcoin_hashes::sha256::Midstate
+pub fn bitcoin_hashes::sha256::Midstate::cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256::Midstate::default() -> bitcoin_hashes::sha256::Midstate
+pub fn bitcoin_hashes::sha256::Midstate::eq(&self, other: &bitcoin_hashes::sha256::Midstate) -> bool
+pub fn bitcoin_hashes::sha256::Midstate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256::MidstateError::clone(&self) -> bitcoin_hashes::sha256::MidstateError
+pub fn bitcoin_hashes::sha256::MidstateError::eq(&self, other: &bitcoin_hashes::sha256::MidstateError) -> bool
+pub fn bitcoin_hashes::sha256::MidstateError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256d::HashEngine
+pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool
+pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256d::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256d::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256d::HashEngine) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256d::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256d::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256d::HashEngine::clone(&self) -> bitcoin_hashes::sha256d::HashEngine
+pub fn bitcoin_hashes::sha256d::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha256d::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::sha256d::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256t::Hash<T>::default() -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
+pub fn bitcoin_hashes::sha256t::Hash<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash<T>
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash<H: core::hash::Hasher>(&self, h: &mut H)
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256t::Hash<T>::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8; 48]
+pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8; 48]
+pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash
+pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine
+pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool
+pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha384::Hash::from_bytes_mut(bytes: &mut [u8; 48]) -> &mut Self
+pub fn bitcoin_hashes::sha384::Hash::from_bytes_ref(bytes: &[u8; 48]) -> &Self
+pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::HashEngine) -> bitcoin_hashes::sha384::Hash
+pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha384::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha384::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha384::HashEngine::clone(&self) -> bitcoin_hashes::sha384::HashEngine
+pub fn bitcoin_hashes::sha384::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha384::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha384::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8; 64]
+pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8; 64]
+pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash
+pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine
+pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool
+pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha512::Hash::from_bytes_mut(bytes: &mut [u8; 64]) -> &mut Self
+pub fn bitcoin_hashes::sha512::Hash::from_bytes_ref(bytes: &[u8; 64]) -> &Self
+pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::HashEngine) -> bitcoin_hashes::sha512::Hash
+pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha512::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha512::HashEngine::clone(&self) -> bitcoin_hashes::sha512::HashEngine
+pub fn bitcoin_hashes::sha512::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha512::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha512::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash
+pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine
+pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool
+pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_256::HashEngine) -> bitcoin_hashes::sha512_256::Hash
+pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512_256::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha512_256::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha512_256::HashEngine::clone(&self) -> bitcoin_hashes::sha512_256::HashEngine
+pub fn bitcoin_hashes::sha512_256::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha512_256::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha512_256::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8; 8]
+pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::siphash24::Hash::as_u64(&self) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8; 8]
+pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
+pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::siphash24::Hash::from_bytes_mut(bytes: &mut [u8; 8]) -> &mut Self
+pub fn bitcoin_hashes::siphash24::Hash::from_bytes_ref(bytes: &[u8; 8]) -> &Self
+pub fn bitcoin_hashes::siphash24::Hash::from_engine(e: bitcoin_hashes::siphash24::HashEngine) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::from_engine_to_u64(e: bitcoin_hashes::siphash24::HashEngine) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::siphash24::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::siphash24::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::partial_cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::siphash24::Hash::to_u64(self) -> u64
+pub fn bitcoin_hashes::siphash24::HashEngine::clone(&self) -> bitcoin_hashes::siphash24::HashEngine
+pub fn bitcoin_hashes::siphash24::HashEngine::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::siphash24::HashEngine::input(&mut self, msg: &[u8])
+pub fn bitcoin_hashes::siphash24::HashEngine::keys(&self) -> (u64, u64)
+pub fn bitcoin_hashes::siphash24::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::siphash24::State::clone(&self) -> bitcoin_hashes::siphash24::State
+pub fn bitcoin_hashes::siphash24::State::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub macro bitcoin_hashes::hash_newtype!
+pub macro bitcoin_hashes::impl_debug_only_for_newtype!
+pub macro bitcoin_hashes::impl_hex_for_newtype!
+pub macro bitcoin_hashes::serde_impl!
+pub macro bitcoin_hashes::sha256t_hash_newtype!
+pub macro bitcoin_hashes::sha256t_tag!
+pub mod bitcoin_hashes
+pub mod bitcoin_hashes::cmp
+pub mod bitcoin_hashes::error
+pub mod bitcoin_hashes::hash160
+pub mod bitcoin_hashes::hkdf
+pub mod bitcoin_hashes::hmac
+pub mod bitcoin_hashes::macros
+pub mod bitcoin_hashes::ripemd160
+pub mod bitcoin_hashes::serde_macros
+pub mod bitcoin_hashes::sha1
+pub mod bitcoin_hashes::sha256
+pub mod bitcoin_hashes::sha256d
+pub mod bitcoin_hashes::sha256t
+pub mod bitcoin_hashes::sha384
+pub mod bitcoin_hashes::sha512
+pub mod bitcoin_hashes::sha512_256
+pub mod bitcoin_hashes::siphash24
+pub struct bitcoin_hashes::FromSliceError(_)
+pub struct bitcoin_hashes::Hkdf<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::HmacEngine<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::error::FromSliceError(_)
+pub struct bitcoin_hashes::hash160::HashEngine(_)
+pub struct bitcoin_hashes::hkdf::Hkdf<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::hkdf::MaxLengthError
+pub struct bitcoin_hashes::hmac::HmacEngine<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::ripemd160::HashEngine
+pub struct bitcoin_hashes::sha1::HashEngine
+pub struct bitcoin_hashes::sha256::HashEngine
+pub struct bitcoin_hashes::sha256::Midstate
+pub struct bitcoin_hashes::sha256::MidstateError
+pub struct bitcoin_hashes::sha256d::HashEngine(_)
+pub struct bitcoin_hashes::sha384::HashEngine(_)
+pub struct bitcoin_hashes::sha512::HashEngine
+pub struct bitcoin_hashes::sha512_256::HashEngine(_)
+pub struct bitcoin_hashes::siphash24::HashEngine
+pub struct bitcoin_hashes::siphash24::State
+pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
+pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
+pub trait bitcoin_hashes::HashEngine: core::clone::Clone
+pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + sealed::IsByteArray
+pub trait bitcoin_hashes::sha256t::Tag
+pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
+pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
+pub type bitcoin_hashes::HkdfSha256 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha256::Hash>
+pub type bitcoin_hashes::HkdfSha512 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha512::Hash>
+pub type bitcoin_hashes::HmacSha256 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha256::Hash>
+pub type bitcoin_hashes::HmacSha512 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha512::Hash>
+pub type bitcoin_hashes::Sha256t<T> = bitcoin_hashes::sha256t::Hash<T>
+pub type bitcoin_hashes::hash160::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::hash160::Hash::Engine = bitcoin_hashes::hash160::HashEngine
+pub type bitcoin_hashes::hash160::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::hmac::Hmac<T>::Bytes = <T as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_hashes::hmac::Hmac<T>::Engine = bitcoin_hashes::hmac::HmacEngine<T>
+pub type bitcoin_hashes::hmac::Hmac<T>::Err = <T as core::str::traits::FromStr>::Err
+pub type bitcoin_hashes::ripemd160::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::ripemd160::Hash::Engine = bitcoin_hashes::ripemd160::HashEngine
+pub type bitcoin_hashes::ripemd160::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha1::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::sha1::Hash::Engine = bitcoin_hashes::sha1::HashEngine
+pub type bitcoin_hashes::sha1::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha256::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256::Hash::Engine = bitcoin_hashes::sha256::HashEngine
+pub type bitcoin_hashes::sha256::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha256d::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256d::Hash::Engine = bitcoin_hashes::sha256d::HashEngine
+pub type bitcoin_hashes::sha256d::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha256t::Hash<T>::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256t::Hash<T>::Engine = bitcoin_hashes::sha256::HashEngine
+pub type bitcoin_hashes::sha256t::Hash<T>::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha384::Hash::Bytes = [u8; 48]
+pub type bitcoin_hashes::sha384::Hash::Engine = bitcoin_hashes::sha384::HashEngine
+pub type bitcoin_hashes::sha384::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha512::Hash::Bytes = [u8; 64]
+pub type bitcoin_hashes::sha512::Hash::Engine = bitcoin_hashes::sha512::HashEngine
+pub type bitcoin_hashes::sha512::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::sha512_256::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha512_256::Hash::Engine = bitcoin_hashes::sha512_256::HashEngine
+pub type bitcoin_hashes::sha512_256::Hash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_hashes::siphash24::Hash::Bytes = [u8; 8]
+pub type bitcoin_hashes::siphash24::Hash::Engine = bitcoin_hashes::siphash24::HashEngine
+pub type bitcoin_hashes::siphash24::Hash::Err = hex_conservative::error::HexToArrayError
diff --git a/api/hashes/no-features.txt b/api/hashes/no-features.txt
new file mode 100644
index 0000000000..5283250bd7
--- /dev/null
+++ b/api/hashes/no-features.txt
@@ -0,0 +1,882 @@
+#[repr(transparent)] pub struct bitcoin_hashes::Hash160(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Hmac<T: bitcoin_hashes::GeneralHash>(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Ripemd160(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha1(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha256(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha256d(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha384(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha512(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Sha512_256(_)
+#[repr(transparent)] pub struct bitcoin_hashes::Siphash24(_)
+#[repr(transparent)] pub struct bitcoin_hashes::hash160::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::hmac::Hmac<T: bitcoin_hashes::GeneralHash>(_)
+#[repr(transparent)] pub struct bitcoin_hashes::ripemd160::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha1::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256d::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha256t::Hash<T>(_, _)
+#[repr(transparent)] pub struct bitcoin_hashes::sha384::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha512::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::sha512_256::Hash(_)
+#[repr(transparent)] pub struct bitcoin_hashes::siphash24::Hash(_)
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::GeneralHash for bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::Hash for bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::hash160::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::ripemd160::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha1::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256d::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha384::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512_256::HashEngine
+impl bitcoin_hashes::HashEngine for bitcoin_hashes::siphash24::HashEngine
+impl bitcoin_hashes::error::FromSliceError
+impl bitcoin_hashes::hash160::Hash
+impl bitcoin_hashes::hash160::HashEngine
+impl bitcoin_hashes::ripemd160::Hash
+impl bitcoin_hashes::ripemd160::HashEngine
+impl bitcoin_hashes::sha1::Hash
+impl bitcoin_hashes::sha1::HashEngine
+impl bitcoin_hashes::sha256::Hash
+impl bitcoin_hashes::sha256::HashEngine
+impl bitcoin_hashes::sha256::Midstate
+impl bitcoin_hashes::sha256d::Hash
+impl bitcoin_hashes::sha256d::HashEngine
+impl bitcoin_hashes::sha384::Hash
+impl bitcoin_hashes::sha384::HashEngine
+impl bitcoin_hashes::sha512::Hash
+impl bitcoin_hashes::sha512::HashEngine
+impl bitcoin_hashes::sha512_256::Hash
+impl bitcoin_hashes::sha512_256::HashEngine
+impl bitcoin_hashes::siphash24::Hash
+impl bitcoin_hashes::siphash24::HashEngine
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::hash160::Hash
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::sha1::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256d::Hash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
+impl core::borrow::Borrow<[u8; 48]> for bitcoin_hashes::sha384::Hash
+impl core::borrow::Borrow<[u8; 64]> for bitcoin_hashes::sha512::Hash
+impl core::borrow::Borrow<[u8; 8]> for bitcoin_hashes::siphash24::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::hash160::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::ripemd160::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha1::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256d::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha384::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512_256::Hash
+impl core::borrow::Borrow<[u8]> for bitcoin_hashes::siphash24::Hash
+impl core::clone::Clone for bitcoin_hashes::error::FromSliceError
+impl core::clone::Clone for bitcoin_hashes::hash160::Hash
+impl core::clone::Clone for bitcoin_hashes::hash160::HashEngine
+impl core::clone::Clone for bitcoin_hashes::hkdf::MaxLengthError
+impl core::clone::Clone for bitcoin_hashes::ripemd160::Hash
+impl core::clone::Clone for bitcoin_hashes::ripemd160::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha1::Hash
+impl core::clone::Clone for bitcoin_hashes::sha1::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha256::Hash
+impl core::clone::Clone for bitcoin_hashes::sha256::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha256::Midstate
+impl core::clone::Clone for bitcoin_hashes::sha256::MidstateError
+impl core::clone::Clone for bitcoin_hashes::sha256d::Hash
+impl core::clone::Clone for bitcoin_hashes::sha256d::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha384::Hash
+impl core::clone::Clone for bitcoin_hashes::sha384::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha512::Hash
+impl core::clone::Clone for bitcoin_hashes::sha512::HashEngine
+impl core::clone::Clone for bitcoin_hashes::sha512_256::Hash
+impl core::clone::Clone for bitcoin_hashes::sha512_256::HashEngine
+impl core::clone::Clone for bitcoin_hashes::siphash24::Hash
+impl core::clone::Clone for bitcoin_hashes::siphash24::HashEngine
+impl core::clone::Clone for bitcoin_hashes::siphash24::State
+impl core::cmp::Eq for bitcoin_hashes::error::FromSliceError
+impl core::cmp::Eq for bitcoin_hashes::hash160::Hash
+impl core::cmp::Eq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::cmp::Eq for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha1::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha256::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha256::Midstate
+impl core::cmp::Eq for bitcoin_hashes::sha256::MidstateError
+impl core::cmp::Eq for bitcoin_hashes::sha256d::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha384::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha512::Hash
+impl core::cmp::Eq for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::Eq for bitcoin_hashes::siphash24::Hash
+impl core::cmp::Ord for bitcoin_hashes::hash160::Hash
+impl core::cmp::Ord for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha1::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha256::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha256::Midstate
+impl core::cmp::Ord for bitcoin_hashes::sha256d::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha384::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha512::Hash
+impl core::cmp::Ord for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::Ord for bitcoin_hashes::siphash24::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::error::FromSliceError
+impl core::cmp::PartialEq for bitcoin_hashes::hash160::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::cmp::PartialEq for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha1::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::Midstate
+impl core::cmp::PartialEq for bitcoin_hashes::sha256::MidstateError
+impl core::cmp::PartialEq for bitcoin_hashes::sha256d::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha384::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha512::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::PartialEq for bitcoin_hashes::siphash24::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::hash160::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::ripemd160::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha1::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Midstate
+impl core::cmp::PartialOrd for bitcoin_hashes::sha256d::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha384::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha512::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::sha512_256::Hash
+impl core::cmp::PartialOrd for bitcoin_hashes::siphash24::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::hash160::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
+impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::sha1::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256d::Hash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
+impl core::convert::AsRef<[u8; 48]> for bitcoin_hashes::sha384::Hash
+impl core::convert::AsRef<[u8; 64]> for bitcoin_hashes::sha512::Hash
+impl core::convert::AsRef<[u8; 8]> for bitcoin_hashes::siphash24::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::hash160::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::ripemd160::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha1::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Midstate
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256d::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha384::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512_256::Hash
+impl core::convert::AsRef<[u8]> for bitcoin_hashes::siphash24::Hash
+impl core::convert::From<core::convert::Infallible> for bitcoin_hashes::error::FromSliceError
+impl core::default::Default for bitcoin_hashes::hash160::HashEngine
+impl core::default::Default for bitcoin_hashes::ripemd160::HashEngine
+impl core::default::Default for bitcoin_hashes::sha1::HashEngine
+impl core::default::Default for bitcoin_hashes::sha256::HashEngine
+impl core::default::Default for bitcoin_hashes::sha256::Midstate
+impl core::default::Default for bitcoin_hashes::sha256d::HashEngine
+impl core::default::Default for bitcoin_hashes::sha384::HashEngine
+impl core::default::Default for bitcoin_hashes::sha512::HashEngine
+impl core::default::Default for bitcoin_hashes::sha512_256::HashEngine
+impl core::fmt::Debug for bitcoin_hashes::error::FromSliceError
+impl core::fmt::Debug for bitcoin_hashes::hash160::Hash
+impl core::fmt::Debug for bitcoin_hashes::hkdf::MaxLengthError
+impl core::fmt::Debug for bitcoin_hashes::ripemd160::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha1::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha256::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha256::Midstate
+impl core::fmt::Debug for bitcoin_hashes::sha256::MidstateError
+impl core::fmt::Debug for bitcoin_hashes::sha256d::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha384::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha512::Hash
+impl core::fmt::Debug for bitcoin_hashes::sha512_256::Hash
+impl core::fmt::Debug for bitcoin_hashes::siphash24::Hash
+impl core::fmt::Debug for bitcoin_hashes::siphash24::HashEngine
+impl core::fmt::Debug for bitcoin_hashes::siphash24::State
+impl core::fmt::Display for bitcoin_hashes::error::FromSliceError
+impl core::fmt::Display for bitcoin_hashes::hkdf::MaxLengthError
+impl core::fmt::Display for bitcoin_hashes::sha256::MidstateError
+impl core::hash::Hash for bitcoin_hashes::hash160::Hash
+impl core::hash::Hash for bitcoin_hashes::ripemd160::Hash
+impl core::hash::Hash for bitcoin_hashes::sha1::Hash
+impl core::hash::Hash for bitcoin_hashes::sha256::Hash
+impl core::hash::Hash for bitcoin_hashes::sha256::Midstate
+impl core::hash::Hash for bitcoin_hashes::sha256d::Hash
+impl core::hash::Hash for bitcoin_hashes::sha384::Hash
+impl core::hash::Hash for bitcoin_hashes::sha512::Hash
+impl core::hash::Hash for bitcoin_hashes::sha512_256::Hash
+impl core::hash::Hash for bitcoin_hashes::siphash24::Hash
+impl core::marker::Copy for bitcoin_hashes::hash160::Hash
+impl core::marker::Copy for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Copy for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Copy for bitcoin_hashes::sha1::Hash
+impl core::marker::Copy for bitcoin_hashes::sha256::Hash
+impl core::marker::Copy for bitcoin_hashes::sha256::Midstate
+impl core::marker::Copy for bitcoin_hashes::sha256d::Hash
+impl core::marker::Copy for bitcoin_hashes::sha384::Hash
+impl core::marker::Copy for bitcoin_hashes::sha512::Hash
+impl core::marker::Copy for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Copy for bitcoin_hashes::siphash24::Hash
+impl core::marker::Freeze for bitcoin_hashes::error::FromSliceError
+impl core::marker::Freeze for bitcoin_hashes::hash160::Hash
+impl core::marker::Freeze for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Freeze for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Freeze for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha1::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha256::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha256::Midstate
+impl core::marker::Freeze for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Freeze for bitcoin_hashes::sha256d::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha384::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha512::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Freeze for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::siphash24::Hash
+impl core::marker::Freeze for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Freeze for bitcoin_hashes::siphash24::State
+impl core::marker::Send for bitcoin_hashes::error::FromSliceError
+impl core::marker::Send for bitcoin_hashes::hash160::Hash
+impl core::marker::Send for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Send for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Send for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Send for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha1::Hash
+impl core::marker::Send for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha256::Hash
+impl core::marker::Send for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha256::Midstate
+impl core::marker::Send for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Send for bitcoin_hashes::sha256d::Hash
+impl core::marker::Send for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha384::Hash
+impl core::marker::Send for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha512::Hash
+impl core::marker::Send for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Send for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Send for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Send for bitcoin_hashes::siphash24::Hash
+impl core::marker::Send for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Send for bitcoin_hashes::siphash24::State
+impl core::marker::StructuralPartialEq for bitcoin_hashes::error::FromSliceError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::hash160::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::ripemd160::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha1::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Midstate
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::MidstateError
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256d::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha384::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512_256::Hash
+impl core::marker::StructuralPartialEq for bitcoin_hashes::siphash24::Hash
+impl core::marker::Sync for bitcoin_hashes::error::FromSliceError
+impl core::marker::Sync for bitcoin_hashes::hash160::Hash
+impl core::marker::Sync for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Sync for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Sync for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Sync for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha1::Hash
+impl core::marker::Sync for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha256::Hash
+impl core::marker::Sync for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha256::Midstate
+impl core::marker::Sync for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Sync for bitcoin_hashes::sha256d::Hash
+impl core::marker::Sync for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha384::Hash
+impl core::marker::Sync for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha512::Hash
+impl core::marker::Sync for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Sync for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Sync for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Sync for bitcoin_hashes::siphash24::Hash
+impl core::marker::Sync for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Sync for bitcoin_hashes::siphash24::State
+impl core::marker::Unpin for bitcoin_hashes::error::FromSliceError
+impl core::marker::Unpin for bitcoin_hashes::hash160::Hash
+impl core::marker::Unpin for bitcoin_hashes::hash160::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::hkdf::MaxLengthError
+impl core::marker::Unpin for bitcoin_hashes::ripemd160::Hash
+impl core::marker::Unpin for bitcoin_hashes::ripemd160::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha1::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha1::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha256::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha256::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha256::Midstate
+impl core::marker::Unpin for bitcoin_hashes::sha256::MidstateError
+impl core::marker::Unpin for bitcoin_hashes::sha256d::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha256d::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha384::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha384::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha512::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha512::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::sha512_256::Hash
+impl core::marker::Unpin for bitcoin_hashes::sha512_256::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::siphash24::Hash
+impl core::marker::Unpin for bitcoin_hashes::siphash24::HashEngine
+impl core::marker::Unpin for bitcoin_hashes::siphash24::State
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::error::FromSliceError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Midstate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::MidstateError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::Hash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::HashEngine
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::State
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::error::FromSliceError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Midstate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::MidstateError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::Hash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::HashEngine
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::State
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::Debug> core::fmt::Debug for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::Display> core::fmt::Display for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::fmt::LowerHex> core::fmt::LowerHex for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash + core::str::traits::FromStr> core::str::traits::FromStr for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
+impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::GeneralHash> core::default::Default for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::Hash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::clone::Clone for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Eq for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Ord for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::default::Default for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::hash::Hash for bitcoin_hashes::sha256t::Hash<T>
+impl<T: bitcoin_hashes::sha256t::Tag> core::marker::Copy for bitcoin_hashes::sha256t::Hash<T>
+impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::clone::Clone
+impl<T: core::cmp::Eq + bitcoin_hashes::GeneralHash> core::cmp::Eq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::Ord + bitcoin_hashes::GeneralHash> core::cmp::Ord for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::PartialEq + bitcoin_hashes::GeneralHash> core::cmp::PartialEq for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::cmp::PartialOrd + bitcoin_hashes::GeneralHash> core::cmp::PartialOrd for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::hash::Hash + bitcoin_hashes::GeneralHash> core::hash::Hash for bitcoin_hashes::hmac::Hmac<T>
+impl<T: core::marker::Copy + bitcoin_hashes::GeneralHash> core::marker::Copy for bitcoin_hashes::hmac::Hmac<T>
+impl<T> bitcoin_hashes::sha256t::Hash<T> where T: bitcoin_hashes::sha256t::Tag
+impl<T> core::marker::Freeze for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_hashes::sha256t::Hash<T>
+impl<T> core::marker::Send for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Send
+impl<T> core::marker::Send for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Send
+impl<T> core::marker::Sync for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Unpin
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<const N: usize> bitcoin_hashes::IsByteArray for [u8; N]
+pub const [u8; N]::LEN: usize
+pub const bitcoin_hashes::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::Hash::LEN: usize
+pub const bitcoin_hashes::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::IsByteArray::LEN: usize
+pub const bitcoin_hashes::hash160::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::hash160::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::hmac::HmacEngine<T>::BLOCK_SIZE: usize
+pub const bitcoin_hashes::ripemd160::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::ripemd160::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha1::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha1::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha256::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256d::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha256d::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha256t::Hash<T>::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha384::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha384::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha512::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha512::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::sha512_256::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::sha512_256::HashEngine::BLOCK_SIZE: usize
+pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool
+pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize
+pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::hash160::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::ripemd160::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20]
+pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self
+pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20]
+pub const fn bitcoin_hashes::sha1::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::hash_unoptimized(bytes: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha256::HashEngine::can_extract_midstate(&self) -> bool
+pub const fn bitcoin_hashes::sha256::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::as_parts(&self) -> (&[u8; 32], u64)
+pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::new(state: [u8; 32], bytes_hashed: u64) -> Self
+pub const fn bitcoin_hashes::sha256::Midstate::to_parts(self) -> ([u8; 32], u64)
+pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha256d::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48]
+pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self
+pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48]
+pub const fn bitcoin_hashes::sha384::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64]
+pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self
+pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64]
+pub const fn bitcoin_hashes::sha512::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32]
+pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
+pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32]
+pub const fn bitcoin_hashes::sha512_256::HashEngine::new() -> Self
+pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8]
+pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self
+pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8]
+pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
+pub fn bitcoin_hashes::GeneralHash::engine() -> Self::Engine where Self::Engine: core::default::Default
+pub fn bitcoin_hashes::GeneralHash::from_engine(e: Self::Engine) -> Self
+pub fn bitcoin_hashes::GeneralHash::hash(data: &[u8]) -> Self where Self::Engine: core::default::Default
+pub fn bitcoin_hashes::GeneralHash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>, Self::Engine: core::default::Default
+pub fn bitcoin_hashes::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::Hash::from_slice(sl: &[u8]) -> core::result::Result<Self, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::cmp::fixed_time_eq(a: &[u8], b: &[u8]) -> bool
+pub fn bitcoin_hashes::debug_hex(bytes: &[u8], f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::error::FromSliceError::clone(&self) -> bitcoin_hashes::error::FromSliceError
+pub fn bitcoin_hashes::error::FromSliceError::eq(&self, other: &bitcoin_hashes::error::FromSliceError) -> bool
+pub fn bitcoin_hashes::error::FromSliceError::expected_length(&self) -> usize
+pub fn bitcoin_hashes::error::FromSliceError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::error::FromSliceError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_hashes::error::FromSliceError::invalid_length(&self) -> usize
+pub fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash
+pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::hash160::HashEngine
+pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool
+pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::hash160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::hash160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::hash160::HashEngine) -> bitcoin_hashes::hash160::Hash
+pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hash160::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::hash160::HashEngine::clone(&self) -> bitcoin_hashes::hash160::HashEngine
+pub fn bitcoin_hashes::hash160::HashEngine::default() -> Self
+pub fn bitcoin_hashes::hash160::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::hash160::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand(&self, info: &[u8], okm: &mut [u8]) -> core::result::Result<(), bitcoin_hashes::hkdf::MaxLengthError>
+pub fn bitcoin_hashes::hkdf::Hkdf<T>::new(salt: &[u8], ikm: &[u8]) -> Self
+pub fn bitcoin_hashes::hkdf::MaxLengthError::clone(&self) -> bitcoin_hashes::hkdf::MaxLengthError
+pub fn bitcoin_hashes::hkdf::MaxLengthError::eq(&self, other: &bitcoin_hashes::hkdf::MaxLengthError) -> bool
+pub fn bitcoin_hashes::hkdf::MaxLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hmac::Hmac<T>::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
+pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
+pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
+pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_engine(e: bitcoin_hashes::hmac::HmacEngine<T>) -> bitcoin_hashes::hmac::Hmac<T>
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::hmac::Hmac<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_hashes::hmac::Hmac<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::default() -> Self
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::input(&mut self, buf: &[u8])
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::hmac::HmacEngine<T>::new(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+pub fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash
+pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine
+pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool
+pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160::HashEngine) -> bitcoin_hashes::ripemd160::Hash
+pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::ripemd160::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::ripemd160::HashEngine::clone(&self) -> bitcoin_hashes::ripemd160::HashEngine
+pub fn bitcoin_hashes::ripemd160::HashEngine::default() -> Self
+pub fn bitcoin_hashes::ripemd160::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::ripemd160::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash
+pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine
+pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool
+pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha1::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
+pub fn bitcoin_hashes::sha1::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
+pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngine) -> bitcoin_hashes::sha1::Hash
+pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha1::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha1::HashEngine::clone(&self) -> bitcoin_hashes::sha1::HashEngine
+pub fn bitcoin_hashes::sha1::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha1::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha1::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash
+pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool
+pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256::Hash
+pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256::HashEngine::clone(&self) -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha256::HashEngine::from_midstate(midstate: bitcoin_hashes::sha256::Midstate) -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha256::HashEngine::midstate(&self) -> core::result::Result<bitcoin_hashes::sha256::Midstate, bitcoin_hashes::sha256::MidstateError>
+pub fn bitcoin_hashes::sha256::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha256::Midstate::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256::Midstate::clone(&self) -> bitcoin_hashes::sha256::Midstate
+pub fn bitcoin_hashes::sha256::Midstate::cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256::Midstate::default() -> bitcoin_hashes::sha256::Midstate
+pub fn bitcoin_hashes::sha256::Midstate::eq(&self, other: &bitcoin_hashes::sha256::Midstate) -> bool
+pub fn bitcoin_hashes::sha256::Midstate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256::MidstateError::clone(&self) -> bitcoin_hashes::sha256::MidstateError
+pub fn bitcoin_hashes::sha256::MidstateError::eq(&self, other: &bitcoin_hashes::sha256::MidstateError) -> bool
+pub fn bitcoin_hashes::sha256::MidstateError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256d::HashEngine
+pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool
+pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256d::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256d::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256d::HashEngine) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256d::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256d::HashEngine::clone(&self) -> bitcoin_hashes::sha256d::HashEngine
+pub fn bitcoin_hashes::sha256d::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha256d::HashEngine::input(&mut self, data: &[u8])
+pub fn bitcoin_hashes::sha256d::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha256t::Hash<T>::default() -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
+pub fn bitcoin_hashes::sha256t::Hash<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash<T>
+pub fn bitcoin_hashes::sha256t::Hash<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash<H: core::hash::Hasher>(&self, h: &mut H)
+pub fn bitcoin_hashes::sha256t::Hash<T>::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha256t::Hash<T>::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8; 48]
+pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8; 48]
+pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash
+pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine
+pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool
+pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha384::Hash::from_bytes_mut(bytes: &mut [u8; 48]) -> &mut Self
+pub fn bitcoin_hashes::sha384::Hash::from_bytes_ref(bytes: &[u8; 48]) -> &Self
+pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::HashEngine) -> bitcoin_hashes::sha384::Hash
+pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha384::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha384::HashEngine::clone(&self) -> bitcoin_hashes::sha384::HashEngine
+pub fn bitcoin_hashes::sha384::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha384::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha384::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8; 64]
+pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8; 64]
+pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash
+pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine
+pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool
+pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha512::Hash::from_bytes_mut(bytes: &mut [u8; 64]) -> &mut Self
+pub fn bitcoin_hashes::sha512::Hash::from_bytes_ref(bytes: &[u8; 64]) -> &Self
+pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::HashEngine) -> bitcoin_hashes::sha512::Hash
+pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha512::HashEngine::clone(&self) -> bitcoin_hashes::sha512::HashEngine
+pub fn bitcoin_hashes::sha512::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha512::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha512::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash
+pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine
+pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool
+pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
+pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_256::HashEngine) -> bitcoin_hashes::sha512_256::Hash
+pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512_256::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self
+pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
+pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::sha512_256::HashEngine::clone(&self) -> bitcoin_hashes::sha512_256::HashEngine
+pub fn bitcoin_hashes::sha512_256::HashEngine::default() -> Self
+pub fn bitcoin_hashes::sha512_256::HashEngine::input(&mut self, inp: &[u8])
+pub fn bitcoin_hashes::sha512_256::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8; 8]
+pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8]
+pub fn bitcoin_hashes::siphash24::Hash::as_u64(&self) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8; 8]
+pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
+pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
+pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_hashes::siphash24::Hash::from_bytes_mut(bytes: &mut [u8; 8]) -> &mut Self
+pub fn bitcoin_hashes::siphash24::Hash::from_bytes_ref(bytes: &[u8; 8]) -> &Self
+pub fn bitcoin_hashes::siphash24::Hash::from_engine(e: bitcoin_hashes::siphash24::HashEngine) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::from_engine_to_u64(e: bitcoin_hashes::siphash24::HashEngine) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::siphash24::Hash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64
+pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash
+pub fn bitcoin_hashes::siphash24::Hash::partial_cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_hashes::siphash24::Hash::to_u64(self) -> u64
+pub fn bitcoin_hashes::siphash24::HashEngine::clone(&self) -> bitcoin_hashes::siphash24::HashEngine
+pub fn bitcoin_hashes::siphash24::HashEngine::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_hashes::siphash24::HashEngine::input(&mut self, msg: &[u8])
+pub fn bitcoin_hashes::siphash24::HashEngine::keys(&self) -> (u64, u64)
+pub fn bitcoin_hashes::siphash24::HashEngine::n_bytes_hashed(&self) -> u64
+pub fn bitcoin_hashes::siphash24::State::clone(&self) -> bitcoin_hashes::siphash24::State
+pub fn bitcoin_hashes::siphash24::State::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub macro bitcoin_hashes::hash_newtype!
+pub macro bitcoin_hashes::impl_debug_only_for_newtype!
+pub macro bitcoin_hashes::serde_impl!
+pub macro bitcoin_hashes::sha256t_hash_newtype!
+pub macro bitcoin_hashes::sha256t_tag!
+pub mod bitcoin_hashes
+pub mod bitcoin_hashes::cmp
+pub mod bitcoin_hashes::error
+pub mod bitcoin_hashes::hash160
+pub mod bitcoin_hashes::hkdf
+pub mod bitcoin_hashes::hmac
+pub mod bitcoin_hashes::macros
+pub mod bitcoin_hashes::ripemd160
+pub mod bitcoin_hashes::serde_macros
+pub mod bitcoin_hashes::sha1
+pub mod bitcoin_hashes::sha256
+pub mod bitcoin_hashes::sha256d
+pub mod bitcoin_hashes::sha256t
+pub mod bitcoin_hashes::sha384
+pub mod bitcoin_hashes::sha512
+pub mod bitcoin_hashes::sha512_256
+pub mod bitcoin_hashes::siphash24
+pub struct bitcoin_hashes::FromSliceError(_)
+pub struct bitcoin_hashes::Hkdf<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::HmacEngine<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::error::FromSliceError(_)
+pub struct bitcoin_hashes::hash160::HashEngine(_)
+pub struct bitcoin_hashes::hkdf::Hkdf<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::hkdf::MaxLengthError
+pub struct bitcoin_hashes::hmac::HmacEngine<T: bitcoin_hashes::GeneralHash>
+pub struct bitcoin_hashes::ripemd160::HashEngine
+pub struct bitcoin_hashes::sha1::HashEngine
+pub struct bitcoin_hashes::sha256::HashEngine
+pub struct bitcoin_hashes::sha256::Midstate
+pub struct bitcoin_hashes::sha256::MidstateError
+pub struct bitcoin_hashes::sha256d::HashEngine(_)
+pub struct bitcoin_hashes::sha384::HashEngine(_)
+pub struct bitcoin_hashes::sha512::HashEngine
+pub struct bitcoin_hashes::sha512_256::HashEngine(_)
+pub struct bitcoin_hashes::siphash24::HashEngine
+pub struct bitcoin_hashes::siphash24::State
+pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
+pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
+pub trait bitcoin_hashes::HashEngine: core::clone::Clone
+pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + sealed::IsByteArray
+pub trait bitcoin_hashes::sha256t::Tag
+pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
+pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
+pub type bitcoin_hashes::HkdfSha256 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha256::Hash>
+pub type bitcoin_hashes::HkdfSha512 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha512::Hash>
+pub type bitcoin_hashes::HmacSha256 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha256::Hash>
+pub type bitcoin_hashes::HmacSha512 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha512::Hash>
+pub type bitcoin_hashes::Sha256t<T> = bitcoin_hashes::sha256t::Hash<T>
+pub type bitcoin_hashes::hash160::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::hash160::Hash::Engine = bitcoin_hashes::hash160::HashEngine
+pub type bitcoin_hashes::hmac::Hmac<T>::Bytes = <T as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_hashes::hmac::Hmac<T>::Engine = bitcoin_hashes::hmac::HmacEngine<T>
+pub type bitcoin_hashes::hmac::Hmac<T>::Err = <T as core::str::traits::FromStr>::Err
+pub type bitcoin_hashes::ripemd160::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::ripemd160::Hash::Engine = bitcoin_hashes::ripemd160::HashEngine
+pub type bitcoin_hashes::sha1::Hash::Bytes = [u8; 20]
+pub type bitcoin_hashes::sha1::Hash::Engine = bitcoin_hashes::sha1::HashEngine
+pub type bitcoin_hashes::sha256::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256::Hash::Engine = bitcoin_hashes::sha256::HashEngine
+pub type bitcoin_hashes::sha256d::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256d::Hash::Engine = bitcoin_hashes::sha256d::HashEngine
+pub type bitcoin_hashes::sha256t::Hash<T>::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha256t::Hash<T>::Engine = bitcoin_hashes::sha256::HashEngine
+pub type bitcoin_hashes::sha384::Hash::Bytes = [u8; 48]
+pub type bitcoin_hashes::sha384::Hash::Engine = bitcoin_hashes::sha384::HashEngine
+pub type bitcoin_hashes::sha512::Hash::Bytes = [u8; 64]
+pub type bitcoin_hashes::sha512::Hash::Engine = bitcoin_hashes::sha512::HashEngine
+pub type bitcoin_hashes::sha512_256::Hash::Bytes = [u8; 32]
+pub type bitcoin_hashes::sha512_256::Hash::Engine = bitcoin_hashes::sha512_256::HashEngine
+pub type bitcoin_hashes::siphash24::Hash::Bytes = [u8; 8]
+pub type bitcoin_hashes::siphash24::Hash::Engine = bitcoin_hashes::siphash24::HashEngine
diff --git a/api/io/all-features.txt b/api/io/all-features.txt
new file mode 100644
index 0000000000..aef13ac563
--- /dev/null
+++ b/api/io/all-features.txt
@@ -0,0 +1,377 @@
+#[repr(transparent)] pub struct bitcoin_io::FromStd<T>(_)
+#[repr(transparent)] pub struct bitcoin_io::ToStd<T>(_)
+impl !core::marker::Sync for bitcoin_io::Error
+impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
+impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
+impl bitcoin_io::BufRead for &[u8]
+impl bitcoin_io::BufRead for alloc::collections::vec_deque::VecDeque<u8>
+impl bitcoin_io::BufRead for std::io::stdio::StdinLock<'_>
+impl bitcoin_io::BufRead for std::io::util::Empty
+impl bitcoin_io::Error
+impl bitcoin_io::Read for &[u8]
+impl bitcoin_io::Read for &std::fs::File
+impl bitcoin_io::Read for &std::io::stdio::Stdin
+impl bitcoin_io::Read for &std::net::tcp::TcpStream
+impl bitcoin_io::Read for &std::os::unix::net::stream::UnixStream
+impl bitcoin_io::Read for alloc::collections::vec_deque::VecDeque<u8>
+impl bitcoin_io::Read for alloc::sync::Arc<std::fs::File>
+impl bitcoin_io::Read for std::fs::File
+impl bitcoin_io::Read for std::io::stdio::Stdin
+impl bitcoin_io::Read for std::io::stdio::StdinLock<'_>
+impl bitcoin_io::Read for std::io::util::Empty
+impl bitcoin_io::Read for std::io::util::Repeat
+impl bitcoin_io::Read for std::net::tcp::TcpStream
+impl bitcoin_io::Read for std::os::unix::net::stream::UnixStream
+impl bitcoin_io::Read for std::process::ChildStderr
+impl bitcoin_io::Read for std::process::ChildStdout
+impl bitcoin_io::Write for &mut [u8]
+impl bitcoin_io::Write for &std::fs::File
+impl bitcoin_io::Write for &std::io::stdio::Stderr
+impl bitcoin_io::Write for &std::io::stdio::Stdout
+impl bitcoin_io::Write for &std::io::util::Empty
+impl bitcoin_io::Write for &std::net::tcp::TcpStream
+impl bitcoin_io::Write for &std::os::unix::net::stream::UnixStream
+impl bitcoin_io::Write for &std::process::ChildStdin
+impl bitcoin_io::Write for alloc::collections::vec_deque::VecDeque<u8>
+impl bitcoin_io::Write for alloc::sync::Arc<std::fs::File>
+impl bitcoin_io::Write for alloc::vec::Vec<u8>
+impl bitcoin_io::Write for bitcoin_io::Sink
+impl bitcoin_io::Write for std::fs::File
+impl bitcoin_io::Write for std::io::cursor::Cursor<&mut alloc::vec::Vec<u8>>
+impl bitcoin_io::Write for std::io::cursor::Cursor<alloc::boxed::Box<[u8]>>
+impl bitcoin_io::Write for std::io::cursor::Cursor<alloc::vec::Vec<u8>>
+impl bitcoin_io::Write for std::io::stdio::Stderr
+impl bitcoin_io::Write for std::io::stdio::Stdout
+impl bitcoin_io::Write for std::io::util::Empty
+impl bitcoin_io::Write for std::net::tcp::TcpStream
+impl bitcoin_io::Write for std::os::unix::net::stream::UnixStream
+impl bitcoin_io::Write for std::process::ChildStdin
+impl core::clone::Clone for bitcoin_io::ErrorKind
+impl core::cmp::Eq for bitcoin_io::ErrorKind
+impl core::cmp::PartialEq for bitcoin_io::ErrorKind
+impl core::convert::From<bitcoin_io::Error> for std::io::error::Error
+impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
+impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
+impl core::convert::From<std::io::error::Error> for bitcoin_io::Error
+impl core::error::Error for bitcoin_io::Error
+impl core::fmt::Debug for bitcoin_io::Error
+impl core::fmt::Debug for bitcoin_io::ErrorKind
+impl core::fmt::Display for bitcoin_io::Error
+impl core::hash::Hash for bitcoin_io::ErrorKind
+impl core::marker::Copy for bitcoin_io::ErrorKind
+impl core::marker::Freeze for bitcoin_io::Error
+impl core::marker::Freeze for bitcoin_io::ErrorKind
+impl core::marker::Freeze for bitcoin_io::Sink
+impl core::marker::Send for bitcoin_io::Error
+impl core::marker::Send for bitcoin_io::ErrorKind
+impl core::marker::Send for bitcoin_io::Sink
+impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::Sink
+impl core::marker::Unpin for bitcoin_io::Error
+impl core::marker::Unpin for bitcoin_io::ErrorKind
+impl core::marker::Unpin for bitcoin_io::Sink
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ErrorKind
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
+impl std::io::Write for bitcoin_io::Sink
+impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
+impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
+impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
+impl<'a, R> core::marker::Sync for bitcoin_io::Take<'a, R> where R: core::marker::Sync + ?core::marker::Sized
+impl<'a, R> core::marker::Unpin for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
+impl<'a, R> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Take<'a, R> where R: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<R1: std::io::BufRead, R2: std::io::BufRead> bitcoin_io::BufRead for std::io::Chain<R1, R2>
+impl<R1: std::io::Read, R2: std::io::Read> bitcoin_io::Read for std::io::Chain<R1, R2>
+impl<R: bitcoin_io::BufRead + ?core::marker::Sized> bitcoin_io::BufRead for bitcoin_io::Take<'_, R>
+impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Read for bitcoin_io::Take<'_, R>
+impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Take<'_, R>
+impl<R: std::io::BufRead> bitcoin_io::BufRead for std::io::Take<R>
+impl<R: std::io::Read> bitcoin_io::Read for std::io::Take<R>
+impl<R> bitcoin_io::BufRead for std::io::buffered::bufreader::BufReader<R> where R: ?core::marker::Sized + std::io::Read
+impl<R> bitcoin_io::Read for std::io::buffered::bufreader::BufReader<R> where R: ?core::marker::Sized + std::io::Read
+impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for &mut T
+impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for bitcoin_io::ToStd<T>
+impl<T: bitcoin_io::BufRead> std::io::BufRead for bitcoin_io::ToStd<T>
+impl<T: bitcoin_io::Read> bitcoin_io::Read for &mut T
+impl<T: bitcoin_io::Read> bitcoin_io::Read for bitcoin_io::ToStd<T>
+impl<T: bitcoin_io::Read> std::io::Read for bitcoin_io::ToStd<T>
+impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
+impl<T: bitcoin_io::Write> bitcoin_io::Write for bitcoin_io::ToStd<T>
+impl<T: bitcoin_io::Write> std::io::Write for bitcoin_io::ToStd<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for std::io::cursor::Cursor<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for std::io::cursor::Cursor<T>
+impl<T: std::io::BufRead> bitcoin_io::BufRead for bitcoin_io::FromStd<T>
+impl<T: std::io::BufRead> std::io::BufRead for bitcoin_io::FromStd<T>
+impl<T: std::io::Read> bitcoin_io::Read for bitcoin_io::FromStd<T>
+impl<T: std::io::Read> std::io::Read for bitcoin_io::FromStd<T>
+impl<T: std::io::Write> bitcoin_io::Write for bitcoin_io::FromStd<T>
+impl<T: std::io::Write> std::io::Write for bitcoin_io::FromStd<T>
+impl<T> bitcoin_io::FromStd<T>
+impl<T> bitcoin_io::ToStd<T>
+impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_io::FromStd<T> where T: core::marker::Freeze
+impl<T> core::marker::Freeze for bitcoin_io::ToStd<T> where T: core::marker::Freeze
+impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_io::FromStd<T> where T: core::marker::Send
+impl<T> core::marker::Send for bitcoin_io::ToStd<T> where T: core::marker::Send
+impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_io::FromStd<T> where T: core::marker::Sync
+impl<T> core::marker::Sync for bitcoin_io::ToStd<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_io::Cursor<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_io::FromStd<T> where T: core::marker::Unpin
+impl<T> core::marker::Unpin for bitcoin_io::ToStd<T> where T: core::marker::Unpin
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::FromStd<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ToStd<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::FromStd<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::ToStd<T> where T: core::panic::unwind_safe::UnwindSafe
+impl<W> bitcoin_io::Write for std::io::buffered::bufwriter::BufWriter<W> where W: ?core::marker::Sized + std::io::Write
+impl<W> bitcoin_io::Write for std::io::buffered::linewriter::LineWriter<W> where W: ?core::marker::Sized + std::io::Write
+pub bitcoin_io::ErrorKind::AddrInUse
+pub bitcoin_io::ErrorKind::AddrNotAvailable
+pub bitcoin_io::ErrorKind::AlreadyExists
+pub bitcoin_io::ErrorKind::BrokenPipe
+pub bitcoin_io::ErrorKind::ConnectionAborted
+pub bitcoin_io::ErrorKind::ConnectionRefused
+pub bitcoin_io::ErrorKind::ConnectionReset
+pub bitcoin_io::ErrorKind::Interrupted
+pub bitcoin_io::ErrorKind::InvalidData
+pub bitcoin_io::ErrorKind::InvalidInput
+pub bitcoin_io::ErrorKind::NotConnected
+pub bitcoin_io::ErrorKind::NotFound
+pub bitcoin_io::ErrorKind::Other
+pub bitcoin_io::ErrorKind::PermissionDenied
+pub bitcoin_io::ErrorKind::TimedOut
+pub bitcoin_io::ErrorKind::UnexpectedEof
+pub bitcoin_io::ErrorKind::WouldBlock
+pub bitcoin_io::ErrorKind::WriteZero
+pub const fn bitcoin_io::FromStd<T>::new(inner: T) -> Self
+pub const fn bitcoin_io::ToStd<T>::new(inner: T) -> Self
+pub const fn bitcoin_io::from_std<T>(std_io: T) -> bitcoin_io::FromStd<T>
+pub enum bitcoin_io::ErrorKind
+pub fn &[u8]::consume(&mut self, amount: usize)
+pub fn &[u8]::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn &[u8]::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::consume(&mut self, amount: usize)
+pub fn &mut T::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn &mut T::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &mut T::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn &mut T::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &mut [u8]::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &mut [u8]::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &std::fs::File::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &std::fs::File::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &std::fs::File::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn &std::fs::File::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &std::fs::File::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &std::io::stdio::Stderr::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &std::io::stdio::Stderr::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &std::io::stdio::Stderr::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &std::io::stdio::Stdin::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &std::io::stdio::Stdin::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn &std::io::stdio::Stdout::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &std::io::stdio::Stdout::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &std::io::stdio::Stdout::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &std::io::util::Empty::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &std::io::util::Empty::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &std::io::util::Empty::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &std::net::tcp::TcpStream::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &std::net::tcp::TcpStream::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &std::net::tcp::TcpStream::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn &std::net::tcp::TcpStream::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &std::net::tcp::TcpStream::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &std::os::unix::net::stream::UnixStream::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &std::os::unix::net::stream::UnixStream::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &std::os::unix::net::stream::UnixStream::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn &std::os::unix::net::stream::UnixStream::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &std::os::unix::net::stream::UnixStream::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &std::process::ChildStdin::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &std::process::ChildStdin::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &std::process::ChildStdin::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn alloc::collections::vec_deque::VecDeque<u8>::consume(&mut self, amount: usize)
+pub fn alloc::collections::vec_deque::VecDeque<u8>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn alloc::collections::vec_deque::VecDeque<u8>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn alloc::collections::vec_deque::VecDeque<u8>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn alloc::collections::vec_deque::VecDeque<u8>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn alloc::collections::vec_deque::VecDeque<u8>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn alloc::collections::vec_deque::VecDeque<u8>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn alloc::sync::Arc<std::fs::File>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn alloc::sync::Arc<std::fs::File>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn alloc::sync::Arc<std::fs::File>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn alloc::sync::Arc<std::fs::File>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn alloc::sync::Arc<std::fs::File>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn alloc::vec::Vec<u8>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn alloc::vec::Vec<u8>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
+pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
+pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
+pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
+pub fn bitcoin_io::Cursor<T>::position(&self) -> u64
+pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
+pub fn bitcoin_io::Error::cause(&self) -> core::option::Option<&dyn core::error::Error>
+pub fn bitcoin_io::Error::description(&self) -> &str
+pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_io::Error::fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
+pub fn bitcoin_io::Error::from(kind: bitcoin_io::ErrorKind) -> bitcoin_io::Error
+pub fn bitcoin_io::Error::from(o: std::io::error::Error) -> bitcoin_io::Error
+pub fn bitcoin_io::Error::get_ref(&self) -> core::option::Option<&(dyn core::error::Error + core::marker::Send + core::marker::Sync + 'static)>
+pub fn bitcoin_io::Error::kind(&self) -> bitcoin_io::ErrorKind
+pub fn bitcoin_io::Error::new<E>(kind: bitcoin_io::ErrorKind, error: E) -> bitcoin_io::Error where E: core::convert::Into<alloc::boxed::Box<(dyn core::error::Error + core::marker::Send + core::marker::Sync + 'static)>>
+pub fn bitcoin_io::Error::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_io::ErrorKind::clone(&self) -> bitcoin_io::ErrorKind
+pub fn bitcoin_io::ErrorKind::eq(&self, other: &bitcoin_io::ErrorKind) -> bool
+pub fn bitcoin_io::ErrorKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_io::ErrorKind::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_io::ErrorKind::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_io::FromStd<T>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::FromStd<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::FromStd<T>::fill_buf(&mut self) -> std::io::error::Result<&[u8]>
+pub fn bitcoin_io::FromStd<T>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::FromStd<T>::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_io::FromStd<T>::inner(&self) -> &T
+pub fn bitcoin_io::FromStd<T>::inner_mut(&mut self) -> &mut T
+pub fn bitcoin_io::FromStd<T>::into_inner(self) -> T
+pub fn bitcoin_io::FromStd<T>::new_boxed(inner: alloc::boxed::Box<T>) -> alloc::boxed::Box<Self>
+pub fn bitcoin_io::FromStd<T>::new_mut(inner: &mut T) -> &mut Self
+pub fn bitcoin_io::FromStd<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::FromStd<T>::read(&mut self, buf: &mut [u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_io::FromStd<T>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::FromStd<T>::read_exact(&mut self, buf: &mut [u8]) -> std::io::error::Result<()>
+pub fn bitcoin_io::FromStd<T>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::FromStd<T>::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_io::FromStd<T>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::FromStd<T>::write_all(&mut self, buf: &[u8]) -> std::io::error::Result<()>
+pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Read::read_to_limit(&mut self, buf: &mut alloc::vec::Vec<u8>, limit: u64) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
+pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Sink::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> std::io::error::Result<()>
+pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Take<'_, R>::read_to_end(&mut self, buf: &mut alloc::vec::Vec<u8>) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::ToStd<T>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::ToStd<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::ToStd<T>::fill_buf(&mut self) -> std::io::error::Result<&[u8]>
+pub fn bitcoin_io::ToStd<T>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::ToStd<T>::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_io::ToStd<T>::inner(&self) -> &T
+pub fn bitcoin_io::ToStd<T>::inner_mut(&mut self) -> &mut T
+pub fn bitcoin_io::ToStd<T>::into_inner(self) -> T
+pub fn bitcoin_io::ToStd<T>::new_boxed(inner: alloc::boxed::Box<T>) -> alloc::boxed::Box<Self>
+pub fn bitcoin_io::ToStd<T>::new_mut(inner: &mut T) -> &mut Self
+pub fn bitcoin_io::ToStd<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::ToStd<T>::read(&mut self, buf: &mut [u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_io::ToStd<T>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::ToStd<T>::read_exact(&mut self, buf: &mut [u8]) -> std::io::error::Result<()>
+pub fn bitcoin_io::ToStd<T>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::ToStd<T>::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
+pub fn bitcoin_io::ToStd<T>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::ToStd<T>::write_all(&mut self, buf: &[u8]) -> std::io::error::Result<()>
+pub fn bitcoin_io::Write::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Write::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Write::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::from_std_mut<T>(std_io: &mut T) -> &mut bitcoin_io::FromStd<T>
+pub fn bitcoin_io::sink() -> bitcoin_io::Sink
+pub fn std::fs::File::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::fs::File::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::fs::File::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::fs::File::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::fs::File::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::Chain<R1, R2>::consume(&mut self, amount: usize)
+pub fn std::io::Chain<R1, R2>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn std::io::Chain<R1, R2>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::Chain<R1, R2>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::io::Take<R>::consume(&mut self, amount: usize)
+pub fn std::io::Take<R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn std::io::Take<R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::Take<R>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::io::buffered::bufreader::BufReader<R>::consume(&mut self, amount: usize)
+pub fn std::io::buffered::bufreader::BufReader<R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn std::io::buffered::bufreader::BufReader<R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::buffered::bufreader::BufReader<R>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::io::buffered::bufwriter::BufWriter<W>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::io::buffered::bufwriter::BufWriter<W>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::buffered::bufwriter::BufWriter<W>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::buffered::linewriter::LineWriter<W>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::io::buffered::linewriter::LineWriter<W>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::buffered::linewriter::LineWriter<W>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::cursor::Cursor<&mut alloc::vec::Vec<u8>>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::io::cursor::Cursor<&mut alloc::vec::Vec<u8>>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::cursor::Cursor<&mut alloc::vec::Vec<u8>>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::cursor::Cursor<T>::consume(&mut self, amount: usize)
+pub fn std::io::cursor::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn std::io::cursor::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::cursor::Cursor<T>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::io::cursor::Cursor<alloc::boxed::Box<[u8]>>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::io::cursor::Cursor<alloc::boxed::Box<[u8]>>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::cursor::Cursor<alloc::boxed::Box<[u8]>>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::cursor::Cursor<alloc::vec::Vec<u8>>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::io::cursor::Cursor<alloc::vec::Vec<u8>>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::cursor::Cursor<alloc::vec::Vec<u8>>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::error::Error::from(o: bitcoin_io::Error) -> std::io::error::Error
+pub fn std::io::stdio::Stderr::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::io::stdio::Stderr::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::stdio::Stderr::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::stdio::Stdin::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::stdio::Stdin::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::io::stdio::StdinLock<'_>::consume(&mut self, amount: usize)
+pub fn std::io::stdio::StdinLock<'_>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn std::io::stdio::StdinLock<'_>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::stdio::StdinLock<'_>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::io::stdio::Stdout::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::io::stdio::Stdout::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::stdio::Stdout::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::util::Empty::consume(&mut self, amount: usize)
+pub fn std::io::util::Empty::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn std::io::util::Empty::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::io::util::Empty::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::util::Empty::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::io::util::Empty::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::util::Empty::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::io::util::Repeat::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::io::util::Repeat::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::net::tcp::TcpStream::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::net::tcp::TcpStream::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::net::tcp::TcpStream::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::net::tcp::TcpStream::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::net::tcp::TcpStream::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::os::unix::net::stream::UnixStream::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::os::unix::net::stream::UnixStream::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::os::unix::net::stream::UnixStream::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::os::unix::net::stream::UnixStream::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::os::unix::net::stream::UnixStream::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::process::ChildStderr::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::process::ChildStderr::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn std::process::ChildStdin::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn std::process::ChildStdin::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn std::process::ChildStdin::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn std::process::ChildStdout::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn std::process::ChildStdout::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub macro bitcoin_io::impl_write!
+pub mod bitcoin_io
+pub struct bitcoin_io::Cursor<T>
+pub struct bitcoin_io::Error
+pub struct bitcoin_io::Sink
+pub struct bitcoin_io::Take<'a, R: bitcoin_io::Read + ?core::marker::Sized>
+pub trait bitcoin_io::BufRead: bitcoin_io::Read
+pub trait bitcoin_io::Read
+pub trait bitcoin_io::Write
+pub type bitcoin_io::Result<T> = core::result::Result<T, bitcoin_io::Error>
diff --git a/api/io/alloc-only.txt b/api/io/alloc-only.txt
new file mode 100644
index 0000000000..b0aaeff4e2
--- /dev/null
+++ b/api/io/alloc-only.txt
@@ -0,0 +1,135 @@
+impl !core::marker::Sync for bitcoin_io::Error
+impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
+impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
+impl bitcoin_io::BufRead for &[u8]
+impl bitcoin_io::Error
+impl bitcoin_io::Read for &[u8]
+impl bitcoin_io::Write for &mut [u8]
+impl bitcoin_io::Write for alloc::vec::Vec<u8>
+impl bitcoin_io::Write for bitcoin_io::Sink
+impl core::clone::Clone for bitcoin_io::ErrorKind
+impl core::cmp::Eq for bitcoin_io::ErrorKind
+impl core::cmp::PartialEq for bitcoin_io::ErrorKind
+impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
+impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
+impl core::fmt::Debug for bitcoin_io::Error
+impl core::fmt::Debug for bitcoin_io::ErrorKind
+impl core::fmt::Display for bitcoin_io::Error
+impl core::hash::Hash for bitcoin_io::ErrorKind
+impl core::marker::Copy for bitcoin_io::ErrorKind
+impl core::marker::Freeze for bitcoin_io::Error
+impl core::marker::Freeze for bitcoin_io::ErrorKind
+impl core::marker::Freeze for bitcoin_io::Sink
+impl core::marker::Send for bitcoin_io::Error
+impl core::marker::Send for bitcoin_io::ErrorKind
+impl core::marker::Send for bitcoin_io::Sink
+impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::Sink
+impl core::marker::Unpin for bitcoin_io::Error
+impl core::marker::Unpin for bitcoin_io::ErrorKind
+impl core::marker::Unpin for bitcoin_io::Sink
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ErrorKind
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
+impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
+impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
+impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
+impl<'a, R> core::marker::Sync for bitcoin_io::Take<'a, R> where R: core::marker::Sync + ?core::marker::Sized
+impl<'a, R> core::marker::Unpin for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
+impl<'a, R> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Take<'a, R> where R: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<R: bitcoin_io::BufRead + ?core::marker::Sized> bitcoin_io::BufRead for bitcoin_io::Take<'_, R>
+impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Read for bitcoin_io::Take<'_, R>
+impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Take<'_, R>
+impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for &mut T
+impl<T: bitcoin_io::Read> bitcoin_io::Read for &mut T
+impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
+impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
+impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
+impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_io::Cursor<T> where T: core::marker::Unpin
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::UnwindSafe
+pub bitcoin_io::ErrorKind::AddrInUse
+pub bitcoin_io::ErrorKind::AddrNotAvailable
+pub bitcoin_io::ErrorKind::AlreadyExists
+pub bitcoin_io::ErrorKind::BrokenPipe
+pub bitcoin_io::ErrorKind::ConnectionAborted
+pub bitcoin_io::ErrorKind::ConnectionRefused
+pub bitcoin_io::ErrorKind::ConnectionReset
+pub bitcoin_io::ErrorKind::Interrupted
+pub bitcoin_io::ErrorKind::InvalidData
+pub bitcoin_io::ErrorKind::InvalidInput
+pub bitcoin_io::ErrorKind::NotConnected
+pub bitcoin_io::ErrorKind::NotFound
+pub bitcoin_io::ErrorKind::Other
+pub bitcoin_io::ErrorKind::PermissionDenied
+pub bitcoin_io::ErrorKind::TimedOut
+pub bitcoin_io::ErrorKind::UnexpectedEof
+pub bitcoin_io::ErrorKind::WouldBlock
+pub bitcoin_io::ErrorKind::WriteZero
+pub enum bitcoin_io::ErrorKind
+pub fn &[u8]::consume(&mut self, amount: usize)
+pub fn &[u8]::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn &[u8]::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::consume(&mut self, amount: usize)
+pub fn &mut T::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn &mut T::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &mut T::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn &mut T::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &mut [u8]::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &mut [u8]::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn alloc::vec::Vec<u8>::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn alloc::vec::Vec<u8>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
+pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
+pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
+pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
+pub fn bitcoin_io::Cursor<T>::position(&self) -> u64
+pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
+pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_io::Error::fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
+pub fn bitcoin_io::Error::from(kind: bitcoin_io::ErrorKind) -> bitcoin_io::Error
+pub fn bitcoin_io::Error::get_ref(&self) -> core::option::Option<&(dyn core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static)>
+pub fn bitcoin_io::Error::kind(&self) -> bitcoin_io::ErrorKind
+pub fn bitcoin_io::Error::new<E: sealed::IntoBoxDynDebug>(kind: bitcoin_io::ErrorKind, error: E) -> bitcoin_io::Error
+pub fn bitcoin_io::ErrorKind::clone(&self) -> bitcoin_io::ErrorKind
+pub fn bitcoin_io::ErrorKind::eq(&self, other: &bitcoin_io::ErrorKind) -> bool
+pub fn bitcoin_io::ErrorKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_io::ErrorKind::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_io::ErrorKind::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Read::read_to_limit(&mut self, buf: &mut alloc::vec::Vec<u8>, limit: u64) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
+pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Take<'_, R>::read_to_end(&mut self, buf: &mut alloc::vec::Vec<u8>) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Write::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Write::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Write::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::sink() -> bitcoin_io::Sink
+pub macro bitcoin_io::impl_write!
+pub mod bitcoin_io
+pub struct bitcoin_io::Cursor<T>
+pub struct bitcoin_io::Error
+pub struct bitcoin_io::Sink
+pub struct bitcoin_io::Take<'a, R: bitcoin_io::Read + ?core::marker::Sized>
+pub trait bitcoin_io::BufRead: bitcoin_io::Read
+pub trait bitcoin_io::Read
+pub trait bitcoin_io::Write
+pub type bitcoin_io::Result<T> = core::result::Result<T, bitcoin_io::Error>
diff --git a/api/io/no-features.txt b/api/io/no-features.txt
new file mode 100644
index 0000000000..facd4c3ef6
--- /dev/null
+++ b/api/io/no-features.txt
@@ -0,0 +1,127 @@
+impl !core::marker::Sync for bitcoin_io::Error
+impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
+impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
+impl bitcoin_io::BufRead for &[u8]
+impl bitcoin_io::Error
+impl bitcoin_io::Read for &[u8]
+impl bitcoin_io::Write for &mut [u8]
+impl bitcoin_io::Write for bitcoin_io::Sink
+impl core::clone::Clone for bitcoin_io::ErrorKind
+impl core::cmp::Eq for bitcoin_io::ErrorKind
+impl core::cmp::PartialEq for bitcoin_io::ErrorKind
+impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
+impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
+impl core::fmt::Debug for bitcoin_io::Error
+impl core::fmt::Debug for bitcoin_io::ErrorKind
+impl core::fmt::Display for bitcoin_io::Error
+impl core::hash::Hash for bitcoin_io::ErrorKind
+impl core::marker::Copy for bitcoin_io::ErrorKind
+impl core::marker::Freeze for bitcoin_io::Error
+impl core::marker::Freeze for bitcoin_io::ErrorKind
+impl core::marker::Freeze for bitcoin_io::Sink
+impl core::marker::Send for bitcoin_io::Error
+impl core::marker::Send for bitcoin_io::ErrorKind
+impl core::marker::Send for bitcoin_io::Sink
+impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::Sink
+impl core::marker::Unpin for bitcoin_io::Error
+impl core::marker::Unpin for bitcoin_io::ErrorKind
+impl core::marker::Unpin for bitcoin_io::Sink
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ErrorKind
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
+impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
+impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
+impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
+impl<'a, R> core::marker::Sync for bitcoin_io::Take<'a, R> where R: core::marker::Sync + ?core::marker::Sized
+impl<'a, R> core::marker::Unpin for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
+impl<'a, R> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Take<'a, R> where R: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
+impl<R: bitcoin_io::BufRead + ?core::marker::Sized> bitcoin_io::BufRead for bitcoin_io::Take<'_, R>
+impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Read for bitcoin_io::Take<'_, R>
+impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for &mut T
+impl<T: bitcoin_io::Read> bitcoin_io::Read for &mut T
+impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
+impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
+impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
+impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
+impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
+impl<T> core::marker::Unpin for bitcoin_io::Cursor<T> where T: core::marker::Unpin
+impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::UnwindSafe
+pub bitcoin_io::ErrorKind::AddrInUse
+pub bitcoin_io::ErrorKind::AddrNotAvailable
+pub bitcoin_io::ErrorKind::AlreadyExists
+pub bitcoin_io::ErrorKind::BrokenPipe
+pub bitcoin_io::ErrorKind::ConnectionAborted
+pub bitcoin_io::ErrorKind::ConnectionRefused
+pub bitcoin_io::ErrorKind::ConnectionReset
+pub bitcoin_io::ErrorKind::Interrupted
+pub bitcoin_io::ErrorKind::InvalidData
+pub bitcoin_io::ErrorKind::InvalidInput
+pub bitcoin_io::ErrorKind::NotConnected
+pub bitcoin_io::ErrorKind::NotFound
+pub bitcoin_io::ErrorKind::Other
+pub bitcoin_io::ErrorKind::PermissionDenied
+pub bitcoin_io::ErrorKind::TimedOut
+pub bitcoin_io::ErrorKind::UnexpectedEof
+pub bitcoin_io::ErrorKind::WouldBlock
+pub bitcoin_io::ErrorKind::WriteZero
+pub enum bitcoin_io::ErrorKind
+pub fn &[u8]::consume(&mut self, amount: usize)
+pub fn &[u8]::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn &[u8]::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::consume(&mut self, amount: usize)
+pub fn &mut T::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn &mut T::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &mut T::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn &mut T::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn &mut T::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn &mut [u8]::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn &mut [u8]::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
+pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
+pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
+pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
+pub fn bitcoin_io::Cursor<T>::position(&self) -> u64
+pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
+pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_io::Error::fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
+pub fn bitcoin_io::Error::from(kind: bitcoin_io::ErrorKind) -> bitcoin_io::Error
+pub fn bitcoin_io::Error::kind(&self) -> bitcoin_io::ErrorKind
+pub fn bitcoin_io::ErrorKind::clone(&self) -> bitcoin_io::ErrorKind
+pub fn bitcoin_io::ErrorKind::eq(&self, other: &bitcoin_io::ErrorKind) -> bool
+pub fn bitcoin_io::ErrorKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_io::ErrorKind::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_io::ErrorKind::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
+pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Write::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Write::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Write::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::sink() -> bitcoin_io::Sink
+pub macro bitcoin_io::impl_write!
+pub mod bitcoin_io
+pub struct bitcoin_io::Cursor<T>
+pub struct bitcoin_io::Error
+pub struct bitcoin_io::Sink
+pub struct bitcoin_io::Take<'a, R: bitcoin_io::Read + ?core::marker::Sized>
+pub trait bitcoin_io::BufRead: bitcoin_io::Read
+pub trait bitcoin_io::Read
+pub trait bitcoin_io::Write
+pub type bitcoin_io::Result<T> = core::result::Result<T, bitcoin_io::Error>
diff --git a/api/primitives/all-features.txt b/api/primitives/all-features.txt
new file mode 100644
index 0000000000..fddc60bcc6
--- /dev/null
+++ b/api/primitives/all-features.txt
@@ -0,0 +1,1873 @@
+#[non_exhaustive] pub enum bitcoin_primitives::transaction::ParseOutPointError
+#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleHeightError
+#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleTimeError
+#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleHeightError
+#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleTimeError
+#[repr(transparent)] pub struct bitcoin_primitives::script::Script(_)
+impl !core::marker::Sized for bitcoin_primitives::script::Script
+impl alloc::borrow::ToOwned for bitcoin_primitives::script::Script
+impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
+impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapLeafHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapNodeHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapTweakHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Txid
+impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Wtxid
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapBranchTag
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapLeafTag
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapTweakTag
+impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
+impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
+impl bitcoin_primitives::block::BlockHash
+impl bitcoin_primitives::block::Header
+impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Checked
+impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Unchecked
+impl bitcoin_primitives::block::Version
+impl bitcoin_primitives::block::WitnessCommitment
+impl bitcoin_primitives::locktime::absolute::LockTime
+impl bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl bitcoin_primitives::locktime::relative::LockTime
+impl bitcoin_primitives::merkle_tree::TxMerkleNode
+impl bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl bitcoin_primitives::opcodes::Opcode
+impl bitcoin_primitives::pow::CompactTarget
+impl bitcoin_primitives::script::Script
+impl bitcoin_primitives::script::ScriptBuf
+impl bitcoin_primitives::sequence::Sequence
+impl bitcoin_primitives::taproot::TapLeafHash
+impl bitcoin_primitives::taproot::TapNodeHash
+impl bitcoin_primitives::taproot::TapTweakHash
+impl bitcoin_primitives::transaction::OutPoint
+impl bitcoin_primitives::transaction::Transaction
+impl bitcoin_primitives::transaction::TxIn
+impl bitcoin_primitives::transaction::TxOut
+impl bitcoin_primitives::transaction::Txid
+impl bitcoin_primitives::transaction::Version
+impl bitcoin_primitives::transaction::Wtxid
+impl bitcoin_primitives::witness::Witness
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::BlockHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Txid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::BlockHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::WitnessCommitment
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Txid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Wtxid
+impl core::borrow::Borrow<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::borrow::BorrowMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::clone::Clone for bitcoin_primitives::block::BlockHash
+impl core::clone::Clone for bitcoin_primitives::block::Checked
+impl core::clone::Clone for bitcoin_primitives::block::Header
+impl core::clone::Clone for bitcoin_primitives::block::Unchecked
+impl core::clone::Clone for bitcoin_primitives::block::Version
+impl core::clone::Clone for bitcoin_primitives::block::WitnessCommitment
+impl core::clone::Clone for bitcoin_primitives::locktime::absolute::LockTime
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::LockTime
+impl core::clone::Clone for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::clone::Clone for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::clone::Clone for bitcoin_primitives::opcodes::Class
+impl core::clone::Clone for bitcoin_primitives::opcodes::ClassifyContext
+impl core::clone::Clone for bitcoin_primitives::opcodes::Opcode
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
+impl core::clone::Clone for bitcoin_primitives::script::ScriptBuf
+impl core::clone::Clone for bitcoin_primitives::sequence::Sequence
+impl core::clone::Clone for bitcoin_primitives::taproot::TapBranchTag
+impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafTag
+impl core::clone::Clone for bitcoin_primitives::taproot::TapNodeHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakTag
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
+impl core::clone::Clone for bitcoin_primitives::transaction::ParseOutPointError
+impl core::clone::Clone for bitcoin_primitives::transaction::Transaction
+impl core::clone::Clone for bitcoin_primitives::transaction::TxIn
+impl core::clone::Clone for bitcoin_primitives::transaction::TxOut
+impl core::clone::Clone for bitcoin_primitives::transaction::Txid
+impl core::clone::Clone for bitcoin_primitives::transaction::Version
+impl core::clone::Clone for bitcoin_primitives::transaction::Wtxid
+impl core::clone::Clone for bitcoin_primitives::witness::Witness
+impl core::cmp::Eq for bitcoin_primitives::block::BlockHash
+impl core::cmp::Eq for bitcoin_primitives::block::Checked
+impl core::cmp::Eq for bitcoin_primitives::block::Header
+impl core::cmp::Eq for bitcoin_primitives::block::Unchecked
+impl core::cmp::Eq for bitcoin_primitives::block::Version
+impl core::cmp::Eq for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::Eq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::LockTime
+impl core::cmp::Eq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
+impl core::cmp::Eq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::Eq for bitcoin_primitives::opcodes::Opcode
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Eq for bitcoin_primitives::script::Script
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::Eq for bitcoin_primitives::sequence::Sequence
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Eq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::cmp::Eq for bitcoin_primitives::transaction::Transaction
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxIn
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxOut
+impl core::cmp::Eq for bitcoin_primitives::transaction::Txid
+impl core::cmp::Eq for bitcoin_primitives::transaction::Version
+impl core::cmp::Eq for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::Eq for bitcoin_primitives::witness::Witness
+impl core::cmp::Ord for bitcoin_primitives::block::BlockHash
+impl core::cmp::Ord for bitcoin_primitives::block::Checked
+impl core::cmp::Ord for bitcoin_primitives::block::Header
+impl core::cmp::Ord for bitcoin_primitives::block::Unchecked
+impl core::cmp::Ord for bitcoin_primitives::block::Version
+impl core::cmp::Ord for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::Ord for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Ord for bitcoin_primitives::script::Script
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::Ord for bitcoin_primitives::sequence::Sequence
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Ord for bitcoin_primitives::transaction::Transaction
+impl core::cmp::Ord for bitcoin_primitives::transaction::TxIn
+impl core::cmp::Ord for bitcoin_primitives::transaction::TxOut
+impl core::cmp::Ord for bitcoin_primitives::transaction::Txid
+impl core::cmp::Ord for bitcoin_primitives::transaction::Version
+impl core::cmp::Ord for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::Ord for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHash
+impl core::cmp::PartialEq for bitcoin_primitives::block::Checked
+impl core::cmp::PartialEq for bitcoin_primitives::block::Header
+impl core::cmp::PartialEq for bitcoin_primitives::block::Unchecked
+impl core::cmp::PartialEq for bitcoin_primitives::block::Version
+impl core::cmp::PartialEq for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::LockTime
+impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Opcode
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialEq for bitcoin_primitives::script::Script
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialEq for bitcoin_primitives::sequence::Sequence
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Transaction
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxIn
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxOut
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Txid
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::PartialEq for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialEq<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialEq<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::Script
+impl core::cmp::PartialOrd for bitcoin_primitives::block::BlockHash
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Checked
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Unchecked
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::PartialOrd for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::PartialOrd for bitcoin_primitives::locktime::relative::LockTime
+impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialOrd for bitcoin_primitives::script::Script
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialOrd for bitcoin_primitives::sequence::Sequence
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Transaction
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxIn
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxOut
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Txid
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::PartialOrd for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialOrd<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialOrd<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::Script
+impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::Script
+impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
+impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::BlockHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Txid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::BlockHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::Script
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Txid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::AsRef<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
+impl core::convert::AsRef<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::From<&[&[u8]]> for bitcoin_primitives::witness::Witness
+impl core::convert::From<&[alloc::vec::Vec<u8>]> for bitcoin_primitives::witness::Witness
+impl core::convert::From<&bitcoin_primitives::block::Block> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Txid
+impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::From<alloc::vec::Vec<&[u8]>> for bitcoin_primitives::witness::Witness
+impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for bitcoin_primitives::witness::Witness
+impl core::convert::From<alloc::vec::Vec<u8>> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Txid
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::From<bitcoin_primitives::block::Block> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_primitives::block::BlockHash> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_primitives::block::WitnessCommitment> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::locktime::relative::LockTime> for bitcoin_primitives::sequence::Sequence
+impl core::convert::From<bitcoin_primitives::merkle_tree::TxMerkleNode> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>
+impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::boxed::Box<bitcoin_primitives::script::Script>
+impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::vec::Vec<u8>
+impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
+impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
+impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::From<bitcoin_primitives::taproot::TapNodeHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
+impl core::convert::From<bitcoin_primitives::taproot::TapTweakHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
+impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Txid
+impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::From<bitcoin_primitives::transaction::Txid> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::transaction::Wtxid> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::absolute::Time> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_primitives::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::Time> for bitcoin_primitives::locktime::relative::LockTime
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::ParseOutPointError
+impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
+impl core::convert::TryFrom<&str> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::TryFrom<&str> for bitcoin_primitives::sequence::Sequence
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::sequence::Sequence
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::sequence::Sequence
+impl core::convert::TryFrom<bitcoin_primitives::sequence::Sequence> for bitcoin_primitives::locktime::relative::LockTime
+impl core::default::Default for bitcoin_primitives::block::Version
+impl core::default::Default for bitcoin_primitives::pow::CompactTarget
+impl core::default::Default for bitcoin_primitives::script::ScriptBuf
+impl core::default::Default for bitcoin_primitives::sequence::Sequence
+impl core::default::Default for bitcoin_primitives::taproot::TapBranchTag
+impl core::default::Default for bitcoin_primitives::taproot::TapLeafTag
+impl core::default::Default for bitcoin_primitives::taproot::TapTweakTag
+impl core::default::Default for bitcoin_primitives::witness::Witness
+impl core::error::Error for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::error::Error for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::error::Error for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::error::Error for bitcoin_primitives::transaction::ParseOutPointError
+impl core::fmt::Debug for bitcoin_primitives::block::BlockHash
+impl core::fmt::Debug for bitcoin_primitives::block::Checked
+impl core::fmt::Debug for bitcoin_primitives::block::Header
+impl core::fmt::Debug for bitcoin_primitives::block::Unchecked
+impl core::fmt::Debug for bitcoin_primitives::block::Version
+impl core::fmt::Debug for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::Debug for bitcoin_primitives::locktime::absolute::LockTime
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::LockTime
+impl core::fmt::Debug for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
+impl core::fmt::Debug for bitcoin_primitives::opcodes::ClassifyContext
+impl core::fmt::Debug for bitcoin_primitives::opcodes::Opcode
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::Debug for bitcoin_primitives::script::Script
+impl core::fmt::Debug for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::Debug for bitcoin_primitives::sequence::Sequence
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Debug for bitcoin_primitives::transaction::ParseOutPointError
+impl core::fmt::Debug for bitcoin_primitives::transaction::Transaction
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxIn
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxOut
+impl core::fmt::Debug for bitcoin_primitives::transaction::Txid
+impl core::fmt::Debug for bitcoin_primitives::transaction::Version
+impl core::fmt::Debug for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::Debug for bitcoin_primitives::witness::Witness
+impl core::fmt::Display for bitcoin_primitives::block::BlockHash
+impl core::fmt::Display for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::Display for bitcoin_primitives::locktime::absolute::LockTime
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::LockTime
+impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
+impl core::fmt::Display for bitcoin_primitives::script::Script
+impl core::fmt::Display for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::Display for bitcoin_primitives::sequence::Sequence
+impl core::fmt::Display for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::Display for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::Display for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::Display for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Display for bitcoin_primitives::transaction::ParseOutPointError
+impl core::fmt::Display for bitcoin_primitives::transaction::Txid
+impl core::fmt::Display for bitcoin_primitives::transaction::Version
+impl core::fmt::Display for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::LowerHex for bitcoin_primitives::block::BlockHash
+impl core::fmt::LowerHex for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::LowerHex for bitcoin_primitives::script::Script
+impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::LowerHex for bitcoin_primitives::sequence::Sequence
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::LowerHex for bitcoin_primitives::transaction::Txid
+impl core::fmt::LowerHex for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::UpperHex for bitcoin_primitives::block::BlockHash
+impl core::fmt::UpperHex for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::UpperHex for bitcoin_primitives::script::Script
+impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::UpperHex for bitcoin_primitives::sequence::Sequence
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::UpperHex for bitcoin_primitives::transaction::Txid
+impl core::fmt::UpperHex for bitcoin_primitives::transaction::Wtxid
+impl core::hash::Hash for bitcoin_primitives::block::BlockHash
+impl core::hash::Hash for bitcoin_primitives::block::Checked
+impl core::hash::Hash for bitcoin_primitives::block::Header
+impl core::hash::Hash for bitcoin_primitives::block::Unchecked
+impl core::hash::Hash for bitcoin_primitives::block::Version
+impl core::hash::Hash for bitcoin_primitives::block::WitnessCommitment
+impl core::hash::Hash for bitcoin_primitives::locktime::absolute::LockTime
+impl core::hash::Hash for bitcoin_primitives::locktime::relative::LockTime
+impl core::hash::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::hash::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
+impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
+impl core::hash::Hash for bitcoin_primitives::script::Script
+impl core::hash::Hash for bitcoin_primitives::script::ScriptBuf
+impl core::hash::Hash for bitcoin_primitives::sequence::Sequence
+impl core::hash::Hash for bitcoin_primitives::taproot::TapBranchTag
+impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafTag
+impl core::hash::Hash for bitcoin_primitives::taproot::TapNodeHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakTag
+impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
+impl core::hash::Hash for bitcoin_primitives::transaction::Transaction
+impl core::hash::Hash for bitcoin_primitives::transaction::TxIn
+impl core::hash::Hash for bitcoin_primitives::transaction::TxOut
+impl core::hash::Hash for bitcoin_primitives::transaction::Txid
+impl core::hash::Hash for bitcoin_primitives::transaction::Version
+impl core::hash::Hash for bitcoin_primitives::transaction::Wtxid
+impl core::hash::Hash for bitcoin_primitives::witness::Witness
+impl core::iter::traits::exact_size::ExactSizeIterator for bitcoin_primitives::witness::Iter<'_>
+impl core::marker::Copy for bitcoin_primitives::block::BlockHash
+impl core::marker::Copy for bitcoin_primitives::block::Header
+impl core::marker::Copy for bitcoin_primitives::block::Version
+impl core::marker::Copy for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Copy for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Copy for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Copy for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Copy for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Copy for bitcoin_primitives::opcodes::Class
+impl core::marker::Copy for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Copy for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Copy for bitcoin_primitives::sequence::Sequence
+impl core::marker::Copy for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Copy for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Copy for bitcoin_primitives::transaction::Txid
+impl core::marker::Copy for bitcoin_primitives::transaction::Version
+impl core::marker::Copy for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHash
+impl core::marker::Freeze for bitcoin_primitives::block::Checked
+impl core::marker::Freeze for bitcoin_primitives::block::Header
+impl core::marker::Freeze for bitcoin_primitives::block::Unchecked
+impl core::marker::Freeze for bitcoin_primitives::block::Version
+impl core::marker::Freeze for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Freeze for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
+impl core::marker::Freeze for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Freeze for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Freeze for bitcoin_primitives::script::Script
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Freeze for bitcoin_primitives::sequence::Sequence
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Freeze for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Freeze for bitcoin_primitives::transaction::Transaction
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxIn
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxOut
+impl core::marker::Freeze for bitcoin_primitives::transaction::Txid
+impl core::marker::Freeze for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Freeze for bitcoin_primitives::witness::Witness
+impl core::marker::Send for bitcoin_primitives::block::BlockHash
+impl core::marker::Send for bitcoin_primitives::block::Checked
+impl core::marker::Send for bitcoin_primitives::block::Header
+impl core::marker::Send for bitcoin_primitives::block::Unchecked
+impl core::marker::Send for bitcoin_primitives::block::Version
+impl core::marker::Send for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Send for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Send for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Send for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Send for bitcoin_primitives::opcodes::Class
+impl core::marker::Send for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Send for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Send for bitcoin_primitives::script::Script
+impl core::marker::Send for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Send for bitcoin_primitives::sequence::Sequence
+impl core::marker::Send for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Send for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Send for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Send for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Send for bitcoin_primitives::transaction::Transaction
+impl core::marker::Send for bitcoin_primitives::transaction::TxIn
+impl core::marker::Send for bitcoin_primitives::transaction::TxOut
+impl core::marker::Send for bitcoin_primitives::transaction::Txid
+impl core::marker::Send for bitcoin_primitives::transaction::Version
+impl core::marker::Send for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Send for bitcoin_primitives::witness::Witness
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Checked
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Unchecked
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Opcode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::Script
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBuf
+impl core::marker::StructuralPartialEq for bitcoin_primitives::sequence::Sequence
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Transaction
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxIn
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxOut
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Txid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Wtxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::Witness
+impl core::marker::Sync for bitcoin_primitives::block::BlockHash
+impl core::marker::Sync for bitcoin_primitives::block::Checked
+impl core::marker::Sync for bitcoin_primitives::block::Header
+impl core::marker::Sync for bitcoin_primitives::block::Unchecked
+impl core::marker::Sync for bitcoin_primitives::block::Version
+impl core::marker::Sync for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Sync for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Sync for bitcoin_primitives::opcodes::Class
+impl core::marker::Sync for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Sync for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Sync for bitcoin_primitives::script::Script
+impl core::marker::Sync for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Sync for bitcoin_primitives::sequence::Sequence
+impl core::marker::Sync for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Sync for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Sync for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Sync for bitcoin_primitives::transaction::Transaction
+impl core::marker::Sync for bitcoin_primitives::transaction::TxIn
+impl core::marker::Sync for bitcoin_primitives::transaction::TxOut
+impl core::marker::Sync for bitcoin_primitives::transaction::Txid
+impl core::marker::Sync for bitcoin_primitives::transaction::Version
+impl core::marker::Sync for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Sync for bitcoin_primitives::witness::Witness
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHash
+impl core::marker::Unpin for bitcoin_primitives::block::Checked
+impl core::marker::Unpin for bitcoin_primitives::block::Header
+impl core::marker::Unpin for bitcoin_primitives::block::Unchecked
+impl core::marker::Unpin for bitcoin_primitives::block::Version
+impl core::marker::Unpin for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Unpin for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
+impl core::marker::Unpin for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Unpin for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Unpin for bitcoin_primitives::script::Script
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Unpin for bitcoin_primitives::sequence::Sequence
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Unpin for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Unpin for bitcoin_primitives::transaction::Transaction
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxIn
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxOut
+impl core::marker::Unpin for bitcoin_primitives::transaction::Txid
+impl core::marker::Unpin for bitcoin_primitives::transaction::Version
+impl core::marker::Unpin for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Unpin for bitcoin_primitives::witness::Witness
+impl core::ops::deref::Deref for bitcoin_primitives::script::ScriptBuf
+impl core::ops::deref::DerefMut for bitcoin_primitives::script::ScriptBuf
+impl core::ops::index::Index<(core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::Range<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeFrom<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeFull> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeInclusive<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeTo<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeToInclusive<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<usize> for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Checked
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Unchecked
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::WitnessCommitment
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Class
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Opcode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::Script
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBuf
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::sequence::Sequence
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapBranchTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapNodeHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Transaction
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxIn
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOut
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Txid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Wtxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Checked
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Unchecked
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::WitnessCommitment
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Opcode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::Script
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBuf
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::sequence::Sequence
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapBranchTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapNodeHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Transaction
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxIn
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOut
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Txid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Wtxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Witness
+impl core::str::traits::FromStr for bitcoin_primitives::block::BlockHash
+impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
+impl core::str::traits::FromStr for bitcoin_primitives::locktime::absolute::LockTime
+impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::sequence::Sequence
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapNodeHash
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapTweakHash
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::OutPoint
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::Txid
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::Wtxid
+impl ordered::ArbitraryOrd for bitcoin_primitives::locktime::absolute::LockTime
+impl ordered::ArbitraryOrd for bitcoin_primitives::locktime::relative::LockTime
+impl serde::ser::Serialize for bitcoin_primitives::block::BlockHash
+impl serde::ser::Serialize for bitcoin_primitives::block::Header
+impl serde::ser::Serialize for bitcoin_primitives::block::Version
+impl serde::ser::Serialize for bitcoin_primitives::block::WitnessCommitment
+impl serde::ser::Serialize for bitcoin_primitives::locktime::absolute::LockTime
+impl serde::ser::Serialize for bitcoin_primitives::locktime::relative::LockTime
+impl serde::ser::Serialize for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl serde::ser::Serialize for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl serde::ser::Serialize for bitcoin_primitives::opcodes::Opcode
+impl serde::ser::Serialize for bitcoin_primitives::pow::CompactTarget
+impl serde::ser::Serialize for bitcoin_primitives::script::Script
+impl serde::ser::Serialize for bitcoin_primitives::script::ScriptBuf
+impl serde::ser::Serialize for bitcoin_primitives::sequence::Sequence
+impl serde::ser::Serialize for bitcoin_primitives::taproot::TapLeafHash
+impl serde::ser::Serialize for bitcoin_primitives::taproot::TapNodeHash
+impl serde::ser::Serialize for bitcoin_primitives::taproot::TapTweakHash
+impl serde::ser::Serialize for bitcoin_primitives::transaction::OutPoint
+impl serde::ser::Serialize for bitcoin_primitives::transaction::Transaction
+impl serde::ser::Serialize for bitcoin_primitives::transaction::TxIn
+impl serde::ser::Serialize for bitcoin_primitives::transaction::TxOut
+impl serde::ser::Serialize for bitcoin_primitives::transaction::Txid
+impl serde::ser::Serialize for bitcoin_primitives::transaction::Version
+impl serde::ser::Serialize for bitcoin_primitives::transaction::Wtxid
+impl serde::ser::Serialize for bitcoin_primitives::witness::Witness
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Block
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Header
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Version
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::locktime::absolute::LockTime
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::script::ScriptBuf
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::sequence::Sequence
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::OutPoint
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::Transaction
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::TxIn
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::TxOut
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::Txid
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::Version
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::witness::Witness
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::boxed::Box<bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::rc::Rc<bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::sync::Arc<bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl<'a> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>> for alloc::boxed::Box<bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>> for bitcoin_primitives::script::ScriptBuf
+impl<'a> core::iter::traits::collect::IntoIterator for &'a bitcoin_primitives::witness::Witness
+impl<'a> core::iter::traits::iterator::Iterator for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Freeze for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Send for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Sync for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Unpin for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Iter<'a>
+impl<'de, V> serde::de::Deserialize<'de> for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+impl<'de> serde::de::Deserialize<'de> for &'de bitcoin_primitives::script::Script
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::BlockHash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::Header
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::Version
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::WitnessCommitment
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::locktime::absolute::LockTime
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::locktime::relative::LockTime
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::pow::CompactTarget
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::ScriptBuf
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::sequence::Sequence
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::taproot::TapLeafHash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::taproot::TapNodeHash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::taproot::TapTweakHash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::OutPoint
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Transaction
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::TxIn
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::TxOut
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Txid
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Version
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Wtxid
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::witness::Witness
+impl<V: bitcoin_primitives::block::Validation> bitcoin_primitives::block::Block<V>
+impl<V> core::clone::Clone for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::clone::Clone
+impl<V> core::cmp::Eq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::Eq
+impl<V> core::cmp::PartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::PartialEq
+impl<V> core::fmt::Debug for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::fmt::Debug
+impl<V> core::marker::Freeze for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::Send for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::StructuralPartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+impl<V> core::marker::Sync for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::Unpin for bitcoin_primitives::block::Block<V>
+impl<V> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::RefUnwindSafe
+impl<V> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::UnwindSafe
+impl<V> serde::ser::Serialize for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
+pub bitcoin_primitives::BlockHeader::nonce: u32
+pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::block::BlockHash
+pub bitcoin_primitives::BlockHeader::time: u32
+pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::Transaction::input: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
+pub bitcoin_primitives::Transaction::lock_time: bitcoin_primitives::locktime::absolute::LockTime
+pub bitcoin_primitives::Transaction::output: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
+pub bitcoin_primitives::Transaction::version: bitcoin_primitives::transaction::Version
+pub bitcoin_primitives::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
+pub bitcoin_primitives::TxIn::script_sig: bitcoin_primitives::script::ScriptBuf
+pub bitcoin_primitives::TxIn::sequence: bitcoin_primitives::sequence::Sequence
+pub bitcoin_primitives::TxIn::witness: bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::TxOut::script_pubkey: bitcoin_primitives::script::ScriptBuf
+pub bitcoin_primitives::TxOut::value: bitcoin_units::amount::unsigned::Amount
+pub bitcoin_primitives::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_primitives::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
+pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
+pub bitcoin_primitives::block::Header::nonce: u32
+pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::block::BlockHash
+pub bitcoin_primitives::block::Header::time: u32
+pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_primitives::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
+pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
+pub bitcoin_primitives::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
+pub bitcoin_primitives::opcodes::Class::IllegalOp
+pub bitcoin_primitives::opcodes::Class::NoOp
+pub bitcoin_primitives::opcodes::Class::Ordinary(Ordinary)
+pub bitcoin_primitives::opcodes::Class::PushBytes(u32)
+pub bitcoin_primitives::opcodes::Class::PushNum(i32)
+pub bitcoin_primitives::opcodes::Class::ReturnOp
+pub bitcoin_primitives::opcodes::Class::SuccessOp
+pub bitcoin_primitives::opcodes::ClassifyContext::Legacy
+pub bitcoin_primitives::opcodes::ClassifyContext::TapScript
+pub bitcoin_primitives::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
+pub bitcoin_primitives::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
+pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
+pub bitcoin_primitives::transaction::OutPoint::vout: u32
+pub bitcoin_primitives::transaction::ParseOutPointError::Format
+pub bitcoin_primitives::transaction::ParseOutPointError::TooLong
+pub bitcoin_primitives::transaction::ParseOutPointError::Txid(hex_conservative::error::HexToArrayError)
+pub bitcoin_primitives::transaction::ParseOutPointError::Vout(bitcoin_units::parse::ParseIntError)
+pub bitcoin_primitives::transaction::ParseOutPointError::VoutNotCanonical
+pub bitcoin_primitives::transaction::Transaction::input: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
+pub bitcoin_primitives::transaction::Transaction::lock_time: bitcoin_primitives::locktime::absolute::LockTime
+pub bitcoin_primitives::transaction::Transaction::output: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
+pub bitcoin_primitives::transaction::Transaction::version: bitcoin_primitives::transaction::Version
+pub bitcoin_primitives::transaction::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
+pub bitcoin_primitives::transaction::TxIn::script_sig: bitcoin_primitives::script::ScriptBuf
+pub bitcoin_primitives::transaction::TxIn::sequence: bitcoin_primitives::sequence::Sequence
+pub bitcoin_primitives::transaction::TxIn::witness: bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::transaction::TxOut::script_pubkey: bitcoin_primitives::script::ScriptBuf
+pub bitcoin_primitives::transaction::TxOut::value: bitcoin_units::amount::unsigned::Amount
+pub const bitcoin_primitives::BlockValidation::IS_CHECKED: bool
+pub const bitcoin_primitives::block::BlockHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::block::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::block::Checked::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Header::SIZE: usize
+pub const bitcoin_primitives::block::Unchecked::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Validation::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
+pub const bitcoin_primitives::block::Version::ONE: Self
+pub const bitcoin_primitives::block::Version::TWO: Self
+pub const bitcoin_primitives::block::WitnessCommitment::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::locktime::absolute::LockTime::SIZE: usize
+pub const bitcoin_primitives::locktime::absolute::LockTime::ZERO: bitcoin_primitives::locktime::absolute::LockTime
+pub const bitcoin_primitives::locktime::relative::LockTime::SIZE: usize
+pub const bitcoin_primitives::locktime::relative::LockTime::ZERO: bitcoin_primitives::locktime::relative::LockTime
+pub const bitcoin_primitives::merkle_tree::TxMerkleNode::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::merkle_tree::WitnessMerkleNode::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::opcodes::all::OP_0NOTEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_1ADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_1SUB: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DIV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DROP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2MUL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2OVER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2ROT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2SWAP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_3DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ABS: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_AND: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_BOOLAND: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_BOOLOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CAT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIG: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIGVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIG: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CLTV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CODESEPARATOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CSV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DEPTH: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DIV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DROP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ELSE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ENDIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_EQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_EQUALVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_FROMALTSTACK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_GREATERTHAN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_GREATERTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_HASH160: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_HASH256: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_IF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_IFDUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_INVALIDOPCODE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_INVERT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LEFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LESSTHAN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LESSTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LSHIFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MAX: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MIN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MOD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MUL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NEGATE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NIP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOTIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMEQUALVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMNOTEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_OR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_OVER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PICK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_0: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_11: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_12: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_13: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_14: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_15: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_16: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_17: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_18: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_19: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_20: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_21: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_22: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_23: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_24: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_25: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_26: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_27: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_28: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_29: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_30: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_31: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_32: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_33: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_34: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_35: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_36: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_37: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_38: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_39: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_3: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_40: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_41: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_42: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_43: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_44: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_45: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_46: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_47: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_48: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_49: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_50: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_51: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_52: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_53: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_54: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_55: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_56: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_57: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_58: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_59: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_60: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_61: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_62: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_63: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_64: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_65: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_66: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_67: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_68: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_69: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_70: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_71: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_72: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_73: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_74: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_75: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_11: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_12: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_13: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_14: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_15: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_16: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_3: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_NEG1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_187: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_188: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_189: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_190: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_191: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_192: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_193: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_194: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_195: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_196: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_197: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_198: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_199: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_200: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_201: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_202: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_203: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_204: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_205: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_206: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_207: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_208: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_209: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_210: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_211: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_212: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_213: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_214: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_215: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_216: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_217: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_218: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_219: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_220: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_221: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_222: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_223: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_224: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_225: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_226: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_227: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_228: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_229: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_230: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_231: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_232: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_233: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_234: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_235: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_236: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_237: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_238: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_239: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_240: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_241: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_242: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_243: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_244: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_245: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_246: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_247: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_248: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_249: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_250: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_251: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_252: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_253: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_254: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RIGHT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RIPEMD160: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ROLL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ROT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RSHIFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SHA1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SHA256: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SIZE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SUB: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SUBSTR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SWAP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_TOALTSTACK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_TUCK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERNOTIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_WITHIN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_XOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
+pub const bitcoin_primitives::sequence::Sequence::FINAL: Self
+pub const bitcoin_primitives::sequence::Sequence::MAX: Self
+pub const bitcoin_primitives::sequence::Sequence::SIZE: usize
+pub const bitcoin_primitives::sequence::Sequence::ZERO: Self
+pub const bitcoin_primitives::taproot::TapLeafHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::taproot::TapNodeHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::taproot::TapTweakHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
+pub const bitcoin_primitives::transaction::Transaction::MAX_STANDARD_WEIGHT: bitcoin_units::weight::Weight
+pub const bitcoin_primitives::transaction::TxIn::EMPTY_COINBASE: bitcoin_primitives::transaction::TxIn
+pub const bitcoin_primitives::transaction::TxOut::NULL: Self
+pub const bitcoin_primitives::transaction::Txid::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::Txid::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::transaction::Version::ONE: Self
+pub const bitcoin_primitives::transaction::Version::THREE: Self
+pub const bitcoin_primitives::transaction::Version::TWO: Self
+pub const bitcoin_primitives::transaction::Wtxid::COINBASE: Self
+pub const bitcoin_primitives::transaction::Wtxid::DISPLAY_BACKWARD: bool
+pub const fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
+pub const fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_height(&self) -> bool
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_time(&self) -> bool
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_height(n: u16) -> Self
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_height(&self) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_time(&self) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::opcodes::Opcode::decode_pushnum(self) -> core::option::Option<u8>
+pub const fn bitcoin_primitives::opcodes::Opcode::to_u8(self) -> u8
+pub const fn bitcoin_primitives::script::ScriptBuf::new() -> Self
+pub const fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::witness::Witness::new() -> Self
+pub enum bitcoin_primitives::BlockChecked
+pub enum bitcoin_primitives::BlockUnchecked
+pub enum bitcoin_primitives::absolute::LockTime
+pub enum bitcoin_primitives::block::Checked
+pub enum bitcoin_primitives::block::Unchecked
+pub enum bitcoin_primitives::locktime::absolute::LockTime
+pub enum bitcoin_primitives::locktime::relative::LockTime
+pub enum bitcoin_primitives::opcodes::Class
+pub enum bitcoin_primitives::opcodes::ClassifyContext
+pub enum bitcoin_primitives::relative::LockTime
+pub fn &'a bitcoin_primitives::witness::Witness::into_iter(self) -> Self::IntoIter
+pub fn &'de bitcoin_primitives::script::Script::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>::from(value: bitcoin_primitives::script::ScriptBuf) -> Self
+pub fn alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>) -> Self
+pub fn alloc::rc::Rc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn alloc::sync::Arc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn alloc::vec::Vec<u8>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Txid) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Wtxid) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>::from(hashtype: bitcoin_primitives::taproot::TapNodeHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>::from(hashtype: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>::from(hashtype: bitcoin_primitives::taproot::TapTweakHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
+pub fn bitcoin_primitives::block::Block::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::block::Block<V>::block_hash(&self) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::Block<V>::clone(&self) -> bitcoin_primitives::block::Block<V>
+pub fn bitcoin_primitives::block::Block<V>::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::block::Block<V>::eq(&self, other: &bitcoin_primitives::block::Block<V>) -> bool
+pub fn bitcoin_primitives::block::Block<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Block<V>::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::cached_witness_root(&self) -> core::option::Option<bitcoin_primitives::merkle_tree::WitnessMerkleNode>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::header(&self) -> &bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::transactions(&self) -> &[bitcoin_primitives::transaction::Transaction]
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::assume_checked(self, witness_root: core::option::Option<bitcoin_primitives::merkle_tree::WitnessMerkleNode>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::into_parts(self) -> (bitcoin_primitives::block::Header, alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>)
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::new_unchecked(header: bitcoin_primitives::block::Header, transactions: alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
+pub fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::block::BlockHash::clone(&self) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::BlockHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::block::BlockHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::block::BlockHash::eq(&self, other: &bitcoin_primitives::block::BlockHash) -> bool
+pub fn bitcoin_primitives::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::BlockHash::from(block: &bitcoin_primitives::block::Block) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(block: bitcoin_primitives::block::Block) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(header: &bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(header: bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::BlockHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::block::BlockHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::BlockHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::block::Checked::clone(&self) -> bitcoin_primitives::block::Checked
+pub fn bitcoin_primitives::block::Checked::cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Checked::eq(&self, other: &bitcoin_primitives::block::Checked) -> bool
+pub fn bitcoin_primitives::block::Checked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Checked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Checked::partial_cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Header::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Header::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
+pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Header::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::block::Unchecked::clone(&self) -> bitcoin_primitives::block::Unchecked
+pub fn bitcoin_primitives::block::Unchecked::cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Unchecked::eq(&self, other: &bitcoin_primitives::block::Unchecked) -> bool
+pub fn bitcoin_primitives::block::Unchecked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Unchecked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Unchecked::partial_cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Version::default() -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
+pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(&self, bit: u8) -> bool
+pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
+pub fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::block::WitnessCommitment::clone(&self) -> bitcoin_primitives::block::WitnessCommitment
+pub fn bitcoin_primitives::block::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::WitnessCommitment::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::block::WitnessCommitment, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::block::WitnessCommitment::eq(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> bool
+pub fn bitcoin_primitives::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::WitnessCommitment
+pub fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::WitnessCommitment, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::block::WitnessCommitment::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::WitnessCommitment::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::locktime::absolute::LockTime::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::arbitrary_cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_primitives::locktime::absolute::LockTime::clone(&self) -> bitcoin_primitives::locktime::absolute::LockTime
+pub fn bitcoin_primitives::locktime::absolute::LockTime::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::eq(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::Time) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_time(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::locktime::absolute::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::is_satisfied_by(&self, height: bitcoin_units::locktime::absolute::Height, time: bitcoin_units::locktime::absolute::Time) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::DisabledLockTimeError
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::DisabledLockTimeError) -> bool
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleHeightError
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleHeightError) -> bool
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleTimeError
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleTimeError) -> bool
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::LockTime::arbitrary_cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_primitives::locktime::relative::LockTime::clone(&self) -> bitcoin_primitives::locktime::relative::LockTime
+pub fn bitcoin_primitives::locktime::relative::LockTime::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::locktime::relative::LockTime::eq(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::Height) -> Self
+pub fn bitcoin_primitives::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::Time) -> Self
+pub fn bitcoin_primitives::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::from_sequence(n: bitcoin_primitives::sequence::Sequence) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by_sequence(&self, other: bitcoin_primitives::sequence::Sequence) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self, h: bitcoin_units::locktime::relative::Height, t: bitcoin_units::locktime::relative::Time) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::locktime::relative::LockTime::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::TxMerkleNode
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::merkle_tree::TxMerkleNode, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> bool
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::TxMerkleNode
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::TxMerkleNode, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::merkle_tree::WitnessMerkleNode, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bool
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::WitnessMerkleNode, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::opcodes::Class::clone(&self) -> bitcoin_primitives::opcodes::Class
+pub fn bitcoin_primitives::opcodes::Class::eq(&self, other: &bitcoin_primitives::opcodes::Class) -> bool
+pub fn bitcoin_primitives::opcodes::Class::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::ClassifyContext::clone(&self) -> bitcoin_primitives::opcodes::ClassifyContext
+pub fn bitcoin_primitives::opcodes::ClassifyContext::cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::cmp::Ordering
+pub fn bitcoin_primitives::opcodes::ClassifyContext::eq(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> bool
+pub fn bitcoin_primitives::opcodes::ClassifyContext::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::ClassifyContext::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::opcodes::ClassifyContext::partial_cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::opcodes::Opcode::classify(self, ctx: bitcoin_primitives::opcodes::ClassifyContext) -> bitcoin_primitives::opcodes::Class
+pub fn bitcoin_primitives::opcodes::Opcode::clone(&self) -> bitcoin_primitives::opcodes::Opcode
+pub fn bitcoin_primitives::opcodes::Opcode::eq(&self, other: &bitcoin_primitives::opcodes::Opcode) -> bool
+pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
+pub fn bitcoin_primitives::opcodes::Opcode::from(b: u8) -> bitcoin_primitives::opcodes::Opcode
+pub fn bitcoin_primitives::opcodes::Opcode::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
+pub fn bitcoin_primitives::pow::CompactTarget::default() -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
+pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
+pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::pow::CompactTarget::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
+pub fn bitcoin_primitives::pow::CompactTarget::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::Script::as_bytes(&self) -> &[u8]
+pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::as_mut_bytes(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::Script::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::Script::as_ref(&self) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::cmp(&self, other: &bitcoin_primitives::script::Script) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::Script::eq(&self, other: &bitcoin_primitives::script::Script) -> bool
+pub fn bitcoin_primitives::script::Script::eq(&self, other: &bitcoin_primitives::script::ScriptBuf) -> bool
+pub fn bitcoin_primitives::script::Script::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::Script::from_bytes(bytes: &[u8]) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::from_bytes_mut(bytes: &mut [u8]) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::Script::index(&self, index: (core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::Range<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeFrom<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeFull) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeInclusive<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeTo<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeToInclusive<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::into_script_buf(self: alloc::boxed::Box<Self>) -> bitcoin_primitives::script::ScriptBuf
+pub fn bitcoin_primitives::script::Script::is_empty(&self) -> bool
+pub fn bitcoin_primitives::script::Script::len(&self) -> usize
+pub fn bitcoin_primitives::script::Script::new() -> &'static bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::partial_cmp(&self, other: &bitcoin_primitives::script::Script) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::script::Script::to_bytes(&self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::Script::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::Script::to_owned(&self) -> Self::Owned
+pub fn bitcoin_primitives::script::Script::to_vec(&self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::ScriptBuf::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::script::ScriptBuf::as_mut(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::ScriptBuf::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::as_mut_script(&mut self) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptBuf::as_ref(&self) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::as_script(&self) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::borrow(&self) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::borrow_mut(&mut self) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::clone(&self) -> bitcoin_primitives::script::ScriptBuf
+pub fn bitcoin_primitives::script::ScriptBuf::cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptBuf::default() -> bitcoin_primitives::script::ScriptBuf
+pub fn bitcoin_primitives::script::ScriptBuf::deref(&self) -> &Self::Target
+pub fn bitcoin_primitives::script::ScriptBuf::deref_mut(&mut self) -> &mut Self::Target
+pub fn bitcoin_primitives::script::ScriptBuf::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::script::ScriptBuf::eq(&self, other: &bitcoin_primitives::script::Script) -> bool
+pub fn bitcoin_primitives::script::ScriptBuf::eq(&self, other: &bitcoin_primitives::script::ScriptBuf) -> bool
+pub fn bitcoin_primitives::script::ScriptBuf::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptBuf::from(v: alloc::vec::Vec<u8>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf::from_bytes(bytes: alloc::vec::Vec<u8>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptBuf::into_boxed_script(self) -> alloc::boxed::Box<bitcoin_primitives::script::Script>
+pub fn bitcoin_primitives::script::ScriptBuf::into_bytes(self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::ScriptBuf::partial_cmp(&self, other: &bitcoin_primitives::script::Script) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptBuf::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptBuf::reserve(&mut self, additional_len: usize)
+pub fn bitcoin_primitives::script::ScriptBuf::reserve_exact(&mut self, additional_len: usize)
+pub fn bitcoin_primitives::script::ScriptBuf::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::script::ScriptBuf::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::ScriptBuf::with_capacity(capacity: usize) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::sequence::Sequence::clone(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::sequence::Sequence::cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::cmp::Ordering
+pub fn bitcoin_primitives::sequence::Sequence::default() -> Self
+pub fn bitcoin_primitives::sequence::Sequence::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::sequence::Sequence::enables_absolute_lock_time(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::eq(&self, other: &bitcoin_primitives::sequence::Sequence) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::sequence::Sequence::from(lt: bitcoin_primitives::locktime::relative::LockTime) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_consensus(n: u32) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_height(height: u16) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_primitives::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub fn bitcoin_primitives::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub fn bitcoin_primitives::sequence::Sequence::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_primitives::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::sequence::Sequence::is_final(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_height_locked(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_rbf(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::sequence::Sequence::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::sequence::Sequence::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
+pub fn bitcoin_primitives::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
+pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
+pub fn bitcoin_primitives::taproot::TapBranchTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapBranchTag::eq(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> bool
+pub fn bitcoin_primitives::taproot::TapBranchTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapBranchTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapLeafHash::clone(&self) -> bitcoin_primitives::taproot::TapLeafHash
+pub fn bitcoin_primitives::taproot::TapLeafHash::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapLeafHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::taproot::TapLeafHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::taproot::TapLeafHash::eq(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> bool
+pub fn bitcoin_primitives::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>) -> bitcoin_primitives::taproot::TapLeafHash
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapLeafHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapLeafHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapLeafTag::clone(&self) -> bitcoin_primitives::taproot::TapLeafTag
+pub fn bitcoin_primitives::taproot::TapLeafTag::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapLeafTag::default() -> bitcoin_primitives::taproot::TapLeafTag
+pub fn bitcoin_primitives::taproot::TapLeafTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapLeafTag::eq(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> bool
+pub fn bitcoin_primitives::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapNodeHash::clone(&self) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapNodeHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::taproot::TapNodeHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::taproot::TapNodeHash::eq(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> bool
+pub fn bitcoin_primitives::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::from(leaf: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapNodeHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapNodeHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapTweakHash::clone(&self) -> bitcoin_primitives::taproot::TapTweakHash
+pub fn bitcoin_primitives::taproot::TapTweakHash::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapTweakHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::taproot::TapTweakHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::taproot::TapTweakHash::eq(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> bool
+pub fn bitcoin_primitives::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>) -> bitcoin_primitives::taproot::TapTweakHash
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapTweakHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapTweakHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakTag::clone(&self) -> bitcoin_primitives::taproot::TapTweakTag
+pub fn bitcoin_primitives::taproot::TapTweakTag::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapTweakTag::default() -> bitcoin_primitives::taproot::TapTweakTag
+pub fn bitcoin_primitives::taproot::TapTweakTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapTweakTag::eq(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> bool
+pub fn bitcoin_primitives::taproot::TapTweakTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapTweakTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPoint::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
+pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::OutPoint::deserialize<D>(deserializer: D) -> core::result::Result<bitcoin_primitives::transaction::OutPoint, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
+pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPoint::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPoint::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::transaction::ParseOutPointError::clone(&self) -> bitcoin_primitives::transaction::ParseOutPointError
+pub fn bitcoin_primitives::transaction::ParseOutPointError::eq(&self, other: &bitcoin_primitives::transaction::ParseOutPointError) -> bool
+pub fn bitcoin_primitives::transaction::ParseOutPointError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::ParseOutPointError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::ParseOutPointError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_primitives::transaction::Transaction::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::Transaction::clone(&self) -> bitcoin_primitives::transaction::Transaction
+pub fn bitcoin_primitives::transaction::Transaction::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Transaction::compute_ntxid(&self) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_primitives::transaction::Transaction::compute_txid(&self) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Transaction::compute_wtxid(&self) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Transaction::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::transaction::Transaction::eq(&self, other: &bitcoin_primitives::transaction::Transaction) -> bool
+pub fn bitcoin_primitives::transaction::Transaction::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Transaction::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Transaction::inputs(&self) -> &[bitcoin_primitives::transaction::TxIn]
+pub fn bitcoin_primitives::transaction::Transaction::inputs_mut(&mut self) -> &mut [bitcoin_primitives::transaction::TxIn]
+pub fn bitcoin_primitives::transaction::Transaction::outputs(&self) -> &[bitcoin_primitives::transaction::TxOut]
+pub fn bitcoin_primitives::transaction::Transaction::outputs_mut(&mut self) -> &mut [bitcoin_primitives::transaction::TxOut]
+pub fn bitcoin_primitives::transaction::Transaction::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Transaction::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::transaction::TxIn::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::TxIn::clone(&self) -> bitcoin_primitives::transaction::TxIn
+pub fn bitcoin_primitives::transaction::TxIn::cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::TxIn::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::transaction::TxIn::eq(&self, other: &bitcoin_primitives::transaction::TxIn) -> bool
+pub fn bitcoin_primitives::transaction::TxIn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxIn::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::TxIn::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TxIn::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::transaction::TxOut::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::TxOut::clone(&self) -> bitcoin_primitives::transaction::TxOut
+pub fn bitcoin_primitives::transaction::TxOut::cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::TxOut::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::transaction::TxOut::eq(&self, other: &bitcoin_primitives::transaction::TxOut) -> bool
+pub fn bitcoin_primitives::transaction::TxOut::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxOut::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::TxOut::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TxOut::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::transaction::Txid::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Txid::clone(&self) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Txid::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::transaction::Txid, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::transaction::Txid::eq(&self, other: &bitcoin_primitives::transaction::Txid) -> bool
+pub fn bitcoin_primitives::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::from(tx: &bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::from(tx: bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Txid, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::transaction::Txid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Txid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Txid::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::transaction::Version::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
+pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Version::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
+pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Version::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Wtxid::clone(&self) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Wtxid::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::transaction::Wtxid, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::transaction::Wtxid::eq(&self, other: &bitcoin_primitives::transaction::Wtxid) -> bool
+pub fn bitcoin_primitives::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::from(tx: &bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::from(tx: bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Wtxid, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::transaction::Wtxid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Wtxid::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::witness::Iter<'a>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn bitcoin_primitives::witness::Iter<'a>::size_hint(&self) -> (usize, core::option::Option<usize>)
+pub fn bitcoin_primitives::witness::Witness::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_primitives::witness::Witness::clear(&mut self)
+pub fn bitcoin_primitives::witness::Witness::clone(&self) -> bitcoin_primitives::witness::Witness
+pub fn bitcoin_primitives::witness::Witness::cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::cmp::Ordering
+pub fn bitcoin_primitives::witness::Witness::default() -> Self
+pub fn bitcoin_primitives::witness::Witness::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_primitives::witness::Witness::eq(&self, other: &bitcoin_primitives::witness::Witness) -> bool
+pub fn bitcoin_primitives::witness::Witness::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8]]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[alloc::vec::Vec<u8>]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<&[u8]>) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<alloc::vec::Vec<u8>>) -> Self
+pub fn bitcoin_primitives::witness::Witness::from_slice<T: core::convert::AsRef<[u8]>>(slice: &[T]) -> Self
+pub fn bitcoin_primitives::witness::Witness::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::witness::Witness::index(&self, index: usize) -> &Self::Output
+pub fn bitcoin_primitives::witness::Witness::is_empty(&self) -> bool
+pub fn bitcoin_primitives::witness::Witness::iter(&self) -> bitcoin_primitives::witness::Iter<'_>
+pub fn bitcoin_primitives::witness::Witness::last(&self) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::len(&self) -> usize
+pub fn bitcoin_primitives::witness::Witness::nth(&self, index: usize) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::partial_cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::witness::Witness::push<T: core::convert::AsRef<[u8]>>(&mut self, new_element: T)
+pub fn bitcoin_primitives::witness::Witness::second_to_last(&self) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_primitives::witness::Witness::size(&self) -> usize
+pub fn bitcoin_primitives::witness::Witness::third_to_last(&self) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::to_vec(&self) -> alloc::vec::Vec<alloc::vec::Vec<u8>>
+pub fn u32::from(sequence: bitcoin_primitives::sequence::Sequence) -> u32
+pub mod bitcoin_primitives
+pub mod bitcoin_primitives::absolute
+pub mod bitcoin_primitives::block
+pub mod bitcoin_primitives::locktime
+pub mod bitcoin_primitives::locktime::absolute
+pub mod bitcoin_primitives::locktime::relative
+pub mod bitcoin_primitives::merkle_tree
+pub mod bitcoin_primitives::opcodes
+pub mod bitcoin_primitives::opcodes::all
+pub mod bitcoin_primitives::pow
+pub mod bitcoin_primitives::relative
+pub mod bitcoin_primitives::script
+pub mod bitcoin_primitives::sequence
+pub mod bitcoin_primitives::taproot
+pub mod bitcoin_primitives::transaction
+pub mod bitcoin_primitives::witness
+pub static bitcoin_primitives::opcodes::OP_0: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_FALSE: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_NOP2: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_NOP3: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_TRUE: bitcoin_primitives::opcodes::Opcode
+pub struct bitcoin_primitives::Block<V> where V: bitcoin_primitives::block::Validation
+pub struct bitcoin_primitives::BlockHash(_)
+pub struct bitcoin_primitives::BlockHeader
+pub struct bitcoin_primitives::CompactTarget(_)
+pub struct bitcoin_primitives::Sequence(pub u32)
+pub struct bitcoin_primitives::TapBranchTag
+pub struct bitcoin_primitives::TapLeafHash(_)
+pub struct bitcoin_primitives::TapLeafTag
+pub struct bitcoin_primitives::TapNodeHash(_)
+pub struct bitcoin_primitives::TapTweakHash(_)
+pub struct bitcoin_primitives::TapTweakTag
+pub struct bitcoin_primitives::Transaction
+pub struct bitcoin_primitives::TxIn
+pub struct bitcoin_primitives::TxMerkleNode(_)
+pub struct bitcoin_primitives::TxOut
+pub struct bitcoin_primitives::Txid(_)
+pub struct bitcoin_primitives::Witness
+pub struct bitcoin_primitives::WitnessCommitment(_)
+pub struct bitcoin_primitives::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::Wtxid(_)
+pub struct bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+pub struct bitcoin_primitives::block::BlockHash(_)
+pub struct bitcoin_primitives::block::Header
+pub struct bitcoin_primitives::block::Version(_)
+pub struct bitcoin_primitives::block::WitnessCommitment(_)
+pub struct bitcoin_primitives::locktime::relative::DisabledLockTimeError(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
+pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::opcodes::Opcode
+pub struct bitcoin_primitives::pow::CompactTarget(_)
+pub struct bitcoin_primitives::relative::DisabledLockTimeError(_)
+pub struct bitcoin_primitives::script::ScriptBuf(_)
+pub struct bitcoin_primitives::sequence::Sequence(pub u32)
+pub struct bitcoin_primitives::taproot::TapBranchTag
+pub struct bitcoin_primitives::taproot::TapLeafHash(_)
+pub struct bitcoin_primitives::taproot::TapLeafTag
+pub struct bitcoin_primitives::taproot::TapNodeHash(_)
+pub struct bitcoin_primitives::taproot::TapTweakHash(_)
+pub struct bitcoin_primitives::taproot::TapTweakTag
+pub struct bitcoin_primitives::transaction::OutPoint
+pub struct bitcoin_primitives::transaction::Transaction
+pub struct bitcoin_primitives::transaction::TxIn
+pub struct bitcoin_primitives::transaction::TxOut
+pub struct bitcoin_primitives::transaction::Txid(_)
+pub struct bitcoin_primitives::transaction::Version(pub i32)
+pub struct bitcoin_primitives::transaction::Wtxid(_)
+pub struct bitcoin_primitives::witness::Iter<'a>
+pub struct bitcoin_primitives::witness::Witness
+pub trait bitcoin_primitives::BlockValidation: sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::block::Validation: sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub type &'a bitcoin_primitives::witness::Witness::IntoIter = bitcoin_primitives::witness::Iter<'a>
+pub type &'a bitcoin_primitives::witness::Witness::Item = &'a [u8]
+pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::block::BlockHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::block::WitnessCommitment::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::block::WitnessCommitment::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::locktime::absolute::LockTime::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::locktime::absolute::LockTime::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::locktime::relative::LockTime::Error = bitcoin_primitives::locktime::relative::DisabledLockTimeError
+pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::script::Script::Output = bitcoin_primitives::script::Script
+pub type bitcoin_primitives::script::Script::Owned = bitcoin_primitives::script::ScriptBuf
+pub type bitcoin_primitives::script::ScriptBuf::Target = bitcoin_primitives::script::Script
+pub type bitcoin_primitives::sequence::Sequence::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::sequence::Sequence::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::taproot::TapLeafHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapLeafHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::taproot::TapNodeHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapNodeHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::taproot::TapTweakHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapTweakHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::transaction::OutPoint::Err = bitcoin_primitives::transaction::ParseOutPointError
+pub type bitcoin_primitives::transaction::Txid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::transaction::Txid::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::transaction::Wtxid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::transaction::Wtxid::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::witness::Iter<'a>::Item = &'a [u8]
+pub type bitcoin_primitives::witness::Witness::Output = [u8]
+pub use bitcoin_primitives::Amount
+pub use bitcoin_primitives::BlockHeight
+pub use bitcoin_primitives::BlockInterval
+pub use bitcoin_primitives::FeeRate
+pub use bitcoin_primitives::SignedAmount
+pub use bitcoin_primitives::Weight
+pub use bitcoin_primitives::absolute::ConversionError
+pub use bitcoin_primitives::absolute::Height
+pub use bitcoin_primitives::absolute::LOCK_TIME_THRESHOLD
+pub use bitcoin_primitives::absolute::ParseHeightError
+pub use bitcoin_primitives::absolute::ParseTimeError
+pub use bitcoin_primitives::absolute::Time
+pub use bitcoin_primitives::amount
+pub use bitcoin_primitives::fee_rate
+pub use bitcoin_primitives::locktime::absolute::ConversionError
+pub use bitcoin_primitives::locktime::absolute::Height
+pub use bitcoin_primitives::locktime::absolute::LOCK_TIME_THRESHOLD
+pub use bitcoin_primitives::locktime::absolute::ParseHeightError
+pub use bitcoin_primitives::locktime::absolute::ParseTimeError
+pub use bitcoin_primitives::locktime::absolute::Time
+pub use bitcoin_primitives::locktime::relative::Height
+pub use bitcoin_primitives::locktime::relative::Time
+pub use bitcoin_primitives::locktime::relative::TimeOverflowError
+pub use bitcoin_primitives::relative::Height
+pub use bitcoin_primitives::relative::Time
+pub use bitcoin_primitives::relative::TimeOverflowError
+pub use bitcoin_primitives::weight
diff --git a/api/primitives/alloc-only.txt b/api/primitives/alloc-only.txt
new file mode 100644
index 0000000000..02441de462
--- /dev/null
+++ b/api/primitives/alloc-only.txt
@@ -0,0 +1,1740 @@
+#[non_exhaustive] pub enum bitcoin_primitives::transaction::ParseOutPointError
+#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleHeightError
+#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleTimeError
+#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleHeightError
+#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleTimeError
+#[repr(transparent)] pub struct bitcoin_primitives::script::Script(_)
+impl !core::marker::Sized for bitcoin_primitives::script::Script
+impl alloc::borrow::ToOwned for bitcoin_primitives::script::Script
+impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
+impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapLeafHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapNodeHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapTweakHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Txid
+impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Wtxid
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapBranchTag
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapLeafTag
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapTweakTag
+impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
+impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
+impl bitcoin_primitives::block::BlockHash
+impl bitcoin_primitives::block::Header
+impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Checked
+impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Unchecked
+impl bitcoin_primitives::block::Version
+impl bitcoin_primitives::block::WitnessCommitment
+impl bitcoin_primitives::locktime::absolute::LockTime
+impl bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl bitcoin_primitives::locktime::relative::LockTime
+impl bitcoin_primitives::merkle_tree::TxMerkleNode
+impl bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl bitcoin_primitives::opcodes::Opcode
+impl bitcoin_primitives::pow::CompactTarget
+impl bitcoin_primitives::script::Script
+impl bitcoin_primitives::script::ScriptBuf
+impl bitcoin_primitives::sequence::Sequence
+impl bitcoin_primitives::taproot::TapLeafHash
+impl bitcoin_primitives::taproot::TapNodeHash
+impl bitcoin_primitives::taproot::TapTweakHash
+impl bitcoin_primitives::transaction::OutPoint
+impl bitcoin_primitives::transaction::Transaction
+impl bitcoin_primitives::transaction::TxIn
+impl bitcoin_primitives::transaction::TxOut
+impl bitcoin_primitives::transaction::Txid
+impl bitcoin_primitives::transaction::Version
+impl bitcoin_primitives::transaction::Wtxid
+impl bitcoin_primitives::witness::Witness
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::BlockHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Txid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::BlockHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::WitnessCommitment
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Txid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Wtxid
+impl core::borrow::Borrow<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::borrow::BorrowMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::clone::Clone for bitcoin_primitives::block::BlockHash
+impl core::clone::Clone for bitcoin_primitives::block::Checked
+impl core::clone::Clone for bitcoin_primitives::block::Header
+impl core::clone::Clone for bitcoin_primitives::block::Unchecked
+impl core::clone::Clone for bitcoin_primitives::block::Version
+impl core::clone::Clone for bitcoin_primitives::block::WitnessCommitment
+impl core::clone::Clone for bitcoin_primitives::locktime::absolute::LockTime
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::LockTime
+impl core::clone::Clone for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::clone::Clone for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::clone::Clone for bitcoin_primitives::opcodes::Class
+impl core::clone::Clone for bitcoin_primitives::opcodes::ClassifyContext
+impl core::clone::Clone for bitcoin_primitives::opcodes::Opcode
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
+impl core::clone::Clone for bitcoin_primitives::script::ScriptBuf
+impl core::clone::Clone for bitcoin_primitives::sequence::Sequence
+impl core::clone::Clone for bitcoin_primitives::taproot::TapBranchTag
+impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafTag
+impl core::clone::Clone for bitcoin_primitives::taproot::TapNodeHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakTag
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
+impl core::clone::Clone for bitcoin_primitives::transaction::ParseOutPointError
+impl core::clone::Clone for bitcoin_primitives::transaction::Transaction
+impl core::clone::Clone for bitcoin_primitives::transaction::TxIn
+impl core::clone::Clone for bitcoin_primitives::transaction::TxOut
+impl core::clone::Clone for bitcoin_primitives::transaction::Txid
+impl core::clone::Clone for bitcoin_primitives::transaction::Version
+impl core::clone::Clone for bitcoin_primitives::transaction::Wtxid
+impl core::clone::Clone for bitcoin_primitives::witness::Witness
+impl core::cmp::Eq for bitcoin_primitives::block::BlockHash
+impl core::cmp::Eq for bitcoin_primitives::block::Checked
+impl core::cmp::Eq for bitcoin_primitives::block::Header
+impl core::cmp::Eq for bitcoin_primitives::block::Unchecked
+impl core::cmp::Eq for bitcoin_primitives::block::Version
+impl core::cmp::Eq for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::Eq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::LockTime
+impl core::cmp::Eq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
+impl core::cmp::Eq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::Eq for bitcoin_primitives::opcodes::Opcode
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Eq for bitcoin_primitives::script::Script
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::Eq for bitcoin_primitives::sequence::Sequence
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Eq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::cmp::Eq for bitcoin_primitives::transaction::Transaction
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxIn
+impl core::cmp::Eq for bitcoin_primitives::transaction::TxOut
+impl core::cmp::Eq for bitcoin_primitives::transaction::Txid
+impl core::cmp::Eq for bitcoin_primitives::transaction::Version
+impl core::cmp::Eq for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::Eq for bitcoin_primitives::witness::Witness
+impl core::cmp::Ord for bitcoin_primitives::block::BlockHash
+impl core::cmp::Ord for bitcoin_primitives::block::Checked
+impl core::cmp::Ord for bitcoin_primitives::block::Header
+impl core::cmp::Ord for bitcoin_primitives::block::Unchecked
+impl core::cmp::Ord for bitcoin_primitives::block::Version
+impl core::cmp::Ord for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::Ord for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Ord for bitcoin_primitives::script::Script
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::Ord for bitcoin_primitives::sequence::Sequence
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Ord for bitcoin_primitives::transaction::Transaction
+impl core::cmp::Ord for bitcoin_primitives::transaction::TxIn
+impl core::cmp::Ord for bitcoin_primitives::transaction::TxOut
+impl core::cmp::Ord for bitcoin_primitives::transaction::Txid
+impl core::cmp::Ord for bitcoin_primitives::transaction::Version
+impl core::cmp::Ord for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::Ord for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHash
+impl core::cmp::PartialEq for bitcoin_primitives::block::Checked
+impl core::cmp::PartialEq for bitcoin_primitives::block::Header
+impl core::cmp::PartialEq for bitcoin_primitives::block::Unchecked
+impl core::cmp::PartialEq for bitcoin_primitives::block::Version
+impl core::cmp::PartialEq for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::LockTime
+impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Opcode
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialEq for bitcoin_primitives::script::Script
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialEq for bitcoin_primitives::sequence::Sequence
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Transaction
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxIn
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxOut
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Txid
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::PartialEq for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialEq<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialEq<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::Script
+impl core::cmp::PartialOrd for bitcoin_primitives::block::BlockHash
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Checked
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Unchecked
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::PartialOrd for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::PartialOrd for bitcoin_primitives::locktime::relative::LockTime
+impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialOrd for bitcoin_primitives::script::Script
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialOrd for bitcoin_primitives::sequence::Sequence
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Transaction
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxIn
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxOut
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Txid
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::PartialOrd for bitcoin_primitives::witness::Witness
+impl core::cmp::PartialOrd<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialOrd<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::Script
+impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::Script
+impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
+impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::BlockHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Txid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::BlockHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::Script
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Txid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::AsRef<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
+impl core::convert::AsRef<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::From<&[&[u8]]> for bitcoin_primitives::witness::Witness
+impl core::convert::From<&[alloc::vec::Vec<u8>]> for bitcoin_primitives::witness::Witness
+impl core::convert::From<&bitcoin_primitives::block::Block> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Txid
+impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::From<alloc::vec::Vec<&[u8]>> for bitcoin_primitives::witness::Witness
+impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for bitcoin_primitives::witness::Witness
+impl core::convert::From<alloc::vec::Vec<u8>> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Txid
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::From<bitcoin_primitives::block::Block> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_primitives::block::BlockHash> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_primitives::block::WitnessCommitment> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::locktime::relative::LockTime> for bitcoin_primitives::sequence::Sequence
+impl core::convert::From<bitcoin_primitives::merkle_tree::TxMerkleNode> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>
+impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::boxed::Box<bitcoin_primitives::script::Script>
+impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::vec::Vec<u8>
+impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
+impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
+impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::From<bitcoin_primitives::taproot::TapNodeHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
+impl core::convert::From<bitcoin_primitives::taproot::TapTweakHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
+impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Txid
+impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::From<bitcoin_primitives::transaction::Txid> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::transaction::Wtxid> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::absolute::Time> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_primitives::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::Time> for bitcoin_primitives::locktime::relative::LockTime
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::ParseOutPointError
+impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
+impl core::convert::TryFrom<&str> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::TryFrom<&str> for bitcoin_primitives::sequence::Sequence
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::sequence::Sequence
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::sequence::Sequence
+impl core::convert::TryFrom<bitcoin_primitives::sequence::Sequence> for bitcoin_primitives::locktime::relative::LockTime
+impl core::default::Default for bitcoin_primitives::block::Version
+impl core::default::Default for bitcoin_primitives::pow::CompactTarget
+impl core::default::Default for bitcoin_primitives::script::ScriptBuf
+impl core::default::Default for bitcoin_primitives::sequence::Sequence
+impl core::default::Default for bitcoin_primitives::taproot::TapBranchTag
+impl core::default::Default for bitcoin_primitives::taproot::TapLeafTag
+impl core::default::Default for bitcoin_primitives::taproot::TapTweakTag
+impl core::default::Default for bitcoin_primitives::witness::Witness
+impl core::fmt::Debug for bitcoin_primitives::block::BlockHash
+impl core::fmt::Debug for bitcoin_primitives::block::Checked
+impl core::fmt::Debug for bitcoin_primitives::block::Header
+impl core::fmt::Debug for bitcoin_primitives::block::Unchecked
+impl core::fmt::Debug for bitcoin_primitives::block::Version
+impl core::fmt::Debug for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::Debug for bitcoin_primitives::locktime::absolute::LockTime
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::LockTime
+impl core::fmt::Debug for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
+impl core::fmt::Debug for bitcoin_primitives::opcodes::ClassifyContext
+impl core::fmt::Debug for bitcoin_primitives::opcodes::Opcode
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::Debug for bitcoin_primitives::script::Script
+impl core::fmt::Debug for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::Debug for bitcoin_primitives::sequence::Sequence
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Debug for bitcoin_primitives::transaction::ParseOutPointError
+impl core::fmt::Debug for bitcoin_primitives::transaction::Transaction
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxIn
+impl core::fmt::Debug for bitcoin_primitives::transaction::TxOut
+impl core::fmt::Debug for bitcoin_primitives::transaction::Txid
+impl core::fmt::Debug for bitcoin_primitives::transaction::Version
+impl core::fmt::Debug for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::Debug for bitcoin_primitives::witness::Witness
+impl core::fmt::Display for bitcoin_primitives::block::BlockHash
+impl core::fmt::Display for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::Display for bitcoin_primitives::locktime::absolute::LockTime
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::LockTime
+impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
+impl core::fmt::Display for bitcoin_primitives::script::Script
+impl core::fmt::Display for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::Display for bitcoin_primitives::sequence::Sequence
+impl core::fmt::Display for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::Display for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::Display for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::Display for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Display for bitcoin_primitives::transaction::ParseOutPointError
+impl core::fmt::Display for bitcoin_primitives::transaction::Txid
+impl core::fmt::Display for bitcoin_primitives::transaction::Version
+impl core::fmt::Display for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::LowerHex for bitcoin_primitives::block::BlockHash
+impl core::fmt::LowerHex for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::LowerHex for bitcoin_primitives::script::Script
+impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::LowerHex for bitcoin_primitives::sequence::Sequence
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::LowerHex for bitcoin_primitives::transaction::Txid
+impl core::fmt::LowerHex for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::UpperHex for bitcoin_primitives::block::BlockHash
+impl core::fmt::UpperHex for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::UpperHex for bitcoin_primitives::script::Script
+impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::UpperHex for bitcoin_primitives::sequence::Sequence
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::UpperHex for bitcoin_primitives::transaction::Txid
+impl core::fmt::UpperHex for bitcoin_primitives::transaction::Wtxid
+impl core::hash::Hash for bitcoin_primitives::block::BlockHash
+impl core::hash::Hash for bitcoin_primitives::block::Checked
+impl core::hash::Hash for bitcoin_primitives::block::Header
+impl core::hash::Hash for bitcoin_primitives::block::Unchecked
+impl core::hash::Hash for bitcoin_primitives::block::Version
+impl core::hash::Hash for bitcoin_primitives::block::WitnessCommitment
+impl core::hash::Hash for bitcoin_primitives::locktime::absolute::LockTime
+impl core::hash::Hash for bitcoin_primitives::locktime::relative::LockTime
+impl core::hash::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::hash::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
+impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
+impl core::hash::Hash for bitcoin_primitives::script::Script
+impl core::hash::Hash for bitcoin_primitives::script::ScriptBuf
+impl core::hash::Hash for bitcoin_primitives::sequence::Sequence
+impl core::hash::Hash for bitcoin_primitives::taproot::TapBranchTag
+impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafTag
+impl core::hash::Hash for bitcoin_primitives::taproot::TapNodeHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakTag
+impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
+impl core::hash::Hash for bitcoin_primitives::transaction::Transaction
+impl core::hash::Hash for bitcoin_primitives::transaction::TxIn
+impl core::hash::Hash for bitcoin_primitives::transaction::TxOut
+impl core::hash::Hash for bitcoin_primitives::transaction::Txid
+impl core::hash::Hash for bitcoin_primitives::transaction::Version
+impl core::hash::Hash for bitcoin_primitives::transaction::Wtxid
+impl core::hash::Hash for bitcoin_primitives::witness::Witness
+impl core::iter::traits::exact_size::ExactSizeIterator for bitcoin_primitives::witness::Iter<'_>
+impl core::marker::Copy for bitcoin_primitives::block::BlockHash
+impl core::marker::Copy for bitcoin_primitives::block::Header
+impl core::marker::Copy for bitcoin_primitives::block::Version
+impl core::marker::Copy for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Copy for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Copy for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Copy for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Copy for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Copy for bitcoin_primitives::opcodes::Class
+impl core::marker::Copy for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Copy for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Copy for bitcoin_primitives::sequence::Sequence
+impl core::marker::Copy for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Copy for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Copy for bitcoin_primitives::transaction::Txid
+impl core::marker::Copy for bitcoin_primitives::transaction::Version
+impl core::marker::Copy for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHash
+impl core::marker::Freeze for bitcoin_primitives::block::Checked
+impl core::marker::Freeze for bitcoin_primitives::block::Header
+impl core::marker::Freeze for bitcoin_primitives::block::Unchecked
+impl core::marker::Freeze for bitcoin_primitives::block::Version
+impl core::marker::Freeze for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Freeze for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
+impl core::marker::Freeze for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Freeze for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Freeze for bitcoin_primitives::script::Script
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Freeze for bitcoin_primitives::sequence::Sequence
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Freeze for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Freeze for bitcoin_primitives::transaction::Transaction
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxIn
+impl core::marker::Freeze for bitcoin_primitives::transaction::TxOut
+impl core::marker::Freeze for bitcoin_primitives::transaction::Txid
+impl core::marker::Freeze for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Freeze for bitcoin_primitives::witness::Witness
+impl core::marker::Send for bitcoin_primitives::block::BlockHash
+impl core::marker::Send for bitcoin_primitives::block::Checked
+impl core::marker::Send for bitcoin_primitives::block::Header
+impl core::marker::Send for bitcoin_primitives::block::Unchecked
+impl core::marker::Send for bitcoin_primitives::block::Version
+impl core::marker::Send for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Send for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Send for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Send for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Send for bitcoin_primitives::opcodes::Class
+impl core::marker::Send for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Send for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Send for bitcoin_primitives::script::Script
+impl core::marker::Send for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Send for bitcoin_primitives::sequence::Sequence
+impl core::marker::Send for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Send for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Send for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Send for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Send for bitcoin_primitives::transaction::Transaction
+impl core::marker::Send for bitcoin_primitives::transaction::TxIn
+impl core::marker::Send for bitcoin_primitives::transaction::TxOut
+impl core::marker::Send for bitcoin_primitives::transaction::Txid
+impl core::marker::Send for bitcoin_primitives::transaction::Version
+impl core::marker::Send for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Send for bitcoin_primitives::witness::Witness
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Checked
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Unchecked
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Opcode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::Script
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBuf
+impl core::marker::StructuralPartialEq for bitcoin_primitives::sequence::Sequence
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Transaction
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxIn
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxOut
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Txid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Wtxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::Witness
+impl core::marker::Sync for bitcoin_primitives::block::BlockHash
+impl core::marker::Sync for bitcoin_primitives::block::Checked
+impl core::marker::Sync for bitcoin_primitives::block::Header
+impl core::marker::Sync for bitcoin_primitives::block::Unchecked
+impl core::marker::Sync for bitcoin_primitives::block::Version
+impl core::marker::Sync for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Sync for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Sync for bitcoin_primitives::opcodes::Class
+impl core::marker::Sync for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Sync for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Sync for bitcoin_primitives::script::Script
+impl core::marker::Sync for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Sync for bitcoin_primitives::sequence::Sequence
+impl core::marker::Sync for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Sync for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Sync for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Sync for bitcoin_primitives::transaction::Transaction
+impl core::marker::Sync for bitcoin_primitives::transaction::TxIn
+impl core::marker::Sync for bitcoin_primitives::transaction::TxOut
+impl core::marker::Sync for bitcoin_primitives::transaction::Txid
+impl core::marker::Sync for bitcoin_primitives::transaction::Version
+impl core::marker::Sync for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Sync for bitcoin_primitives::witness::Witness
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHash
+impl core::marker::Unpin for bitcoin_primitives::block::Checked
+impl core::marker::Unpin for bitcoin_primitives::block::Header
+impl core::marker::Unpin for bitcoin_primitives::block::Unchecked
+impl core::marker::Unpin for bitcoin_primitives::block::Version
+impl core::marker::Unpin for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Unpin for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::LockTime
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
+impl core::marker::Unpin for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Unpin for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Unpin for bitcoin_primitives::script::Script
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Unpin for bitcoin_primitives::sequence::Sequence
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Unpin for bitcoin_primitives::transaction::ParseOutPointError
+impl core::marker::Unpin for bitcoin_primitives::transaction::Transaction
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxIn
+impl core::marker::Unpin for bitcoin_primitives::transaction::TxOut
+impl core::marker::Unpin for bitcoin_primitives::transaction::Txid
+impl core::marker::Unpin for bitcoin_primitives::transaction::Version
+impl core::marker::Unpin for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Unpin for bitcoin_primitives::witness::Witness
+impl core::ops::deref::Deref for bitcoin_primitives::script::ScriptBuf
+impl core::ops::deref::DerefMut for bitcoin_primitives::script::ScriptBuf
+impl core::ops::index::Index<(core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::Range<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeFrom<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeFull> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeInclusive<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeTo<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<core::ops::range::RangeToInclusive<usize>> for bitcoin_primitives::script::Script
+impl core::ops::index::Index<usize> for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Checked
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Unchecked
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::WitnessCommitment
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Class
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Opcode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::Script
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBuf
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::sequence::Sequence
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapBranchTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapNodeHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Transaction
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxIn
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOut
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Txid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Wtxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Witness
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Checked
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Unchecked
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::WitnessCommitment
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Opcode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::Script
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBuf
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::sequence::Sequence
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapBranchTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapNodeHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Transaction
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxIn
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOut
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Txid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Wtxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Witness
+impl core::str::traits::FromStr for bitcoin_primitives::block::BlockHash
+impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
+impl core::str::traits::FromStr for bitcoin_primitives::locktime::absolute::LockTime
+impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::sequence::Sequence
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapNodeHash
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapTweakHash
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::OutPoint
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::Txid
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::Wtxid
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::boxed::Box<bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::rc::Rc<bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::sync::Arc<bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl<'a> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>> for alloc::boxed::Box<bitcoin_primitives::script::Script>
+impl<'a> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>> for bitcoin_primitives::script::ScriptBuf
+impl<'a> core::iter::traits::collect::IntoIterator for &'a bitcoin_primitives::witness::Witness
+impl<'a> core::iter::traits::iterator::Iterator for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Freeze for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Send for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Sync for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::marker::Unpin for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Iter<'a>
+impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Iter<'a>
+impl<V: bitcoin_primitives::block::Validation> bitcoin_primitives::block::Block<V>
+impl<V> core::clone::Clone for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::clone::Clone
+impl<V> core::cmp::Eq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::Eq
+impl<V> core::cmp::PartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::PartialEq
+impl<V> core::fmt::Debug for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::fmt::Debug
+impl<V> core::marker::Freeze for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::Send for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::StructuralPartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+impl<V> core::marker::Sync for bitcoin_primitives::block::Block<V>
+impl<V> core::marker::Unpin for bitcoin_primitives::block::Block<V>
+impl<V> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::RefUnwindSafe
+impl<V> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::UnwindSafe
+pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
+pub bitcoin_primitives::BlockHeader::nonce: u32
+pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::block::BlockHash
+pub bitcoin_primitives::BlockHeader::time: u32
+pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::Transaction::input: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
+pub bitcoin_primitives::Transaction::lock_time: bitcoin_primitives::locktime::absolute::LockTime
+pub bitcoin_primitives::Transaction::output: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
+pub bitcoin_primitives::Transaction::version: bitcoin_primitives::transaction::Version
+pub bitcoin_primitives::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
+pub bitcoin_primitives::TxIn::script_sig: bitcoin_primitives::script::ScriptBuf
+pub bitcoin_primitives::TxIn::sequence: bitcoin_primitives::sequence::Sequence
+pub bitcoin_primitives::TxIn::witness: bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::TxOut::script_pubkey: bitcoin_primitives::script::ScriptBuf
+pub bitcoin_primitives::TxOut::value: bitcoin_units::amount::unsigned::Amount
+pub bitcoin_primitives::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_primitives::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
+pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
+pub bitcoin_primitives::block::Header::nonce: u32
+pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::block::BlockHash
+pub bitcoin_primitives::block::Header::time: u32
+pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_primitives::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
+pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
+pub bitcoin_primitives::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
+pub bitcoin_primitives::opcodes::Class::IllegalOp
+pub bitcoin_primitives::opcodes::Class::NoOp
+pub bitcoin_primitives::opcodes::Class::Ordinary(Ordinary)
+pub bitcoin_primitives::opcodes::Class::PushBytes(u32)
+pub bitcoin_primitives::opcodes::Class::PushNum(i32)
+pub bitcoin_primitives::opcodes::Class::ReturnOp
+pub bitcoin_primitives::opcodes::Class::SuccessOp
+pub bitcoin_primitives::opcodes::ClassifyContext::Legacy
+pub bitcoin_primitives::opcodes::ClassifyContext::TapScript
+pub bitcoin_primitives::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
+pub bitcoin_primitives::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
+pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
+pub bitcoin_primitives::transaction::OutPoint::vout: u32
+pub bitcoin_primitives::transaction::ParseOutPointError::Format
+pub bitcoin_primitives::transaction::ParseOutPointError::TooLong
+pub bitcoin_primitives::transaction::ParseOutPointError::Txid(hex_conservative::error::HexToArrayError)
+pub bitcoin_primitives::transaction::ParseOutPointError::Vout(bitcoin_units::parse::ParseIntError)
+pub bitcoin_primitives::transaction::ParseOutPointError::VoutNotCanonical
+pub bitcoin_primitives::transaction::Transaction::input: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
+pub bitcoin_primitives::transaction::Transaction::lock_time: bitcoin_primitives::locktime::absolute::LockTime
+pub bitcoin_primitives::transaction::Transaction::output: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
+pub bitcoin_primitives::transaction::Transaction::version: bitcoin_primitives::transaction::Version
+pub bitcoin_primitives::transaction::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
+pub bitcoin_primitives::transaction::TxIn::script_sig: bitcoin_primitives::script::ScriptBuf
+pub bitcoin_primitives::transaction::TxIn::sequence: bitcoin_primitives::sequence::Sequence
+pub bitcoin_primitives::transaction::TxIn::witness: bitcoin_primitives::witness::Witness
+pub bitcoin_primitives::transaction::TxOut::script_pubkey: bitcoin_primitives::script::ScriptBuf
+pub bitcoin_primitives::transaction::TxOut::value: bitcoin_units::amount::unsigned::Amount
+pub const bitcoin_primitives::BlockValidation::IS_CHECKED: bool
+pub const bitcoin_primitives::block::BlockHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::block::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::block::Checked::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Header::SIZE: usize
+pub const bitcoin_primitives::block::Unchecked::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Validation::IS_CHECKED: bool
+pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
+pub const bitcoin_primitives::block::Version::ONE: Self
+pub const bitcoin_primitives::block::Version::TWO: Self
+pub const bitcoin_primitives::block::WitnessCommitment::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::locktime::absolute::LockTime::SIZE: usize
+pub const bitcoin_primitives::locktime::absolute::LockTime::ZERO: bitcoin_primitives::locktime::absolute::LockTime
+pub const bitcoin_primitives::locktime::relative::LockTime::SIZE: usize
+pub const bitcoin_primitives::locktime::relative::LockTime::ZERO: bitcoin_primitives::locktime::relative::LockTime
+pub const bitcoin_primitives::merkle_tree::TxMerkleNode::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::merkle_tree::WitnessMerkleNode::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::opcodes::all::OP_0NOTEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_1ADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_1SUB: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DIV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DROP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2MUL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2OVER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2ROT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2SWAP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_3DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ABS: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_AND: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_BOOLAND: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_BOOLOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CAT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIG: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIGVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIG: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CLTV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CODESEPARATOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CSV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DEPTH: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DIV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DROP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ELSE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ENDIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_EQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_EQUALVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_FROMALTSTACK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_GREATERTHAN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_GREATERTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_HASH160: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_HASH256: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_IF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_IFDUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_INVALIDOPCODE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_INVERT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LEFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LESSTHAN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LESSTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LSHIFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MAX: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MIN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MOD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MUL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NEGATE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NIP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOTIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMEQUALVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMNOTEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_OR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_OVER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PICK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_0: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_11: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_12: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_13: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_14: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_15: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_16: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_17: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_18: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_19: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_20: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_21: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_22: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_23: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_24: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_25: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_26: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_27: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_28: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_29: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_30: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_31: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_32: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_33: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_34: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_35: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_36: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_37: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_38: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_39: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_3: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_40: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_41: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_42: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_43: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_44: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_45: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_46: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_47: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_48: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_49: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_50: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_51: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_52: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_53: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_54: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_55: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_56: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_57: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_58: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_59: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_60: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_61: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_62: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_63: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_64: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_65: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_66: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_67: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_68: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_69: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_70: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_71: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_72: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_73: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_74: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_75: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_11: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_12: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_13: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_14: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_15: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_16: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_3: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_NEG1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_187: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_188: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_189: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_190: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_191: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_192: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_193: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_194: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_195: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_196: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_197: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_198: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_199: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_200: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_201: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_202: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_203: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_204: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_205: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_206: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_207: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_208: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_209: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_210: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_211: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_212: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_213: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_214: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_215: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_216: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_217: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_218: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_219: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_220: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_221: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_222: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_223: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_224: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_225: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_226: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_227: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_228: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_229: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_230: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_231: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_232: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_233: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_234: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_235: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_236: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_237: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_238: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_239: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_240: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_241: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_242: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_243: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_244: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_245: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_246: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_247: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_248: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_249: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_250: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_251: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_252: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_253: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_254: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RIGHT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RIPEMD160: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ROLL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ROT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RSHIFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SHA1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SHA256: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SIZE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SUB: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SUBSTR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SWAP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_TOALTSTACK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_TUCK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERNOTIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_WITHIN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_XOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
+pub const bitcoin_primitives::sequence::Sequence::FINAL: Self
+pub const bitcoin_primitives::sequence::Sequence::MAX: Self
+pub const bitcoin_primitives::sequence::Sequence::SIZE: usize
+pub const bitcoin_primitives::sequence::Sequence::ZERO: Self
+pub const bitcoin_primitives::taproot::TapLeafHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::taproot::TapNodeHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::taproot::TapTweakHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
+pub const bitcoin_primitives::transaction::Transaction::MAX_STANDARD_WEIGHT: bitcoin_units::weight::Weight
+pub const bitcoin_primitives::transaction::TxIn::EMPTY_COINBASE: bitcoin_primitives::transaction::TxIn
+pub const bitcoin_primitives::transaction::TxOut::NULL: Self
+pub const bitcoin_primitives::transaction::Txid::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::Txid::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::transaction::Version::ONE: Self
+pub const bitcoin_primitives::transaction::Version::THREE: Self
+pub const bitcoin_primitives::transaction::Version::TWO: Self
+pub const bitcoin_primitives::transaction::Wtxid::COINBASE: Self
+pub const bitcoin_primitives::transaction::Wtxid::DISPLAY_BACKWARD: bool
+pub const fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
+pub const fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_height(&self) -> bool
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_time(&self) -> bool
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_height(n: u16) -> Self
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_height(&self) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_time(&self) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::opcodes::Opcode::decode_pushnum(self) -> core::option::Option<u8>
+pub const fn bitcoin_primitives::opcodes::Opcode::to_u8(self) -> u8
+pub const fn bitcoin_primitives::script::ScriptBuf::new() -> Self
+pub const fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::witness::Witness::new() -> Self
+pub enum bitcoin_primitives::BlockChecked
+pub enum bitcoin_primitives::BlockUnchecked
+pub enum bitcoin_primitives::absolute::LockTime
+pub enum bitcoin_primitives::block::Checked
+pub enum bitcoin_primitives::block::Unchecked
+pub enum bitcoin_primitives::locktime::absolute::LockTime
+pub enum bitcoin_primitives::locktime::relative::LockTime
+pub enum bitcoin_primitives::opcodes::Class
+pub enum bitcoin_primitives::opcodes::ClassifyContext
+pub enum bitcoin_primitives::relative::LockTime
+pub fn &'a bitcoin_primitives::witness::Witness::into_iter(self) -> Self::IntoIter
+pub fn alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>::from(value: bitcoin_primitives::script::ScriptBuf) -> Self
+pub fn alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>) -> Self
+pub fn alloc::rc::Rc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn alloc::sync::Arc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn alloc::vec::Vec<u8>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Txid) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Wtxid) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>::from(hashtype: bitcoin_primitives::taproot::TapNodeHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>::from(hashtype: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>::from(hashtype: bitcoin_primitives::taproot::TapTweakHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
+pub fn bitcoin_primitives::block::Block<V>::block_hash(&self) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::Block<V>::clone(&self) -> bitcoin_primitives::block::Block<V>
+pub fn bitcoin_primitives::block::Block<V>::eq(&self, other: &bitcoin_primitives::block::Block<V>) -> bool
+pub fn bitcoin_primitives::block::Block<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::cached_witness_root(&self) -> core::option::Option<bitcoin_primitives::merkle_tree::WitnessMerkleNode>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::header(&self) -> &bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::transactions(&self) -> &[bitcoin_primitives::transaction::Transaction]
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::assume_checked(self, witness_root: core::option::Option<bitcoin_primitives::merkle_tree::WitnessMerkleNode>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::into_parts(self) -> (bitcoin_primitives::block::Header, alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>)
+pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::new_unchecked(header: bitcoin_primitives::block::Header, transactions: alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
+pub fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::block::BlockHash::clone(&self) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::BlockHash::eq(&self, other: &bitcoin_primitives::block::BlockHash) -> bool
+pub fn bitcoin_primitives::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::BlockHash::from(block: &bitcoin_primitives::block::Block) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(block: bitcoin_primitives::block::Block) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(header: &bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(header: bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::BlockHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::block::BlockHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::block::Checked::clone(&self) -> bitcoin_primitives::block::Checked
+pub fn bitcoin_primitives::block::Checked::cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Checked::eq(&self, other: &bitcoin_primitives::block::Checked) -> bool
+pub fn bitcoin_primitives::block::Checked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Checked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Checked::partial_cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
+pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Unchecked::clone(&self) -> bitcoin_primitives::block::Unchecked
+pub fn bitcoin_primitives::block::Unchecked::cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Unchecked::eq(&self, other: &bitcoin_primitives::block::Unchecked) -> bool
+pub fn bitcoin_primitives::block::Unchecked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Unchecked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Unchecked::partial_cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Version::default() -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
+pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(&self, bit: u8) -> bool
+pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
+pub fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::block::WitnessCommitment::clone(&self) -> bitcoin_primitives::block::WitnessCommitment
+pub fn bitcoin_primitives::block::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::WitnessCommitment::eq(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> bool
+pub fn bitcoin_primitives::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::WitnessCommitment
+pub fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::WitnessCommitment, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::block::WitnessCommitment::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::locktime::absolute::LockTime::clone(&self) -> bitcoin_primitives::locktime::absolute::LockTime
+pub fn bitcoin_primitives::locktime::absolute::LockTime::eq(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::Time) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_time(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::locktime::absolute::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::is_satisfied_by(&self, height: bitcoin_units::locktime::absolute::Height, time: bitcoin_units::locktime::absolute::Time) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::DisabledLockTimeError
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::DisabledLockTimeError) -> bool
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleHeightError
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleHeightError) -> bool
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleTimeError
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleTimeError) -> bool
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::LockTime::clone(&self) -> bitcoin_primitives::locktime::relative::LockTime
+pub fn bitcoin_primitives::locktime::relative::LockTime::eq(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::Height) -> Self
+pub fn bitcoin_primitives::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::Time) -> Self
+pub fn bitcoin_primitives::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::from_sequence(n: bitcoin_primitives::sequence::Sequence) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by_sequence(&self, other: bitcoin_primitives::sequence::Sequence) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self, h: bitcoin_units::locktime::relative::Height, t: bitcoin_units::locktime::relative::Time) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::TxMerkleNode
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> bool
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::TxMerkleNode
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::TxMerkleNode, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bool
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::WitnessMerkleNode, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::opcodes::Class::clone(&self) -> bitcoin_primitives::opcodes::Class
+pub fn bitcoin_primitives::opcodes::Class::eq(&self, other: &bitcoin_primitives::opcodes::Class) -> bool
+pub fn bitcoin_primitives::opcodes::Class::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::ClassifyContext::clone(&self) -> bitcoin_primitives::opcodes::ClassifyContext
+pub fn bitcoin_primitives::opcodes::ClassifyContext::cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::cmp::Ordering
+pub fn bitcoin_primitives::opcodes::ClassifyContext::eq(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> bool
+pub fn bitcoin_primitives::opcodes::ClassifyContext::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::ClassifyContext::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::opcodes::ClassifyContext::partial_cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::opcodes::Opcode::classify(self, ctx: bitcoin_primitives::opcodes::ClassifyContext) -> bitcoin_primitives::opcodes::Class
+pub fn bitcoin_primitives::opcodes::Opcode::clone(&self) -> bitcoin_primitives::opcodes::Opcode
+pub fn bitcoin_primitives::opcodes::Opcode::eq(&self, other: &bitcoin_primitives::opcodes::Opcode) -> bool
+pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
+pub fn bitcoin_primitives::opcodes::Opcode::from(b: u8) -> bitcoin_primitives::opcodes::Opcode
+pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
+pub fn bitcoin_primitives::pow::CompactTarget::default() -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
+pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
+pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
+pub fn bitcoin_primitives::pow::CompactTarget::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::Script::as_bytes(&self) -> &[u8]
+pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::as_mut_bytes(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::Script::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::Script::as_ref(&self) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::cmp(&self, other: &bitcoin_primitives::script::Script) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::Script::eq(&self, other: &bitcoin_primitives::script::Script) -> bool
+pub fn bitcoin_primitives::script::Script::eq(&self, other: &bitcoin_primitives::script::ScriptBuf) -> bool
+pub fn bitcoin_primitives::script::Script::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::Script::from_bytes(bytes: &[u8]) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::from_bytes_mut(bytes: &mut [u8]) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::Script::index(&self, index: (core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::Range<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeFrom<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeFull) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeInclusive<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeTo<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeToInclusive<usize>) -> &Self::Output
+pub fn bitcoin_primitives::script::Script::into_script_buf(self: alloc::boxed::Box<Self>) -> bitcoin_primitives::script::ScriptBuf
+pub fn bitcoin_primitives::script::Script::is_empty(&self) -> bool
+pub fn bitcoin_primitives::script::Script::len(&self) -> usize
+pub fn bitcoin_primitives::script::Script::new() -> &'static bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::Script::partial_cmp(&self, other: &bitcoin_primitives::script::Script) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::Script::to_bytes(&self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::Script::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::Script::to_owned(&self) -> Self::Owned
+pub fn bitcoin_primitives::script::Script::to_vec(&self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::ScriptBuf::as_mut(&mut self) -> &mut [u8]
+pub fn bitcoin_primitives::script::ScriptBuf::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::as_mut_script(&mut self) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptBuf::as_ref(&self) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::as_script(&self) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::borrow(&self) -> &bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::borrow_mut(&mut self) -> &mut bitcoin_primitives::script::Script
+pub fn bitcoin_primitives::script::ScriptBuf::clone(&self) -> bitcoin_primitives::script::ScriptBuf
+pub fn bitcoin_primitives::script::ScriptBuf::cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptBuf::default() -> bitcoin_primitives::script::ScriptBuf
+pub fn bitcoin_primitives::script::ScriptBuf::deref(&self) -> &Self::Target
+pub fn bitcoin_primitives::script::ScriptBuf::deref_mut(&mut self) -> &mut Self::Target
+pub fn bitcoin_primitives::script::ScriptBuf::eq(&self, other: &bitcoin_primitives::script::Script) -> bool
+pub fn bitcoin_primitives::script::ScriptBuf::eq(&self, other: &bitcoin_primitives::script::ScriptBuf) -> bool
+pub fn bitcoin_primitives::script::ScriptBuf::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptBuf::from(v: alloc::vec::Vec<u8>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf::from(value: &'a bitcoin_primitives::script::Script) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf::from_bytes(bytes: alloc::vec::Vec<u8>) -> Self
+pub fn bitcoin_primitives::script::ScriptBuf::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptBuf::into_boxed_script(self) -> alloc::boxed::Box<bitcoin_primitives::script::Script>
+pub fn bitcoin_primitives::script::ScriptBuf::into_bytes(self) -> alloc::vec::Vec<u8>
+pub fn bitcoin_primitives::script::ScriptBuf::partial_cmp(&self, other: &bitcoin_primitives::script::Script) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptBuf::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptBuf::reserve(&mut self, additional_len: usize)
+pub fn bitcoin_primitives::script::ScriptBuf::reserve_exact(&mut self, additional_len: usize)
+pub fn bitcoin_primitives::script::ScriptBuf::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::ScriptBuf::with_capacity(capacity: usize) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::clone(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::sequence::Sequence::cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::cmp::Ordering
+pub fn bitcoin_primitives::sequence::Sequence::default() -> Self
+pub fn bitcoin_primitives::sequence::Sequence::enables_absolute_lock_time(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::eq(&self, other: &bitcoin_primitives::sequence::Sequence) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::sequence::Sequence::from(lt: bitcoin_primitives::locktime::relative::LockTime) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_consensus(n: u32) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_height(height: u16) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_primitives::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub fn bitcoin_primitives::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub fn bitcoin_primitives::sequence::Sequence::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_primitives::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::sequence::Sequence::is_final(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_height_locked(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_rbf(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::sequence::Sequence::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
+pub fn bitcoin_primitives::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
+pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
+pub fn bitcoin_primitives::taproot::TapBranchTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapBranchTag::eq(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> bool
+pub fn bitcoin_primitives::taproot::TapBranchTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapBranchTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapLeafHash::clone(&self) -> bitcoin_primitives::taproot::TapLeafHash
+pub fn bitcoin_primitives::taproot::TapLeafHash::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapLeafHash::eq(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> bool
+pub fn bitcoin_primitives::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>) -> bitcoin_primitives::taproot::TapLeafHash
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapLeafHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapLeafTag::clone(&self) -> bitcoin_primitives::taproot::TapLeafTag
+pub fn bitcoin_primitives::taproot::TapLeafTag::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapLeafTag::default() -> bitcoin_primitives::taproot::TapLeafTag
+pub fn bitcoin_primitives::taproot::TapLeafTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapLeafTag::eq(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> bool
+pub fn bitcoin_primitives::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapNodeHash::clone(&self) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapNodeHash::eq(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> bool
+pub fn bitcoin_primitives::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::from(leaf: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapNodeHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapTweakHash::clone(&self) -> bitcoin_primitives::taproot::TapTweakHash
+pub fn bitcoin_primitives::taproot::TapTweakHash::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapTweakHash::eq(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> bool
+pub fn bitcoin_primitives::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>) -> bitcoin_primitives::taproot::TapTweakHash
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapTweakHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakTag::clone(&self) -> bitcoin_primitives::taproot::TapTweakTag
+pub fn bitcoin_primitives::taproot::TapTweakTag::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapTweakTag::default() -> bitcoin_primitives::taproot::TapTweakTag
+pub fn bitcoin_primitives::taproot::TapTweakTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapTweakTag::eq(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> bool
+pub fn bitcoin_primitives::taproot::TapTweakTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapTweakTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
+pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
+pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPoint::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::ParseOutPointError::clone(&self) -> bitcoin_primitives::transaction::ParseOutPointError
+pub fn bitcoin_primitives::transaction::ParseOutPointError::eq(&self, other: &bitcoin_primitives::transaction::ParseOutPointError) -> bool
+pub fn bitcoin_primitives::transaction::ParseOutPointError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::ParseOutPointError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_primitives::transaction::Transaction::clone(&self) -> bitcoin_primitives::transaction::Transaction
+pub fn bitcoin_primitives::transaction::Transaction::cmp(&self, other: &Self) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Transaction::compute_ntxid(&self) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_primitives::transaction::Transaction::compute_txid(&self) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Transaction::compute_wtxid(&self) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Transaction::eq(&self, other: &bitcoin_primitives::transaction::Transaction) -> bool
+pub fn bitcoin_primitives::transaction::Transaction::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Transaction::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Transaction::inputs(&self) -> &[bitcoin_primitives::transaction::TxIn]
+pub fn bitcoin_primitives::transaction::Transaction::inputs_mut(&mut self) -> &mut [bitcoin_primitives::transaction::TxIn]
+pub fn bitcoin_primitives::transaction::Transaction::outputs(&self) -> &[bitcoin_primitives::transaction::TxOut]
+pub fn bitcoin_primitives::transaction::Transaction::outputs_mut(&mut self) -> &mut [bitcoin_primitives::transaction::TxOut]
+pub fn bitcoin_primitives::transaction::Transaction::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TxIn::clone(&self) -> bitcoin_primitives::transaction::TxIn
+pub fn bitcoin_primitives::transaction::TxIn::cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::TxIn::eq(&self, other: &bitcoin_primitives::transaction::TxIn) -> bool
+pub fn bitcoin_primitives::transaction::TxIn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxIn::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::TxIn::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::TxOut::clone(&self) -> bitcoin_primitives::transaction::TxOut
+pub fn bitcoin_primitives::transaction::TxOut::cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::TxOut::eq(&self, other: &bitcoin_primitives::transaction::TxOut) -> bool
+pub fn bitcoin_primitives::transaction::TxOut::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::TxOut::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::TxOut::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Txid::clone(&self) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Txid::eq(&self, other: &bitcoin_primitives::transaction::Txid) -> bool
+pub fn bitcoin_primitives::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::from(tx: &bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::from(tx: bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Txid, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::transaction::Txid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Txid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
+pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
+pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Wtxid::clone(&self) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Wtxid::eq(&self, other: &bitcoin_primitives::transaction::Wtxid) -> bool
+pub fn bitcoin_primitives::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::from(tx: &bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::from(tx: bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Wtxid, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::transaction::Wtxid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::witness::Iter<'a>::next(&mut self) -> core::option::Option<Self::Item>
+pub fn bitcoin_primitives::witness::Iter<'a>::size_hint(&self) -> (usize, core::option::Option<usize>)
+pub fn bitcoin_primitives::witness::Witness::clear(&mut self)
+pub fn bitcoin_primitives::witness::Witness::clone(&self) -> bitcoin_primitives::witness::Witness
+pub fn bitcoin_primitives::witness::Witness::cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::cmp::Ordering
+pub fn bitcoin_primitives::witness::Witness::default() -> Self
+pub fn bitcoin_primitives::witness::Witness::eq(&self, other: &bitcoin_primitives::witness::Witness) -> bool
+pub fn bitcoin_primitives::witness::Witness::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8]]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(slice: &[alloc::vec::Vec<u8>]) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<&[u8]>) -> Self
+pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<alloc::vec::Vec<u8>>) -> Self
+pub fn bitcoin_primitives::witness::Witness::from_slice<T: core::convert::AsRef<[u8]>>(slice: &[T]) -> Self
+pub fn bitcoin_primitives::witness::Witness::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::witness::Witness::index(&self, index: usize) -> &Self::Output
+pub fn bitcoin_primitives::witness::Witness::is_empty(&self) -> bool
+pub fn bitcoin_primitives::witness::Witness::iter(&self) -> bitcoin_primitives::witness::Iter<'_>
+pub fn bitcoin_primitives::witness::Witness::last(&self) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::len(&self) -> usize
+pub fn bitcoin_primitives::witness::Witness::nth(&self, index: usize) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::partial_cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::witness::Witness::push<T: core::convert::AsRef<[u8]>>(&mut self, new_element: T)
+pub fn bitcoin_primitives::witness::Witness::second_to_last(&self) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::size(&self) -> usize
+pub fn bitcoin_primitives::witness::Witness::third_to_last(&self) -> core::option::Option<&[u8]>
+pub fn bitcoin_primitives::witness::Witness::to_vec(&self) -> alloc::vec::Vec<alloc::vec::Vec<u8>>
+pub fn u32::from(sequence: bitcoin_primitives::sequence::Sequence) -> u32
+pub mod bitcoin_primitives
+pub mod bitcoin_primitives::absolute
+pub mod bitcoin_primitives::block
+pub mod bitcoin_primitives::locktime
+pub mod bitcoin_primitives::locktime::absolute
+pub mod bitcoin_primitives::locktime::relative
+pub mod bitcoin_primitives::merkle_tree
+pub mod bitcoin_primitives::opcodes
+pub mod bitcoin_primitives::opcodes::all
+pub mod bitcoin_primitives::pow
+pub mod bitcoin_primitives::relative
+pub mod bitcoin_primitives::script
+pub mod bitcoin_primitives::sequence
+pub mod bitcoin_primitives::taproot
+pub mod bitcoin_primitives::transaction
+pub mod bitcoin_primitives::witness
+pub static bitcoin_primitives::opcodes::OP_0: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_FALSE: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_NOP2: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_NOP3: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_TRUE: bitcoin_primitives::opcodes::Opcode
+pub struct bitcoin_primitives::Block<V> where V: bitcoin_primitives::block::Validation
+pub struct bitcoin_primitives::BlockHash(_)
+pub struct bitcoin_primitives::BlockHeader
+pub struct bitcoin_primitives::CompactTarget(_)
+pub struct bitcoin_primitives::Sequence(pub u32)
+pub struct bitcoin_primitives::TapBranchTag
+pub struct bitcoin_primitives::TapLeafHash(_)
+pub struct bitcoin_primitives::TapLeafTag
+pub struct bitcoin_primitives::TapNodeHash(_)
+pub struct bitcoin_primitives::TapTweakHash(_)
+pub struct bitcoin_primitives::TapTweakTag
+pub struct bitcoin_primitives::Transaction
+pub struct bitcoin_primitives::TxIn
+pub struct bitcoin_primitives::TxMerkleNode(_)
+pub struct bitcoin_primitives::TxOut
+pub struct bitcoin_primitives::Txid(_)
+pub struct bitcoin_primitives::Witness
+pub struct bitcoin_primitives::WitnessCommitment(_)
+pub struct bitcoin_primitives::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::Wtxid(_)
+pub struct bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
+pub struct bitcoin_primitives::block::BlockHash(_)
+pub struct bitcoin_primitives::block::Header
+pub struct bitcoin_primitives::block::Version(_)
+pub struct bitcoin_primitives::block::WitnessCommitment(_)
+pub struct bitcoin_primitives::locktime::relative::DisabledLockTimeError(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
+pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::opcodes::Opcode
+pub struct bitcoin_primitives::pow::CompactTarget(_)
+pub struct bitcoin_primitives::relative::DisabledLockTimeError(_)
+pub struct bitcoin_primitives::script::ScriptBuf(_)
+pub struct bitcoin_primitives::sequence::Sequence(pub u32)
+pub struct bitcoin_primitives::taproot::TapBranchTag
+pub struct bitcoin_primitives::taproot::TapLeafHash(_)
+pub struct bitcoin_primitives::taproot::TapLeafTag
+pub struct bitcoin_primitives::taproot::TapNodeHash(_)
+pub struct bitcoin_primitives::taproot::TapTweakHash(_)
+pub struct bitcoin_primitives::taproot::TapTweakTag
+pub struct bitcoin_primitives::transaction::OutPoint
+pub struct bitcoin_primitives::transaction::Transaction
+pub struct bitcoin_primitives::transaction::TxIn
+pub struct bitcoin_primitives::transaction::TxOut
+pub struct bitcoin_primitives::transaction::Txid(_)
+pub struct bitcoin_primitives::transaction::Version(pub i32)
+pub struct bitcoin_primitives::transaction::Wtxid(_)
+pub struct bitcoin_primitives::witness::Iter<'a>
+pub struct bitcoin_primitives::witness::Witness
+pub trait bitcoin_primitives::BlockValidation: sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::block::Validation: sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub type &'a bitcoin_primitives::witness::Witness::IntoIter = bitcoin_primitives::witness::Iter<'a>
+pub type &'a bitcoin_primitives::witness::Witness::Item = &'a [u8]
+pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::block::BlockHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::block::WitnessCommitment::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::block::WitnessCommitment::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::locktime::absolute::LockTime::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::locktime::absolute::LockTime::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::locktime::relative::LockTime::Error = bitcoin_primitives::locktime::relative::DisabledLockTimeError
+pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::script::Script::Output = bitcoin_primitives::script::Script
+pub type bitcoin_primitives::script::Script::Owned = bitcoin_primitives::script::ScriptBuf
+pub type bitcoin_primitives::script::ScriptBuf::Target = bitcoin_primitives::script::Script
+pub type bitcoin_primitives::sequence::Sequence::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::sequence::Sequence::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::taproot::TapLeafHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapLeafHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::taproot::TapNodeHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapNodeHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::taproot::TapTweakHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapTweakHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::transaction::OutPoint::Err = bitcoin_primitives::transaction::ParseOutPointError
+pub type bitcoin_primitives::transaction::Txid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::transaction::Txid::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::transaction::Wtxid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::transaction::Wtxid::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::witness::Iter<'a>::Item = &'a [u8]
+pub type bitcoin_primitives::witness::Witness::Output = [u8]
+pub use bitcoin_primitives::Amount
+pub use bitcoin_primitives::BlockHeight
+pub use bitcoin_primitives::BlockInterval
+pub use bitcoin_primitives::FeeRate
+pub use bitcoin_primitives::SignedAmount
+pub use bitcoin_primitives::Weight
+pub use bitcoin_primitives::absolute::ConversionError
+pub use bitcoin_primitives::absolute::Height
+pub use bitcoin_primitives::absolute::LOCK_TIME_THRESHOLD
+pub use bitcoin_primitives::absolute::ParseHeightError
+pub use bitcoin_primitives::absolute::ParseTimeError
+pub use bitcoin_primitives::absolute::Time
+pub use bitcoin_primitives::amount
+pub use bitcoin_primitives::fee_rate
+pub use bitcoin_primitives::locktime::absolute::ConversionError
+pub use bitcoin_primitives::locktime::absolute::Height
+pub use bitcoin_primitives::locktime::absolute::LOCK_TIME_THRESHOLD
+pub use bitcoin_primitives::locktime::absolute::ParseHeightError
+pub use bitcoin_primitives::locktime::absolute::ParseTimeError
+pub use bitcoin_primitives::locktime::absolute::Time
+pub use bitcoin_primitives::locktime::relative::Height
+pub use bitcoin_primitives::locktime::relative::Time
+pub use bitcoin_primitives::locktime::relative::TimeOverflowError
+pub use bitcoin_primitives::relative::Height
+pub use bitcoin_primitives::relative::Time
+pub use bitcoin_primitives::relative::TimeOverflowError
+pub use bitcoin_primitives::weight
diff --git a/api/primitives/no-features.txt b/api/primitives/no-features.txt
new file mode 100644
index 0000000000..0d63cb004f
--- /dev/null
+++ b/api/primitives/no-features.txt
@@ -0,0 +1,1098 @@
+impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
+impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapLeafHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapNodeHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapTweakHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Txid
+impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Wtxid
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapBranchTag
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapLeafTag
+impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapTweakTag
+impl bitcoin_primitives::block::BlockHash
+impl bitcoin_primitives::block::Header
+impl bitcoin_primitives::block::Version
+impl bitcoin_primitives::block::WitnessCommitment
+impl bitcoin_primitives::merkle_tree::TxMerkleNode
+impl bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl bitcoin_primitives::opcodes::Opcode
+impl bitcoin_primitives::pow::CompactTarget
+impl bitcoin_primitives::sequence::Sequence
+impl bitcoin_primitives::taproot::TapLeafHash
+impl bitcoin_primitives::taproot::TapNodeHash
+impl bitcoin_primitives::taproot::TapTweakHash
+impl bitcoin_primitives::transaction::OutPoint
+impl bitcoin_primitives::transaction::Txid
+impl bitcoin_primitives::transaction::Version
+impl bitcoin_primitives::transaction::Wtxid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::BlockHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Txid
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::BlockHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::WitnessCommitment
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Txid
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Wtxid
+impl core::clone::Clone for bitcoin_primitives::block::BlockHash
+impl core::clone::Clone for bitcoin_primitives::block::Header
+impl core::clone::Clone for bitcoin_primitives::block::Version
+impl core::clone::Clone for bitcoin_primitives::block::WitnessCommitment
+impl core::clone::Clone for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::clone::Clone for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::clone::Clone for bitcoin_primitives::opcodes::Class
+impl core::clone::Clone for bitcoin_primitives::opcodes::ClassifyContext
+impl core::clone::Clone for bitcoin_primitives::opcodes::Opcode
+impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
+impl core::clone::Clone for bitcoin_primitives::sequence::Sequence
+impl core::clone::Clone for bitcoin_primitives::taproot::TapBranchTag
+impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafTag
+impl core::clone::Clone for bitcoin_primitives::taproot::TapNodeHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakHash
+impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakTag
+impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
+impl core::clone::Clone for bitcoin_primitives::transaction::Txid
+impl core::clone::Clone for bitcoin_primitives::transaction::Version
+impl core::clone::Clone for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::Eq for bitcoin_primitives::block::BlockHash
+impl core::cmp::Eq for bitcoin_primitives::block::Header
+impl core::cmp::Eq for bitcoin_primitives::block::Version
+impl core::cmp::Eq for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::Eq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
+impl core::cmp::Eq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::Eq for bitcoin_primitives::opcodes::Opcode
+impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Eq for bitcoin_primitives::sequence::Sequence
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Eq for bitcoin_primitives::transaction::Txid
+impl core::cmp::Eq for bitcoin_primitives::transaction::Version
+impl core::cmp::Eq for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::Ord for bitcoin_primitives::block::BlockHash
+impl core::cmp::Ord for bitcoin_primitives::block::Header
+impl core::cmp::Ord for bitcoin_primitives::block::Version
+impl core::cmp::Ord for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::Ord for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::Ord for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Ord for bitcoin_primitives::sequence::Sequence
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::Ord for bitcoin_primitives::transaction::Txid
+impl core::cmp::Ord for bitcoin_primitives::transaction::Version
+impl core::cmp::Ord for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHash
+impl core::cmp::PartialEq for bitcoin_primitives::block::Header
+impl core::cmp::PartialEq for bitcoin_primitives::block::Version
+impl core::cmp::PartialEq for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Opcode
+impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialEq for bitcoin_primitives::sequence::Sequence
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Txid
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialEq for bitcoin_primitives::transaction::Wtxid
+impl core::cmp::PartialOrd for bitcoin_primitives::block::BlockHash
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
+impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
+impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialOrd for bitcoin_primitives::sequence::Sequence
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapBranchTag
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafTag
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapNodeHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakHash
+impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakTag
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Txid
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
+impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Wtxid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::BlockHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Txid
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::BlockHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Txid
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::WitnessCommitment
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Txid
+impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Wtxid
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>> for bitcoin_primitives::taproot::TapLeafHash
+impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>> for bitcoin_primitives::taproot::TapTweakHash
+impl core::convert::From<bitcoin_primitives::block::BlockHash> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
+impl core::convert::From<bitcoin_primitives::block::WitnessCommitment> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::merkle_tree::TxMerkleNode> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
+impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
+impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_primitives::taproot::TapNodeHash
+impl core::convert::From<bitcoin_primitives::taproot::TapNodeHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
+impl core::convert::From<bitcoin_primitives::taproot::TapTweakHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
+impl core::convert::From<bitcoin_primitives::transaction::Txid> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::transaction::Wtxid> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
+impl core::default::Default for bitcoin_primitives::block::Version
+impl core::default::Default for bitcoin_primitives::pow::CompactTarget
+impl core::default::Default for bitcoin_primitives::sequence::Sequence
+impl core::default::Default for bitcoin_primitives::taproot::TapBranchTag
+impl core::default::Default for bitcoin_primitives::taproot::TapLeafTag
+impl core::default::Default for bitcoin_primitives::taproot::TapTweakTag
+impl core::fmt::Debug for bitcoin_primitives::block::BlockHash
+impl core::fmt::Debug for bitcoin_primitives::block::Header
+impl core::fmt::Debug for bitcoin_primitives::block::Version
+impl core::fmt::Debug for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::Debug for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
+impl core::fmt::Debug for bitcoin_primitives::opcodes::ClassifyContext
+impl core::fmt::Debug for bitcoin_primitives::opcodes::Opcode
+impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::Debug for bitcoin_primitives::sequence::Sequence
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::Debug for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Debug for bitcoin_primitives::transaction::Txid
+impl core::fmt::Debug for bitcoin_primitives::transaction::Version
+impl core::fmt::Debug for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::Display for bitcoin_primitives::block::BlockHash
+impl core::fmt::Display for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
+impl core::fmt::Display for bitcoin_primitives::sequence::Sequence
+impl core::fmt::Display for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::Display for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::Display for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::Display for bitcoin_primitives::transaction::OutPoint
+impl core::fmt::Display for bitcoin_primitives::transaction::Txid
+impl core::fmt::Display for bitcoin_primitives::transaction::Version
+impl core::fmt::Display for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::LowerHex for bitcoin_primitives::block::BlockHash
+impl core::fmt::LowerHex for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::LowerHex for bitcoin_primitives::sequence::Sequence
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::LowerHex for bitcoin_primitives::transaction::Txid
+impl core::fmt::LowerHex for bitcoin_primitives::transaction::Wtxid
+impl core::fmt::UpperHex for bitcoin_primitives::block::BlockHash
+impl core::fmt::UpperHex for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::UpperHex for bitcoin_primitives::sequence::Sequence
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapLeafHash
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapNodeHash
+impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapTweakHash
+impl core::fmt::UpperHex for bitcoin_primitives::transaction::Txid
+impl core::fmt::UpperHex for bitcoin_primitives::transaction::Wtxid
+impl core::hash::Hash for bitcoin_primitives::block::BlockHash
+impl core::hash::Hash for bitcoin_primitives::block::Header
+impl core::hash::Hash for bitcoin_primitives::block::Version
+impl core::hash::Hash for bitcoin_primitives::block::WitnessCommitment
+impl core::hash::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::hash::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
+impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
+impl core::hash::Hash for bitcoin_primitives::sequence::Sequence
+impl core::hash::Hash for bitcoin_primitives::taproot::TapBranchTag
+impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafTag
+impl core::hash::Hash for bitcoin_primitives::taproot::TapNodeHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakHash
+impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakTag
+impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
+impl core::hash::Hash for bitcoin_primitives::transaction::Txid
+impl core::hash::Hash for bitcoin_primitives::transaction::Version
+impl core::hash::Hash for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Copy for bitcoin_primitives::block::BlockHash
+impl core::marker::Copy for bitcoin_primitives::block::Header
+impl core::marker::Copy for bitcoin_primitives::block::Version
+impl core::marker::Copy for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Copy for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Copy for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Copy for bitcoin_primitives::opcodes::Class
+impl core::marker::Copy for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Copy for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Copy for bitcoin_primitives::sequence::Sequence
+impl core::marker::Copy for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Copy for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Copy for bitcoin_primitives::transaction::Txid
+impl core::marker::Copy for bitcoin_primitives::transaction::Version
+impl core::marker::Copy for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Freeze for bitcoin_primitives::block::BlockHash
+impl core::marker::Freeze for bitcoin_primitives::block::Header
+impl core::marker::Freeze for bitcoin_primitives::block::Version
+impl core::marker::Freeze for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
+impl core::marker::Freeze for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Freeze for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Freeze for bitcoin_primitives::sequence::Sequence
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Freeze for bitcoin_primitives::transaction::Txid
+impl core::marker::Freeze for bitcoin_primitives::transaction::Version
+impl core::marker::Freeze for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Send for bitcoin_primitives::block::BlockHash
+impl core::marker::Send for bitcoin_primitives::block::Header
+impl core::marker::Send for bitcoin_primitives::block::Version
+impl core::marker::Send for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Send for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Send for bitcoin_primitives::opcodes::Class
+impl core::marker::Send for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Send for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Send for bitcoin_primitives::sequence::Sequence
+impl core::marker::Send for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Send for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Send for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Send for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Send for bitcoin_primitives::transaction::Txid
+impl core::marker::Send for bitcoin_primitives::transaction::Version
+impl core::marker::Send for bitcoin_primitives::transaction::Wtxid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Opcode
+impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::marker::StructuralPartialEq for bitcoin_primitives::sequence::Sequence
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Txid
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
+impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Sync for bitcoin_primitives::block::BlockHash
+impl core::marker::Sync for bitcoin_primitives::block::Header
+impl core::marker::Sync for bitcoin_primitives::block::Version
+impl core::marker::Sync for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Sync for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Sync for bitcoin_primitives::opcodes::Class
+impl core::marker::Sync for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Sync for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Sync for bitcoin_primitives::sequence::Sequence
+impl core::marker::Sync for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Sync for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Sync for bitcoin_primitives::transaction::Txid
+impl core::marker::Sync for bitcoin_primitives::transaction::Version
+impl core::marker::Sync for bitcoin_primitives::transaction::Wtxid
+impl core::marker::Unpin for bitcoin_primitives::block::BlockHash
+impl core::marker::Unpin for bitcoin_primitives::block::Header
+impl core::marker::Unpin for bitcoin_primitives::block::Version
+impl core::marker::Unpin for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
+impl core::marker::Unpin for bitcoin_primitives::opcodes::ClassifyContext
+impl core::marker::Unpin for bitcoin_primitives::opcodes::Opcode
+impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Unpin for bitcoin_primitives::sequence::Sequence
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapBranchTag
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafTag
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapNodeHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakHash
+impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakTag
+impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
+impl core::marker::Unpin for bitcoin_primitives::transaction::Txid
+impl core::marker::Unpin for bitcoin_primitives::transaction::Version
+impl core::marker::Unpin for bitcoin_primitives::transaction::Wtxid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::WitnessCommitment
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Class
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Opcode
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::sequence::Sequence
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapBranchTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapNodeHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakTag
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Txid
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Wtxid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::WitnessCommitment
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Opcode
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::sequence::Sequence
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapBranchTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapNodeHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakTag
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Txid
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Wtxid
+impl core::str::traits::FromStr for bitcoin_primitives::block::BlockHash
+impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
+impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapNodeHash
+impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapTweakHash
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::Txid
+impl core::str::traits::FromStr for bitcoin_primitives::transaction::Wtxid
+pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
+pub bitcoin_primitives::BlockHeader::nonce: u32
+pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::block::BlockHash
+pub bitcoin_primitives::BlockHeader::time: u32
+pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
+pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
+pub bitcoin_primitives::block::Header::nonce: u32
+pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::block::BlockHash
+pub bitcoin_primitives::block::Header::time: u32
+pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::opcodes::Class::IllegalOp
+pub bitcoin_primitives::opcodes::Class::NoOp
+pub bitcoin_primitives::opcodes::Class::Ordinary(Ordinary)
+pub bitcoin_primitives::opcodes::Class::PushBytes(u32)
+pub bitcoin_primitives::opcodes::Class::PushNum(i32)
+pub bitcoin_primitives::opcodes::Class::ReturnOp
+pub bitcoin_primitives::opcodes::Class::SuccessOp
+pub bitcoin_primitives::opcodes::ClassifyContext::Legacy
+pub bitcoin_primitives::opcodes::ClassifyContext::TapScript
+pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
+pub bitcoin_primitives::transaction::OutPoint::vout: u32
+pub const bitcoin_primitives::block::BlockHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::block::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
+pub const bitcoin_primitives::block::Header::SIZE: usize
+pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
+pub const bitcoin_primitives::block::Version::ONE: Self
+pub const bitcoin_primitives::block::Version::TWO: Self
+pub const bitcoin_primitives::block::WitnessCommitment::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::merkle_tree::TxMerkleNode::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::merkle_tree::WitnessMerkleNode::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::opcodes::all::OP_0NOTEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_1ADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_1SUB: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DIV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DROP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2MUL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2OVER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2ROT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_2SWAP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_3DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ABS: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_AND: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_BOOLAND: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_BOOLOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CAT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIG: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIGVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIG: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGADD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CLTV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CODESEPARATOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_CSV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DEPTH: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DIV: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DROP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_DUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ELSE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ENDIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_EQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_EQUALVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_FROMALTSTACK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_GREATERTHAN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_GREATERTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_HASH160: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_HASH256: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_IF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_IFDUP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_INVALIDOPCODE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_INVERT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LEFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LESSTHAN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LESSTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_LSHIFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MAX: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MIN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MOD: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_MUL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NEGATE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NIP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NOTIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMEQUALVERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_NUMNOTEQUAL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_OR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_OVER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PICK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_0: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_11: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_12: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_13: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_14: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_15: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_16: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_17: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_18: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_19: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_20: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_21: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_22: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_23: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_24: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_25: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_26: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_27: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_28: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_29: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_30: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_31: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_32: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_33: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_34: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_35: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_36: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_37: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_38: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_39: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_3: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_40: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_41: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_42: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_43: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_44: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_45: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_46: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_47: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_48: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_49: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_50: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_51: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_52: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_53: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_54: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_55: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_56: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_57: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_58: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_59: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_60: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_61: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_62: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_63: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_64: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_65: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_66: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_67: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_68: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_69: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_70: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_71: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_72: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_73: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_74: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_75: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_10: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_11: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_12: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_13: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_14: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_15: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_16: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_3: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_4: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_5: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_6: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_7: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_8: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_9: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_NEG1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED2: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RESERVED: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_187: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_188: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_189: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_190: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_191: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_192: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_193: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_194: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_195: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_196: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_197: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_198: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_199: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_200: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_201: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_202: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_203: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_204: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_205: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_206: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_207: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_208: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_209: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_210: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_211: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_212: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_213: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_214: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_215: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_216: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_217: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_218: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_219: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_220: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_221: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_222: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_223: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_224: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_225: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_226: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_227: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_228: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_229: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_230: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_231: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_232: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_233: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_234: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_235: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_236: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_237: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_238: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_239: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_240: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_241: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_242: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_243: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_244: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_245: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_246: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_247: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_248: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_249: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_250: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_251: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_252: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_253: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RETURN_254: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RIGHT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RIPEMD160: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ROLL: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_ROT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_RSHIFT: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SHA1: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SHA256: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SIZE: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SUB: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SUBSTR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_SWAP: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_TOALTSTACK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_TUCK: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VER: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERIFY: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_VERNOTIF: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_WITHIN: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::opcodes::all::OP_XOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
+pub const bitcoin_primitives::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
+pub const bitcoin_primitives::sequence::Sequence::FINAL: Self
+pub const bitcoin_primitives::sequence::Sequence::MAX: Self
+pub const bitcoin_primitives::sequence::Sequence::SIZE: usize
+pub const bitcoin_primitives::sequence::Sequence::ZERO: Self
+pub const bitcoin_primitives::taproot::TapLeafHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::taproot::TapNodeHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::taproot::TapTweakHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
+pub const bitcoin_primitives::transaction::Txid::COINBASE_PREVOUT: Self
+pub const bitcoin_primitives::transaction::Txid::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::transaction::Version::ONE: Self
+pub const bitcoin_primitives::transaction::Version::THREE: Self
+pub const bitcoin_primitives::transaction::Version::TWO: Self
+pub const bitcoin_primitives::transaction::Wtxid::COINBASE: Self
+pub const bitcoin_primitives::transaction::Wtxid::DISPLAY_BACKWARD: bool
+pub const fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
+pub const fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::opcodes::Opcode::decode_pushnum(self) -> core::option::Option<u8>
+pub const fn bitcoin_primitives::opcodes::Opcode::to_u8(self) -> u8
+pub const fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub enum bitcoin_primitives::opcodes::Class
+pub enum bitcoin_primitives::opcodes::ClassifyContext
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Txid) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Wtxid) -> bitcoin_hashes::sha256d::Hash
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>::from(hashtype: bitcoin_primitives::taproot::TapNodeHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>::from(hashtype: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
+pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>::from(hashtype: bitcoin_primitives::taproot::TapTweakHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
+pub fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::block::BlockHash::clone(&self) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::BlockHash::eq(&self, other: &bitcoin_primitives::block::BlockHash) -> bool
+pub fn bitcoin_primitives::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::BlockHash::from(header: &bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(header: bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::BlockHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::block::BlockHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::block::BlockHash
+pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
+pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
+pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::Version::default() -> bitcoin_primitives::block::Version
+pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
+pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(&self, bit: u8) -> bool
+pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
+pub fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::block::WitnessCommitment::clone(&self) -> bitcoin_primitives::block::WitnessCommitment
+pub fn bitcoin_primitives::block::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::cmp::Ordering
+pub fn bitcoin_primitives::block::WitnessCommitment::eq(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> bool
+pub fn bitcoin_primitives::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::WitnessCommitment
+pub fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::WitnessCommitment, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::block::WitnessCommitment::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::TxMerkleNode
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> bool
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::TxMerkleNode
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::TxMerkleNode, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::cmp::Ordering
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bool
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::WitnessMerkleNode, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::opcodes::Class::clone(&self) -> bitcoin_primitives::opcodes::Class
+pub fn bitcoin_primitives::opcodes::Class::eq(&self, other: &bitcoin_primitives::opcodes::Class) -> bool
+pub fn bitcoin_primitives::opcodes::Class::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::ClassifyContext::clone(&self) -> bitcoin_primitives::opcodes::ClassifyContext
+pub fn bitcoin_primitives::opcodes::ClassifyContext::cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::cmp::Ordering
+pub fn bitcoin_primitives::opcodes::ClassifyContext::eq(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> bool
+pub fn bitcoin_primitives::opcodes::ClassifyContext::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::ClassifyContext::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::opcodes::ClassifyContext::partial_cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::opcodes::Opcode::classify(self, ctx: bitcoin_primitives::opcodes::ClassifyContext) -> bitcoin_primitives::opcodes::Class
+pub fn bitcoin_primitives::opcodes::Opcode::clone(&self) -> bitcoin_primitives::opcodes::Opcode
+pub fn bitcoin_primitives::opcodes::Opcode::eq(&self, other: &bitcoin_primitives::opcodes::Opcode) -> bool
+pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
+pub fn bitcoin_primitives::opcodes::Opcode::from(b: u8) -> bitcoin_primitives::opcodes::Opcode
+pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
+pub fn bitcoin_primitives::pow::CompactTarget::default() -> bitcoin_primitives::pow::CompactTarget
+pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
+pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
+pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
+pub fn bitcoin_primitives::sequence::Sequence::clone(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::sequence::Sequence::cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::cmp::Ordering
+pub fn bitcoin_primitives::sequence::Sequence::default() -> Self
+pub fn bitcoin_primitives::sequence::Sequence::enables_absolute_lock_time(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::eq(&self, other: &bitcoin_primitives::sequence::Sequence) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_consensus(n: u32) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_height(height: u16) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::sequence::Sequence::is_final(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_height_locked(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_rbf(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
+pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
+pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
+pub fn bitcoin_primitives::taproot::TapBranchTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapBranchTag::eq(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> bool
+pub fn bitcoin_primitives::taproot::TapBranchTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapBranchTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapLeafHash::clone(&self) -> bitcoin_primitives::taproot::TapLeafHash
+pub fn bitcoin_primitives::taproot::TapLeafHash::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapLeafHash::eq(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> bool
+pub fn bitcoin_primitives::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>) -> bitcoin_primitives::taproot::TapLeafHash
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapLeafHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapLeafTag::clone(&self) -> bitcoin_primitives::taproot::TapLeafTag
+pub fn bitcoin_primitives::taproot::TapLeafTag::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapLeafTag::default() -> bitcoin_primitives::taproot::TapLeafTag
+pub fn bitcoin_primitives::taproot::TapLeafTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapLeafTag::eq(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> bool
+pub fn bitcoin_primitives::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapNodeHash::clone(&self) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapNodeHash::eq(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> bool
+pub fn bitcoin_primitives::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::from(leaf: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_primitives::taproot::TapNodeHash
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapNodeHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::taproot::TapTweakHash::clone(&self) -> bitcoin_primitives::taproot::TapTweakHash
+pub fn bitcoin_primitives::taproot::TapTweakHash::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapTweakHash::eq(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> bool
+pub fn bitcoin_primitives::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>) -> bitcoin_primitives::taproot::TapTweakHash
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapTweakHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::taproot::TapTweakTag::clone(&self) -> bitcoin_primitives::taproot::TapTweakTag
+pub fn bitcoin_primitives::taproot::TapTweakTag::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::cmp::Ordering
+pub fn bitcoin_primitives::taproot::TapTweakTag::default() -> bitcoin_primitives::taproot::TapTweakTag
+pub fn bitcoin_primitives::taproot::TapTweakTag::engine() -> bitcoin_hashes::sha256::HashEngine
+pub fn bitcoin_primitives::taproot::TapTweakTag::eq(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> bool
+pub fn bitcoin_primitives::taproot::TapTweakTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::taproot::TapTweakTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
+pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
+pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Txid::clone(&self) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Txid::eq(&self, other: &bitcoin_primitives::transaction::Txid) -> bool
+pub fn bitcoin_primitives::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Txid
+pub fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Txid, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::transaction::Txid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Txid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
+pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
+pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::transaction::Wtxid::clone(&self) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::cmp::Ordering
+pub fn bitcoin_primitives::transaction::Wtxid::eq(&self, other: &bitcoin_primitives::transaction::Wtxid) -> bool
+pub fn bitcoin_primitives::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Wtxid
+pub fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Wtxid, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::transaction::Wtxid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::transaction::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> Self::Bytes
+pub fn u32::from(sequence: bitcoin_primitives::sequence::Sequence) -> u32
+pub mod bitcoin_primitives
+pub mod bitcoin_primitives::block
+pub mod bitcoin_primitives::merkle_tree
+pub mod bitcoin_primitives::opcodes
+pub mod bitcoin_primitives::opcodes::all
+pub mod bitcoin_primitives::pow
+pub mod bitcoin_primitives::sequence
+pub mod bitcoin_primitives::taproot
+pub mod bitcoin_primitives::transaction
+pub static bitcoin_primitives::opcodes::OP_0: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_FALSE: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_NOP2: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_NOP3: bitcoin_primitives::opcodes::Opcode
+pub static bitcoin_primitives::opcodes::OP_TRUE: bitcoin_primitives::opcodes::Opcode
+pub struct bitcoin_primitives::BlockHash(_)
+pub struct bitcoin_primitives::BlockHeader
+pub struct bitcoin_primitives::CompactTarget(_)
+pub struct bitcoin_primitives::Sequence(pub u32)
+pub struct bitcoin_primitives::TapBranchTag
+pub struct bitcoin_primitives::TapLeafHash(_)
+pub struct bitcoin_primitives::TapLeafTag
+pub struct bitcoin_primitives::TapNodeHash(_)
+pub struct bitcoin_primitives::TapTweakHash(_)
+pub struct bitcoin_primitives::TapTweakTag
+pub struct bitcoin_primitives::TxMerkleNode(_)
+pub struct bitcoin_primitives::Txid(_)
+pub struct bitcoin_primitives::WitnessCommitment(_)
+pub struct bitcoin_primitives::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::Wtxid(_)
+pub struct bitcoin_primitives::block::BlockHash(_)
+pub struct bitcoin_primitives::block::Header
+pub struct bitcoin_primitives::block::Version(_)
+pub struct bitcoin_primitives::block::WitnessCommitment(_)
+pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
+pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
+pub struct bitcoin_primitives::opcodes::Opcode
+pub struct bitcoin_primitives::pow::CompactTarget(_)
+pub struct bitcoin_primitives::sequence::Sequence(pub u32)
+pub struct bitcoin_primitives::taproot::TapBranchTag
+pub struct bitcoin_primitives::taproot::TapLeafHash(_)
+pub struct bitcoin_primitives::taproot::TapLeafTag
+pub struct bitcoin_primitives::taproot::TapNodeHash(_)
+pub struct bitcoin_primitives::taproot::TapTweakHash(_)
+pub struct bitcoin_primitives::taproot::TapTweakTag
+pub struct bitcoin_primitives::transaction::OutPoint
+pub struct bitcoin_primitives::transaction::Txid(_)
+pub struct bitcoin_primitives::transaction::Version(pub i32)
+pub struct bitcoin_primitives::transaction::Wtxid(_)
+pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::block::BlockHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::block::WitnessCommitment::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::block::WitnessCommitment::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::taproot::TapLeafHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapLeafHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::taproot::TapNodeHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapNodeHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::taproot::TapTweakHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::taproot::TapTweakHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::transaction::Txid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::transaction::Txid::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::transaction::Wtxid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::transaction::Wtxid::Err = hex_conservative::error::HexToArrayError
+pub use bitcoin_primitives::Amount
+pub use bitcoin_primitives::SignedAmount
+pub use bitcoin_primitives::amount
diff --git a/api/units/all-features.txt b/api/units/all-features.txt
new file mode 100644
index 0000000000..60e32f3243
--- /dev/null
+++ b/api/units/all-features.txt
@@ -0,0 +1,1218 @@
+#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
+#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
+impl bitcoin_units::Amount
+impl bitcoin_units::SignedAmount
+impl bitcoin_units::amount::Denomination
+impl bitcoin_units::amount::Display
+impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::amount::serde::SerdeAmount for bitcoin_units::Amount
+impl bitcoin_units::amount::serde::SerdeAmount for bitcoin_units::SignedAmount
+impl bitcoin_units::amount::serde::SerdeAmountForOpt for bitcoin_units::Amount
+impl bitcoin_units::amount::serde::SerdeAmountForOpt for bitcoin_units::SignedAmount
+impl bitcoin_units::block::BlockHeight
+impl bitcoin_units::block::BlockInterval
+impl bitcoin_units::fee_rate::FeeRate
+impl bitcoin_units::locktime::absolute::Height
+impl bitcoin_units::locktime::absolute::Time
+impl bitcoin_units::locktime::relative::Height
+impl bitcoin_units::locktime::relative::Time
+impl bitcoin_units::locktime::relative::TimeOverflowError
+impl bitcoin_units::parse::Integer for i128
+impl bitcoin_units::parse::Integer for i16
+impl bitcoin_units::parse::Integer for i32
+impl bitcoin_units::parse::Integer for i64
+impl bitcoin_units::parse::Integer for i8
+impl bitcoin_units::parse::Integer for u128
+impl bitcoin_units::parse::Integer for u16
+impl bitcoin_units::parse::Integer for u32
+impl bitcoin_units::parse::Integer for u64
+impl bitcoin_units::parse::Integer for u8
+impl bitcoin_units::weight::Weight
+impl core::clone::Clone for bitcoin_units::Amount
+impl core::clone::Clone for bitcoin_units::SignedAmount
+impl core::clone::Clone for bitcoin_units::amount::Denomination
+impl core::clone::Clone for bitcoin_units::amount::Display
+impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseError
+impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::block::BlockHeight
+impl core::clone::Clone for bitcoin_units::block::BlockInterval
+impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::clone::Clone for bitcoin_units::fee_rate::FeeRate
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ConversionError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Time
+impl core::clone::Clone for bitcoin_units::locktime::relative::Height
+impl core::clone::Clone for bitcoin_units::locktime::relative::Time
+impl core::clone::Clone for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::clone::Clone for bitcoin_units::parse::ParseIntError
+impl core::clone::Clone for bitcoin_units::parse::PrefixedHexError
+impl core::clone::Clone for bitcoin_units::parse::UnprefixedHexError
+impl core::clone::Clone for bitcoin_units::weight::Weight
+impl core::cmp::Eq for bitcoin_units::Amount
+impl core::cmp::Eq for bitcoin_units::SignedAmount
+impl core::cmp::Eq for bitcoin_units::amount::Denomination
+impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::block::BlockHeight
+impl core::cmp::Eq for bitcoin_units::block::BlockInterval
+impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::cmp::Eq for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ConversionError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Time
+impl core::cmp::Eq for bitcoin_units::locktime::relative::Height
+impl core::cmp::Eq for bitcoin_units::locktime::relative::Time
+impl core::cmp::Eq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::cmp::Eq for bitcoin_units::parse::ParseIntError
+impl core::cmp::Eq for bitcoin_units::parse::PrefixedHexError
+impl core::cmp::Eq for bitcoin_units::parse::UnprefixedHexError
+impl core::cmp::Eq for bitcoin_units::weight::Weight
+impl core::cmp::Ord for bitcoin_units::Amount
+impl core::cmp::Ord for bitcoin_units::SignedAmount
+impl core::cmp::Ord for bitcoin_units::block::BlockHeight
+impl core::cmp::Ord for bitcoin_units::block::BlockInterval
+impl core::cmp::Ord for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Time
+impl core::cmp::Ord for bitcoin_units::locktime::relative::Height
+impl core::cmp::Ord for bitcoin_units::locktime::relative::Time
+impl core::cmp::Ord for bitcoin_units::weight::Weight
+impl core::cmp::PartialEq for bitcoin_units::Amount
+impl core::cmp::PartialEq for bitcoin_units::SignedAmount
+impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
+impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::cmp::PartialEq for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ConversionError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Time
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Time
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::cmp::PartialEq for bitcoin_units::parse::ParseIntError
+impl core::cmp::PartialEq for bitcoin_units::parse::PrefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::parse::UnprefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::weight::Weight
+impl core::cmp::PartialOrd for bitcoin_units::Amount
+impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockInterval
+impl core::cmp::PartialOrd for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Time
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
+impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
+impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
+impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
+impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
+impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_units::block::BlockInterval
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::PrefixedHexError
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
+impl core::convert::From<bitcoin_units::weight::Weight> for u64
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
+impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
+impl core::convert::From<u32> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::fee_rate::FeeRate
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Time
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Time
+impl core::convert::TryFrom<&str> for bitcoin_units::weight::Weight
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::fee_rate::FeeRate
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Time
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::Height
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::Time
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::weight::Weight
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::fee_rate::FeeRate
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Time
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Height
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Time
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::weight::Weight
+impl core::convert::TryFrom<bitcoin_units::Amount> for bitcoin_units::SignedAmount
+impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
+impl core::default::Default for bitcoin_units::Amount
+impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::locktime::relative::Height
+impl core::default::Default for bitcoin_units::locktime::relative::Time
+impl core::error::Error for bitcoin_units::amount::error::InputTooLargeError
+impl core::error::Error for bitcoin_units::amount::error::InvalidCharacterError
+impl core::error::Error for bitcoin_units::amount::error::MissingDigitsError
+impl core::error::Error for bitcoin_units::amount::error::OutOfRangeError
+impl core::error::Error for bitcoin_units::amount::error::ParseAmountError
+impl core::error::Error for bitcoin_units::amount::error::ParseDenominationError
+impl core::error::Error for bitcoin_units::amount::error::ParseError
+impl core::error::Error for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::error::Error for bitcoin_units::amount::error::TooPreciseError
+impl core::error::Error for bitcoin_units::amount::error::UnknownDenominationError
+impl core::error::Error for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::error::Error for bitcoin_units::locktime::absolute::ConversionError
+impl core::error::Error for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::error::Error for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::error::Error for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::error::Error for bitcoin_units::parse::ParseIntError
+impl core::error::Error for bitcoin_units::parse::PrefixedHexError
+impl core::error::Error for bitcoin_units::parse::UnprefixedHexError
+impl core::fmt::Debug for bitcoin_units::Amount
+impl core::fmt::Debug for bitcoin_units::SignedAmount
+impl core::fmt::Debug for bitcoin_units::amount::Denomination
+impl core::fmt::Debug for bitcoin_units::amount::Display
+impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::block::BlockHeight
+impl core::fmt::Debug for bitcoin_units::block::BlockInterval
+impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::fmt::Debug for bitcoin_units::fee_rate::FeeRate
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ConversionError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Time
+impl core::fmt::Debug for bitcoin_units::locktime::relative::Height
+impl core::fmt::Debug for bitcoin_units::locktime::relative::Time
+impl core::fmt::Debug for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::fmt::Debug for bitcoin_units::parse::ParseIntError
+impl core::fmt::Debug for bitcoin_units::parse::PrefixedHexError
+impl core::fmt::Debug for bitcoin_units::parse::UnprefixedHexError
+impl core::fmt::Debug for bitcoin_units::weight::Weight
+impl core::fmt::Display for bitcoin_units::Amount
+impl core::fmt::Display for bitcoin_units::SignedAmount
+impl core::fmt::Display for bitcoin_units::amount::Denomination
+impl core::fmt::Display for bitcoin_units::amount::Display
+impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseError
+impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::block::BlockHeight
+impl core::fmt::Display for bitcoin_units::block::BlockInterval
+impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::fmt::Display for bitcoin_units::fee_rate::FeeRate
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ConversionError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Time
+impl core::fmt::Display for bitcoin_units::locktime::relative::Height
+impl core::fmt::Display for bitcoin_units::locktime::relative::Time
+impl core::fmt::Display for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::fmt::Display for bitcoin_units::parse::ParseIntError
+impl core::fmt::Display for bitcoin_units::parse::PrefixedHexError
+impl core::fmt::Display for bitcoin_units::parse::UnprefixedHexError
+impl core::fmt::Display for bitcoin_units::weight::Weight
+impl core::hash::Hash for bitcoin_units::Amount
+impl core::hash::Hash for bitcoin_units::SignedAmount
+impl core::hash::Hash for bitcoin_units::amount::Denomination
+impl core::hash::Hash for bitcoin_units::block::BlockHeight
+impl core::hash::Hash for bitcoin_units::block::BlockInterval
+impl core::hash::Hash for bitcoin_units::fee_rate::FeeRate
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Time
+impl core::hash::Hash for bitcoin_units::locktime::relative::Height
+impl core::hash::Hash for bitcoin_units::locktime::relative::Time
+impl core::hash::Hash for bitcoin_units::weight::Weight
+impl core::iter::traits::accum::Sum for bitcoin_units::Amount
+impl core::iter::traits::accum::Sum for bitcoin_units::SignedAmount
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::fee_rate::FeeRate
+impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
+impl core::marker::Copy for bitcoin_units::Amount
+impl core::marker::Copy for bitcoin_units::SignedAmount
+impl core::marker::Copy for bitcoin_units::amount::Denomination
+impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::block::BlockHeight
+impl core::marker::Copy for bitcoin_units::block::BlockInterval
+impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Time
+impl core::marker::Copy for bitcoin_units::locktime::relative::Height
+impl core::marker::Copy for bitcoin_units::locktime::relative::Time
+impl core::marker::Copy for bitcoin_units::weight::Weight
+impl core::marker::Freeze for bitcoin_units::Amount
+impl core::marker::Freeze for bitcoin_units::SignedAmount
+impl core::marker::Freeze for bitcoin_units::amount::Denomination
+impl core::marker::Freeze for bitcoin_units::amount::Display
+impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::block::BlockHeight
+impl core::marker::Freeze for bitcoin_units::block::BlockInterval
+impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Freeze for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Time
+impl core::marker::Freeze for bitcoin_units::locktime::relative::Height
+impl core::marker::Freeze for bitcoin_units::locktime::relative::Time
+impl core::marker::Freeze for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Freeze for bitcoin_units::parse::ParseIntError
+impl core::marker::Freeze for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Freeze for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Freeze for bitcoin_units::weight::Weight
+impl core::marker::Send for bitcoin_units::Amount
+impl core::marker::Send for bitcoin_units::SignedAmount
+impl core::marker::Send for bitcoin_units::amount::Denomination
+impl core::marker::Send for bitcoin_units::amount::Display
+impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::ParseError
+impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::block::BlockHeight
+impl core::marker::Send for bitcoin_units::block::BlockInterval
+impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Send for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Send for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Height
+impl core::marker::Send for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Time
+impl core::marker::Send for bitcoin_units::locktime::relative::Height
+impl core::marker::Send for bitcoin_units::locktime::relative::Time
+impl core::marker::Send for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Send for bitcoin_units::parse::ParseIntError
+impl core::marker::Send for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Send for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Send for bitcoin_units::weight::Weight
+impl core::marker::StructuralPartialEq for bitcoin_units::Amount
+impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::FeeRate
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Time
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Time
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::ParseIntError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::PrefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::weight::Weight
+impl core::marker::Sync for bitcoin_units::Amount
+impl core::marker::Sync for bitcoin_units::SignedAmount
+impl core::marker::Sync for bitcoin_units::amount::Denomination
+impl core::marker::Sync for bitcoin_units::amount::Display
+impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseError
+impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::block::BlockHeight
+impl core::marker::Sync for bitcoin_units::block::BlockInterval
+impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Sync for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Time
+impl core::marker::Sync for bitcoin_units::locktime::relative::Height
+impl core::marker::Sync for bitcoin_units::locktime::relative::Time
+impl core::marker::Sync for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Sync for bitcoin_units::parse::ParseIntError
+impl core::marker::Sync for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Sync for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Sync for bitcoin_units::weight::Weight
+impl core::marker::Unpin for bitcoin_units::Amount
+impl core::marker::Unpin for bitcoin_units::SignedAmount
+impl core::marker::Unpin for bitcoin_units::amount::Denomination
+impl core::marker::Unpin for bitcoin_units::amount::Display
+impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::block::BlockHeight
+impl core::marker::Unpin for bitcoin_units::block::BlockInterval
+impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Unpin for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Time
+impl core::marker::Unpin for bitcoin_units::locktime::relative::Height
+impl core::marker::Unpin for bitcoin_units::locktime::relative::Time
+impl core::marker::Unpin for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Unpin for bitcoin_units::parse::ParseIntError
+impl core::marker::Unpin for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Unpin for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Unpin for bitcoin_units::weight::Weight
+impl core::ops::arith::Add for bitcoin_units::Amount
+impl core::ops::arith::Add for bitcoin_units::SignedAmount
+impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
+impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::Amount
+impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
+impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Div for bitcoin_units::weight::Weight
+impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::DivAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::Mul<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::weight::Weight
+impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for u64
+impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::MulAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::Neg for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
+impl core::ops::arith::RemAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::RemAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
+impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::Amount
+impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
+impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ConversionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Time
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Time
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::ParseIntError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::PrefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::UnprefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::weight::Weight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ConversionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Time
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Time
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::ParseIntError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::PrefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::UnprefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::weight::Weight
+impl core::str::traits::FromStr for bitcoin_units::Amount
+impl core::str::traits::FromStr for bitcoin_units::SignedAmount
+impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
+impl core::str::traits::FromStr for bitcoin_units::block::BlockInterval
+impl core::str::traits::FromStr for bitcoin_units::fee_rate::FeeRate
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Time
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Time
+impl core::str::traits::FromStr for bitcoin_units::weight::Weight
+impl serde::ser::Serialize for bitcoin_units::block::BlockHeight
+impl serde::ser::Serialize for bitcoin_units::block::BlockInterval
+impl serde::ser::Serialize for bitcoin_units::fee_rate::FeeRate
+impl serde::ser::Serialize for bitcoin_units::locktime::absolute::Height
+impl serde::ser::Serialize for bitcoin_units::locktime::absolute::Time
+impl serde::ser::Serialize for bitcoin_units::locktime::relative::Height
+impl serde::ser::Serialize for bitcoin_units::locktime::relative::Time
+impl serde::ser::Serialize for bitcoin_units::weight::Weight
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::Amount
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::SignedAmount
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::fee_rate::FeeRate
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::weight::Weight
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Amount> for bitcoin_units::Amount
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockHeight
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockInterval
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::fee_rate::FeeRate
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::absolute::Height
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::absolute::Time
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::relative::Height
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::relative::Time
+impl<'de> serde::de::Deserialize<'de> for bitcoin_units::weight::Weight
+impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::Amount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::Amount>
+impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::SignedAmount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::SignedAmount>
+pub bitcoin_units::amount::Denomination::Bit
+pub bitcoin_units::amount::Denomination::Bitcoin
+pub bitcoin_units::amount::Denomination::CentiBitcoin
+pub bitcoin_units::amount::Denomination::MicroBitcoin
+pub bitcoin_units::amount::Denomination::MilliBitcoin
+pub bitcoin_units::amount::Denomination::Satoshi
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub const bitcoin_units::Amount::MAX: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MAX_MONEY: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MIN: bitcoin_units::Amount
+pub const bitcoin_units::Amount::ONE_BTC: bitcoin_units::Amount
+pub const bitcoin_units::Amount::ONE_SAT: bitcoin_units::Amount
+pub const bitcoin_units::Amount::SIZE: usize
+pub const bitcoin_units::Amount::ZERO: bitcoin_units::Amount
+pub const bitcoin_units::SignedAmount::MAX: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::MAX_MONEY: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::MIN: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ONE_BTC: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ONE_SAT: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ZERO: bitcoin_units::SignedAmount
+pub const bitcoin_units::amount::Denomination::BTC: Self
+pub const bitcoin_units::amount::Denomination::SAT: Self
+pub const bitcoin_units::block::BlockHeight::MAX: Self
+pub const bitcoin_units::block::BlockHeight::MIN: Self
+pub const bitcoin_units::block::BlockHeight::ZERO: Self
+pub const bitcoin_units::block::BlockInterval::MAX: Self
+pub const bitcoin_units::block::BlockInterval::MIN: Self
+pub const bitcoin_units::block::BlockInterval::ZERO: Self
+pub const bitcoin_units::fee_rate::FeeRate::BROADCAST_MIN: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::DUST: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::MAX: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::MIN: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::ZERO: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::locktime::absolute::Height::MAX: Self
+pub const bitcoin_units::locktime::absolute::Height::MIN: Self
+pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
+pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::locktime::absolute::Time::MAX: Self
+pub const bitcoin_units::locktime::absolute::Time::MIN: Self
+pub const bitcoin_units::locktime::relative::Height::MAX: Self
+pub const bitcoin_units::locktime::relative::Height::MIN: Self
+pub const bitcoin_units::locktime::relative::Height::ZERO: Self
+pub const bitcoin_units::locktime::relative::Time::MAX: Self
+pub const bitcoin_units::locktime::relative::Time::MIN: Self
+pub const bitcoin_units::locktime::relative::Time::ZERO: Self
+pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
+pub const bitcoin_units::weight::Weight::MAX: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MAX_BLOCK: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MIN: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MIN_TRANSACTION: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
+pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
+pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
+pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
+pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::from_int_btc_const(btc: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::to_sat(self) -> u64
+pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
+pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb_unchecked(sat_vb: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_kwu(self) -> u64
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_ceil(self) -> u64
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_floor(self) -> u64
+pub const fn bitcoin_units::locktime::absolute::Height::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Height, bitcoin_units::locktime::absolute::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Height::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::Time::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Time, bitcoin_units::locktime::absolute::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
+pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
+pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
+pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_wu_usize(wu: usize) -> Self
+pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
+pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
+pub fn bitcoin_units::Amount::default() -> Self
+pub fn bitcoin_units::Amount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::Amount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
+pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_int_btc(btc: u64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
+pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
+pub fn bitcoin_units::Amount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
+pub fn bitcoin_units::Amount::to_btc(self) -> f64
+pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
+pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::Amount::type_prefix(_: private::Token) -> &'static str
+pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
+pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
+pub fn bitcoin_units::SignedAmount::default() -> Self
+pub fn bitcoin_units::SignedAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::SignedAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
+pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_int_btc(btc: i64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
+pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::mul_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
+pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
+pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
+pub fn bitcoin_units::SignedAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
+pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
+pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
+pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::SignedAmount::type_prefix(_: private::Token) -> &'static str
+pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
+pub fn bitcoin_units::amount::CheckedSum::checked_sum(self) -> core::option::Option<R>
+pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
+pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
+pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
+pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
+pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
+pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
+pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
+pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
+pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(&self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(&self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(&self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
+pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
+pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
+pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
+pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
+pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
+pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::UnknownDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::serde::SerdeAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::type_prefix(_: private::Token) -> &'static str
+pub fn bitcoin_units::amount::serde::as_btc::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::as_btc::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::as_btc::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::as_btc::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::as_sat::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::as_sat::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::as_sat::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::as_sat::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
+pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeight::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
+pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeight::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
+pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
+pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockInterval::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
+pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockInterval::from(h: bitcoin_units::locktime::relative::Height) -> Self
+pub fn bitcoin_units::block::BlockInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockInterval::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_units::block::BlockInterval::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
+pub fn bitcoin_units::block::BlockInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::block::BlockInterval>
+pub fn bitcoin_units::block::BlockInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
+pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
+pub fn bitcoin_units::fee_rate::FeeRate::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
+pub fn bitcoin_units::fee_rate::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::fee_rate::FeeRate::fee_wu(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::fee_rate::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb(sat_vb: u64) -> core::option::Option<Self>
+pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::fee_rate::FeeRate::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
+pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::ConversionError
+pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
+pub fn bitcoin_units::locktime::absolute::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::ConversionError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Height::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseHeightError>
+pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Height::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::ParseHeightError
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::ParseTimeError
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::absolute::Time::clone(&self) -> bitcoin_units::locktime::absolute::Time
+pub fn bitcoin_units::locktime::absolute::Time::cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Time::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::locktime::absolute::Time::eq(&self, other: &bitcoin_units::locktime::absolute::Time) -> bool
+pub fn bitcoin_units::locktime::absolute::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Time::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseTimeError>
+pub fn bitcoin_units::locktime::absolute::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Time::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Time::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
+pub fn bitcoin_units::locktime::absolute::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::clone(&self) -> bitcoin_units::locktime::relative::Height
+pub fn bitcoin_units::locktime::relative::Height::cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::Height::default() -> bitcoin_units::locktime::relative::Height
+pub fn bitcoin_units::locktime::relative::Height::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::locktime::relative::Height::eq(&self, other: &bitcoin_units::locktime::relative::Height) -> bool
+pub fn bitcoin_units::locktime::relative::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::Height::from(value: u16) -> Self
+pub fn bitcoin_units::locktime::relative::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::Height::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::Height::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_units::locktime::relative::Height::try_from(h: bitcoin_units::block::BlockInterval) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Time::clone(&self) -> bitcoin_units::locktime::relative::Time
+pub fn bitcoin_units::locktime::relative::Time::cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::Time::default() -> bitcoin_units::locktime::relative::Time
+pub fn bitcoin_units::locktime::relative::Time::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::locktime::relative::Time::eq(&self, other: &bitcoin_units::locktime::relative::Time) -> bool
+pub fn bitcoin_units::locktime::relative::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::Time::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::Time::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_units::locktime::relative::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::TimeOverflowError
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::TimeOverflowError) -> bool
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::new(seconds: u32) -> Self
+pub fn bitcoin_units::parse::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
+pub fn bitcoin_units::parse::ParseIntError::clone(&self) -> bitcoin_units::parse::ParseIntError
+pub fn bitcoin_units::parse::ParseIntError::eq(&self, other: &bitcoin_units::parse::ParseIntError) -> bool
+pub fn bitcoin_units::parse::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::ParseIntError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::parse::PrefixedHexError::clone(&self) -> bitcoin_units::parse::PrefixedHexError
+pub fn bitcoin_units::parse::PrefixedHexError::eq(&self, other: &bitcoin_units::parse::PrefixedHexError) -> bool
+pub fn bitcoin_units::parse::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::PrefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
+pub fn bitcoin_units::parse::PrefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse::PrefixedHexError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::parse::UnprefixedHexError::clone(&self) -> bitcoin_units::parse::UnprefixedHexError
+pub fn bitcoin_units::parse::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse::UnprefixedHexError) -> bool
+pub fn bitcoin_units::parse::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::UnprefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
+pub fn bitcoin_units::parse::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse::UnprefixedHexError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::parse::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
+pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
+pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
+pub fn bitcoin_units::weight::Weight::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
+pub fn bitcoin_units::weight::Weight::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::weight::Weight::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::weight::Weight::eq(&self, other: &bitcoin_units::weight::Weight) -> bool
+pub fn bitcoin_units::weight::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::weight::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
+pub fn bitcoin_units::weight::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::weight::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::weight::Weight::mul(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::weight::Weight::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
+pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::weight::Weight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::weight::Weight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse::ParseIntError) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
+pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
+pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
+pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub macro bitcoin_units::impl_parse_str!
+pub macro bitcoin_units::impl_parse_str_from_int_infallible!
+pub macro bitcoin_units::impl_tryfrom_str!
+pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
+pub mod bitcoin_units
+pub mod bitcoin_units::amount
+pub mod bitcoin_units::amount::error
+pub mod bitcoin_units::amount::serde
+pub mod bitcoin_units::amount::serde::as_btc
+pub mod bitcoin_units::amount::serde::as_btc::opt
+pub mod bitcoin_units::amount::serde::as_sat
+pub mod bitcoin_units::amount::serde::as_sat::opt
+pub mod bitcoin_units::block
+pub mod bitcoin_units::fee_rate
+pub mod bitcoin_units::locktime
+pub mod bitcoin_units::locktime::absolute
+pub mod bitcoin_units::locktime::relative
+pub mod bitcoin_units::parse
+pub mod bitcoin_units::weight
+pub struct bitcoin_units::Amount(_)
+pub struct bitcoin_units::BlockHeight(pub u32)
+pub struct bitcoin_units::BlockInterval(pub u32)
+pub struct bitcoin_units::FeeRate(_)
+pub struct bitcoin_units::SignedAmount(_)
+pub struct bitcoin_units::Weight(_)
+pub struct bitcoin_units::amount::Amount(_)
+pub struct bitcoin_units::amount::Display
+pub struct bitcoin_units::amount::InputTooLargeError
+pub struct bitcoin_units::amount::InvalidCharacterError
+pub struct bitcoin_units::amount::MissingDigitsError
+pub struct bitcoin_units::amount::OutOfRangeError
+pub struct bitcoin_units::amount::ParseAmountError(_)
+pub struct bitcoin_units::amount::ParseError(_)
+pub struct bitcoin_units::amount::SignedAmount(_)
+pub struct bitcoin_units::amount::TooPreciseError
+pub struct bitcoin_units::amount::error::InputTooLargeError
+pub struct bitcoin_units::amount::error::InvalidCharacterError
+pub struct bitcoin_units::amount::error::MissingDigitsError
+pub struct bitcoin_units::amount::error::OutOfRangeError
+pub struct bitcoin_units::amount::error::ParseAmountError(_)
+pub struct bitcoin_units::amount::error::ParseError(_)
+pub struct bitcoin_units::amount::error::TooPreciseError
+pub struct bitcoin_units::block::BlockHeight(pub u32)
+pub struct bitcoin_units::block::BlockInterval(pub u32)
+pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
+pub struct bitcoin_units::fee_rate::FeeRate(_)
+pub struct bitcoin_units::locktime::absolute::Height(_)
+pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
+pub struct bitcoin_units::locktime::absolute::Time(_)
+pub struct bitcoin_units::locktime::relative::Height(_)
+pub struct bitcoin_units::locktime::relative::Time(_)
+pub struct bitcoin_units::locktime::relative::TimeOverflowError
+pub struct bitcoin_units::parse::PrefixedHexError(_)
+pub struct bitcoin_units::parse::UnprefixedHexError(_)
+pub struct bitcoin_units::weight::Weight(_)
+pub trait bitcoin_units::amount::CheckedSum<R>: private::SumSeal<R>
+pub trait bitcoin_units::amount::serde::SerdeAmount: core::marker::Copy + core::marker::Sized
+pub trait bitcoin_units::amount::serde::SerdeAmountForOpt: core::marker::Copy + core::marker::Sized + bitcoin_units::amount::serde::SerdeAmount
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized
+pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockInterval
+pub type bitcoin_units::block::BlockInterval::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockInterval::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockInterval::Output = bitcoin_units::block::BlockInterval
+pub type bitcoin_units::fee_rate::FeeRate::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::fee_rate::FeeRate::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::Amount
+pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ConversionError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Time::Err = bitcoin_units::locktime::absolute::ParseTimeError
+pub type bitcoin_units::locktime::absolute::Time::Error = bitcoin_units::locktime::absolute::ParseTimeError
+pub type bitcoin_units::locktime::relative::Height::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::block::TooBigForRelativeBlockHeightError
+pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Time::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Time::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Output = bitcoin_units::Amount
+pub type bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
+pub type bitcoin_units::weight::Weight::Output = u64
+pub type u64::Output = bitcoin_units::weight::Weight
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
new file mode 100644
index 0000000000..0555c7d432
--- /dev/null
+++ b/api/units/alloc-only.txt
@@ -0,0 +1,1109 @@
+#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
+#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
+impl bitcoin_units::Amount
+impl bitcoin_units::SignedAmount
+impl bitcoin_units::amount::Denomination
+impl bitcoin_units::amount::Display
+impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::block::BlockHeight
+impl bitcoin_units::block::BlockInterval
+impl bitcoin_units::fee_rate::FeeRate
+impl bitcoin_units::locktime::absolute::Height
+impl bitcoin_units::locktime::absolute::Time
+impl bitcoin_units::locktime::relative::Height
+impl bitcoin_units::locktime::relative::Time
+impl bitcoin_units::locktime::relative::TimeOverflowError
+impl bitcoin_units::parse::Integer for i128
+impl bitcoin_units::parse::Integer for i16
+impl bitcoin_units::parse::Integer for i32
+impl bitcoin_units::parse::Integer for i64
+impl bitcoin_units::parse::Integer for i8
+impl bitcoin_units::parse::Integer for u128
+impl bitcoin_units::parse::Integer for u16
+impl bitcoin_units::parse::Integer for u32
+impl bitcoin_units::parse::Integer for u64
+impl bitcoin_units::parse::Integer for u8
+impl bitcoin_units::weight::Weight
+impl core::clone::Clone for bitcoin_units::Amount
+impl core::clone::Clone for bitcoin_units::SignedAmount
+impl core::clone::Clone for bitcoin_units::amount::Denomination
+impl core::clone::Clone for bitcoin_units::amount::Display
+impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseError
+impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::block::BlockHeight
+impl core::clone::Clone for bitcoin_units::block::BlockInterval
+impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::clone::Clone for bitcoin_units::fee_rate::FeeRate
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ConversionError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Time
+impl core::clone::Clone for bitcoin_units::locktime::relative::Height
+impl core::clone::Clone for bitcoin_units::locktime::relative::Time
+impl core::clone::Clone for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::clone::Clone for bitcoin_units::parse::ParseIntError
+impl core::clone::Clone for bitcoin_units::parse::PrefixedHexError
+impl core::clone::Clone for bitcoin_units::parse::UnprefixedHexError
+impl core::clone::Clone for bitcoin_units::weight::Weight
+impl core::cmp::Eq for bitcoin_units::Amount
+impl core::cmp::Eq for bitcoin_units::SignedAmount
+impl core::cmp::Eq for bitcoin_units::amount::Denomination
+impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::block::BlockHeight
+impl core::cmp::Eq for bitcoin_units::block::BlockInterval
+impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::cmp::Eq for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ConversionError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Time
+impl core::cmp::Eq for bitcoin_units::locktime::relative::Height
+impl core::cmp::Eq for bitcoin_units::locktime::relative::Time
+impl core::cmp::Eq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::cmp::Eq for bitcoin_units::parse::ParseIntError
+impl core::cmp::Eq for bitcoin_units::parse::PrefixedHexError
+impl core::cmp::Eq for bitcoin_units::parse::UnprefixedHexError
+impl core::cmp::Eq for bitcoin_units::weight::Weight
+impl core::cmp::Ord for bitcoin_units::Amount
+impl core::cmp::Ord for bitcoin_units::SignedAmount
+impl core::cmp::Ord for bitcoin_units::block::BlockHeight
+impl core::cmp::Ord for bitcoin_units::block::BlockInterval
+impl core::cmp::Ord for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Time
+impl core::cmp::Ord for bitcoin_units::locktime::relative::Height
+impl core::cmp::Ord for bitcoin_units::locktime::relative::Time
+impl core::cmp::Ord for bitcoin_units::weight::Weight
+impl core::cmp::PartialEq for bitcoin_units::Amount
+impl core::cmp::PartialEq for bitcoin_units::SignedAmount
+impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
+impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::cmp::PartialEq for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ConversionError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Time
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Time
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::cmp::PartialEq for bitcoin_units::parse::ParseIntError
+impl core::cmp::PartialEq for bitcoin_units::parse::PrefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::parse::UnprefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::weight::Weight
+impl core::cmp::PartialOrd for bitcoin_units::Amount
+impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockInterval
+impl core::cmp::PartialOrd for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Time
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
+impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
+impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
+impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
+impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
+impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_units::block::BlockInterval
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::PrefixedHexError
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
+impl core::convert::From<bitcoin_units::weight::Weight> for u64
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
+impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
+impl core::convert::From<u32> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::fee_rate::FeeRate
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Time
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Time
+impl core::convert::TryFrom<&str> for bitcoin_units::weight::Weight
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::fee_rate::FeeRate
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Time
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::Height
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::Time
+impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::weight::Weight
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::fee_rate::FeeRate
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Time
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Height
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Time
+impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::weight::Weight
+impl core::convert::TryFrom<bitcoin_units::Amount> for bitcoin_units::SignedAmount
+impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
+impl core::default::Default for bitcoin_units::Amount
+impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::locktime::relative::Height
+impl core::default::Default for bitcoin_units::locktime::relative::Time
+impl core::fmt::Debug for bitcoin_units::Amount
+impl core::fmt::Debug for bitcoin_units::SignedAmount
+impl core::fmt::Debug for bitcoin_units::amount::Denomination
+impl core::fmt::Debug for bitcoin_units::amount::Display
+impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::block::BlockHeight
+impl core::fmt::Debug for bitcoin_units::block::BlockInterval
+impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::fmt::Debug for bitcoin_units::fee_rate::FeeRate
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ConversionError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Time
+impl core::fmt::Debug for bitcoin_units::locktime::relative::Height
+impl core::fmt::Debug for bitcoin_units::locktime::relative::Time
+impl core::fmt::Debug for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::fmt::Debug for bitcoin_units::parse::ParseIntError
+impl core::fmt::Debug for bitcoin_units::parse::PrefixedHexError
+impl core::fmt::Debug for bitcoin_units::parse::UnprefixedHexError
+impl core::fmt::Debug for bitcoin_units::weight::Weight
+impl core::fmt::Display for bitcoin_units::Amount
+impl core::fmt::Display for bitcoin_units::SignedAmount
+impl core::fmt::Display for bitcoin_units::amount::Denomination
+impl core::fmt::Display for bitcoin_units::amount::Display
+impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseError
+impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::block::BlockHeight
+impl core::fmt::Display for bitcoin_units::block::BlockInterval
+impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::fmt::Display for bitcoin_units::fee_rate::FeeRate
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ConversionError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Time
+impl core::fmt::Display for bitcoin_units::locktime::relative::Height
+impl core::fmt::Display for bitcoin_units::locktime::relative::Time
+impl core::fmt::Display for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::fmt::Display for bitcoin_units::parse::ParseIntError
+impl core::fmt::Display for bitcoin_units::parse::PrefixedHexError
+impl core::fmt::Display for bitcoin_units::parse::UnprefixedHexError
+impl core::fmt::Display for bitcoin_units::weight::Weight
+impl core::hash::Hash for bitcoin_units::Amount
+impl core::hash::Hash for bitcoin_units::SignedAmount
+impl core::hash::Hash for bitcoin_units::amount::Denomination
+impl core::hash::Hash for bitcoin_units::block::BlockHeight
+impl core::hash::Hash for bitcoin_units::block::BlockInterval
+impl core::hash::Hash for bitcoin_units::fee_rate::FeeRate
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Time
+impl core::hash::Hash for bitcoin_units::locktime::relative::Height
+impl core::hash::Hash for bitcoin_units::locktime::relative::Time
+impl core::hash::Hash for bitcoin_units::weight::Weight
+impl core::iter::traits::accum::Sum for bitcoin_units::Amount
+impl core::iter::traits::accum::Sum for bitcoin_units::SignedAmount
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::fee_rate::FeeRate
+impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
+impl core::marker::Copy for bitcoin_units::Amount
+impl core::marker::Copy for bitcoin_units::SignedAmount
+impl core::marker::Copy for bitcoin_units::amount::Denomination
+impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::block::BlockHeight
+impl core::marker::Copy for bitcoin_units::block::BlockInterval
+impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Time
+impl core::marker::Copy for bitcoin_units::locktime::relative::Height
+impl core::marker::Copy for bitcoin_units::locktime::relative::Time
+impl core::marker::Copy for bitcoin_units::weight::Weight
+impl core::marker::Freeze for bitcoin_units::Amount
+impl core::marker::Freeze for bitcoin_units::SignedAmount
+impl core::marker::Freeze for bitcoin_units::amount::Denomination
+impl core::marker::Freeze for bitcoin_units::amount::Display
+impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::block::BlockHeight
+impl core::marker::Freeze for bitcoin_units::block::BlockInterval
+impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Freeze for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Time
+impl core::marker::Freeze for bitcoin_units::locktime::relative::Height
+impl core::marker::Freeze for bitcoin_units::locktime::relative::Time
+impl core::marker::Freeze for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Freeze for bitcoin_units::parse::ParseIntError
+impl core::marker::Freeze for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Freeze for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Freeze for bitcoin_units::weight::Weight
+impl core::marker::Send for bitcoin_units::Amount
+impl core::marker::Send for bitcoin_units::SignedAmount
+impl core::marker::Send for bitcoin_units::amount::Denomination
+impl core::marker::Send for bitcoin_units::amount::Display
+impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::ParseError
+impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::block::BlockHeight
+impl core::marker::Send for bitcoin_units::block::BlockInterval
+impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Send for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Send for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Height
+impl core::marker::Send for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Time
+impl core::marker::Send for bitcoin_units::locktime::relative::Height
+impl core::marker::Send for bitcoin_units::locktime::relative::Time
+impl core::marker::Send for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Send for bitcoin_units::parse::ParseIntError
+impl core::marker::Send for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Send for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Send for bitcoin_units::weight::Weight
+impl core::marker::StructuralPartialEq for bitcoin_units::Amount
+impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::FeeRate
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Time
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Time
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::ParseIntError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::PrefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::weight::Weight
+impl core::marker::Sync for bitcoin_units::Amount
+impl core::marker::Sync for bitcoin_units::SignedAmount
+impl core::marker::Sync for bitcoin_units::amount::Denomination
+impl core::marker::Sync for bitcoin_units::amount::Display
+impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseError
+impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::block::BlockHeight
+impl core::marker::Sync for bitcoin_units::block::BlockInterval
+impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Sync for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Time
+impl core::marker::Sync for bitcoin_units::locktime::relative::Height
+impl core::marker::Sync for bitcoin_units::locktime::relative::Time
+impl core::marker::Sync for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Sync for bitcoin_units::parse::ParseIntError
+impl core::marker::Sync for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Sync for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Sync for bitcoin_units::weight::Weight
+impl core::marker::Unpin for bitcoin_units::Amount
+impl core::marker::Unpin for bitcoin_units::SignedAmount
+impl core::marker::Unpin for bitcoin_units::amount::Denomination
+impl core::marker::Unpin for bitcoin_units::amount::Display
+impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::block::BlockHeight
+impl core::marker::Unpin for bitcoin_units::block::BlockInterval
+impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Unpin for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Time
+impl core::marker::Unpin for bitcoin_units::locktime::relative::Height
+impl core::marker::Unpin for bitcoin_units::locktime::relative::Time
+impl core::marker::Unpin for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Unpin for bitcoin_units::parse::ParseIntError
+impl core::marker::Unpin for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Unpin for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Unpin for bitcoin_units::weight::Weight
+impl core::ops::arith::Add for bitcoin_units::Amount
+impl core::ops::arith::Add for bitcoin_units::SignedAmount
+impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
+impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::Amount
+impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
+impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Div for bitcoin_units::weight::Weight
+impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::DivAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::Mul<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::weight::Weight
+impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for u64
+impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::MulAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::Neg for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
+impl core::ops::arith::RemAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::RemAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
+impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::Amount
+impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
+impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ConversionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Time
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Time
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::ParseIntError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::PrefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::UnprefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::weight::Weight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ConversionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Time
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Time
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::ParseIntError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::PrefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::UnprefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::weight::Weight
+impl core::str::traits::FromStr for bitcoin_units::Amount
+impl core::str::traits::FromStr for bitcoin_units::SignedAmount
+impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
+impl core::str::traits::FromStr for bitcoin_units::block::BlockInterval
+impl core::str::traits::FromStr for bitcoin_units::fee_rate::FeeRate
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Time
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Time
+impl core::str::traits::FromStr for bitcoin_units::weight::Weight
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Amount> for bitcoin_units::Amount
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::Amount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::Amount>
+impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::SignedAmount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::SignedAmount>
+pub bitcoin_units::amount::Denomination::Bit
+pub bitcoin_units::amount::Denomination::Bitcoin
+pub bitcoin_units::amount::Denomination::CentiBitcoin
+pub bitcoin_units::amount::Denomination::MicroBitcoin
+pub bitcoin_units::amount::Denomination::MilliBitcoin
+pub bitcoin_units::amount::Denomination::Satoshi
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub const bitcoin_units::Amount::MAX: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MAX_MONEY: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MIN: bitcoin_units::Amount
+pub const bitcoin_units::Amount::ONE_BTC: bitcoin_units::Amount
+pub const bitcoin_units::Amount::ONE_SAT: bitcoin_units::Amount
+pub const bitcoin_units::Amount::SIZE: usize
+pub const bitcoin_units::Amount::ZERO: bitcoin_units::Amount
+pub const bitcoin_units::SignedAmount::MAX: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::MAX_MONEY: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::MIN: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ONE_BTC: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ONE_SAT: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ZERO: bitcoin_units::SignedAmount
+pub const bitcoin_units::amount::Denomination::BTC: Self
+pub const bitcoin_units::amount::Denomination::SAT: Self
+pub const bitcoin_units::block::BlockHeight::MAX: Self
+pub const bitcoin_units::block::BlockHeight::MIN: Self
+pub const bitcoin_units::block::BlockHeight::ZERO: Self
+pub const bitcoin_units::block::BlockInterval::MAX: Self
+pub const bitcoin_units::block::BlockInterval::MIN: Self
+pub const bitcoin_units::block::BlockInterval::ZERO: Self
+pub const bitcoin_units::fee_rate::FeeRate::BROADCAST_MIN: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::DUST: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::MAX: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::MIN: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::ZERO: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::locktime::absolute::Height::MAX: Self
+pub const bitcoin_units::locktime::absolute::Height::MIN: Self
+pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
+pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::locktime::absolute::Time::MAX: Self
+pub const bitcoin_units::locktime::absolute::Time::MIN: Self
+pub const bitcoin_units::locktime::relative::Height::MAX: Self
+pub const bitcoin_units::locktime::relative::Height::MIN: Self
+pub const bitcoin_units::locktime::relative::Height::ZERO: Self
+pub const bitcoin_units::locktime::relative::Time::MAX: Self
+pub const bitcoin_units::locktime::relative::Time::MIN: Self
+pub const bitcoin_units::locktime::relative::Time::ZERO: Self
+pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
+pub const bitcoin_units::weight::Weight::MAX: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MAX_BLOCK: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MIN: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MIN_TRANSACTION: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
+pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
+pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
+pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
+pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::from_int_btc_const(btc: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::to_sat(self) -> u64
+pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
+pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb_unchecked(sat_vb: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_kwu(self) -> u64
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_ceil(self) -> u64
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_floor(self) -> u64
+pub const fn bitcoin_units::locktime::absolute::Height::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Height, bitcoin_units::locktime::absolute::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Height::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::Time::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Time, bitcoin_units::locktime::absolute::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
+pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
+pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
+pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_wu_usize(wu: usize) -> Self
+pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
+pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
+pub fn bitcoin_units::Amount::default() -> Self
+pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
+pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_int_btc(btc: u64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
+pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
+pub fn bitcoin_units::Amount::to_btc(self) -> f64
+pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
+pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
+pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
+pub fn bitcoin_units::SignedAmount::default() -> Self
+pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
+pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_int_btc(btc: i64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
+pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::mul_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
+pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
+pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
+pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
+pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
+pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
+pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
+pub fn bitcoin_units::amount::CheckedSum::checked_sum(self) -> core::option::Option<R>
+pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
+pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
+pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
+pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
+pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
+pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
+pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
+pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
+pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(&self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(&self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(&self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
+pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
+pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
+pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
+pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
+pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
+pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
+pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
+pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
+pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
+pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
+pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockInterval::from(h: bitcoin_units::locktime::relative::Height) -> Self
+pub fn bitcoin_units::block::BlockInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockInterval::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
+pub fn bitcoin_units::block::BlockInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::block::BlockInterval>
+pub fn bitcoin_units::block::BlockInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
+pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
+pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
+pub fn bitcoin_units::fee_rate::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::fee_rate::FeeRate::fee_wu(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::fee_rate::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb(sat_vb: u64) -> core::option::Option<Self>
+pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
+pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::ConversionError
+pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
+pub fn bitcoin_units::locktime::absolute::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseHeightError>
+pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::ParseHeightError
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::ParseTimeError
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Time::clone(&self) -> bitcoin_units::locktime::absolute::Time
+pub fn bitcoin_units::locktime::absolute::Time::cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Time::eq(&self, other: &bitcoin_units::locktime::absolute::Time) -> bool
+pub fn bitcoin_units::locktime::absolute::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Time::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseTimeError>
+pub fn bitcoin_units::locktime::absolute::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Time::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::clone(&self) -> bitcoin_units::locktime::relative::Height
+pub fn bitcoin_units::locktime::relative::Height::cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::Height::default() -> bitcoin_units::locktime::relative::Height
+pub fn bitcoin_units::locktime::relative::Height::eq(&self, other: &bitcoin_units::locktime::relative::Height) -> bool
+pub fn bitcoin_units::locktime::relative::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::Height::from(value: u16) -> Self
+pub fn bitcoin_units::locktime::relative::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::Height::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::Height::try_from(h: bitcoin_units::block::BlockInterval) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Time::clone(&self) -> bitcoin_units::locktime::relative::Time
+pub fn bitcoin_units::locktime::relative::Time::cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::Time::default() -> bitcoin_units::locktime::relative::Time
+pub fn bitcoin_units::locktime::relative::Time::eq(&self, other: &bitcoin_units::locktime::relative::Time) -> bool
+pub fn bitcoin_units::locktime::relative::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::Time::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::TimeOverflowError
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::TimeOverflowError) -> bool
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::new(seconds: u32) -> Self
+pub fn bitcoin_units::parse::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
+pub fn bitcoin_units::parse::ParseIntError::clone(&self) -> bitcoin_units::parse::ParseIntError
+pub fn bitcoin_units::parse::ParseIntError::eq(&self, other: &bitcoin_units::parse::ParseIntError) -> bool
+pub fn bitcoin_units::parse::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::PrefixedHexError::clone(&self) -> bitcoin_units::parse::PrefixedHexError
+pub fn bitcoin_units::parse::PrefixedHexError::eq(&self, other: &bitcoin_units::parse::PrefixedHexError) -> bool
+pub fn bitcoin_units::parse::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::PrefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
+pub fn bitcoin_units::parse::PrefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse::UnprefixedHexError::clone(&self) -> bitcoin_units::parse::UnprefixedHexError
+pub fn bitcoin_units::parse::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse::UnprefixedHexError) -> bool
+pub fn bitcoin_units::parse::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::UnprefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
+pub fn bitcoin_units::parse::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
+pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
+pub fn bitcoin_units::weight::Weight::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::weight::Weight::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::weight::Weight::eq(&self, other: &bitcoin_units::weight::Weight) -> bool
+pub fn bitcoin_units::weight::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::weight::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
+pub fn bitcoin_units::weight::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::weight::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::weight::Weight::mul(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
+pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::weight::Weight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::weight::Weight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse::ParseIntError) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
+pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
+pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
+pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub macro bitcoin_units::impl_parse_str!
+pub macro bitcoin_units::impl_parse_str_from_int_infallible!
+pub macro bitcoin_units::impl_tryfrom_str!
+pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
+pub mod bitcoin_units
+pub mod bitcoin_units::amount
+pub mod bitcoin_units::amount::error
+pub mod bitcoin_units::block
+pub mod bitcoin_units::fee_rate
+pub mod bitcoin_units::locktime
+pub mod bitcoin_units::locktime::absolute
+pub mod bitcoin_units::locktime::relative
+pub mod bitcoin_units::parse
+pub mod bitcoin_units::weight
+pub struct bitcoin_units::Amount(_)
+pub struct bitcoin_units::BlockHeight(pub u32)
+pub struct bitcoin_units::BlockInterval(pub u32)
+pub struct bitcoin_units::FeeRate(_)
+pub struct bitcoin_units::SignedAmount(_)
+pub struct bitcoin_units::Weight(_)
+pub struct bitcoin_units::amount::Amount(_)
+pub struct bitcoin_units::amount::Display
+pub struct bitcoin_units::amount::InputTooLargeError
+pub struct bitcoin_units::amount::InvalidCharacterError
+pub struct bitcoin_units::amount::MissingDigitsError
+pub struct bitcoin_units::amount::OutOfRangeError
+pub struct bitcoin_units::amount::ParseAmountError(_)
+pub struct bitcoin_units::amount::ParseError(_)
+pub struct bitcoin_units::amount::SignedAmount(_)
+pub struct bitcoin_units::amount::TooPreciseError
+pub struct bitcoin_units::amount::error::InputTooLargeError
+pub struct bitcoin_units::amount::error::InvalidCharacterError
+pub struct bitcoin_units::amount::error::MissingDigitsError
+pub struct bitcoin_units::amount::error::OutOfRangeError
+pub struct bitcoin_units::amount::error::ParseAmountError(_)
+pub struct bitcoin_units::amount::error::ParseError(_)
+pub struct bitcoin_units::amount::error::TooPreciseError
+pub struct bitcoin_units::block::BlockHeight(pub u32)
+pub struct bitcoin_units::block::BlockInterval(pub u32)
+pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
+pub struct bitcoin_units::fee_rate::FeeRate(_)
+pub struct bitcoin_units::locktime::absolute::Height(_)
+pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
+pub struct bitcoin_units::locktime::absolute::Time(_)
+pub struct bitcoin_units::locktime::relative::Height(_)
+pub struct bitcoin_units::locktime::relative::Time(_)
+pub struct bitcoin_units::locktime::relative::TimeOverflowError
+pub struct bitcoin_units::parse::PrefixedHexError(_)
+pub struct bitcoin_units::parse::UnprefixedHexError(_)
+pub struct bitcoin_units::weight::Weight(_)
+pub trait bitcoin_units::amount::CheckedSum<R>: private::SumSeal<R>
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized
+pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockInterval
+pub type bitcoin_units::block::BlockInterval::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockInterval::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockInterval::Output = bitcoin_units::block::BlockInterval
+pub type bitcoin_units::fee_rate::FeeRate::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::fee_rate::FeeRate::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::Amount
+pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ConversionError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Time::Err = bitcoin_units::locktime::absolute::ParseTimeError
+pub type bitcoin_units::locktime::absolute::Time::Error = bitcoin_units::locktime::absolute::ParseTimeError
+pub type bitcoin_units::locktime::relative::Height::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::block::TooBigForRelativeBlockHeightError
+pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Time::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Time::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Output = bitcoin_units::Amount
+pub type bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
+pub type bitcoin_units::weight::Weight::Output = u64
+pub type u64::Output = bitcoin_units::weight::Weight
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
new file mode 100644
index 0000000000..cf4fddd59b
--- /dev/null
+++ b/api/units/no-features.txt
@@ -0,0 +1,1063 @@
+#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
+#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
+#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
+#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
+#[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
+impl bitcoin_units::Amount
+impl bitcoin_units::SignedAmount
+impl bitcoin_units::amount::Denomination
+impl bitcoin_units::amount::Display
+impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::block::BlockHeight
+impl bitcoin_units::block::BlockInterval
+impl bitcoin_units::fee_rate::FeeRate
+impl bitcoin_units::locktime::absolute::Height
+impl bitcoin_units::locktime::absolute::Time
+impl bitcoin_units::locktime::relative::Height
+impl bitcoin_units::locktime::relative::Time
+impl bitcoin_units::locktime::relative::TimeOverflowError
+impl bitcoin_units::parse::Integer for i128
+impl bitcoin_units::parse::Integer for i16
+impl bitcoin_units::parse::Integer for i32
+impl bitcoin_units::parse::Integer for i64
+impl bitcoin_units::parse::Integer for i8
+impl bitcoin_units::parse::Integer for u128
+impl bitcoin_units::parse::Integer for u16
+impl bitcoin_units::parse::Integer for u32
+impl bitcoin_units::parse::Integer for u64
+impl bitcoin_units::parse::Integer for u8
+impl bitcoin_units::weight::Weight
+impl core::clone::Clone for bitcoin_units::Amount
+impl core::clone::Clone for bitcoin_units::SignedAmount
+impl core::clone::Clone for bitcoin_units::amount::Denomination
+impl core::clone::Clone for bitcoin_units::amount::Display
+impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::ParseError
+impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::block::BlockHeight
+impl core::clone::Clone for bitcoin_units::block::BlockInterval
+impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::clone::Clone for bitcoin_units::fee_rate::FeeRate
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ConversionError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::clone::Clone for bitcoin_units::locktime::absolute::Time
+impl core::clone::Clone for bitcoin_units::locktime::relative::Height
+impl core::clone::Clone for bitcoin_units::locktime::relative::Time
+impl core::clone::Clone for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::clone::Clone for bitcoin_units::parse::ParseIntError
+impl core::clone::Clone for bitcoin_units::parse::PrefixedHexError
+impl core::clone::Clone for bitcoin_units::parse::UnprefixedHexError
+impl core::clone::Clone for bitcoin_units::weight::Weight
+impl core::cmp::Eq for bitcoin_units::Amount
+impl core::cmp::Eq for bitcoin_units::SignedAmount
+impl core::cmp::Eq for bitcoin_units::amount::Denomination
+impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::block::BlockHeight
+impl core::cmp::Eq for bitcoin_units::block::BlockInterval
+impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::cmp::Eq for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ConversionError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::cmp::Eq for bitcoin_units::locktime::absolute::Time
+impl core::cmp::Eq for bitcoin_units::locktime::relative::Height
+impl core::cmp::Eq for bitcoin_units::locktime::relative::Time
+impl core::cmp::Eq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::cmp::Eq for bitcoin_units::parse::ParseIntError
+impl core::cmp::Eq for bitcoin_units::parse::PrefixedHexError
+impl core::cmp::Eq for bitcoin_units::parse::UnprefixedHexError
+impl core::cmp::Eq for bitcoin_units::weight::Weight
+impl core::cmp::Ord for bitcoin_units::Amount
+impl core::cmp::Ord for bitcoin_units::SignedAmount
+impl core::cmp::Ord for bitcoin_units::block::BlockHeight
+impl core::cmp::Ord for bitcoin_units::block::BlockInterval
+impl core::cmp::Ord for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
+impl core::cmp::Ord for bitcoin_units::locktime::absolute::Time
+impl core::cmp::Ord for bitcoin_units::locktime::relative::Height
+impl core::cmp::Ord for bitcoin_units::locktime::relative::Time
+impl core::cmp::Ord for bitcoin_units::weight::Weight
+impl core::cmp::PartialEq for bitcoin_units::Amount
+impl core::cmp::PartialEq for bitcoin_units::SignedAmount
+impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
+impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::cmp::PartialEq for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ConversionError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Time
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Height
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Time
+impl core::cmp::PartialEq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::cmp::PartialEq for bitcoin_units::parse::ParseIntError
+impl core::cmp::PartialEq for bitcoin_units::parse::PrefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::parse::UnprefixedHexError
+impl core::cmp::PartialEq for bitcoin_units::weight::Weight
+impl core::cmp::PartialOrd for bitcoin_units::Amount
+impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
+impl core::cmp::PartialOrd for bitcoin_units::block::BlockInterval
+impl core::cmp::PartialOrd for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Time
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
+impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
+impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
+impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
+impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
+impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
+impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_units::block::BlockInterval
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::PrefixedHexError
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
+impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
+impl core::convert::From<bitcoin_units::weight::Weight> for u64
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
+impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
+impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
+impl core::convert::From<u32> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
+impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockInterval
+impl core::convert::TryFrom<&str> for bitcoin_units::fee_rate::FeeRate
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Time
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Height
+impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Time
+impl core::convert::TryFrom<&str> for bitcoin_units::weight::Weight
+impl core::convert::TryFrom<bitcoin_units::Amount> for bitcoin_units::SignedAmount
+impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
+impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
+impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
+impl core::default::Default for bitcoin_units::Amount
+impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::locktime::relative::Height
+impl core::default::Default for bitcoin_units::locktime::relative::Time
+impl core::fmt::Debug for bitcoin_units::Amount
+impl core::fmt::Debug for bitcoin_units::SignedAmount
+impl core::fmt::Debug for bitcoin_units::amount::Denomination
+impl core::fmt::Debug for bitcoin_units::amount::Display
+impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::block::BlockHeight
+impl core::fmt::Debug for bitcoin_units::block::BlockInterval
+impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::fmt::Debug for bitcoin_units::fee_rate::FeeRate
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ConversionError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::fmt::Debug for bitcoin_units::locktime::absolute::Time
+impl core::fmt::Debug for bitcoin_units::locktime::relative::Height
+impl core::fmt::Debug for bitcoin_units::locktime::relative::Time
+impl core::fmt::Debug for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::fmt::Debug for bitcoin_units::parse::ParseIntError
+impl core::fmt::Debug for bitcoin_units::parse::PrefixedHexError
+impl core::fmt::Debug for bitcoin_units::parse::UnprefixedHexError
+impl core::fmt::Debug for bitcoin_units::weight::Weight
+impl core::fmt::Display for bitcoin_units::Amount
+impl core::fmt::Display for bitcoin_units::SignedAmount
+impl core::fmt::Display for bitcoin_units::amount::Denomination
+impl core::fmt::Display for bitcoin_units::amount::Display
+impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::ParseError
+impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::block::BlockHeight
+impl core::fmt::Display for bitcoin_units::block::BlockInterval
+impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::fmt::Display for bitcoin_units::fee_rate::FeeRate
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ConversionError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::fmt::Display for bitcoin_units::locktime::absolute::Time
+impl core::fmt::Display for bitcoin_units::locktime::relative::Height
+impl core::fmt::Display for bitcoin_units::locktime::relative::Time
+impl core::fmt::Display for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::fmt::Display for bitcoin_units::parse::ParseIntError
+impl core::fmt::Display for bitcoin_units::parse::PrefixedHexError
+impl core::fmt::Display for bitcoin_units::parse::UnprefixedHexError
+impl core::fmt::Display for bitcoin_units::weight::Weight
+impl core::hash::Hash for bitcoin_units::Amount
+impl core::hash::Hash for bitcoin_units::SignedAmount
+impl core::hash::Hash for bitcoin_units::amount::Denomination
+impl core::hash::Hash for bitcoin_units::block::BlockHeight
+impl core::hash::Hash for bitcoin_units::block::BlockInterval
+impl core::hash::Hash for bitcoin_units::fee_rate::FeeRate
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
+impl core::hash::Hash for bitcoin_units::locktime::absolute::Time
+impl core::hash::Hash for bitcoin_units::locktime::relative::Height
+impl core::hash::Hash for bitcoin_units::locktime::relative::Time
+impl core::hash::Hash for bitcoin_units::weight::Weight
+impl core::iter::traits::accum::Sum for bitcoin_units::Amount
+impl core::iter::traits::accum::Sum for bitcoin_units::SignedAmount
+impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockInterval
+impl core::iter::traits::accum::Sum for bitcoin_units::fee_rate::FeeRate
+impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
+impl core::marker::Copy for bitcoin_units::Amount
+impl core::marker::Copy for bitcoin_units::SignedAmount
+impl core::marker::Copy for bitcoin_units::amount::Denomination
+impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::block::BlockHeight
+impl core::marker::Copy for bitcoin_units::block::BlockInterval
+impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
+impl core::marker::Copy for bitcoin_units::locktime::absolute::Time
+impl core::marker::Copy for bitcoin_units::locktime::relative::Height
+impl core::marker::Copy for bitcoin_units::locktime::relative::Time
+impl core::marker::Copy for bitcoin_units::weight::Weight
+impl core::marker::Freeze for bitcoin_units::Amount
+impl core::marker::Freeze for bitcoin_units::SignedAmount
+impl core::marker::Freeze for bitcoin_units::amount::Denomination
+impl core::marker::Freeze for bitcoin_units::amount::Display
+impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::block::BlockHeight
+impl core::marker::Freeze for bitcoin_units::block::BlockInterval
+impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Freeze for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Freeze for bitcoin_units::locktime::absolute::Time
+impl core::marker::Freeze for bitcoin_units::locktime::relative::Height
+impl core::marker::Freeze for bitcoin_units::locktime::relative::Time
+impl core::marker::Freeze for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Freeze for bitcoin_units::parse::ParseIntError
+impl core::marker::Freeze for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Freeze for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Freeze for bitcoin_units::weight::Weight
+impl core::marker::Send for bitcoin_units::Amount
+impl core::marker::Send for bitcoin_units::SignedAmount
+impl core::marker::Send for bitcoin_units::amount::Denomination
+impl core::marker::Send for bitcoin_units::amount::Display
+impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::ParseError
+impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::block::BlockHeight
+impl core::marker::Send for bitcoin_units::block::BlockInterval
+impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Send for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Send for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Height
+impl core::marker::Send for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Send for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Send for bitcoin_units::locktime::absolute::Time
+impl core::marker::Send for bitcoin_units::locktime::relative::Height
+impl core::marker::Send for bitcoin_units::locktime::relative::Time
+impl core::marker::Send for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Send for bitcoin_units::parse::ParseIntError
+impl core::marker::Send for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Send for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Send for bitcoin_units::weight::Weight
+impl core::marker::StructuralPartialEq for bitcoin_units::Amount
+impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
+impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
+impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::FeeRate
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Time
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Height
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Time
+impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::ParseIntError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::PrefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::StructuralPartialEq for bitcoin_units::weight::Weight
+impl core::marker::Sync for bitcoin_units::Amount
+impl core::marker::Sync for bitcoin_units::SignedAmount
+impl core::marker::Sync for bitcoin_units::amount::Denomination
+impl core::marker::Sync for bitcoin_units::amount::Display
+impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::ParseError
+impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::block::BlockHeight
+impl core::marker::Sync for bitcoin_units::block::BlockInterval
+impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Sync for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Sync for bitcoin_units::locktime::absolute::Time
+impl core::marker::Sync for bitcoin_units::locktime::relative::Height
+impl core::marker::Sync for bitcoin_units::locktime::relative::Time
+impl core::marker::Sync for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Sync for bitcoin_units::parse::ParseIntError
+impl core::marker::Sync for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Sync for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Sync for bitcoin_units::weight::Weight
+impl core::marker::Unpin for bitcoin_units::Amount
+impl core::marker::Unpin for bitcoin_units::SignedAmount
+impl core::marker::Unpin for bitcoin_units::amount::Denomination
+impl core::marker::Unpin for bitcoin_units::amount::Display
+impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::block::BlockHeight
+impl core::marker::Unpin for bitcoin_units::block::BlockInterval
+impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::marker::Unpin for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ConversionError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::marker::Unpin for bitcoin_units::locktime::absolute::Time
+impl core::marker::Unpin for bitcoin_units::locktime::relative::Height
+impl core::marker::Unpin for bitcoin_units::locktime::relative::Time
+impl core::marker::Unpin for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::marker::Unpin for bitcoin_units::parse::ParseIntError
+impl core::marker::Unpin for bitcoin_units::parse::PrefixedHexError
+impl core::marker::Unpin for bitcoin_units::parse::UnprefixedHexError
+impl core::marker::Unpin for bitcoin_units::weight::Weight
+impl core::ops::arith::Add for bitcoin_units::Amount
+impl core::ops::arith::Add for bitcoin_units::SignedAmount
+impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
+impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::Amount
+impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
+impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
+impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Div for bitcoin_units::weight::Weight
+impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
+impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Div<u64> for bitcoin_units::Amount
+impl core::ops::arith::Div<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::DivAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::DivAssign<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::Mul<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::weight::Weight
+impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for u64
+impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
+impl core::ops::arith::Mul<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::MulAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::MulAssign<u64> for bitcoin_units::weight::Weight
+impl core::ops::arith::Neg for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
+impl core::ops::arith::RemAssign<i64> for bitcoin_units::SignedAmount
+impl core::ops::arith::RemAssign<u64> for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::Amount
+impl core::ops::arith::Sub for bitcoin_units::SignedAmount
+impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
+impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
+impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::Amount
+impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
+impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
+impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ConversionError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Time
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Height
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Time
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::ParseIntError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::PrefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::UnprefixedHexError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::weight::Weight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ConversionError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Time
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Height
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Time
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::ParseIntError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::PrefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::UnprefixedHexError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::weight::Weight
+impl core::str::traits::FromStr for bitcoin_units::Amount
+impl core::str::traits::FromStr for bitcoin_units::SignedAmount
+impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
+impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
+impl core::str::traits::FromStr for bitcoin_units::block::BlockInterval
+impl core::str::traits::FromStr for bitcoin_units::fee_rate::FeeRate
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Time
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Height
+impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Time
+impl core::str::traits::FromStr for bitcoin_units::weight::Weight
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Amount> for bitcoin_units::Amount
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::Amount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::Amount>
+impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::SignedAmount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::SignedAmount>
+pub bitcoin_units::amount::Denomination::Bit
+pub bitcoin_units::amount::Denomination::Bitcoin
+pub bitcoin_units::amount::Denomination::CentiBitcoin
+pub bitcoin_units::amount::Denomination::MicroBitcoin
+pub bitcoin_units::amount::Denomination::MilliBitcoin
+pub bitcoin_units::amount::Denomination::Satoshi
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub const bitcoin_units::Amount::MAX: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MAX_MONEY: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MIN: bitcoin_units::Amount
+pub const bitcoin_units::Amount::ONE_BTC: bitcoin_units::Amount
+pub const bitcoin_units::Amount::ONE_SAT: bitcoin_units::Amount
+pub const bitcoin_units::Amount::SIZE: usize
+pub const bitcoin_units::Amount::ZERO: bitcoin_units::Amount
+pub const bitcoin_units::SignedAmount::MAX: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::MAX_MONEY: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::MIN: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ONE_BTC: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ONE_SAT: bitcoin_units::SignedAmount
+pub const bitcoin_units::SignedAmount::ZERO: bitcoin_units::SignedAmount
+pub const bitcoin_units::amount::Denomination::BTC: Self
+pub const bitcoin_units::amount::Denomination::SAT: Self
+pub const bitcoin_units::block::BlockHeight::MAX: Self
+pub const bitcoin_units::block::BlockHeight::MIN: Self
+pub const bitcoin_units::block::BlockHeight::ZERO: Self
+pub const bitcoin_units::block::BlockInterval::MAX: Self
+pub const bitcoin_units::block::BlockInterval::MIN: Self
+pub const bitcoin_units::block::BlockInterval::ZERO: Self
+pub const bitcoin_units::fee_rate::FeeRate::BROADCAST_MIN: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::DUST: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::MAX: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::MIN: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::fee_rate::FeeRate::ZERO: bitcoin_units::fee_rate::FeeRate
+pub const bitcoin_units::locktime::absolute::Height::MAX: Self
+pub const bitcoin_units::locktime::absolute::Height::MIN: Self
+pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
+pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
+pub const bitcoin_units::locktime::absolute::Time::MAX: Self
+pub const bitcoin_units::locktime::absolute::Time::MIN: Self
+pub const bitcoin_units::locktime::relative::Height::MAX: Self
+pub const bitcoin_units::locktime::relative::Height::MIN: Self
+pub const bitcoin_units::locktime::relative::Height::ZERO: Self
+pub const bitcoin_units::locktime::relative::Time::MAX: Self
+pub const bitcoin_units::locktime::relative::Time::MIN: Self
+pub const bitcoin_units::locktime::relative::Time::ZERO: Self
+pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
+pub const bitcoin_units::weight::Weight::MAX: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MAX_BLOCK: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MIN: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::MIN_TRANSACTION: bitcoin_units::weight::Weight
+pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
+pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
+pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::from_int_btc_const(btc: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::to_sat(self) -> u64
+pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
+pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
+pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb_unchecked(sat_vb: u64) -> Self
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_kwu(self) -> u64
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_ceil(self) -> u64
+pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_floor(self) -> u64
+pub const fn bitcoin_units::locktime::absolute::Height::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Height, bitcoin_units::locktime::absolute::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Height::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::Time::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Time, bitcoin_units::locktime::absolute::ConversionError>
+pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) -> u32
+pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
+pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
+pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
+pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
+pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
+pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::from_wu_usize(wu: usize) -> Self
+pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
+pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
+pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::add_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
+pub fn bitcoin_units::Amount::default() -> Self
+pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
+pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::Amount::from_int_btc(btc: u64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
+pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
+pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn bitcoin_units::Amount::sub_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
+pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
+pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
+pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
+pub fn bitcoin_units::SignedAmount::default() -> Self
+pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
+pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from_int_btc(btc: i64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
+pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
+pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
+pub fn bitcoin_units::SignedAmount::mul_assign(&mut self, rhs: i64)
+pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
+pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
+pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
+pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
+pub fn bitcoin_units::amount::CheckedSum::checked_sum(self) -> core::option::Option<R>
+pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
+pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
+pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
+pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
+pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
+pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
+pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
+pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
+pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(&self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(&self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(&self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
+pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
+pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
+pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
+pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
+pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
+pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
+pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
+pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
+pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
+pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
+pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::block::BlockInterval::from(h: bitcoin_units::locktime::relative::Height) -> Self
+pub fn bitcoin_units::block::BlockInterval::from(inner: u32) -> Self
+pub fn bitcoin_units::block::BlockInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::block::BlockInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::block::BlockInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::block::BlockInterval::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
+pub fn bitcoin_units::block::BlockInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
+pub fn bitcoin_units::block::BlockInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::block::BlockInterval>
+pub fn bitcoin_units::block::BlockInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
+pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
+pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
+pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
+pub fn bitcoin_units::fee_rate::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::fee_rate::FeeRate::fee_wu(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub fn bitcoin_units::fee_rate::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb(sat_vb: u64) -> core::option::Option<Self>
+pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
+pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::ConversionError
+pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
+pub fn bitcoin_units::locktime::absolute::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
+pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
+pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseHeightError>
+pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::ParseHeightError
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseHeightError) -> bool
+pub fn bitcoin_units::locktime::absolute::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::ParseTimeError
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseTimeError) -> bool
+pub fn bitcoin_units::locktime::absolute::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Time::clone(&self) -> bitcoin_units::locktime::absolute::Time
+pub fn bitcoin_units::locktime::absolute::Time::cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::absolute::Time::eq(&self, other: &bitcoin_units::locktime::absolute::Time) -> bool
+pub fn bitcoin_units::locktime::absolute::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::absolute::Time::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseTimeError>
+pub fn bitcoin_units::locktime::absolute::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::absolute::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::absolute::Time::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::absolute::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::clone(&self) -> bitcoin_units::locktime::relative::Height
+pub fn bitcoin_units::locktime::relative::Height::cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::Height::default() -> bitcoin_units::locktime::relative::Height
+pub fn bitcoin_units::locktime::relative::Height::eq(&self, other: &bitcoin_units::locktime::relative::Height) -> bool
+pub fn bitcoin_units::locktime::relative::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::Height::from(value: u16) -> Self
+pub fn bitcoin_units::locktime::relative::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::Height::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::Height::try_from(h: bitcoin_units::block::BlockInterval) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Time::clone(&self) -> bitcoin_units::locktime::relative::Time
+pub fn bitcoin_units::locktime::relative::Time::cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::cmp::Ordering
+pub fn bitcoin_units::locktime::relative::Time::default() -> bitcoin_units::locktime::relative::Time
+pub fn bitcoin_units::locktime::relative::Time::eq(&self, other: &bitcoin_units::locktime::relative::Time) -> bool
+pub fn bitcoin_units::locktime::relative::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::locktime::relative::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::locktime::relative::Time::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::locktime::relative::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::TimeOverflowError
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::TimeOverflowError) -> bool
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::locktime::relative::TimeOverflowError::new(seconds: u32) -> Self
+pub fn bitcoin_units::parse::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
+pub fn bitcoin_units::parse::ParseIntError::clone(&self) -> bitcoin_units::parse::ParseIntError
+pub fn bitcoin_units::parse::ParseIntError::eq(&self, other: &bitcoin_units::parse::ParseIntError) -> bool
+pub fn bitcoin_units::parse::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::PrefixedHexError::clone(&self) -> bitcoin_units::parse::PrefixedHexError
+pub fn bitcoin_units::parse::PrefixedHexError::eq(&self, other: &bitcoin_units::parse::PrefixedHexError) -> bool
+pub fn bitcoin_units::parse::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::PrefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
+pub fn bitcoin_units::parse::PrefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse::UnprefixedHexError::clone(&self) -> bitcoin_units::parse::UnprefixedHexError
+pub fn bitcoin_units::parse::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse::UnprefixedHexError) -> bool
+pub fn bitcoin_units::parse::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::parse::UnprefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
+pub fn bitcoin_units::parse::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::parse::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
+pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
+pub fn bitcoin_units::weight::Weight::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::div(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::weight::Weight::div_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::weight::Weight::eq(&self, other: &bitcoin_units::weight::Weight) -> bool
+pub fn bitcoin_units::weight::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::weight::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
+pub fn bitcoin_units::weight::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_units::weight::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_units::weight::Weight::mul(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
+pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
+pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
+pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse::ParseIntError) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
+pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
+pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
+pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
+pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub macro bitcoin_units::impl_parse_str!
+pub macro bitcoin_units::impl_parse_str_from_int_infallible!
+pub macro bitcoin_units::impl_tryfrom_str!
+pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
+pub mod bitcoin_units
+pub mod bitcoin_units::amount
+pub mod bitcoin_units::amount::error
+pub mod bitcoin_units::block
+pub mod bitcoin_units::fee_rate
+pub mod bitcoin_units::locktime
+pub mod bitcoin_units::locktime::absolute
+pub mod bitcoin_units::locktime::relative
+pub mod bitcoin_units::parse
+pub mod bitcoin_units::weight
+pub struct bitcoin_units::Amount(_)
+pub struct bitcoin_units::BlockHeight(pub u32)
+pub struct bitcoin_units::BlockInterval(pub u32)
+pub struct bitcoin_units::FeeRate(_)
+pub struct bitcoin_units::SignedAmount(_)
+pub struct bitcoin_units::Weight(_)
+pub struct bitcoin_units::amount::Amount(_)
+pub struct bitcoin_units::amount::Display
+pub struct bitcoin_units::amount::InputTooLargeError
+pub struct bitcoin_units::amount::InvalidCharacterError
+pub struct bitcoin_units::amount::MissingDigitsError
+pub struct bitcoin_units::amount::OutOfRangeError
+pub struct bitcoin_units::amount::ParseAmountError(_)
+pub struct bitcoin_units::amount::ParseError(_)
+pub struct bitcoin_units::amount::SignedAmount(_)
+pub struct bitcoin_units::amount::TooPreciseError
+pub struct bitcoin_units::amount::error::InputTooLargeError
+pub struct bitcoin_units::amount::error::InvalidCharacterError
+pub struct bitcoin_units::amount::error::MissingDigitsError
+pub struct bitcoin_units::amount::error::OutOfRangeError
+pub struct bitcoin_units::amount::error::ParseAmountError(_)
+pub struct bitcoin_units::amount::error::ParseError(_)
+pub struct bitcoin_units::amount::error::TooPreciseError
+pub struct bitcoin_units::block::BlockHeight(pub u32)
+pub struct bitcoin_units::block::BlockInterval(pub u32)
+pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
+pub struct bitcoin_units::fee_rate::FeeRate(_)
+pub struct bitcoin_units::locktime::absolute::Height(_)
+pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
+pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
+pub struct bitcoin_units::locktime::absolute::Time(_)
+pub struct bitcoin_units::locktime::relative::Height(_)
+pub struct bitcoin_units::locktime::relative::Time(_)
+pub struct bitcoin_units::locktime::relative::TimeOverflowError
+pub struct bitcoin_units::parse::PrefixedHexError(_)
+pub struct bitcoin_units::parse::UnprefixedHexError(_)
+pub struct bitcoin_units::weight::Weight(_)
+pub trait bitcoin_units::amount::CheckedSum<R>: private::SumSeal<R>
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized
+pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
+pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
+pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockInterval
+pub type bitcoin_units::block::BlockInterval::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockInterval::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::block::BlockInterval::Output = bitcoin_units::block::BlockInterval
+pub type bitcoin_units::fee_rate::FeeRate::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::fee_rate::FeeRate::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::Amount
+pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ConversionError
+pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ParseHeightError
+pub type bitcoin_units::locktime::absolute::Time::Err = bitcoin_units::locktime::absolute::ParseTimeError
+pub type bitcoin_units::locktime::absolute::Time::Error = bitcoin_units::locktime::absolute::ParseTimeError
+pub type bitcoin_units::locktime::relative::Height::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::block::TooBigForRelativeBlockHeightError
+pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Time::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::locktime::relative::Time::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_units::weight::Weight::Output = bitcoin_units::Amount
+pub type bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
+pub type bitcoin_units::weight::Weight::Output = u64
+pub type u64::Output = bitcoin_units::weight::Weight

From e126a243074ffbe628a9c8425694db5fe93efb8a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 6 Dec 2024 15:23:17 +1100
Subject: [PATCH 048/554] Add API script

Add a script to generate API files using `cargo public-api` for the
crates that we are trying to stabalise (the so called 'leaf crates').

- hashes
- io
- primitives
- units

We already ran the script and committed the files last patch. The fact
that this patch does not include any changes to the `api/` directory and
that CI passes is enough to convince us that last patch was valid.

Add a CI job that runs the script and checks there are no changes to
the committed text files thereby proving no API changes are made in a
PR without explicitly modifying the API text files.

Add documentation to `CONTRIBUTING.md` on what is expected of devs.
---
 .github/workflows/rust.yml       | 20 +++++++
 CONTRIBUTING.md                  | 12 +++++
 contrib/check-for-api-changes.sh | 93 ++++++++++++++++++++++++++++++++
 justfile                         |  4 ++
 4 files changed, 129 insertions(+)
 create mode 100755 contrib/check-for-api-changes.sh

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index cf06c57ae8..c9c230cd2d 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -305,3 +305,23 @@ jobs:
         with:
           args: "--only-codegen"
 
+  API:
+    name: API - nightly toolchain
+    needs: Prepare
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        dep: [recent]
+    steps:
+      - name: "Checkout repo"
+        uses: actions/checkout@v4
+      - name: "Select toolchain"
+        uses: dtolnay/rust-toolchain@v1
+        with:
+          toolchain: ${{ needs.Prepare.outputs.nightly_version }}
+      - name: "Install cargo-public-api"
+        # Pin version so that updates don't introduce changes to the text files.
+        run: cargo +stable install --locked cargo-public-api@0.42.0
+      - name: "Run API checker script"
+        run: ./contrib/check-for-api-changes.sh
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d9139bacc9..ff1d586650 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -145,6 +145,18 @@ 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.
 
+### API changes
+
+The API of the following crates is almost stable. Changing it is supposed to be non-trivial. To
+assist in this effort ll PRs that change the public API of any these crates must include a patch to
+the `api/` text files. This should be a separate final patch to the PR that is the diff created by
+running `just check-api`.
+
+- `hashes`
+- `io`
+- `primitives`
+- `units`
+
 ### Repository maintainers
 
 Pull request merge requirements:
diff --git a/contrib/check-for-api-changes.sh b/contrib/check-for-api-changes.sh
new file mode 100755
index 0000000000..dc305dca05
--- /dev/null
+++ b/contrib/check-for-api-changes.sh
@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+#
+# Checks the public API of crates, exits with non-zero if there are currently
+# changes to the public API not already committed to in the various api/*.txt
+# files.
+
+set -euo pipefail
+
+REPO_DIR=$(git rev-parse --show-toplevel)
+API_DIR="$REPO_DIR/api"
+
+NIGHTLY=$(cat nightly-version)
+# Our docs have broken intra doc links if all features are not enabled.
+RUSTDOCFLAGS="-A rustdoc::broken_intra_doc_links"
+
+# `sort -n -u` doesn't work for some reason.
+SORT="sort --numeric-sort"
+
+# Sort order is effected by locale. See `man sort`.
+# > Set LC_ALL=C to get the traditional sort order that uses native byte values.
+export LC_ALL=C
+
+main() {
+    need_nightly
+
+    generate_api_files "hashes"
+    generate_api_files "io"
+    generate_api_files "primitives"
+    generate_api_files "units"
+
+    check_for_changes
+}
+
+# Uses `CARGO` to generate API files in the specified crate.
+#
+# Files:
+#
+# - no-features.txt
+# - alloc-only.txt
+# - all-features.txt
+generate_api_files() {
+    local crate=$1
+    pushd "$REPO_DIR/$crate" > /dev/null
+
+    run_cargo --no-default-features | $SORT | uniq > "$API_DIR/$crate/no-features.txt"
+    run_cargo --no-default-features --features=alloc | $SORT | uniq > "$API_DIR/$crate/alloc-only.txt"
+    run_cargo_all_features | $SORT | uniq > "$API_DIR/$crate/all-features.txt"
+
+    popd > /dev/null
+}
+
+# Check if there are changes (dirty git index) to the `api/` directory.
+check_for_changes() {
+    pushd "$REPO_DIR" > /dev/null
+
+    if [[ $(git status --porcelain api) ]]; then
+        git diff --color=always
+        echo
+        err "You have introduced changes to the public API, commit the changes to api/ currently in your working directory"
+    else
+        echo "No changes to the current public API"
+    fi
+
+    popd > /dev/null
+}
+
+# Run cargo when --all-features is not used.
+run_cargo() {
+    RUSTDOCFLAGS="$RUSTDOCFLAGS" cargo +"$NIGHTLY" public-api --simplified "$@"
+}
+
+# Run cargo with all features enabled.
+run_cargo_all_features() {
+    cargo +"$NIGHTLY" public-api --simplified --all-features
+}
+
+need_nightly() {
+    cargo_ver=$(cargo +"$NIGHTLY" --version)
+    if echo "$cargo_ver" | grep -q -v nightly; then
+        err "Need a nightly compiler; have $cargo_ver"
+    fi
+}
+
+err() {
+    echo "$1" >&2
+    exit 1
+}
+
+#
+# Main script
+#
+main "$@"
+exit 0
diff --git a/justfile b/justfile
index ce7af6170d..76f5f549e5 100644
--- a/justfile
+++ b/justfile
@@ -36,6 +36,10 @@ sane: lint
   # Make an attempt to catch feature gate problems in doctests
   cargo test --manifest-path bitcoin/Cargo.toml --doc --no-default-features > /dev/null || exit 1
 
+# Check for API changes.
+check-api:
+ contrib/check-for-api-changes.sh
+
 # Update the recent and minimal lock files.
 update-lock-files:
   contrib/update-lock-files.sh

From 7e0501c03cbc02ccd9292a709b51deb96c74901d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 4 Dec 2024 11:41:50 +1100
Subject: [PATCH 049/554] Add a script to query the API

Add a simple script that allows one to query the current API. Done by
parsing the API text files and grepping for things.

This is useful as a dev tool as we try to stabalize the leaf crates.
---
 contrib/api.sh | 149 +++++++++++++++++++++++++++++++++++++++++++++++++
 justfile       |   6 ++
 2 files changed, 155 insertions(+)
 create mode 100755 contrib/api.sh

diff --git a/contrib/api.sh b/contrib/api.sh
new file mode 100755
index 0000000000..e4ec08116d
--- /dev/null
+++ b/contrib/api.sh
@@ -0,0 +1,149 @@
+#!/usr/bin/env bash
+#
+# Script for querying the API.
+#
+# Shellcheck can't search dynamic paths
+# shellcheck source=/dev/null
+
+set -euo pipefail
+
+file=""                         # File name of the all-features API text file.
+crate_full_name=""              # Full crate name using underscores e.g., `bitcoin_primitives`.
+crate=""                        # Short name e.g., `primitives`.
+
+# Set to false to turn off verbose output.
+flag_verbose=false
+
+usage() {
+    cat <<EOF
+Usage:
+
+    ./api.sh CRATE COMMAND
+
+CRATE
+  - hashes          bitcoin_hashes
+  - io              bitcoin-io
+  - primitives      bitcoin-primitives
+  - units           bitcoin-units
+
+CMD
+  - types             Show all public types (structs and enums)
+  - types_no_err      Show all public types (structs and enums) excluding error types.
+EOF
+}
+
+main() {
+    if [ "$#" -lt 1 ]; then
+        usage
+        exit 1
+    fi
+
+    local _crate="${1:---help}"
+    if [[ "$_crate" == "-h" || "$_crate" == "--help" ]]; then
+        usage
+        exit 1
+    fi
+
+    if [ "$#" -lt 2 ]; then
+        say_err "Missing COMMAND"
+        usage
+        exit 1
+    fi
+
+    local _cmd="$2"
+
+    check_required_commands
+
+    case $_crate in
+        hashes)
+            crate_full_name="bitcoin_hashes"
+            ;;
+        io)
+            crate_full_name="bitcoin_io"
+            ;;
+        primitives)
+            crate_full_name="bitcoin_primitives"
+            ;;
+        units)
+            crate_full_name="bitcoin_units"
+            ;;
+        *)
+            say_err "unsupported crate: $_crate"
+            usage
+            exit 1
+    esac
+
+    crate=$_crate
+    file="./api/$crate/all-features.txt"
+
+    verbose_say "Running command '$_cmd' on crate '$crate'"
+
+    case $_cmd in
+	types)
+            structs_and_enums
+            ;;
+
+	types_no_err)
+            structs_and_enums_no_err
+            ;;
+
+        traits)
+            traits
+            ;;
+
+        *)
+            err "Error: unknown cmd $_cmd"
+            ;;
+    esac
+}
+
+# Print all public structs and enums.
+structs_and_enums() {
+    grep -oP 'pub (struct|enum) \K[\w:]+(?=\(|;| )' "$file" | sed "s/^${crate_full_name}:://"
+}
+
+# Print all public structs and enums excluding error types.
+structs_and_enums_no_err() {
+    grep -oP 'pub (struct|enum) \K[\w:]+(?=\(|;| )' "$file" | sed "s/^${crate_full_name}:://" | grep -v Error
+}
+
+# Print all public traits.
+traits() {
+    grep -oP '^pub trait \K[\w:]+' "$file" | sed "s/^${crate_full_name}:://" | sed 's/:$//'
+}
+
+# Check all the commands we use are present in the current environment.
+check_required_commands() {
+    need_cmd grep
+}
+
+say() {
+    echo "api: $1"
+}
+
+say_err() {
+    say "$1" >&2
+}
+
+verbose_say() {
+    if [ "$flag_verbose" = true ]; then
+	say "$1"
+    fi
+}
+
+err() {
+    echo "$1" >&2
+    exit 1
+}
+
+need_cmd() {
+    if ! command -v "$1" > /dev/null 2>&1
+    then err "need '$1' (command not found)"
+    fi
+}
+
+#
+# Main script
+#
+main "$@"
+exit 0
diff --git a/justfile b/justfile
index 76f5f549e5..0be4cd940a 100644
--- a/justfile
+++ b/justfile
@@ -1,3 +1,5 @@
+set positional-arguments
+
 default:
   @just --list
 
@@ -40,6 +42,10 @@ sane: lint
 check-api:
  contrib/check-for-api-changes.sh
 
+# Query the current API.
+@query-api crate command:
+ contrib/api.sh $1 $2
+
 # Update the recent and minimal lock files.
 update-lock-files:
   contrib/update-lock-files.sh

From ac74ed2144e785fef7c395388a4fb7fb394e833e Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Fri, 6 Dec 2024 09:19:56 -0600
Subject: [PATCH 050/554] Range check against SignedAmount::MAX instead of
 i64::MAX

Future proof this check by using SignedAmount::MAX in the case where the
MAX SignedAmount changes to something other then i64::MAX.
---
 units/src/amount/signed.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 1af91950c9..4237ba0bb8 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -108,7 +108,7 @@ impl SignedAmount {
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
         match parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(true))? {
             // (negative, amount)
-            (false, sat) if sat > i64::MAX as u64 => Err(ParseAmountError(
+            (false, sat) if sat > SignedAmount::MAX.to_sat() as u64 => Err(ParseAmountError(
                 ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_big(true)),
             )),
             (false, sat) => Ok(SignedAmount(sat as i64)),

From 78f61f55de7d5c452939edf5b8509314a09d854b Mon Sep 17 00:00:00 2001
From: Update cargo-semver-checks Bot <bot@example.com>
Date: Sat, 7 Dec 2024 01:10:28 +0000
Subject: [PATCH 051/554] Automated update to Github CI to cargo-semver-checks
 version-0.37.0

---
 .github/workflows/cargo-semver-checks-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/cargo-semver-checks-version b/.github/workflows/cargo-semver-checks-version
index 93d4c1ef06..0f1a7dfc7c 100644
--- a/.github/workflows/cargo-semver-checks-version
+++ b/.github/workflows/cargo-semver-checks-version
@@ -1 +1 @@
-0.36.0
+0.37.0

From d3d20d3fb263e9d2034d4bef7823d027cc744af4 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 7 Dec 2024 01:48:31 +0000
Subject: [PATCH 052/554] Automated update to Github CI to rustc
 nightly-2024-12-06

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 67380bdf06..71ef52e171 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2024-12-01
+nightly-2024-12-06

From ffdd63fa8ec3575bc3087241ebdcbccc71818ab7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 9 Dec 2024 10:49:59 +1100
Subject: [PATCH 053/554] units: test for C-SEND-SYNC

Done as part of the Rust API guidelines checklist.

Add a unit test for `Send` and one for `Sync`.
---
 units/tests/api.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/units/tests/api.rs b/units/tests/api.rs
index 8649e7397d..eb6a9530ee 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -235,3 +235,17 @@ fn api_all_non_error_types_have_non_empty_debug() {
     let debug = format!("{:?}", t.b.k);
     assert!(!debug.is_empty());
 }
+
+#[test]
+fn test_send() {
+    fn assert_send<T: Send>() {}
+    assert_send::<Types>();
+    assert_send::<Errors>();
+}
+
+#[test]
+fn test_sync() {
+    fn assert_sync<T: Sync>() {}
+    assert_sync::<Types>();
+    assert_sync::<Errors>();
+}

From 6ae35be0db84d2bf79ffe0cd63d616a55c036b12 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 9 Dec 2024 13:57:26 +1100
Subject: [PATCH 054/554] primitives: Reduce alloc requirements

Recently we reduced the `alloc` requirements in `units` but we did not
propagate these changes up to `primitives`.

Remove a bunch of `alloc` feature gating from `primitives`.
---
 primitives/src/lib.rs      | 7 ++-----
 primitives/src/sequence.rs | 9 ---------
 2 files changed, 2 insertions(+), 14 deletions(-)

diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index b8a5204de6..032aebcdc0 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -31,7 +31,6 @@ extern crate std;
 extern crate serde;
 
 pub mod block;
-#[cfg(feature = "alloc")]
 pub mod locktime;
 pub mod merkle_tree;
 pub mod opcodes;
@@ -45,10 +44,8 @@ pub mod transaction;
 pub mod witness;
 
 #[doc(inline)]
-pub use units::amount::{self, Amount, SignedAmount};
-#[doc(inline)]
-#[cfg(feature = "alloc")]
 pub use units::{
+    amount::{self, Amount, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::{self, FeeRate},
     weight::{self, Weight},
@@ -60,13 +57,13 @@ pub use self::{
     block::{
         Block, Checked as BlockChecked, Unchecked as BlockUnchecked, Validation as BlockValidation,
     },
-    locktime::{absolute, relative},
     transaction::{Transaction, TxIn, TxOut},
     witness::Witness,
 };
 #[doc(inline)]
 pub use self::{
     block::{BlockHash, Header as BlockHeader, WitnessCommitment},
+    locktime::{absolute, relative},
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
     pow::CompactTarget,
     sequence::Sequence,
diff --git a/primitives/src/sequence.rs b/primitives/src/sequence.rs
index 5f0233c9cc..a0adab268e 100644
--- a/primitives/src/sequence.rs
+++ b/primitives/src/sequence.rs
@@ -20,12 +20,9 @@ use core::fmt;
 use arbitrary::{Arbitrary, Unstructured};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-#[cfg(feature = "alloc")]
 use units::locktime::relative::TimeOverflowError;
-#[cfg(feature = "alloc")]
 use units::parse::{self, PrefixedHexError, UnprefixedHexError};
 
-#[cfg(feature = "alloc")]
 use crate::locktime::relative;
 #[cfg(all(doc, feature = "alloc"))]
 use crate::transaction::Transaction;
@@ -127,14 +124,12 @@ impl Sequence {
     }
 
     /// Constructs a new `Sequence` from a prefixed hex string.
-    #[cfg(feature = "alloc")]
     pub fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
         let lock_time = parse::hex_u32_prefixed(s)?;
         Ok(Self::from_consensus(lock_time))
     }
 
     /// Constructs a new `Sequence` from an unprefixed hex string.
-    #[cfg(feature = "alloc")]
     pub fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
         let lock_time = parse::hex_u32_unprefixed(s)?;
         Ok(Self::from_consensus(lock_time))
@@ -158,7 +153,6 @@ impl Sequence {
     ///
     /// Will return an error if the input cannot be encoded in 16 bits.
     #[inline]
-    #[cfg(feature = "alloc")]
     pub fn from_seconds_floor(seconds: u32) -> Result<Self, TimeOverflowError> {
         if let Ok(interval) = u16::try_from(seconds / 512) {
             Ok(Sequence::from_512_second_intervals(interval))
@@ -172,7 +166,6 @@ impl Sequence {
     ///
     /// Will return an error if the input cannot be encoded in 16 bits.
     #[inline]
-    #[cfg(feature = "alloc")]
     pub fn from_seconds_ceil(seconds: u32) -> Result<Self, TimeOverflowError> {
         if let Ok(interval) = u16::try_from((seconds + 511) / 512) {
             Ok(Sequence::from_512_second_intervals(interval))
@@ -191,7 +184,6 @@ impl Sequence {
 
     /// Constructs a new [`relative::LockTime`] from this [`Sequence`] number.
     #[inline]
-    #[cfg(feature = "alloc")]
     pub fn to_relative_lock_time(&self) -> Option<relative::LockTime> {
         use crate::locktime::relative::{Height, LockTime, Time};
 
@@ -211,7 +203,6 @@ impl Sequence {
     /// Returns the low 16 bits from sequence number.
     ///
     /// BIP-68 only uses the low 16 bits for relative lock value.
-    #[cfg(feature = "alloc")]
     fn low_u16(&self) -> u16 { self.0 as u16 }
 }
 

From 428e9787d181a462d06a18b7a45701790cbc0929 Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Wed, 27 Nov 2024 07:06:32 -0600
Subject: [PATCH 055/554] Explicitly define Ord for NodeInfo

---
 bitcoin/src/taproot/mod.rs | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index dbcb65193a..88a6f1c556 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -7,7 +7,7 @@
 pub mod merkle_branch;
 pub mod serialized_signature;
 
-use core::cmp::Reverse;
+use core::cmp::{Ordering, Reverse};
 use core::fmt;
 use core::iter::FusedIterator;
 
@@ -789,7 +789,7 @@ impl DoubleEndedIterator for LeafNodes<'_> {
 ///
 /// You can use [`TaprootSpendInfo::from_node_info`] to a get a [`TaprootSpendInfo`] from the Merkle
 /// root [`NodeInfo`].
-#[derive(Debug, Clone, PartialOrd, Ord)]
+#[derive(Debug, Clone)]
 pub struct NodeInfo {
     /// Merkle hash for this node.
     pub(crate) hash: TapNodeHash,
@@ -799,6 +799,24 @@ pub struct NodeInfo {
     pub(crate) has_hidden_nodes: bool,
 }
 
+/// Explicitly implement Ord so future changes to NodeInfo (e.g. adding a new field) won't result in
+/// potentially changing addresses out from under users
+impl Ord for NodeInfo {
+    fn cmp(&self, other: &Self) -> Ordering {
+        match self.hash.cmp(&other.hash) {
+            Ordering::Equal => match self.leaves.cmp(&other.leaves) {
+                Ordering::Equal => self.has_hidden_nodes.cmp(&other.has_hidden_nodes),
+                other => other,
+            },
+            other => other,
+        }
+    }
+}
+
+impl PartialOrd for NodeInfo {
+    fn partial_cmp(&self, other: &NodeInfo) -> Option<Ordering> { Some(self.cmp(other)) }
+}
+
 impl PartialEq for NodeInfo {
     fn eq(&self, other: &Self) -> bool { self.hash.eq(&other.hash) }
 }

From b9b8ddafdea286c5ed26abb04b966c77fdfa6d17 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 10 Dec 2024 10:56:33 +1100
Subject: [PATCH 056/554] hashes: Add lint return_self_must_use

Add the lint. No additional clippy warnings are introduced.
---
 hashes/src/lib.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 44b13523d1..920ce99731 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -58,6 +58,8 @@
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
+// Pedantic lints that we enforce.
+#![warn(clippy::return_self_not_must_use)]
 // Instead of littering the codebase for non-fuzzing and bench code just globally allow.
 #![cfg_attr(hashes_fuzz, allow(dead_code, unused_imports))]
 #![cfg_attr(bench, allow(dead_code, unused_imports))]

From f4b9c06c8bdffccfe997135f7b6ec168978e9bcc Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 9 Dec 2024 17:05:27 +1100
Subject: [PATCH 057/554] hashes: Add additional must_use

Run the linter with `must_use_candidate` enabled and check all the
warnings.
---
 hashes/src/sha256.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/hashes/src/sha256.rs b/hashes/src/sha256.rs
index 98e8ec1327..8770b332b6 100644
--- a/hashes/src/sha256.rs
+++ b/hashes/src/sha256.rs
@@ -135,6 +135,7 @@ impl crate::HashEngine for HashEngine {
 
 impl Hash {
     /// Iterate the sha256 algorithm to turn a sha256 hash into a sha256d hash
+    #[must_use]
     pub fn hash_again(&self) -> sha256d::Hash {
         crate::Hash::from_byte_array(<Self as crate::GeneralHash>::hash(&self.0).0)
     }
@@ -202,6 +203,7 @@ impl Midstate {
     ///
     /// Computes non-finalized hash of `sha256(tag) || sha256(tag)` for use in [`sha256t`]. It's
     /// provided for use with [`sha256t`].
+    #[must_use]
     pub const fn hash_tag(tag: &[u8]) -> Self {
         let hash = Hash::hash_unoptimized(tag);
         let mut buf = [0u8; 64];

From 199516b599fa11cfabf64b3e641db9fc162e2496 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 10 Dec 2024 11:00:16 +1100
Subject: [PATCH 058/554] io: Add lint return_self_must_use

Add the lint. No additional clippy warnings are introduced.
---
 io/src/lib.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/io/src/lib.rs b/io/src/lib.rs
index b867be1919..9770f6ce84 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -14,6 +14,8 @@
 // Coding conventions.
 #![warn(missing_docs)]
 #![doc(test(attr(warn(unused))))]
+// Pedantic lints that we enforce.
+#![warn(clippy::return_self_not_must_use)]
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.

From 549be547accdb13037bf3ef60310ca30d045dce0 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 9 Dec 2024 16:50:16 +1100
Subject: [PATCH 059/554] primitives: Add must_use

Enable lint `clippy::return_self_not_must_use` and add attribute
`must_use` as required.

Also run the linter with `clippy::must_use_candidate` enabled and
manually check every warning site.

While we are at it change the current `must_use` usages to have no
message. We can always add a message later if needed.
---
 primitives/src/block.rs           | 1 +
 primitives/src/lib.rs             | 3 +++
 primitives/src/opcodes.rs         | 2 ++
 primitives/src/script/borrowed.rs | 2 +-
 primitives/src/script/owned.rs    | 2 +-
 primitives/src/witness.rs         | 1 +
 6 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index 22d31c9ed6..7736fcf8f0 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -77,6 +77,7 @@ impl Block<Unchecked> {
     /// Ignores block validation logic and just assumes you know what you are doing.
     ///
     /// You should only use this function if you trust the block i.e., it comes from a trusted node.
+    #[must_use]
     pub fn assume_checked(self, witness_root: Option<WitnessMerkleNode>) -> Block<Checked> {
         Block {
             header: self.header,
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index b8a5204de6..f3cd95a7af 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -16,6 +16,9 @@
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
+// Pedantic lints that we enforce.
+// #![warn(clippy::must_use_candidate)]
+#![warn(clippy::return_self_not_must_use)]
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index 498713fe2a..bd922e22c0 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -351,6 +351,7 @@ pub enum ClassifyContext {
 impl Opcode {
     /// Classifies an Opcode into a broad class.
     #[inline]
+    #[must_use]
     pub fn classify(self, ctx: ClassifyContext) -> Class {
         match (self, ctx) {
             // 3 opcodes illegal in all contexts
@@ -424,6 +425,7 @@ impl Opcode {
     ///
     /// Returns `None` if `self` is not a PUSHNUM.
     #[inline]
+    #[must_use]
     pub const fn decode_pushnum(self) -> Option<u8> {
         const START: u8 = OP_PUSHNUM_1.code;
         const END: u8 = OP_PUSHNUM_16.code;
diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index a7ea5e2f09..e8ea04bcd1 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -115,7 +115,7 @@ impl Script {
     pub fn is_empty(&self) -> bool { self.0.is_empty() }
 
     /// Converts a [`Box<Script>`](Box) into a [`ScriptBuf`] without copying or allocating.
-    #[must_use = "`self` will be dropped if the result is not used"]
+    #[must_use]
     pub fn into_script_buf(self: Box<Self>) -> ScriptBuf {
         let rw = Box::into_raw(self) as *mut [u8];
         // SAFETY: copied from `std`
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 2e980afa1c..8b640b1068 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -48,7 +48,7 @@ impl ScriptBuf {
     /// 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"]
+    #[must_use]
     #[inline]
     pub fn into_boxed_script(self) -> Box<Script> {
         // Copied from PathBuf::into_boxed_path
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index 4eb025bf4d..b8f507dc59 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -103,6 +103,7 @@ impl Witness {
     pub fn is_empty(&self) -> bool { self.witness_elements == 0 }
 
     /// Returns a struct implementing [`Iterator`].
+    #[must_use = "returned iterator should be used"]
     pub fn iter(&self) -> Iter {
         Iter { inner: self.content.as_slice(), indices_start: self.indices_start, current_index: 0 }
     }

From 5b3e4ab95b015b5bba5b73db2052cbb63a901466 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 10 Dec 2024 13:46:14 +1100
Subject: [PATCH 060/554] base58ck: Bump version to 0.2.0

In preparation for release add a changelog entry, bump the version, and
update the lock files.
---
 Cargo-minimal.lock  | 2 +-
 Cargo-recent.lock   | 2 +-
 base58/CHANGELOG.md | 9 +++++++++
 base58/Cargo.toml   | 2 +-
 bitcoin/Cargo.toml  | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 4277d220f5..0b63cbb0f6 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -22,7 +22,7 @@ checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
 
 [[package]]
 name = "base58ck"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "bitcoin-internals",
  "bitcoin_hashes 0.15.0",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index 1f12e5e504..cfd4815abf 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -22,7 +22,7 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "base58ck"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "bitcoin-internals",
  "bitcoin_hashes 0.15.0",
diff --git a/base58/CHANGELOG.md b/base58/CHANGELOG.md
index b219fb4776..9bd3876aa3 100644
--- a/base58/CHANGELOG.md
+++ b/base58/CHANGELOG.md
@@ -1,3 +1,12 @@
+# 0.2.0 - 2024-12-10
+
+- Bump MSRV to `1.63` [#3100](https://github.com/rust-bitcoin/rust-bitcoin/pull/3100)
+- Optimize `base58` on small inputs [#3002](https://github.com/rust-bitcoin/rust-bitcoin/pull/3002)
+- Add `alloc` feature [#2996](https://github.com/rust-bitcoin/rust-bitcoin/pull/2996)
+- Remove zeroed vector by pushing front [#3227](https://github.com/rust-bitcoin/rust-bitcoin/pull/3227)
+- Close all errors [#3533](https://github.com/rust-bitcoin/rust-bitcoin/pull/3533)
+- Bump `hex-conservative` to `0.3.0` [#3543](https://github.com/rust-bitcoin/rust-bitcoin/pull/3543)
+
 # 0.1.0 - 2024-03-14
 
 Initial release of the `base58ck` crate. This crate was cut out of
diff --git a/base58/Cargo.toml b/base58/Cargo.toml
index 198b91bf4d..4cc0823013 100644
--- a/base58/Cargo.toml
+++ b/base58/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "base58ck"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index d17b7a7054..955add7e43 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -25,7 +25,7 @@ secp-recovery = ["secp256k1/recovery"]
 arbitrary = ["dep:arbitrary", "units/arbitrary", "primitives/arbitrary"]
 
 [dependencies]
-base58 = { package = "base58ck", version = "0.1.0", default-features = false, features = ["alloc"] }
+base58 = { package = "base58ck", version = "0.2.0", default-features = false, features = ["alloc"] }
 bech32 = { version = "0.11.0", default-features = false, features = ["alloc"] }
 hashes = { package = "bitcoin_hashes", version = "0.15.0", default-features = false, features = ["alloc", "bitcoin-io", "hex"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, features = ["alloc"] }

From 79a229b39115399729bad41db138a71d09b473c3 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 9 Dec 2024 08:57:46 +1100
Subject: [PATCH 061/554] units: Add pedantic lint return_self_not_must_use

As part of the effort to polish the `units` create ready for the 1.0
release; enable the pedantic lint `return_self_not_must_use`.
---
 units/src/amount/mod.rs      | 1 +
 units/src/amount/signed.rs   | 3 +++
 units/src/amount/unsigned.rs | 2 ++
 units/src/lib.rs             | 2 ++
 4 files changed, 8 insertions(+)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 21eb9ed8c8..db027a1915 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -527,6 +527,7 @@ pub struct Display {
 
 impl Display {
     /// Makes subsequent calls to `Display::fmt` display denomination.
+    #[must_use]
     pub fn show_denomination(mut self) -> Self {
         match &mut self.style {
             DisplayStyle::FixedDenomination { show_denomination, .. } => *show_denomination = true,
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 4237ba0bb8..1061a575a2 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -206,6 +206,7 @@ impl SignedAmount {
     // Some arithmetic that doesn't fit in [`core::ops`] traits.
 
     /// Get the absolute value of this [`SignedAmount`].
+    #[must_use]
     pub fn abs(self) -> SignedAmount { SignedAmount(self.0.abs()) }
 
     /// Gets the absolute value of this [`SignedAmount`] returning [`Amount`].
@@ -307,6 +308,7 @@ impl SignedAmount {
     /// # Panics
     ///
     /// On overflow, panics in debug mode, wraps in release mode.
+    #[must_use]
     pub fn unchecked_add(self, rhs: SignedAmount) -> SignedAmount { Self(self.0 + rhs.0) }
 
     /// Unchecked subtraction.
@@ -316,6 +318,7 @@ impl SignedAmount {
     /// # Panics
     ///
     /// On overflow, panics in debug mode, wraps in release mode.
+    #[must_use]
     pub fn unchecked_sub(self, rhs: SignedAmount) -> SignedAmount { Self(self.0 - rhs.0) }
 
     /// Subtraction that doesn't allow negative [`SignedAmount`]s.
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 9b96c4d510..af43e631b3 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -318,6 +318,7 @@ impl Amount {
     /// # Panics
     ///
     /// On overflow, panics in debug mode, wraps in release mode.
+    #[must_use]
     pub fn unchecked_add(self, rhs: Amount) -> Amount { Self(self.0 + rhs.0) }
 
     /// Unchecked subtraction.
@@ -327,6 +328,7 @@ impl Amount {
     /// # Panics
     ///
     /// On overflow, panics in debug mode, wraps in release mode.
+    #[must_use]
     pub fn unchecked_sub(self, rhs: Amount) -> Amount { Self(self.0 - rhs.0) }
 
     /// Converts to a signed amount.
diff --git a/units/src/lib.rs b/units/src/lib.rs
index b9e7e960ac..59bc16205c 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -11,6 +11,8 @@
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
+// Pedantic lints that we enforce.
+#![warn(clippy::return_self_not_must_use)]
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.

From 601a47fb405872c58a9a41d805c204c4d4851e14 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 08:54:16 +1100
Subject: [PATCH 062/554] Add new api text file changes

In a recent PR (#3682) we introduced api text files. Then in another
PR (#3711) we removed `alloc` feature gating. Possibly due to the
timing of running through CI and merging these two PRs managed to get
merged without an update to the API text files.

As would be expected; removing the `alloc` feature gate adds a bunch of
new lines to the `no-features` api text file.
---
 api/primitives/no-features.txt | 199 +++++++++++++++++++++++++++++++++
 1 file changed, 199 insertions(+)

diff --git a/api/primitives/no-features.txt b/api/primitives/no-features.txt
index 0d63cb004f..57a15c9443 100644
--- a/api/primitives/no-features.txt
+++ b/api/primitives/no-features.txt
@@ -1,3 +1,7 @@
+#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleHeightError
+#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleTimeError
+#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleHeightError
+#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleTimeError
 impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
 impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
@@ -14,6 +18,9 @@ impl bitcoin_primitives::block::BlockHash
 impl bitcoin_primitives::block::Header
 impl bitcoin_primitives::block::Version
 impl bitcoin_primitives::block::WitnessCommitment
+impl bitcoin_primitives::locktime::absolute::LockTime
+impl bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl bitcoin_primitives::locktime::relative::LockTime
 impl bitcoin_primitives::merkle_tree::TxMerkleNode
 impl bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl bitcoin_primitives::opcodes::Opcode
@@ -48,6 +55,11 @@ impl core::clone::Clone for bitcoin_primitives::block::BlockHash
 impl core::clone::Clone for bitcoin_primitives::block::Header
 impl core::clone::Clone for bitcoin_primitives::block::Version
 impl core::clone::Clone for bitcoin_primitives::block::WitnessCommitment
+impl core::clone::Clone for bitcoin_primitives::locktime::absolute::LockTime
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::clone::Clone for bitcoin_primitives::locktime::relative::LockTime
 impl core::clone::Clone for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::clone::Clone for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::clone::Clone for bitcoin_primitives::opcodes::Class
@@ -69,6 +81,11 @@ impl core::cmp::Eq for bitcoin_primitives::block::BlockHash
 impl core::cmp::Eq for bitcoin_primitives::block::Header
 impl core::cmp::Eq for bitcoin_primitives::block::Version
 impl core::cmp::Eq for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::Eq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::cmp::Eq for bitcoin_primitives::locktime::relative::LockTime
 impl core::cmp::Eq for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::cmp::Eq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
@@ -109,6 +126,11 @@ impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHash
 impl core::cmp::PartialEq for bitcoin_primitives::block::Header
 impl core::cmp::PartialEq for bitcoin_primitives::block::Version
 impl core::cmp::PartialEq for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::LockTime
 impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
@@ -130,6 +152,8 @@ impl core::cmp::PartialOrd for bitcoin_primitives::block::BlockHash
 impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
 impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
 impl core::cmp::PartialOrd for bitcoin_primitives::block::WitnessCommitment
+impl core::cmp::PartialOrd for bitcoin_primitives::locktime::absolute::LockTime
+impl core::cmp::PartialOrd for bitcoin_primitives::locktime::relative::LockTime
 impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
@@ -176,6 +200,7 @@ impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::tapro
 impl core::convert::From<bitcoin_primitives::block::BlockHash> for bitcoin_hashes::sha256d::Hash
 impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
 impl core::convert::From<bitcoin_primitives::block::WitnessCommitment> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_primitives::locktime::relative::LockTime> for bitcoin_primitives::sequence::Sequence
 impl core::convert::From<bitcoin_primitives::merkle_tree::TxMerkleNode> for bitcoin_hashes::sha256d::Hash
 impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for bitcoin_hashes::sha256d::Hash
 impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
@@ -185,7 +210,13 @@ impl core::convert::From<bitcoin_primitives::taproot::TapNodeHash> for bitcoin_h
 impl core::convert::From<bitcoin_primitives::taproot::TapTweakHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
 impl core::convert::From<bitcoin_primitives::transaction::Txid> for bitcoin_hashes::sha256d::Hash
 impl core::convert::From<bitcoin_primitives::transaction::Wtxid> for bitcoin_hashes::sha256d::Hash
+impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::absolute::Time> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_primitives::locktime::relative::LockTime
+impl core::convert::From<bitcoin_units::locktime::relative::Time> for bitcoin_primitives::locktime::relative::LockTime
 impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
+impl core::convert::TryFrom<&str> for bitcoin_primitives::locktime::absolute::LockTime
+impl core::convert::TryFrom<bitcoin_primitives::sequence::Sequence> for bitcoin_primitives::locktime::relative::LockTime
 impl core::default::Default for bitcoin_primitives::block::Version
 impl core::default::Default for bitcoin_primitives::pow::CompactTarget
 impl core::default::Default for bitcoin_primitives::sequence::Sequence
@@ -196,6 +227,11 @@ impl core::fmt::Debug for bitcoin_primitives::block::BlockHash
 impl core::fmt::Debug for bitcoin_primitives::block::Header
 impl core::fmt::Debug for bitcoin_primitives::block::Version
 impl core::fmt::Debug for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::Debug for bitcoin_primitives::locktime::absolute::LockTime
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::fmt::Debug for bitcoin_primitives::locktime::relative::LockTime
 impl core::fmt::Debug for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::fmt::Debug for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
@@ -212,6 +248,11 @@ impl core::fmt::Debug for bitcoin_primitives::transaction::Version
 impl core::fmt::Debug for bitcoin_primitives::transaction::Wtxid
 impl core::fmt::Display for bitcoin_primitives::block::BlockHash
 impl core::fmt::Display for bitcoin_primitives::block::WitnessCommitment
+impl core::fmt::Display for bitcoin_primitives::locktime::absolute::LockTime
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::fmt::Display for bitcoin_primitives::locktime::relative::LockTime
 impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
@@ -249,6 +290,8 @@ impl core::hash::Hash for bitcoin_primitives::block::BlockHash
 impl core::hash::Hash for bitcoin_primitives::block::Header
 impl core::hash::Hash for bitcoin_primitives::block::Version
 impl core::hash::Hash for bitcoin_primitives::block::WitnessCommitment
+impl core::hash::Hash for bitcoin_primitives::locktime::absolute::LockTime
+impl core::hash::Hash for bitcoin_primitives::locktime::relative::LockTime
 impl core::hash::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::hash::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
@@ -268,6 +311,8 @@ impl core::marker::Copy for bitcoin_primitives::block::BlockHash
 impl core::marker::Copy for bitcoin_primitives::block::Header
 impl core::marker::Copy for bitcoin_primitives::block::Version
 impl core::marker::Copy for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Copy for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Copy for bitcoin_primitives::locktime::relative::LockTime
 impl core::marker::Copy for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::marker::Copy for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::marker::Copy for bitcoin_primitives::opcodes::Class
@@ -289,6 +334,11 @@ impl core::marker::Freeze for bitcoin_primitives::block::BlockHash
 impl core::marker::Freeze for bitcoin_primitives::block::Header
 impl core::marker::Freeze for bitcoin_primitives::block::Version
 impl core::marker::Freeze for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Freeze for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Freeze for bitcoin_primitives::locktime::relative::LockTime
 impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::marker::Freeze for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
@@ -310,6 +360,11 @@ impl core::marker::Send for bitcoin_primitives::block::BlockHash
 impl core::marker::Send for bitcoin_primitives::block::Header
 impl core::marker::Send for bitcoin_primitives::block::Version
 impl core::marker::Send for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Send for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Send for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Send for bitcoin_primitives::locktime::relative::LockTime
 impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::marker::Send for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::marker::Send for bitcoin_primitives::opcodes::Class
@@ -331,6 +386,11 @@ impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHash
 impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
 impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
 impl core::marker::StructuralPartialEq for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::LockTime
 impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
@@ -352,6 +412,11 @@ impl core::marker::Sync for bitcoin_primitives::block::BlockHash
 impl core::marker::Sync for bitcoin_primitives::block::Header
 impl core::marker::Sync for bitcoin_primitives::block::Version
 impl core::marker::Sync for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Sync for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Sync for bitcoin_primitives::locktime::relative::LockTime
 impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::marker::Sync for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::marker::Sync for bitcoin_primitives::opcodes::Class
@@ -373,6 +438,11 @@ impl core::marker::Unpin for bitcoin_primitives::block::BlockHash
 impl core::marker::Unpin for bitcoin_primitives::block::Header
 impl core::marker::Unpin for bitcoin_primitives::block::Version
 impl core::marker::Unpin for bitcoin_primitives::block::WitnessCommitment
+impl core::marker::Unpin for bitcoin_primitives::locktime::absolute::LockTime
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::marker::Unpin for bitcoin_primitives::locktime::relative::LockTime
 impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::marker::Unpin for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
@@ -394,6 +464,11 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Bloc
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::WitnessCommitment
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::LockTime
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Class
@@ -415,6 +490,11 @@ impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHa
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::WitnessCommitment
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::LockTime
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
@@ -434,6 +514,7 @@ impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::V
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Wtxid
 impl core::str::traits::FromStr for bitcoin_primitives::block::BlockHash
 impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
+impl core::str::traits::FromStr for bitcoin_primitives::locktime::absolute::LockTime
 impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
@@ -447,12 +528,22 @@ pub bitcoin_primitives::BlockHeader::nonce: u32
 pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::block::BlockHash
 pub bitcoin_primitives::BlockHeader::time: u32
 pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_primitives::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
 pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
 pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
 pub bitcoin_primitives::block::Header::nonce: u32
 pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::block::BlockHash
 pub bitcoin_primitives::block::Header::time: u32
 pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
+pub bitcoin_primitives::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
+pub bitcoin_primitives::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
+pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
+pub bitcoin_primitives::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
 pub bitcoin_primitives::opcodes::Class::IllegalOp
 pub bitcoin_primitives::opcodes::Class::NoOp
 pub bitcoin_primitives::opcodes::Class::Ordinary(Ordinary)
@@ -462,6 +553,12 @@ pub bitcoin_primitives::opcodes::Class::ReturnOp
 pub bitcoin_primitives::opcodes::Class::SuccessOp
 pub bitcoin_primitives::opcodes::ClassifyContext::Legacy
 pub bitcoin_primitives::opcodes::ClassifyContext::TapScript
+pub bitcoin_primitives::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
+pub bitcoin_primitives::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
+pub bitcoin_primitives::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
+pub bitcoin_primitives::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
 pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
 pub bitcoin_primitives::transaction::OutPoint::vout: u32
 pub const bitcoin_primitives::block::BlockHash::DISPLAY_BACKWARD: bool
@@ -471,6 +568,10 @@ pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
 pub const bitcoin_primitives::block::Version::ONE: Self
 pub const bitcoin_primitives::block::Version::TWO: Self
 pub const bitcoin_primitives::block::WitnessCommitment::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::locktime::absolute::LockTime::SIZE: usize
+pub const bitcoin_primitives::locktime::absolute::LockTime::ZERO: bitcoin_primitives::locktime::absolute::LockTime
+pub const bitcoin_primitives::locktime::relative::LockTime::SIZE: usize
+pub const bitcoin_primitives::locktime::relative::LockTime::ZERO: bitcoin_primitives::locktime::relative::LockTime
 pub const bitcoin_primitives::merkle_tree::TxMerkleNode::DISPLAY_BACKWARD: bool
 pub const bitcoin_primitives::merkle_tree::WitnessMerkleNode::DISPLAY_BACKWARD: bool
 pub const bitcoin_primitives::opcodes::all::OP_0NOTEQUAL: bitcoin_primitives::opcodes::Opcode
@@ -755,6 +856,16 @@ pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
 pub const fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
 pub const fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
 pub const fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_height(&self) -> bool
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_time(&self) -> bool
+pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_height(n: u16) -> Self
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_height(&self) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_time(&self) -> bool
+pub const fn bitcoin_primitives::locktime::relative::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
 pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
 pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
 pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
@@ -778,8 +889,12 @@ pub const fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> <bitc
 pub const fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
 pub const fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
 pub const fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
+pub enum bitcoin_primitives::absolute::LockTime
+pub enum bitcoin_primitives::locktime::absolute::LockTime
+pub enum bitcoin_primitives::locktime::relative::LockTime
 pub enum bitcoin_primitives::opcodes::Class
 pub enum bitcoin_primitives::opcodes::ClassifyContext
+pub enum bitcoin_primitives::relative::LockTime
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
@@ -839,6 +954,50 @@ pub fn bitcoin_primitives::block::WitnessCommitment::from_str(s: &str) -> core::
 pub fn bitcoin_primitives::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_primitives::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::locktime::absolute::LockTime::clone(&self) -> bitcoin_primitives::locktime::absolute::LockTime
+pub fn bitcoin_primitives::locktime::absolute::LockTime::eq(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::Time) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_time(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::locktime::absolute::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::is_satisfied_by(&self, height: bitcoin_units::locktime::absolute::Height, time: bitcoin_units::locktime::absolute::Time) -> bool
+pub fn bitcoin_primitives::locktime::absolute::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::DisabledLockTimeError
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::DisabledLockTimeError) -> bool
+pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleHeightError
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleHeightError) -> bool
+pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleTimeError
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleTimeError) -> bool
+pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::LockTime::clone(&self) -> bitcoin_primitives::locktime::relative::LockTime
+pub fn bitcoin_primitives::locktime::relative::LockTime::eq(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::Height) -> Self
+pub fn bitcoin_primitives::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::Time) -> Self
+pub fn bitcoin_primitives::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::from_sequence(n: bitcoin_primitives::sequence::Sequence) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by_sequence(&self, other: bitcoin_primitives::sequence::Sequence) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self, h: bitcoin_units::locktime::relative::Height, t: bitcoin_units::locktime::relative::Time) -> bool
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
+pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8]
@@ -901,9 +1060,14 @@ pub fn bitcoin_primitives::sequence::Sequence::default() -> Self
 pub fn bitcoin_primitives::sequence::Sequence::enables_absolute_lock_time(&self) -> bool
 pub fn bitcoin_primitives::sequence::Sequence::eq(&self, other: &bitcoin_primitives::sequence::Sequence) -> bool
 pub fn bitcoin_primitives::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::sequence::Sequence::from(lt: bitcoin_primitives::locktime::relative::LockTime) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
 pub fn bitcoin_primitives::sequence::Sequence::from_consensus(n: u32) -> Self
 pub fn bitcoin_primitives::sequence::Sequence::from_height(height: u16) -> Self
+pub fn bitcoin_primitives::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
+pub fn bitcoin_primitives::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub fn bitcoin_primitives::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
+pub fn bitcoin_primitives::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
 pub fn bitcoin_primitives::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_primitives::sequence::Sequence::is_final(&self) -> bool
 pub fn bitcoin_primitives::sequence::Sequence::is_height_locked(&self) -> bool
@@ -912,6 +1076,7 @@ pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> b
 pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
 pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
 pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
 pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
 pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
@@ -1028,11 +1193,16 @@ pub fn bitcoin_primitives::transaction::Wtxid::partial_cmp(&self, other: &bitcoi
 pub fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> Self::Bytes
 pub fn u32::from(sequence: bitcoin_primitives::sequence::Sequence) -> u32
 pub mod bitcoin_primitives
+pub mod bitcoin_primitives::absolute
 pub mod bitcoin_primitives::block
+pub mod bitcoin_primitives::locktime
+pub mod bitcoin_primitives::locktime::absolute
+pub mod bitcoin_primitives::locktime::relative
 pub mod bitcoin_primitives::merkle_tree
 pub mod bitcoin_primitives::opcodes
 pub mod bitcoin_primitives::opcodes::all
 pub mod bitcoin_primitives::pow
+pub mod bitcoin_primitives::relative
 pub mod bitcoin_primitives::sequence
 pub mod bitcoin_primitives::taproot
 pub mod bitcoin_primitives::transaction
@@ -1060,10 +1230,12 @@ pub struct bitcoin_primitives::block::BlockHash(_)
 pub struct bitcoin_primitives::block::Header
 pub struct bitcoin_primitives::block::Version(_)
 pub struct bitcoin_primitives::block::WitnessCommitment(_)
+pub struct bitcoin_primitives::locktime::relative::DisabledLockTimeError(_)
 pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
 pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
 pub struct bitcoin_primitives::opcodes::Opcode
 pub struct bitcoin_primitives::pow::CompactTarget(_)
+pub struct bitcoin_primitives::relative::DisabledLockTimeError(_)
 pub struct bitcoin_primitives::sequence::Sequence(pub u32)
 pub struct bitcoin_primitives::taproot::TapBranchTag
 pub struct bitcoin_primitives::taproot::TapLeafHash(_)
@@ -1079,6 +1251,9 @@ pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d:
 pub type bitcoin_primitives::block::BlockHash::Err = hex_conservative::error::HexToArrayError
 pub type bitcoin_primitives::block::WitnessCommitment::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
 pub type bitcoin_primitives::block::WitnessCommitment::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::locktime::absolute::LockTime::Err = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::locktime::absolute::LockTime::Error = bitcoin_units::parse::ParseIntError
+pub type bitcoin_primitives::locktime::relative::LockTime::Error = bitcoin_primitives::locktime::relative::DisabledLockTimeError
 pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
 pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Err = hex_conservative::error::HexToArrayError
 pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
@@ -1094,5 +1269,29 @@ pub type bitcoin_primitives::transaction::Txid::Err = hex_conservative::error::H
 pub type bitcoin_primitives::transaction::Wtxid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
 pub type bitcoin_primitives::transaction::Wtxid::Err = hex_conservative::error::HexToArrayError
 pub use bitcoin_primitives::Amount
+pub use bitcoin_primitives::BlockHeight
+pub use bitcoin_primitives::BlockInterval
+pub use bitcoin_primitives::FeeRate
 pub use bitcoin_primitives::SignedAmount
+pub use bitcoin_primitives::Weight
+pub use bitcoin_primitives::absolute::ConversionError
+pub use bitcoin_primitives::absolute::Height
+pub use bitcoin_primitives::absolute::LOCK_TIME_THRESHOLD
+pub use bitcoin_primitives::absolute::ParseHeightError
+pub use bitcoin_primitives::absolute::ParseTimeError
+pub use bitcoin_primitives::absolute::Time
 pub use bitcoin_primitives::amount
+pub use bitcoin_primitives::fee_rate
+pub use bitcoin_primitives::locktime::absolute::ConversionError
+pub use bitcoin_primitives::locktime::absolute::Height
+pub use bitcoin_primitives::locktime::absolute::LOCK_TIME_THRESHOLD
+pub use bitcoin_primitives::locktime::absolute::ParseHeightError
+pub use bitcoin_primitives::locktime::absolute::ParseTimeError
+pub use bitcoin_primitives::locktime::absolute::Time
+pub use bitcoin_primitives::locktime::relative::Height
+pub use bitcoin_primitives::locktime::relative::Time
+pub use bitcoin_primitives::locktime::relative::TimeOverflowError
+pub use bitcoin_primitives::relative::Height
+pub use bitcoin_primitives::relative::Time
+pub use bitcoin_primitives::relative::TimeOverflowError
+pub use bitcoin_primitives::weight

From 2fd8614f5d091377f179440b04ec71f4853fd187 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 9 Dec 2024 09:19:12 +1100
Subject: [PATCH 063/554] units: Add additional must_use

Use the `must_use_candidate` clippy lint to find all functions that are
candidates for having `must_use`.

Add `must_use` attribute but exclude obvious functions like `from_`,
`to_`, and `new`.

This patch is subjective.
---
 units/src/amount/signed.rs     | 11 +++++++++++
 units/src/amount/unsigned.rs   |  9 +++++++++
 units/src/fee_rate.rs          |  7 +++++++
 units/src/locktime/relative.rs |  2 ++
 units/src/weight.rs            |  4 ++++
 5 files changed, 33 insertions(+)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 1061a575a2..375ca66533 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -170,6 +170,7 @@ impl SignedAmount {
     }
 
     /// Constructs a new object that implements [`fmt::Display`] using specified denomination.
+    #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
         Display {
             sats_abs: self.unsigned_abs().to_sat(),
@@ -182,6 +183,7 @@ impl SignedAmount {
     ///
     /// This will use BTC for values greater than or equal to 1 BTC and satoshis otherwise. To
     /// avoid confusion the denomination is always shown.
+    #[must_use]
     pub fn display_dynamic(self) -> Display {
         Display {
             sats_abs: self.unsigned_abs().to_sat(),
@@ -210,6 +212,7 @@ impl SignedAmount {
     pub fn abs(self) -> SignedAmount { SignedAmount(self.0.abs()) }
 
     /// Gets the absolute value of this [`SignedAmount`] returning [`Amount`].
+    #[must_use]
     pub fn unsigned_abs(self) -> Amount { Amount::from_sat(self.0.unsigned_abs()) }
 
     /// Returns a number representing sign of this [`SignedAmount`].
@@ -217,6 +220,7 @@ impl SignedAmount {
     /// - `0` if the amount is zero
     /// - `1` if the amount is positive
     /// - `-1` if the amount is negative
+    #[must_use]
     pub fn signum(self) -> i64 { self.0.signum() }
 
     /// Checks if this [`SignedAmount`] is positive.
@@ -236,6 +240,7 @@ impl SignedAmount {
     /// Consider using `unsigned_abs` which is often more practical.
     ///
     /// Returns [`None`] if overflow occurred. (`self == MIN`)
+    #[must_use]
     pub const fn checked_abs(self) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_abs() {
@@ -247,6 +252,7 @@ impl SignedAmount {
     /// Checked addition.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_add(rhs.0) {
@@ -258,6 +264,7 @@ impl SignedAmount {
     /// Checked subtraction.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_sub(rhs.0) {
@@ -269,6 +276,7 @@ impl SignedAmount {
     /// Checked multiplication.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_mul(rhs) {
@@ -282,6 +290,7 @@ impl SignedAmount {
     /// Be aware that integer division loses the remainder if no exact division can be made.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_div(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_div(rhs) {
@@ -293,6 +302,7 @@ impl SignedAmount {
     /// Checked remainder.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_rem(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_rem(rhs) {
@@ -324,6 +334,7 @@ impl SignedAmount {
     /// Subtraction that doesn't allow negative [`SignedAmount`]s.
     ///
     /// Returns [`None`] if either `self`, `rhs` or the result is strictly negative.
+    #[must_use]
     pub fn positive_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
         if self.is_negative() || rhs.is_negative() || rhs > self {
             None
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index af43e631b3..f51ae4af35 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -178,6 +178,7 @@ impl Amount {
     }
 
     /// Constructs a new object that implements [`fmt::Display`] using specified denomination.
+    #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
         Display {
             sats_abs: self.to_sat(),
@@ -190,6 +191,7 @@ impl Amount {
     ///
     /// This will use BTC for values greater than or equal to 1 BTC and satoshis otherwise. To
     /// avoid confusion the denomination is always shown.
+    #[must_use]
     pub fn display_dynamic(self) -> Display {
         Display {
             sats_abs: self.to_sat(),
@@ -216,6 +218,7 @@ impl Amount {
     /// Checked addition.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_add(self, rhs: Amount) -> Option<Amount> {
         // No `map()` in const context.
         match self.0.checked_add(rhs.0) {
@@ -227,6 +230,7 @@ impl Amount {
     /// Checked subtraction.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_sub(self, rhs: Amount) -> Option<Amount> {
         // No `map()` in const context.
         match self.0.checked_sub(rhs.0) {
@@ -238,6 +242,7 @@ impl Amount {
     /// Checked multiplication.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_mul(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
         match self.0.checked_mul(rhs) {
@@ -251,6 +256,7 @@ impl Amount {
     /// Be aware that integer division loses the remainder if no exact division can be made.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_div(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
         match self.0.checked_div(rhs) {
@@ -267,6 +273,7 @@ impl Amount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[cfg(feature = "alloc")]
+    #[must_use]
     pub const fn checked_div_by_weight_ceil(self, rhs: Weight) -> Option<FeeRate> {
         let wu = rhs.to_wu();
         // No `?` operator in const context.
@@ -289,6 +296,7 @@ impl Amount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[cfg(feature = "alloc")]
+    #[must_use]
     pub const fn checked_div_by_weight_floor(self, rhs: Weight) -> Option<FeeRate> {
         // No `?` operator in const context.
         match self.0.checked_mul(1_000) {
@@ -303,6 +311,7 @@ impl Amount {
     /// Checked remainder.
     ///
     /// Returns [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_rem(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
         match self.0.checked_rem(rhs) {
diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index c6f3f76fb1..d6b4c33cb2 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -79,6 +79,7 @@ impl FeeRate {
     /// Checked multiplication.
     ///
     /// Computes `self * rhs` returning [`None`] if overflow occurred.
+    #[must_use]
     pub const fn checked_mul(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.0.checked_mul(rhs) {
@@ -90,6 +91,7 @@ impl FeeRate {
     /// Checked division.
     ///
     /// Computes `self / rhs` returning [`None`] if `rhs == 0`.
+    #[must_use]
     pub const fn checked_div(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.0.checked_div(rhs) {
@@ -106,6 +108,7 @@ impl FeeRate {
     /// rounded down.
     ///
     /// [`None`] is returned if an overflow occurred.
+    #[must_use]
     pub const fn checked_mul_by_weight(self, rhs: Weight) -> Option<Amount> {
         // No `?` operator in const context.
         match self.0.checked_mul(rhs.to_wu()) {
@@ -120,6 +123,7 @@ impl FeeRate {
     /// Checked addition.
     ///
     /// Computes `self + rhs` returning [`None`] if overflow occured.
+    #[must_use]
     pub const fn checked_add(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.0.checked_add(rhs) {
@@ -131,6 +135,7 @@ impl FeeRate {
     /// Checked subtraction.
     ///
     /// Computes `self - rhs` returning [`None`] if overflow occured.
+    #[must_use]
     pub const fn checked_sub(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.0.checked_sub(rhs) {
@@ -143,6 +148,7 @@ impl FeeRate {
     /// if an overflow occurred.
     ///
     /// This is equivalent to `Self::checked_mul_by_weight()`.
+    #[must_use]
     pub fn fee_wu(self, weight: Weight) -> Option<Amount> { self.checked_mul_by_weight(weight) }
 
     /// Calculates the fee by multiplying this fee rate by weight, in virtual bytes, returning [`None`]
@@ -150,6 +156,7 @@ impl FeeRate {
     ///
     /// This is equivalent to converting `vb` to [`Weight`] using [`Weight::from_vb`] and then calling
     /// `Self::fee_wu(weight)`.
+    #[must_use]
     pub fn fee_vb(self, vb: u64) -> Option<Amount> {
         Weight::from_vb(vb).and_then(|w| self.fee_wu(w))
     }
diff --git a/units/src/locktime/relative.rs b/units/src/locktime/relative.rs
index 9b98e38c4e..c0313dc4fc 100644
--- a/units/src/locktime/relative.rs
+++ b/units/src/locktime/relative.rs
@@ -28,6 +28,7 @@ impl Height {
 
     /// Returns the inner `u16` value.
     #[inline]
+    #[must_use]
     pub const fn value(self) -> u16 { self.0 }
 
     /// Returns the `u32` value used to encode this locktime in an nSequence field or
@@ -108,6 +109,7 @@ impl Time {
 
     /// Returns the inner `u16` value.
     #[inline]
+    #[must_use]
     pub const fn value(self) -> u16 { self.0 }
 
     /// Returns the `u32` value used to encode this locktime in an nSequence field or
diff --git a/units/src/weight.rs b/units/src/weight.rs
index 6f72bc6707..4e0b5026d0 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -106,6 +106,7 @@ impl Weight {
     /// Checked addition.
     ///
     /// Computes `self + rhs` returning [`None`] if an overflow occurred.
+    #[must_use]
     pub const fn checked_add(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
         match self.0.checked_add(rhs.0) {
@@ -117,6 +118,7 @@ impl Weight {
     /// Checked subtraction.
     ///
     /// Computes `self - rhs` returning [`None`] if an overflow occurred.
+    #[must_use]
     pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
         match self.0.checked_sub(rhs.0) {
@@ -128,6 +130,7 @@ impl Weight {
     /// Checked multiplication.
     ///
     /// Computes `self * rhs` returning [`None`] if an overflow occurred.
+    #[must_use]
     pub const fn checked_mul(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.0.checked_mul(rhs) {
@@ -139,6 +142,7 @@ impl Weight {
     /// Checked division.
     ///
     /// Computes `self / rhs` returning [`None`] if `rhs == 0`.
+    #[must_use]
     pub const fn checked_div(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.0.checked_div(rhs) {

From adaf4ac086553674803fadfde776d6dd013a7964 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 09:59:40 +1100
Subject: [PATCH 064/554] Set avoid-breaking-exported-api to false

These lints are valuable, lets get at em.

Changes are API breaking but because the changes make functions consume
self for types that are `Copy` downstream should not notice the breaks.
---
 bitcoin/src/bip32.rs                        | 4 ++--
 bitcoin/src/crypto/key.rs                   | 2 +-
 bitcoin/src/crypto/sighash.rs               | 1 +
 bitcoin/src/internal_macros.rs              | 4 ++--
 bitcoin/src/taproot/serialized_signature.rs | 4 ++--
 clippy.toml                                 | 1 +
 primitives/src/locktime/relative.rs         | 4 ++--
 primitives/src/sequence.rs                  | 2 +-
 units/src/block.rs                          | 4 ++--
 units/src/locktime/relative.rs              | 4 ++--
 10 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 34d93833a8..e65195b085 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -605,8 +605,8 @@ impl Xpriv {
     }
 
     /// Constructs a new extended public key from this extended private key.
-    pub fn to_xpub<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> Xpub {
-        Xpub::from_xpriv(secp, self)
+    pub fn to_xpub<C: secp256k1::Signing>(self, secp: &Secp256k1<C>) -> Xpub {
+        Xpub::from_xpriv(secp, &self)
     }
 
     /// Constructs a new BIP340 keypair for Schnorr signatures and Taproot use matching the internal
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 9772f39d40..7d0e3a95c7 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -327,7 +327,7 @@ impl CompressedPublicKey {
     ///
     /// Note that this can be used as a sort key to get BIP67-compliant sorting.
     /// That's why this type doesn't have the `to_sort_key` method - it would duplicate this one.
-    pub fn to_bytes(&self) -> [u8; 33] { self.0.serialize() }
+    pub fn to_bytes(self) -> [u8; 33] { self.0.serialize() }
 
     /// Deserializes a public key from a slice.
     pub fn from_slice(data: &[u8]) -> Result<Self, secp256k1::Error> {
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index ccbac973e5..5934e29348 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1401,6 +1401,7 @@ impl<E> EncodeSigningDataResult<E> {
     ///     // use the hash from `writer`
     /// }
     /// ```
+    #[allow(clippy::wrong_self_convention)] // Consume self so we can take the error.
     pub fn is_sighash_single_bug(self) -> Result<bool, E> {
         match self {
             EncodeSigningDataResult::SighashSingleBug => Ok(true),
diff --git a/bitcoin/src/internal_macros.rs b/bitcoin/src/internal_macros.rs
index dfecac978d..9b97bb9bbc 100644
--- a/bitcoin/src/internal_macros.rs
+++ b/bitcoin/src/internal_macros.rs
@@ -303,7 +303,7 @@ macro_rules! impl_array_newtype {
 
             /// Copies the underlying bytes into a new `Vec`.
             #[inline]
-            pub fn to_vec(&self) -> alloc::vec::Vec<u8> { self.0.to_vec() }
+            pub fn to_vec(self) -> alloc::vec::Vec<u8> { self.0.to_vec() }
 
             /// Returns a slice of the underlying bytes.
             #[inline]
@@ -312,7 +312,7 @@ macro_rules! impl_array_newtype {
             /// Copies the underlying bytes into a new `Vec`.
             #[inline]
             #[deprecated(since = "TBD", note = "use to_vec instead")]
-            pub fn to_bytes(&self) -> alloc::vec::Vec<u8> { self.to_vec() }
+            pub fn to_bytes(self) -> alloc::vec::Vec<u8> { self.to_vec() }
 
             /// Converts the object to a raw pointer.
             #[inline]
diff --git a/bitcoin/src/taproot/serialized_signature.rs b/bitcoin/src/taproot/serialized_signature.rs
index 14cfa22be0..d007306019 100644
--- a/bitcoin/src/taproot/serialized_signature.rs
+++ b/bitcoin/src/taproot/serialized_signature.rs
@@ -155,8 +155,8 @@ impl SerializedSignature {
     /// Convert the serialized signature into the Signature struct.
     /// (This deserializes it)
     #[inline]
-    pub fn to_signature(&self) -> Result<Signature, SigFromSliceError> {
-        Signature::from_slice(self)
+    pub fn to_signature(self) -> Result<Signature, SigFromSliceError> {
+        Signature::from_slice(&self)
     }
 
     /// Constructs a new SerializedSignature from a Signature.
diff --git a/clippy.toml b/clippy.toml
index ddca6b4cb8..0d54166663 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -1,2 +1,3 @@
 msrv = "1.63.0"
 too-many-arguments-threshold = 13
+avoid-breaking-exported-api = false
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index aa5d611187..98b4efe1c2 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -81,7 +81,7 @@ impl LockTime {
     /// Locktimes are not ordered by the natural ordering on `u32`. If you want to
     /// compare locktimes, use [`Self::is_implied_by`] or similar methods.
     #[inline]
-    pub fn to_consensus_u32(&self) -> u32 {
+    pub fn to_consensus_u32(self) -> u32 {
         match self {
             LockTime::Blocks(ref h) => h.to_consensus_u32(),
             LockTime::Time(ref t) => t.to_consensus_u32(),
@@ -99,7 +99,7 @@ impl LockTime {
 
     /// Encodes the locktime as a sequence number.
     #[inline]
-    pub fn to_sequence(&self) -> Sequence { Sequence::from_consensus(self.to_consensus_u32()) }
+    pub fn to_sequence(self) -> Sequence { Sequence::from_consensus(self.to_consensus_u32()) }
 
     /// Constructs a new `LockTime` from `n`, expecting `n` to be a 16-bit count of blocks.
     #[inline]
diff --git a/primitives/src/sequence.rs b/primitives/src/sequence.rs
index a0adab268e..163f70a05e 100644
--- a/primitives/src/sequence.rs
+++ b/primitives/src/sequence.rs
@@ -184,7 +184,7 @@ impl Sequence {
 
     /// Constructs a new [`relative::LockTime`] from this [`Sequence`] number.
     #[inline]
-    pub fn to_relative_lock_time(&self) -> Option<relative::LockTime> {
+    pub fn to_relative_lock_time(self) -> Option<relative::LockTime> {
         use crate::locktime::relative::{Height, LockTime, Time};
 
         if !self.is_relative_lock_time() {
diff --git a/units/src/block.rs b/units/src/block.rs
index aabb4c2ccb..6afa294530 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -47,7 +47,7 @@ impl BlockHeight {
 
     /// Returns block height as a `u32`.
     // Because type inference doesn't always work using `Into`.
-    pub const fn to_u32(&self) -> u32 { self.0 }
+    pub const fn to_u32(self) -> u32 { self.0 }
 }
 
 impl fmt::Display for BlockHeight {
@@ -114,7 +114,7 @@ impl BlockInterval {
 
     /// Returns block interval as a `u32`.
     // Because type inference doesn't always work using `Into`.
-    pub const fn to_u32(&self) -> u32 { self.0 }
+    pub const fn to_u32(self) -> u32 { self.0 }
 }
 
 impl fmt::Display for BlockInterval {
diff --git a/units/src/locktime/relative.rs b/units/src/locktime/relative.rs
index 9b98e38c4e..5b54d9a6d5 100644
--- a/units/src/locktime/relative.rs
+++ b/units/src/locktime/relative.rs
@@ -33,7 +33,7 @@ impl Height {
     /// Returns the `u32` value used to encode this locktime in an nSequence field or
     /// argument to `OP_CHECKSEQUENCEVERIFY`.
     #[inline]
-    pub const fn to_consensus_u32(&self) -> u32 {
+    pub const fn to_consensus_u32(self) -> u32 {
         self.0 as u32 // cast safety: u32 is wider than u16 on all architectures
     }
 }
@@ -113,7 +113,7 @@ impl Time {
     /// Returns the `u32` value used to encode this locktime in an nSequence field or
     /// argument to `OP_CHECKSEQUENCEVERIFY`.
     #[inline]
-    pub const fn to_consensus_u32(&self) -> u32 {
+    pub const fn to_consensus_u32(self) -> u32 {
         (1u32 << 22) | self.0 as u32 // cast safety: u32 is wider than u16 on all architectures
     }
 }

From 4b926e1908f72af98d24cc64d7e1eef44d624e4e Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 10 Dec 2024 15:39:41 +0000
Subject: [PATCH 065/554] Change`MAX and `MIN` to equal `MAX_MONEY`

To prevent rounding errors converting to and from f64 change
`SignedAmount` `MAX` and `MIN` to +/- `MAX_MONEY` which are within the
limit in f64 that has issues.

Add checks to `from_str_in`, `checked_add`,  `checked_sub` and
`checked_mul` that the result is within MIN and MAX.

Modify tests to work with new `MIN` and `MAX`
---
 units/src/amount/signed.rs | 22 +++++++++++++++-------
 units/src/amount/tests.rs  | 13 +++++++++----
 2 files changed, 24 insertions(+), 11 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 4237ba0bb8..0546857990 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -58,9 +58,9 @@ impl SignedAmount {
     /// 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);
+    pub const MIN: SignedAmount = SignedAmount(-21_000_000 * 100_000_000);
     /// The maximum value of an amount.
-    pub const MAX: SignedAmount = SignedAmount(i64::MAX);
+    pub const MAX: SignedAmount = SignedAmount::MAX_MONEY;
 
     /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
     pub const fn from_sat(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
@@ -112,8 +112,7 @@ impl SignedAmount {
                 ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_big(true)),
             )),
             (false, sat) => Ok(SignedAmount(sat as i64)),
-            (true, sat) if sat == i64::MIN.unsigned_abs() => Ok(SignedAmount(i64::MIN)),
-            (true, sat) if sat > i64::MIN.unsigned_abs() => Err(ParseAmountError(
+            (true, sat) if sat > SignedAmount::MIN.to_sat().unsigned_abs() => Err(ParseAmountError(
                 ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_small()),
             )),
             (true, sat) => Ok(SignedAmount(-(sat as i64))),
@@ -249,7 +248,7 @@ impl SignedAmount {
     pub const fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_add(rhs.0) {
-            Some(res) => Some(SignedAmount(res)),
+            Some(res) => SignedAmount(res).check_min_max(),
             None => None,
         }
     }
@@ -260,7 +259,7 @@ impl SignedAmount {
     pub const fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_sub(rhs.0) {
-            Some(res) => Some(SignedAmount(res)),
+            Some(res) => SignedAmount(res).check_min_max(),
             None => None,
         }
     }
@@ -271,7 +270,7 @@ impl SignedAmount {
     pub const fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.0.checked_mul(rhs) {
-            Some(res) => Some(SignedAmount(res)),
+            Some(res) => SignedAmount(res).check_min_max(),
             None => None,
         }
     }
@@ -337,6 +336,15 @@ impl SignedAmount {
             Ok(Amount::from_sat(self.to_sat() as u64))
         }
     }
+
+    /// Checks the amount is within the allowed range.
+    const fn check_min_max(self) -> Option<SignedAmount> {
+        if self.0 < Self::MIN.0 || self.0 > Self::MAX.0 {
+            None
+        } else {
+            Some(self)
+        }
+    }
 }
 
 impl default::Default for SignedAmount {
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 0d6c27a553..b2a0dfac45 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -283,7 +283,7 @@ fn parsing() {
     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)));
     #[cfg(feature = "alloc")]
-    assert_eq!(sp(&i64::MIN.to_string(), sat), Ok(SignedAmount::from_sat(i64::MIN)));
+    assert_eq!(sp(&SignedAmount::MIN.to_sat().to_string(), sat), Ok(SignedAmount::MIN));
     assert_eq!(p("1.1", btc), Ok(Amount::from_sat(1_100_000_00)));
     assert_eq!(p("100", sat), Ok(Amount::from_sat(100)));
     assert_eq!(p("55", sat), Ok(Amount::from_sat(55)));
@@ -571,7 +571,11 @@ fn from_str() {
     scase("-0.1 satoshi", Err(TooPreciseError { position: 3 }));
     case("0.123456 mBTC", Err(TooPreciseError { position: 7 }));
     scase("-1.001 bits", Err(TooPreciseError { position: 5 }));
-    scase("-200000000000 BTC", Err(OutOfRangeError::too_small()));
+    scase("-21000001 BTC", Err(OutOfRangeError::too_small()));
+    scase("21000001 BTC", Err(OutOfRangeError::too_big(true)));
+    scase("-2100000000000001 SAT", Err(OutOfRangeError::too_small()));
+    scase("2100000000000001 SAT", Err(OutOfRangeError::too_big(true)));
+    case("21000001 BTC", Err(OutOfRangeError::too_big(false)));
     case("18446744073709551616 sat", Err(OutOfRangeError::too_big(false)));
 
     ok_case(".5 bits", Amount::from_sat(50));
@@ -580,8 +584,9 @@ fn from_str() {
     ok_scase("-5 satoshi", SignedAmount::from_sat(-5));
     ok_case("0.10000000 BTC", Amount::from_sat(100_000_00));
     ok_scase("-100 bits", SignedAmount::from_sat(-10_000));
-    #[cfg(feature = "alloc")]
-    ok_scase(&format!("{} SAT", i64::MIN), SignedAmount::from_sat(i64::MIN));
+    ok_case("21000000 BTC", Amount::MAX);
+    ok_scase("21000000 BTC", SignedAmount::MAX);
+    ok_scase("-21000000 BTC", SignedAmount::MIN);
 }
 
 #[cfg(feature = "alloc")]

From d1dd63d6d4939c4570ceea206d9c679d66064d3f Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 10:22:35 +1100
Subject: [PATCH 066/554] Remove wildcard in script re-exports

We don't like wildcard re-exports anymore; explicitly re-export the
types from `primitives::script`.
---
 bitcoin/src/blockdata/script/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/script/mod.rs b/bitcoin/src/blockdata/script/mod.rs
index 55947e43a0..5fe1a0ad8a 100644
--- a/bitcoin/src/blockdata/script/mod.rs
+++ b/bitcoin/src/blockdata/script/mod.rs
@@ -81,7 +81,7 @@ pub use self::{
     push_bytes::{PushBytes, PushBytesBuf, PushBytesError, PushBytesErrorReport},
 };
 #[doc(inline)]
-pub use primitives::script::*;
+pub use primitives::script::{Script, ScriptBuf};
 
 pub(crate) use self::borrowed::ScriptExtPriv;
 pub(crate) use self::owned::ScriptBufExtPriv;

From 3855d3cc8398143c0fd11852e91e89b98a8472d5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 10:30:46 +1100
Subject: [PATCH 067/554] Move script hashes to primitives

Woops, this should have been done before v0.101.0 was released.

Move the `ScriptHash` and `WScriptHash` types to `primitives`.

Requires moving constants and error types as well. We re-export the
errors because they are in the `mod.rs` file so they should appear in
both `primitives::script::FooError` and `bitcoin::script::FooError`.
---
 bitcoin/src/blockdata/constants.rs  |   4 +-
 bitcoin/src/blockdata/script/mod.rs | 159 +---------------------------
 primitives/src/script/mod.rs        | 159 ++++++++++++++++++++++++++++
 3 files changed, 164 insertions(+), 158 deletions(-)

diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 6073570e9a..2daa455fe7 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -38,9 +38,9 @@ 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
 /// The maximum allowed redeem script size for a P2SH output.
-pub const MAX_REDEEM_SCRIPT_SIZE: usize = 520;
+pub const MAX_REDEEM_SCRIPT_SIZE: usize = primitives::script::MAX_REDEEM_SCRIPT_SIZE; // 520
 /// The maximum allowed redeem script size of the witness script.
-pub const MAX_WITNESS_SCRIPT_SIZE: usize = 10_000;
+pub const MAX_WITNESS_SCRIPT_SIZE: usize = primitives::script::MAX_WITNESS_SCRIPT_SIZE; // 10_000
 /// The maximum allowed size of any single witness stack element.
 pub const MAX_STACK_ELEMENT_SIZE: usize = 520;
 /// How may blocks between halvings.
diff --git a/bitcoin/src/blockdata/script/mod.rs b/bitcoin/src/blockdata/script/mod.rs
index 5fe1a0ad8a..9f9284cb19 100644
--- a/bitcoin/src/blockdata/script/mod.rs
+++ b/bitcoin/src/blockdata/script/mod.rs
@@ -59,13 +59,11 @@ pub mod witness_version;
 
 use core::fmt;
 
-use hashes::{hash160, sha256};
 use io::{BufRead, Write};
 use primitives::opcodes::all::*;
 use primitives::opcodes::Opcode;
 
 use crate::consensus::{encode, Decodable, Encodable};
-use crate::constants::{MAX_REDEEM_SCRIPT_SIZE, MAX_WITNESS_SCRIPT_SIZE};
 use crate::internal_macros::impl_asref_push_bytes;
 use crate::key::WPubkeyHash;
 use crate::prelude::Vec;
@@ -81,130 +79,15 @@ pub use self::{
     push_bytes::{PushBytes, PushBytesBuf, PushBytesError, PushBytesErrorReport},
 };
 #[doc(inline)]
-pub use primitives::script::{Script, ScriptBuf};
+pub use primitives::script::{
+    RedeemScriptSizeError, Script, ScriptBuf, ScriptHash, WScriptHash, WitnessScriptSizeError,
+};
 
 pub(crate) use self::borrowed::ScriptExtPriv;
 pub(crate) use self::owned::ScriptBufExtPriv;
 
-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);
-}
-
-hashes::impl_hex_for_newtype!(ScriptHash, WScriptHash);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(ScriptHash, WScriptHash);
-
 impl_asref_push_bytes!(ScriptHash, WScriptHash);
 
-impl ScriptHash {
-    /// Constructs a new `ScriptHash` after first checking the script size.
-    ///
-    /// # 520-byte limitation on serialized script size
-    ///
-    /// > As a consequence of the requirement for backwards compatibility the serialized script is
-    /// > itself subject to the same rules as any other PUSHDATA operation, including the rule that
-    /// > no data greater than 520 bytes may be pushed to the stack. Thus it is not possible to
-    /// > spend a P2SH output if the redemption script it refers to is >520 bytes in length.
-    ///
-    /// ref: [BIP-16](https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size)
-    pub fn from_script(redeem_script: &Script) -> Result<Self, RedeemScriptSizeError> {
-        if redeem_script.len() > MAX_REDEEM_SCRIPT_SIZE {
-            return Err(RedeemScriptSizeError { size: redeem_script.len() });
-        }
-
-        Ok(ScriptHash(hash160::Hash::hash(redeem_script.as_bytes())))
-    }
-
-    /// Constructs a new `ScriptHash` from any script irrespective of script size.
-    ///
-    /// If you hash a script that exceeds 520 bytes in size and use it to create a P2SH output
-    /// then the output will be unspendable (see [BIP-16]).
-    ///
-    /// [BIP-16]: <https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size>
-    pub fn from_script_unchecked(script: &Script) -> Self {
-        ScriptHash(hash160::Hash::hash(script.as_bytes()))
-    }
-}
-
-impl WScriptHash {
-    /// Constructs a new `WScriptHash` after first checking the script size.
-    ///
-    /// # 10,000-byte limit on the witness script
-    ///
-    /// > The witnessScript (≤ 10,000 bytes) is popped off the initial witness stack. SHA256 of the
-    /// > witnessScript must match the 32-byte witness program.
-    ///
-    /// ref: [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
-    pub fn from_script(witness_script: &Script) -> Result<Self, WitnessScriptSizeError> {
-        if witness_script.len() > MAX_WITNESS_SCRIPT_SIZE {
-            return Err(WitnessScriptSizeError { size: witness_script.len() });
-        }
-
-        Ok(WScriptHash(sha256::Hash::hash(witness_script.as_bytes())))
-    }
-
-    /// Constructs a new `WScriptHash` from any script irrespective of script size.
-    ///
-    /// If you hash a script that exceeds 10,000 bytes in size and use it to create a Segwit
-    /// output then the output will be unspendable (see [BIP-141]).
-    ///
-    /// ref: [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
-    pub fn from_script_unchecked(script: &Script) -> Self {
-        WScriptHash(sha256::Hash::hash(script.as_bytes()))
-    }
-}
-
-impl TryFrom<ScriptBuf> for ScriptHash {
-    type Error = RedeemScriptSizeError;
-
-    fn try_from(redeem_script: ScriptBuf) -> Result<Self, Self::Error> {
-        Self::from_script(&redeem_script)
-    }
-}
-
-impl TryFrom<&ScriptBuf> for ScriptHash {
-    type Error = RedeemScriptSizeError;
-
-    fn try_from(redeem_script: &ScriptBuf) -> Result<Self, Self::Error> {
-        Self::from_script(redeem_script)
-    }
-}
-
-impl TryFrom<&Script> for ScriptHash {
-    type Error = RedeemScriptSizeError;
-
-    fn try_from(redeem_script: &Script) -> Result<Self, Self::Error> {
-        Self::from_script(redeem_script)
-    }
-}
-
-impl TryFrom<ScriptBuf> for WScriptHash {
-    type Error = WitnessScriptSizeError;
-
-    fn try_from(witness_script: ScriptBuf) -> Result<Self, Self::Error> {
-        Self::from_script(&witness_script)
-    }
-}
-
-impl TryFrom<&ScriptBuf> for WScriptHash {
-    type Error = WitnessScriptSizeError;
-
-    fn try_from(witness_script: &ScriptBuf) -> Result<Self, Self::Error> {
-        Self::from_script(witness_script)
-    }
-}
-
-impl TryFrom<&Script> for WScriptHash {
-    type Error = WitnessScriptSizeError;
-
-    fn try_from(witness_script: &Script) -> Result<Self, Self::Error> {
-        Self::from_script(witness_script)
-    }
-}
-
 /// Constructs a new [`ScriptBuf`] containing the script code used for spending a P2WPKH output.
 ///
 /// The `scriptCode` is described in [BIP143].
@@ -383,39 +266,3 @@ impl std::error::Error for Error {
         }
     }
 }
-
-/// Error while hashing a redeem script.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RedeemScriptSizeError {
-    /// Invalid redeem script size (cannot exceed 520 bytes).
-    pub size: usize,
-}
-
-internals::impl_from_infallible!(RedeemScriptSizeError);
-
-impl fmt::Display for RedeemScriptSizeError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "redeem script size exceeds {} bytes: {}", MAX_REDEEM_SCRIPT_SIZE, self.size)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for RedeemScriptSizeError {}
-
-/// Error while hashing a witness script.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct WitnessScriptSizeError {
-    /// Invalid witness script size (cannot exceed 10,000 bytes).
-    pub size: usize,
-}
-
-internals::impl_from_infallible!(WitnessScriptSizeError);
-
-impl fmt::Display for WitnessScriptSizeError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "witness script size exceeds {} bytes: {}", MAX_WITNESS_SCRIPT_SIZE, self.size)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for WitnessScriptSizeError {}
diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index c06c57c707..2045d01ebf 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -11,6 +11,7 @@ use core::cmp::Ordering;
 use core::fmt;
 use core::ops::{Deref, DerefMut};
 
+use hashes::{hash160, sha256};
 use hex::DisplayHex;
 use internals::script::{self, PushDataLenLen};
 
@@ -28,6 +29,164 @@ pub use self::{
     owned::ScriptBuf,
 };
 
+/// The maximum allowed redeem script size for a P2SH output.
+pub const MAX_REDEEM_SCRIPT_SIZE: usize = 520;
+/// The maximum allowed redeem script size of the witness script.
+pub const MAX_WITNESS_SCRIPT_SIZE: usize = 10_000;
+
+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);
+}
+
+hashes::impl_hex_for_newtype!(ScriptHash, WScriptHash);
+#[cfg(feature = "serde")]
+hashes::impl_serde_for_newtype!(ScriptHash, WScriptHash);
+
+impl ScriptHash {
+    /// Constructs a new `ScriptHash` after first checking the script size.
+    ///
+    /// # 520-byte limitation on serialized script size
+    ///
+    /// > As a consequence of the requirement for backwards compatibility the serialized script is
+    /// > itself subject to the same rules as any other PUSHDATA operation, including the rule that
+    /// > no data greater than 520 bytes may be pushed to the stack. Thus it is not possible to
+    /// > spend a P2SH output if the redemption script it refers to is >520 bytes in length.
+    ///
+    /// ref: [BIP-16](https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size)
+    pub fn from_script(redeem_script: &Script) -> Result<Self, RedeemScriptSizeError> {
+        if redeem_script.len() > MAX_REDEEM_SCRIPT_SIZE {
+            return Err(RedeemScriptSizeError { size: redeem_script.len() });
+        }
+
+        Ok(ScriptHash(hash160::Hash::hash(redeem_script.as_bytes())))
+    }
+
+    /// Constructs a new `ScriptHash` from any script irrespective of script size.
+    ///
+    /// If you hash a script that exceeds 520 bytes in size and use it to create a P2SH output
+    /// then the output will be unspendable (see [BIP-16]).
+    ///
+    /// [BIP-16]: <https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size>
+    pub fn from_script_unchecked(script: &Script) -> Self {
+        ScriptHash(hash160::Hash::hash(script.as_bytes()))
+    }
+}
+
+impl WScriptHash {
+    /// Constructs a new `WScriptHash` after first checking the script size.
+    ///
+    /// # 10,000-byte limit on the witness script
+    ///
+    /// > The witnessScript (≤ 10,000 bytes) is popped off the initial witness stack. SHA256 of the
+    /// > witnessScript must match the 32-byte witness program.
+    ///
+    /// ref: [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    pub fn from_script(witness_script: &Script) -> Result<Self, WitnessScriptSizeError> {
+        if witness_script.len() > MAX_WITNESS_SCRIPT_SIZE {
+            return Err(WitnessScriptSizeError { size: witness_script.len() });
+        }
+
+        Ok(WScriptHash(sha256::Hash::hash(witness_script.as_bytes())))
+    }
+
+    /// Constructs a new `WScriptHash` from any script irrespective of script size.
+    ///
+    /// If you hash a script that exceeds 10,000 bytes in size and use it to create a Segwit
+    /// output then the output will be unspendable (see [BIP-141]).
+    ///
+    /// ref: [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    pub fn from_script_unchecked(script: &Script) -> Self {
+        WScriptHash(sha256::Hash::hash(script.as_bytes()))
+    }
+}
+
+impl TryFrom<ScriptBuf> for ScriptHash {
+    type Error = RedeemScriptSizeError;
+
+    fn try_from(redeem_script: ScriptBuf) -> Result<Self, Self::Error> {
+        Self::from_script(&redeem_script)
+    }
+}
+
+impl TryFrom<&ScriptBuf> for ScriptHash {
+    type Error = RedeemScriptSizeError;
+
+    fn try_from(redeem_script: &ScriptBuf) -> Result<Self, Self::Error> {
+        Self::from_script(redeem_script)
+    }
+}
+
+impl TryFrom<&Script> for ScriptHash {
+    type Error = RedeemScriptSizeError;
+
+    fn try_from(redeem_script: &Script) -> Result<Self, Self::Error> {
+        Self::from_script(redeem_script)
+    }
+}
+
+impl TryFrom<ScriptBuf> for WScriptHash {
+    type Error = WitnessScriptSizeError;
+
+    fn try_from(witness_script: ScriptBuf) -> Result<Self, Self::Error> {
+        Self::from_script(&witness_script)
+    }
+}
+
+impl TryFrom<&ScriptBuf> for WScriptHash {
+    type Error = WitnessScriptSizeError;
+
+    fn try_from(witness_script: &ScriptBuf) -> Result<Self, Self::Error> {
+        Self::from_script(witness_script)
+    }
+}
+
+impl TryFrom<&Script> for WScriptHash {
+    type Error = WitnessScriptSizeError;
+
+    fn try_from(witness_script: &Script) -> Result<Self, Self::Error> {
+        Self::from_script(witness_script)
+    }
+}
+
+/// Error while hashing a redeem script.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RedeemScriptSizeError {
+    /// Invalid redeem script size (cannot exceed 520 bytes).
+    pub size: usize,
+}
+
+internals::impl_from_infallible!(RedeemScriptSizeError);
+
+impl fmt::Display for RedeemScriptSizeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "redeem script size exceeds {} bytes: {}", MAX_REDEEM_SCRIPT_SIZE, self.size)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for RedeemScriptSizeError {}
+
+/// Error while hashing a witness script.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WitnessScriptSizeError {
+    /// Invalid witness script size (cannot exceed 10,000 bytes).
+    pub size: usize,
+}
+
+internals::impl_from_infallible!(WitnessScriptSizeError);
+
+impl fmt::Display for WitnessScriptSizeError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "witness script size exceeds {} bytes: {}", MAX_WITNESS_SCRIPT_SIZE, self.size)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for WitnessScriptSizeError {}
+
 // We keep all the `Script` and `ScriptBuf` impls together since its easier to see side-by-side.
 
 impl From<ScriptBuf> for Box<Script> {

From 38c329c1b7e393b040da02447c5edfe8946c50cf Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 09:58:58 +1100
Subject: [PATCH 068/554] Add additional catagories

Add `no-std` category to the soon-to-be-released leaf crates.
Also add `cryptography` to the `bitcoin_hashes` crate.

Close: #3731
---
 hashes/Cargo.toml     | 2 +-
 internals/Cargo.toml  | 2 +-
 primitives/Cargo.toml | 2 +-
 units/Cargo.toml      | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
index c05e318809..7cdf06300c 100644
--- a/hashes/Cargo.toml
+++ b/hashes/Cargo.toml
@@ -6,7 +6,7 @@ license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin"
 documentation = "https://docs.rs/bitcoin_hashes/"
 description = "Hash functions used by the rust-bitcoin eccosystem"
-categories = ["algorithms"]
+categories = ["algorithms", "cryptography", "no-std"]
 keywords = [ "crypto", "bitcoin", "hash", "digest" ]
 readme = "README.md"
 edition = "2021"
diff --git a/internals/Cargo.toml b/internals/Cargo.toml
index 3682e47971..0b9b6c2520 100644
--- a/internals/Cargo.toml
+++ b/internals/Cargo.toml
@@ -6,7 +6,7 @@ license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
 documentation = "https://docs.rs/bitcoin-internals"
 description = "Internal types and macros used by rust-bitcoin ecosystem"
-categories = ["cryptography::cryptocurrencies"]
+categories = ["cryptography::cryptocurrencies", "no-std"]
 keywords = ["internal"]
 readme = "README.md"
 edition = "2021"
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 486f3fa524..d70d580fb8 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -7,7 +7,7 @@ authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin"
 description = "Primitive types used by the rust-bitcoin ecosystem"
-categories = ["cryptography::cryptocurrencies"]
+categories = ["cryptography::cryptocurrencies", "no-std"]
 keywords = ["bitcoin", "types"]
 readme = "README.md"
 edition = "2021"
diff --git a/units/Cargo.toml b/units/Cargo.toml
index 682307dde2..87871c74ec 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -6,7 +6,7 @@ license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin/"
 description = "Basic Bitcoin numeric units such as amount"
 categories = ["cryptography::cryptocurrencies"]
-keywords = ["bitcoin", "newtypes"]
+keywords = ["bitcoin", "newtypes", "no-std"]
 readme = "README.md"
 edition = "2021"
 rust-version = "1.63.0"

From a2cab6f925530b7e920362149ac4a472abf035c8 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 16:00:05 +1100
Subject: [PATCH 069/554] units: Add _export::_core

As we do in `bitcoin` add a module for usage in macros to prevent naming
clashes if a module called `core` exists.

Overly paranoid yes but this is bitcoin after all.
---
 units/src/lib.rs   |  8 ++++++++
 units/src/parse.rs | 16 ++++++++--------
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/units/src/lib.rs b/units/src/lib.rs
index 59bc16205c..f97bc430ff 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -23,6 +23,14 @@ extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std;
 
+#[doc(hidden)]
+pub mod _export {
+    /// A re-export of core::*
+    pub mod _core {
+        pub use core::*;
+    }
+}
+
 pub mod amount;
 pub mod block;
 pub mod fee_rate;
diff --git a/units/src/parse.rs b/units/src/parse.rs
index a08fd56923..7e436a5a1a 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -88,10 +88,10 @@ pub fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, Par
 macro_rules! impl_tryfrom_str_from_int_infallible {
     ($($from:ty, $to:ident, $inner:ident, $fn:ident);*) => {
         $(
-        impl core::convert::TryFrom<$from> for $to {
+        impl $crate::_export::_core::convert::TryFrom<$from> for $to {
             type Error = $crate::parse::ParseIntError;
 
-            fn try_from(s: $from) -> core::result::Result<Self, Self::Error> {
+            fn try_from(s: $from) -> $crate::_export::_core::result::Result<Self, Self::Error> {
                 $crate::parse::int::<$inner, $from>(s).map($to::$fn)
             }
         }
@@ -110,10 +110,10 @@ macro_rules! impl_parse_str_from_int_infallible {
         #[cfg(feature = "alloc")]
         $crate::impl_tryfrom_str_from_int_infallible!(alloc::string::String, $to, $inner, $fn; alloc::boxed::Box<str>, $to, $inner, $fn);
 
-        impl core::str::FromStr for $to {
+        impl $crate::_export::_core::str::FromStr for $to {
             type Err = $crate::parse::ParseIntError;
 
-            fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
+            fn from_str(s: &str) -> $crate::_export::_core::result::Result<Self, Self::Err> {
                 $crate::parse::int::<$inner, &str>(s).map($to::$fn)
             }
         }
@@ -126,10 +126,10 @@ macro_rules! impl_parse_str_from_int_infallible {
 macro_rules! impl_tryfrom_str {
     ($($from:ty, $to:ty, $err:ty, $inner_fn:expr);*) => {
         $(
-            impl core::convert::TryFrom<$from> for $to {
+            impl $crate::_export::_core::convert::TryFrom<$from> for $to {
                 type Error = $err;
 
-                fn try_from(s: $from) -> core::result::Result<Self, Self::Error> {
+                fn try_from(s: $from) -> $crate::_export::_core::result::Result<Self, Self::Error> {
                     $inner_fn(s)
                 }
             }
@@ -145,10 +145,10 @@ macro_rules! impl_parse_str {
         #[cfg(feature = "alloc")]
         $crate::impl_tryfrom_str!(alloc::string::String, $to, $err, $inner_fn; alloc::boxed::Box<str>, $to, $err, $inner_fn);
 
-        impl core::str::FromStr for $to {
+        impl $crate::_export::_core::str::FromStr for $to {
             type Err = $err;
 
-            fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
+            fn from_str(s: &str) -> $crate::_export::_core::result::Result<Self, Self::Err> {
                 $inner_fn(s)
             }
         }

From f5c2248a31ef6c75319b665e43530cb2cca6c4c4 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 13:34:27 +1100
Subject: [PATCH 070/554] units: Derive Default for BlockInterval

A block interval is a relative thing so it makes sense to default to
zero. This is the same as how we derive `Debug` for `relative::Height`
but not `absolute::Height`.
---
 units/src/block.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/src/block.rs b/units/src/block.rs
index 6afa294530..bdbf886b0e 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -93,7 +93,7 @@ impl TryFrom<BlockHeight> for absolute::Height {
 ///
 /// This type is not meant for constructing relative height based timelocks, this is a general
 /// purpose block interval abstraction. For locktimes please see [`locktime::relative::Height`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 // Public to try and make it really clear that there are no invariants.
 pub struct BlockInterval(pub u32);

From a4a0f2921cd2425fa46a8ade42f888d5268e6709 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 13:35:34 +1100
Subject: [PATCH 071/554] units: Add regression tests for Default impls

Add a regression test to the `api` tests to check the value returned by
`Default` for all types that implement it.
---
 units/tests/api.rs | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/units/tests/api.rs b/units/tests/api.rs
index eb6a9530ee..20746a3a89 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -98,12 +98,13 @@ struct CommonTraits {
 }
 
 /// A struct that includes all types that implement `Default`.
-#[derive(Default)] // C-COMMON-TRAITS: `Default`
+#[derive(Debug, Default, PartialEq, Eq)] // C-COMMON-TRAITS: `Default`
 struct Default {
     a: Amount,
     b: SignedAmount,
-    c: relative::Height,
-    d: relative::Time,
+    c: BlockInterval,
+    d: relative::Height,
+    e: relative::Time,
 }
 
 /// A struct that includes all public error types.
@@ -249,3 +250,16 @@ fn test_sync() {
     assert_sync::<Types>();
     assert_sync::<Errors>();
 }
+
+#[test]
+fn regression_default() {
+    let got: Default = Default::default();
+    let want = Default {
+        a: Amount::ZERO,
+        b: SignedAmount::ZERO,
+        c: BlockInterval::ZERO,
+        d: relative::Height::ZERO,
+        e: relative::Time::ZERO,
+    };
+    assert_eq!(got, want);
+}

From 7725ca77c589a5215c50f1634f1b095d3e268540 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 13:01:05 +1100
Subject: [PATCH 072/554] Rename private module to sealed

There are two `private` modules in `amount` but they do slightly
different things. One provides a private `Token` and one is for trait
sealing. We have various other trait sealing modules in the codebase and
they are all called `sealed` not `private`. Also the seal trait is
called `Sealed`.

Rename the `private` module and the trait to be uniform with the rest of
the codebase.
---
 units/src/amount/mod.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index db027a1915..893b6bcf03 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -563,7 +563,7 @@ enum DisplayStyle {
 }
 
 /// Calculates the sum over the iterator using checked arithmetic.
-pub trait CheckedSum<R>: private::SumSeal<R> {
+pub trait CheckedSum<R>: sealed::Sealed<R> {
     /// Calculates the sum over the iterator using checked arithmetic. If an over or underflow would
     /// happen it returns [`None`].
     fn checked_sum(self) -> Option<R>;
@@ -591,12 +591,12 @@ where
     }
 }
 
-mod private {
+mod sealed {
     use super::{Amount, SignedAmount};
 
     /// Used to seal the `CheckedSum` trait
-    pub trait SumSeal<A> {}
+    pub trait Sealed<A> {}
 
-    impl<T> SumSeal<Amount> for T where T: Iterator<Item = Amount> {}
-    impl<T> SumSeal<SignedAmount> for T where T: Iterator<Item = SignedAmount> {}
+    impl<T> Sealed<Amount> for T where T: Iterator<Item = Amount> {}
+    impl<T> Sealed<SignedAmount> for T where T: Iterator<Item = SignedAmount> {}
 }

From 4cccbfdf7628442cc198f6399846ad4e98938494 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 12:54:55 +1100
Subject: [PATCH 073/554] units: Seal the Integer trait

This trait is an internal thing, users should never implement it.
---
 units/src/parse.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index a08fd56923..923ae9c764 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -52,18 +52,24 @@ impl AsRef<core::num::ParseIntError> for ParseIntError {
 
 /// Not strictly necessary but serves as a lint - avoids weird behavior if someone accidentally
 /// passes non-integer to the `parse()` function.
-pub trait Integer: FromStr<Err = core::num::ParseIntError> + TryFrom<i8> + Sized {}
+pub trait Integer: FromStr<Err = core::num::ParseIntError> + TryFrom<i8> + Sized + sealed::Sealed {}
 
 macro_rules! impl_integer {
     ($($type:ty),* $(,)?) => {
         $(
         impl Integer for $type {}
+        impl sealed::Sealed for $type {}
         )*
     }
 }
 
 impl_integer!(u8, i8, u16, i16, u32, i32, u64, i64, u128, i128);
 
+mod sealed {
+    /// Seals the extension traits.
+    pub trait Sealed {}
+}
+
 /// 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

From 3c8c95651169fb9329ceb380162721c2d2f9b3aa Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 10:50:22 +1100
Subject: [PATCH 074/554] Remove Weight::from_wu_usize function

This constructor is an anomaly in this repo. Also it is ugly to have the
type parameter hard coded in the function name.

The problem the constructor is trying to solve is that we don't like
casts that don't obviously loose data. We have a solution for that
already in `internals::ToU64`. This trait cannot be used in const
contexts though so we do introduce a single cast in this patch.
---
 bitcoin/src/blockdata/block.rs       | 4 ++--
 bitcoin/src/blockdata/transaction.rs | 6 ++++--
 units/src/weight.rs                  | 4 ----
 3 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs
index 88971c6089..f83cb413e7 100644
--- a/bitcoin/src/blockdata/block.rs
+++ b/bitcoin/src/blockdata/block.rs
@@ -10,7 +10,7 @@
 use core::fmt;
 
 use hashes::{sha256d, HashEngine};
-use internals::compact_size;
+use internals::{compact_size, ToU64};
 use io::{BufRead, Write};
 
 use super::Weight;
@@ -263,7 +263,7 @@ impl BlockCheckedExt for Block<Checked> {
     fn weight(&self) -> Weight {
         // This is the exact definition of a weight unit, as defined by BIP-141 (quote above).
         let wu = block_base_size(self.transactions()) * 3 + self.total_size();
-        Weight::from_wu_usize(wu)
+        Weight::from_wu(wu.to_u64())
     }
 
     fn total_size(&self) -> usize {
diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 35c0ff6066..0c49549c40 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -352,7 +352,7 @@ impl TransactionExt for Transaction {
     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)
+        Weight::from_wu(wu.to_u64())
     }
 
     fn base_size(&self) -> usize {
@@ -1151,7 +1151,9 @@ impl InputWeightPrediction {
     ///
     /// See also [`InputWeightPrediction::total_weight`]
     pub const fn witness_weight(&self) -> Weight {
-        Weight::from_wu_usize(self.script_size * 4 + self.witness_size)
+        let wu = self.script_size * 4 + self.witness_size;
+        let wu = wu as u64; // Can't use `ToU64` in const context.
+        Weight::from_wu(wu)
     }
 }
 
diff --git a/units/src/weight.rs b/units/src/weight.rs
index 4e0b5026d0..8c8827df74 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -48,9 +48,6 @@ impl Weight {
     /// Constructs a new [`Weight`] from weight units.
     pub const fn from_wu(wu: u64) -> Self { Weight(wu) }
 
-    /// Constructs a new [`Weight`] from usize weight units.
-    pub const fn from_wu_usize(wu: usize) -> Self { Weight(wu as u64) }
-
     /// Constructs a new [`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) }
 
@@ -254,7 +251,6 @@ mod tests {
     #[test]
     fn weight_constructor() {
         assert_eq!(Weight::ZERO, Weight::from_wu(0));
-        assert_eq!(Weight::ZERO, Weight::from_wu_usize(0_usize));
     }
 
     #[test]

From 60f2089dcdd697b8ab53c9f96b2192ca030237ac Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 11:38:32 +1100
Subject: [PATCH 075/554] Clean up possibly confusing

Put the list of possibly confusing forms in the same order as the enum
and fix the rustdocs to show the actual error variants returned.
---
 units/src/amount/mod.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index db027a1915..93783085e7 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -126,7 +126,7 @@ impl Denomination {
 
 /// 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; 6] = ["MBTC", "Mbtc", "CBTC", "Cbtc", "UBTC", "Ubtc"];
+const CONFUSING_FORMS: [&str; 6] = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"];
 
 impl fmt::Display for Denomination {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(self.as_str()) }
@@ -139,10 +139,9 @@ impl FromStr for Denomination {
     ///
     /// # Errors
     ///
-    /// - If the denomination begins with a capital `M` a [`PossiblyConfusingDenominationError`] is
-    ///   returned.
-    ///
-    /// - If an unknown denomination is used, an [`UnknownDenominationError`] is returned.
+    /// - [`ParseDenominationError::PossiblyConfusing`]: If the denomination begins with a capital
+    ///   letter that could be confused with centi, milli, or micro-bitcoin.
+    /// - [`ParseDenominationError::Unknown`]: If an unknown denomination is used.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         use self::ParseDenominationError::*;
 

From f42f13cd8da6f6d956542498207260edc79c758c Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 11:47:43 +1100
Subject: [PATCH 076/554] Simplify closures in call to fold

Remove unnecessary code comments and make the closure variable names more
terse with no loss of clarity.

Refactor only, no logic changes.
---
 bitcoin/src/blockdata/transaction.rs | 31 ++++++++++------------------
 1 file changed, 11 insertions(+), 20 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 35c0ff6066..4abb83a8a2 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -851,29 +851,20 @@ where
     I: IntoIterator<Item = InputWeightPrediction>,
     O: IntoIterator<Item = usize>,
 {
-    // sum input_weights, input_count and count of inputs with witness data
-    let (input_count, input_weight, inputs_with_witnesses) = inputs.into_iter().fold(
-        (0, 0, 0),
-        |(count, input_weight, inputs_with_witnesses), prediction| {
+    let (input_count, input_weight, inputs_with_witnesses) =
+        inputs.into_iter().fold((0, 0, 0), |(count, weight, with_witnesses), prediction| {
             (
                 count + 1,
-                input_weight + prediction.total_weight().to_wu() as usize,
-                inputs_with_witnesses + (prediction.witness_size > 0) as usize,
+                weight + prediction.total_weight().to_wu() as usize,
+                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 + compact_size::encoded_size(script_len);
-            (output_count + 1, total_scripts_size + script_size)
-        },
-    );
+        });
+
+    let (output_count, output_scripts_size) =
+        output_script_lens.into_iter().fold((0, 0), |(count, scripts_size), script_len| {
+            (count + 1, scripts_size + script_len + compact_size::encoded_size(script_len))
+        });
+
     predict_weight_internal(
         input_count,
         input_weight,

From 0135cddc32462490528dea549fd8db4c0a30646e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 11:56:18 +1100
Subject: [PATCH 077/554] Refactor non_input_size

Looks like the formatter has put code comments in the wrong place.

Refactor the `non_input_size` line so that the formatter does not mess
with it.
---
 bitcoin/src/blockdata/transaction.rs | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 4abb83a8a2..dace1376fd 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -883,15 +883,11 @@ const fn predict_weight_internal(
 ) -> Weight {
     // 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:
-        compact_size::encoded_size_const(input_count as u64) +
-        compact_size::encoded_size_const(output_count as u64) +
-        output_size +
-    // lock_time
-        4;
+    let non_input_size = 4 // version
+        + compact_size::encoded_size_const(input_count as u64) // Can't use ToU64 in const context.
+        + compact_size::encoded_size_const(output_count as u64)
+        + output_size
+        + 4; // locktime
     let weight = if inputs_with_witnesses == 0 {
         non_input_size * 4 + input_weight
     } else {

From 463fbd16f1431febe7e4fc50abd7415886542109 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 14:35:25 +1100
Subject: [PATCH 078/554] Update to arbitrary v1.4

Out with the old in with the new, update to the latest minor version of
arbitrary.

No real reason to do this except that I wanted to add the minor version
instead of using just `1` so that we don't accidentally pull a new minor
version in during a patch release (after we 1.0).
---
 Cargo-minimal.lock    | 4 ++--
 Cargo-recent.lock     | 4 ++--
 bitcoin/Cargo.toml    | 2 +-
 primitives/Cargo.toml | 2 +-
 units/Cargo.toml      | 2 +-
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 0b63cbb0f6..945f3d0912 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -10,9 +10,9 @@ checksum = "08f9b8508dccb7687a1d6c4ce66b2b0ecef467c94667de27d8d7fe1f8d2a9cdc"
 
 [[package]]
 name = "arbitrary"
-version = "1.0.1"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "237430fd6ed3740afe94eefcc278ae21e050285be882804e0d6e8695f0c94691"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
 
 [[package]]
 name = "arrayvec"
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index cfd4815abf..1be64cc076 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -10,9 +10,9 @@ checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
 
 [[package]]
 name = "arbitrary"
-version = "1.3.2"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
 
 [[package]]
 name = "arrayvec"
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index 955add7e43..0429d0a6fd 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -35,7 +35,7 @@ primitives = { package = "bitcoin-primitives", version = "0.101.0", default-feat
 secp256k1 = { version = "0.29.0", default-features = false, features = ["hashes", "alloc"] }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false, features = ["alloc"] }
 
-arbitrary = { version = "1.0.1", optional = true }
+arbitrary = { version = "1.4", optional = true }
 base64 = { version = "0.22.0", optional = true }
 # `bitcoinconsensus` version includes metadata which indicates the version of Core. Use `cargo tree` to see it.
 bitcoinconsensus = { version = "0.106.0", default-features = false, optional = true }
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 486f3fa524..16c2899f5e 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -28,7 +28,7 @@ internals = { package = "bitcoin-internals", version = "0.4.0" }
 io = { package = "bitcoin-io", version = "0.2.0", default-features = false }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false }
 
-arbitrary = { version = "1", optional = true }
+arbitrary = { version = "1.4", optional = true }
 ordered = { version = "0.2.0", optional = true }
 serde = { version = "1.0.103", default-features = false, features = ["derive", "alloc"], optional = true }
 
diff --git a/units/Cargo.toml b/units/Cargo.toml
index 682307dde2..b993a2980d 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -21,7 +21,7 @@ alloc = ["internals/alloc","serde?/alloc"]
 internals = { package = "bitcoin-internals", version = "0.4.0" }
 
 serde = { version = "1.0.103", default-features = false, features = ["derive"], optional = true }
-arbitrary = { version = "1", optional =true }
+arbitrary = { version = "1.4", optional = true }
 
 [dev-dependencies]
 internals = { package = "bitcoin-internals", version = "0.4.0", features = ["test-serde"] }

From 6e01383f162307a573c3454733ccae0596d3eaf6 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 16:28:49 +1100
Subject: [PATCH 079/554] api: Run just check-api

---
 api/primitives/all-features.txt | 176 +++++++++++++++++++++++++++++++-
 api/primitives/alloc-only.txt   | 166 +++++++++++++++++++++++++++++-
 api/primitives/no-features.txt  |   6 +-
 api/units/all-features.txt      |  23 ++++-
 api/units/alloc-only.txt        |   8 +-
 api/units/no-features.txt       |   8 +-
 6 files changed, 366 insertions(+), 21 deletions(-)

diff --git a/api/primitives/all-features.txt b/api/primitives/all-features.txt
index fddc60bcc6..7412ae3dcb 100644
--- a/api/primitives/all-features.txt
+++ b/api/primitives/all-features.txt
@@ -10,6 +10,8 @@ impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
 impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl bitcoin_hashes::Hash for bitcoin_primitives::script::ScriptHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::script::WScriptHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapLeafHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapNodeHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapTweakHash
@@ -35,6 +37,8 @@ impl bitcoin_primitives::opcodes::Opcode
 impl bitcoin_primitives::pow::CompactTarget
 impl bitcoin_primitives::script::Script
 impl bitcoin_primitives::script::ScriptBuf
+impl bitcoin_primitives::script::ScriptHash
+impl bitcoin_primitives::script::WScriptHash
 impl bitcoin_primitives::sequence::Sequence
 impl bitcoin_primitives::taproot::TapLeafHash
 impl bitcoin_primitives::taproot::TapNodeHash
@@ -47,10 +51,12 @@ impl bitcoin_primitives::transaction::Txid
 impl bitcoin_primitives::transaction::Version
 impl bitcoin_primitives::transaction::Wtxid
 impl bitcoin_primitives::witness::Witness
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_primitives::script::ScriptHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::BlockHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::script::WScriptHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
@@ -60,6 +66,8 @@ impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::BlockHash
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::WitnessCommitment
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::ScriptHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::WScriptHash
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapLeafHash
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapNodeHash
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapTweakHash
@@ -84,7 +92,11 @@ impl core::clone::Clone for bitcoin_primitives::opcodes::Class
 impl core::clone::Clone for bitcoin_primitives::opcodes::ClassifyContext
 impl core::clone::Clone for bitcoin_primitives::opcodes::Opcode
 impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
+impl core::clone::Clone for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::clone::Clone for bitcoin_primitives::script::ScriptBuf
+impl core::clone::Clone for bitcoin_primitives::script::ScriptHash
+impl core::clone::Clone for bitcoin_primitives::script::WScriptHash
+impl core::clone::Clone for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::clone::Clone for bitcoin_primitives::sequence::Sequence
 impl core::clone::Clone for bitcoin_primitives::taproot::TapBranchTag
 impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafHash
@@ -118,8 +130,12 @@ impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
 impl core::cmp::Eq for bitcoin_primitives::opcodes::ClassifyContext
 impl core::cmp::Eq for bitcoin_primitives::opcodes::Opcode
 impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Eq for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::cmp::Eq for bitcoin_primitives::script::Script
 impl core::cmp::Eq for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptHash
+impl core::cmp::Eq for bitcoin_primitives::script::WScriptHash
+impl core::cmp::Eq for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::cmp::Eq for bitcoin_primitives::sequence::Sequence
 impl core::cmp::Eq for bitcoin_primitives::taproot::TapBranchTag
 impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafHash
@@ -148,6 +164,8 @@ impl core::cmp::Ord for bitcoin_primitives::opcodes::ClassifyContext
 impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
 impl core::cmp::Ord for bitcoin_primitives::script::Script
 impl core::cmp::Ord for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptHash
+impl core::cmp::Ord for bitcoin_primitives::script::WScriptHash
 impl core::cmp::Ord for bitcoin_primitives::sequence::Sequence
 impl core::cmp::Ord for bitcoin_primitives::taproot::TapBranchTag
 impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafHash
@@ -180,8 +198,12 @@ impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
 impl core::cmp::PartialEq for bitcoin_primitives::opcodes::ClassifyContext
 impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Opcode
 impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialEq for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::cmp::PartialEq for bitcoin_primitives::script::Script
 impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptHash
+impl core::cmp::PartialEq for bitcoin_primitives::script::WScriptHash
+impl core::cmp::PartialEq for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::cmp::PartialEq for bitcoin_primitives::sequence::Sequence
 impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapBranchTag
 impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafHash
@@ -214,6 +236,8 @@ impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
 impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
 impl core::cmp::PartialOrd for bitcoin_primitives::script::Script
 impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptHash
+impl core::cmp::PartialOrd for bitcoin_primitives::script::WScriptHash
 impl core::cmp::PartialOrd for bitcoin_primitives::sequence::Sequence
 impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapBranchTag
 impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafHash
@@ -235,10 +259,12 @@ impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::Script
 impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::ScriptBuf
 impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
 impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsRef<[u8; 20]> for bitcoin_primitives::script::ScriptHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::BlockHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::script::WScriptHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
@@ -250,6 +276,8 @@ impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNod
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::Script
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::WScriptHash
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapLeafHash
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapNodeHash
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapTweakHash
@@ -266,6 +294,8 @@ impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitc
 impl core::convert::From<alloc::vec::Vec<&[u8]>> for bitcoin_primitives::witness::Witness
 impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for bitcoin_primitives::witness::Witness
 impl core::convert::From<alloc::vec::Vec<u8>> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::From<bitcoin_hashes::hash160::Hash> for bitcoin_primitives::script::ScriptHash
+impl core::convert::From<bitcoin_hashes::sha256::Hash> for bitcoin_primitives::script::WScriptHash
 impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::BlockHash
 impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::WitnessCommitment
 impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::TxMerkleNode
@@ -285,6 +315,8 @@ impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for
 impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>
 impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::boxed::Box<bitcoin_primitives::script::Script>
 impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::vec::Vec<u8>
+impl core::convert::From<bitcoin_primitives::script::ScriptHash> for bitcoin_hashes::hash160::Hash
+impl core::convert::From<bitcoin_primitives::script::WScriptHash> for bitcoin_hashes::sha256::Hash
 impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
 impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
 impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_primitives::taproot::TapNodeHash
@@ -298,14 +330,22 @@ impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_
 impl core::convert::From<bitcoin_units::locktime::absolute::Time> for bitcoin_primitives::locktime::absolute::LockTime
 impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_primitives::locktime::relative::LockTime
 impl core::convert::From<bitcoin_units::locktime::relative::Time> for bitcoin_primitives::locktime::relative::LockTime
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::ParseOutPointError
 impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
+impl core::convert::TryFrom<&bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptHash
+impl core::convert::TryFrom<&bitcoin_primitives::script::Script> for bitcoin_primitives::script::WScriptHash
+impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::ScriptHash
+impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::WScriptHash
 impl core::convert::TryFrom<&str> for bitcoin_primitives::locktime::absolute::LockTime
 impl core::convert::TryFrom<&str> for bitcoin_primitives::sequence::Sequence
 impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::locktime::absolute::LockTime
 impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::sequence::Sequence
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::locktime::absolute::LockTime
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::sequence::Sequence
+impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::ScriptHash
+impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::WScriptHash
 impl core::convert::TryFrom<bitcoin_primitives::sequence::Sequence> for bitcoin_primitives::locktime::relative::LockTime
 impl core::default::Default for bitcoin_primitives::block::Version
 impl core::default::Default for bitcoin_primitives::pow::CompactTarget
@@ -318,6 +358,8 @@ impl core::default::Default for bitcoin_primitives::witness::Witness
 impl core::error::Error for bitcoin_primitives::locktime::relative::DisabledLockTimeError
 impl core::error::Error for bitcoin_primitives::locktime::relative::IncompatibleHeightError
 impl core::error::Error for bitcoin_primitives::locktime::relative::IncompatibleTimeError
+impl core::error::Error for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::error::Error for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::error::Error for bitcoin_primitives::transaction::ParseOutPointError
 impl core::fmt::Debug for bitcoin_primitives::block::BlockHash
 impl core::fmt::Debug for bitcoin_primitives::block::Checked
@@ -336,8 +378,12 @@ impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
 impl core::fmt::Debug for bitcoin_primitives::opcodes::ClassifyContext
 impl core::fmt::Debug for bitcoin_primitives::opcodes::Opcode
 impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::Debug for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::fmt::Debug for bitcoin_primitives::script::Script
 impl core::fmt::Debug for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::Debug for bitcoin_primitives::script::ScriptHash
+impl core::fmt::Debug for bitcoin_primitives::script::WScriptHash
+impl core::fmt::Debug for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::fmt::Debug for bitcoin_primitives::sequence::Sequence
 impl core::fmt::Debug for bitcoin_primitives::taproot::TapLeafHash
 impl core::fmt::Debug for bitcoin_primitives::taproot::TapNodeHash
@@ -361,8 +407,12 @@ impl core::fmt::Display for bitcoin_primitives::locktime::relative::LockTime
 impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
+impl core::fmt::Display for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::fmt::Display for bitcoin_primitives::script::Script
 impl core::fmt::Display for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::Display for bitcoin_primitives::script::ScriptHash
+impl core::fmt::Display for bitcoin_primitives::script::WScriptHash
+impl core::fmt::Display for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::fmt::Display for bitcoin_primitives::sequence::Sequence
 impl core::fmt::Display for bitcoin_primitives::taproot::TapLeafHash
 impl core::fmt::Display for bitcoin_primitives::taproot::TapNodeHash
@@ -379,6 +429,8 @@ impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
 impl core::fmt::LowerHex for bitcoin_primitives::script::Script
 impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptHash
+impl core::fmt::LowerHex for bitcoin_primitives::script::WScriptHash
 impl core::fmt::LowerHex for bitcoin_primitives::sequence::Sequence
 impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapLeafHash
 impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapNodeHash
@@ -392,6 +444,8 @@ impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
 impl core::fmt::UpperHex for bitcoin_primitives::script::Script
 impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptHash
+impl core::fmt::UpperHex for bitcoin_primitives::script::WScriptHash
 impl core::fmt::UpperHex for bitcoin_primitives::sequence::Sequence
 impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapLeafHash
 impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapNodeHash
@@ -412,6 +466,8 @@ impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
 impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
 impl core::hash::Hash for bitcoin_primitives::script::Script
 impl core::hash::Hash for bitcoin_primitives::script::ScriptBuf
+impl core::hash::Hash for bitcoin_primitives::script::ScriptHash
+impl core::hash::Hash for bitcoin_primitives::script::WScriptHash
 impl core::hash::Hash for bitcoin_primitives::sequence::Sequence
 impl core::hash::Hash for bitcoin_primitives::taproot::TapBranchTag
 impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafHash
@@ -440,6 +496,8 @@ impl core::marker::Copy for bitcoin_primitives::opcodes::Class
 impl core::marker::Copy for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Copy for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Copy for bitcoin_primitives::script::ScriptHash
+impl core::marker::Copy for bitcoin_primitives::script::WScriptHash
 impl core::marker::Copy for bitcoin_primitives::sequence::Sequence
 impl core::marker::Copy for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafHash
@@ -468,8 +526,12 @@ impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
 impl core::marker::Freeze for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Freeze for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Freeze for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::Freeze for bitcoin_primitives::script::Script
 impl core::marker::Freeze for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptHash
+impl core::marker::Freeze for bitcoin_primitives::script::WScriptHash
+impl core::marker::Freeze for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::Freeze for bitcoin_primitives::sequence::Sequence
 impl core::marker::Freeze for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafHash
@@ -503,8 +565,12 @@ impl core::marker::Send for bitcoin_primitives::opcodes::Class
 impl core::marker::Send for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Send for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Send for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::Send for bitcoin_primitives::script::Script
 impl core::marker::Send for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Send for bitcoin_primitives::script::ScriptHash
+impl core::marker::Send for bitcoin_primitives::script::WScriptHash
+impl core::marker::Send for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::Send for bitcoin_primitives::sequence::Sequence
 impl core::marker::Send for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Send for bitcoin_primitives::taproot::TapLeafHash
@@ -538,8 +604,12 @@ impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
 impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Opcode
 impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::StructuralPartialEq for bitcoin_primitives::script::Script
 impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBuf
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WScriptHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::StructuralPartialEq for bitcoin_primitives::sequence::Sequence
 impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafHash
@@ -573,8 +643,12 @@ impl core::marker::Sync for bitcoin_primitives::opcodes::Class
 impl core::marker::Sync for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Sync for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Sync for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::Sync for bitcoin_primitives::script::Script
 impl core::marker::Sync for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Sync for bitcoin_primitives::script::ScriptHash
+impl core::marker::Sync for bitcoin_primitives::script::WScriptHash
+impl core::marker::Sync for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::Sync for bitcoin_primitives::sequence::Sequence
 impl core::marker::Sync for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafHash
@@ -608,8 +682,12 @@ impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
 impl core::marker::Unpin for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Unpin for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Unpin for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::Unpin for bitcoin_primitives::script::Script
 impl core::marker::Unpin for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptHash
+impl core::marker::Unpin for bitcoin_primitives::script::WScriptHash
+impl core::marker::Unpin for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::Unpin for bitcoin_primitives::sequence::Sequence
 impl core::marker::Unpin for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafHash
@@ -653,8 +731,12 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Cl
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Opcode
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::Script
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBuf
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WScriptHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::sequence::Sequence
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapBranchTag
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafHash
@@ -688,8 +770,12 @@ impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Opcode
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::Script
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBuf
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WScriptHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::sequence::Sequence
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapBranchTag
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafHash
@@ -711,6 +797,8 @@ impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
 impl core::str::traits::FromStr for bitcoin_primitives::locktime::absolute::LockTime
 impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::script::ScriptHash
+impl core::str::traits::FromStr for bitcoin_primitives::script::WScriptHash
 impl core::str::traits::FromStr for bitcoin_primitives::sequence::Sequence
 impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
 impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapNodeHash
@@ -732,6 +820,8 @@ impl serde::ser::Serialize for bitcoin_primitives::opcodes::Opcode
 impl serde::ser::Serialize for bitcoin_primitives::pow::CompactTarget
 impl serde::ser::Serialize for bitcoin_primitives::script::Script
 impl serde::ser::Serialize for bitcoin_primitives::script::ScriptBuf
+impl serde::ser::Serialize for bitcoin_primitives::script::ScriptHash
+impl serde::ser::Serialize for bitcoin_primitives::script::WScriptHash
 impl serde::ser::Serialize for bitcoin_primitives::sequence::Sequence
 impl serde::ser::Serialize for bitcoin_primitives::taproot::TapLeafHash
 impl serde::ser::Serialize for bitcoin_primitives::taproot::TapNodeHash
@@ -784,6 +874,8 @@ impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::merkle_tree::TxMer
 impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::pow::CompactTarget
 impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::ScriptBuf
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::ScriptHash
+impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::WScriptHash
 impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::sequence::Sequence
 impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::taproot::TapLeafHash
 impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::taproot::TapNodeHash
@@ -856,6 +948,8 @@ pub bitcoin_primitives::relative::IncompatibleTimeError::height: bitcoin_units::
 pub bitcoin_primitives::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
 pub bitcoin_primitives::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
 pub bitcoin_primitives::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
+pub bitcoin_primitives::script::RedeemScriptSizeError::size: usize
+pub bitcoin_primitives::script::WitnessScriptSizeError::size: usize
 pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
 pub bitcoin_primitives::transaction::OutPoint::vout: u32
 pub bitcoin_primitives::transaction::ParseOutPointError::Format
@@ -1146,6 +1240,10 @@ pub const bitcoin_primitives::opcodes::all::OP_VERIFY: bitcoin_primitives::opcod
 pub const bitcoin_primitives::opcodes::all::OP_VERNOTIF: bitcoin_primitives::opcodes::Opcode
 pub const bitcoin_primitives::opcodes::all::OP_WITHIN: bitcoin_primitives::opcodes::Opcode
 pub const bitcoin_primitives::opcodes::all::OP_XOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::script::MAX_REDEEM_SCRIPT_SIZE: usize
+pub const bitcoin_primitives::script::MAX_WITNESS_SCRIPT_SIZE: usize
+pub const bitcoin_primitives::script::ScriptHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::script::WScriptHash::DISPLAY_BACKWARD: bool
 pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
 pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
 pub const bitcoin_primitives::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
@@ -1194,6 +1292,12 @@ pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(s
 pub const fn bitcoin_primitives::opcodes::Opcode::decode_pushnum(self) -> core::option::Option<u8>
 pub const fn bitcoin_primitives::opcodes::Opcode::to_u8(self) -> u8
 pub const fn bitcoin_primitives::script::ScriptBuf::new() -> Self
+pub const fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &<bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
 pub const fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
 pub const fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes) -> Self
 pub const fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
@@ -1230,6 +1334,8 @@ pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: alloc:
 pub fn alloc::rc::Rc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
 pub fn alloc::sync::Arc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
 pub fn alloc::vec::Vec<u8>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
+pub fn bitcoin_hashes::hash160::Hash::from(hashtype: bitcoin_primitives::script::ScriptHash) -> bitcoin_hashes::hash160::Hash
+pub fn bitcoin_hashes::sha256::Hash::from(hashtype: bitcoin_primitives::script::WScriptHash) -> bitcoin_hashes::sha256::Hash
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
@@ -1376,8 +1482,8 @@ pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::locktime::relative::LockTime::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
@@ -1443,6 +1549,10 @@ pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoi
 pub fn bitcoin_primitives::pow::CompactTarget::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
 pub fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
 pub fn bitcoin_primitives::pow::CompactTarget::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::clone(&self) -> bitcoin_primitives::script::RedeemScriptSizeError
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::eq(&self, other: &bitcoin_primitives::script::RedeemScriptSizeError) -> bool
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::from(never: core::convert::Infallible) -> Self
 pub fn bitcoin_primitives::script::Script::as_bytes(&self) -> &[u8]
 pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut [u8]
 pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
@@ -1506,6 +1616,56 @@ pub fn bitcoin_primitives::script::ScriptBuf::reserve_exact(&mut self, additiona
 pub fn bitcoin_primitives::script::ScriptBuf::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
 pub fn bitcoin_primitives::script::ScriptBuf::to_hex(&self) -> alloc::string::String
 pub fn bitcoin_primitives::script::ScriptBuf::with_capacity(capacity: usize) -> Self
+pub fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::clone(&self) -> bitcoin_primitives::script::ScriptHash
+pub fn bitcoin_primitives::script::ScriptHash::cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::script::ScriptHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::script::ScriptHash::eq(&self, other: &bitcoin_primitives::script::ScriptHash) -> bool
+pub fn bitcoin_primitives::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin_primitives::script::ScriptHash
+pub fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::script::ScriptHash::from_script(redeem_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, bitcoin_primitives::script::RedeemScriptSizeError>
+pub fn bitcoin_primitives::script::ScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::Script) -> Self
+pub fn bitcoin_primitives::script::ScriptHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::script::ScriptHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::script::ScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::script::WScriptHash::clone(&self) -> bitcoin_primitives::script::WScriptHash
+pub fn bitcoin_primitives::script::WScriptHash::cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::WScriptHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::script::WScriptHash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_primitives::script::WScriptHash::eq(&self, other: &bitcoin_primitives::script::WScriptHash) -> bool
+pub fn bitcoin_primitives::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::WScriptHash::from(inner: bitcoin_hashes::sha256::Hash) -> bitcoin_primitives::script::WScriptHash
+pub fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::script::WScriptHash::from_script(witness_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, bitcoin_primitives::script::WitnessScriptSizeError>
+pub fn bitcoin_primitives::script::WScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::Script) -> Self
+pub fn bitcoin_primitives::script::WScriptHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::script::WScriptHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::script::WScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::WScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::WScriptHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::clone(&self) -> bitcoin_primitives::script::WitnessScriptSizeError
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::eq(&self, other: &bitcoin_primitives::script::WitnessScriptSizeError) -> bool
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::from(never: core::convert::Infallible) -> Self
 pub fn bitcoin_primitives::sequence::Sequence::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_primitives::sequence::Sequence::clone(&self) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::sequence::Sequence::cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::cmp::Ordering
@@ -1533,7 +1693,7 @@ pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoi
 pub fn bitcoin_primitives::sequence::Sequence::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
 pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
 pub fn bitcoin_primitives::sequence::Sequence::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
@@ -1794,7 +1954,11 @@ pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
 pub struct bitcoin_primitives::opcodes::Opcode
 pub struct bitcoin_primitives::pow::CompactTarget(_)
 pub struct bitcoin_primitives::relative::DisabledLockTimeError(_)
+pub struct bitcoin_primitives::script::RedeemScriptSizeError
 pub struct bitcoin_primitives::script::ScriptBuf(_)
+pub struct bitcoin_primitives::script::ScriptHash(_)
+pub struct bitcoin_primitives::script::WScriptHash(_)
+pub struct bitcoin_primitives::script::WitnessScriptSizeError
 pub struct bitcoin_primitives::sequence::Sequence(pub u32)
 pub struct bitcoin_primitives::taproot::TapBranchTag
 pub struct bitcoin_primitives::taproot::TapLeafHash(_)
@@ -1829,6 +1993,12 @@ pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Err = hex_conservat
 pub type bitcoin_primitives::script::Script::Output = bitcoin_primitives::script::Script
 pub type bitcoin_primitives::script::Script::Owned = bitcoin_primitives::script::ScriptBuf
 pub type bitcoin_primitives::script::ScriptBuf::Target = bitcoin_primitives::script::Script
+pub type bitcoin_primitives::script::ScriptHash::Bytes = <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::script::ScriptHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::script::ScriptHash::Error = bitcoin_primitives::script::RedeemScriptSizeError
+pub type bitcoin_primitives::script::WScriptHash::Bytes = <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::script::WScriptHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::script::WScriptHash::Error = bitcoin_primitives::script::WitnessScriptSizeError
 pub type bitcoin_primitives::sequence::Sequence::Err = bitcoin_units::parse::ParseIntError
 pub type bitcoin_primitives::sequence::Sequence::Error = bitcoin_units::parse::ParseIntError
 pub type bitcoin_primitives::taproot::TapLeafHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
diff --git a/api/primitives/alloc-only.txt b/api/primitives/alloc-only.txt
index 02441de462..3e0f4d2b6c 100644
--- a/api/primitives/alloc-only.txt
+++ b/api/primitives/alloc-only.txt
@@ -10,6 +10,8 @@ impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
 impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl bitcoin_hashes::Hash for bitcoin_primitives::script::ScriptHash
+impl bitcoin_hashes::Hash for bitcoin_primitives::script::WScriptHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapLeafHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapNodeHash
 impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapTweakHash
@@ -35,6 +37,8 @@ impl bitcoin_primitives::opcodes::Opcode
 impl bitcoin_primitives::pow::CompactTarget
 impl bitcoin_primitives::script::Script
 impl bitcoin_primitives::script::ScriptBuf
+impl bitcoin_primitives::script::ScriptHash
+impl bitcoin_primitives::script::WScriptHash
 impl bitcoin_primitives::sequence::Sequence
 impl bitcoin_primitives::taproot::TapLeafHash
 impl bitcoin_primitives::taproot::TapNodeHash
@@ -47,10 +51,12 @@ impl bitcoin_primitives::transaction::Txid
 impl bitcoin_primitives::transaction::Version
 impl bitcoin_primitives::transaction::Wtxid
 impl bitcoin_primitives::witness::Witness
+impl core::borrow::Borrow<[u8; 20]> for bitcoin_primitives::script::ScriptHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::BlockHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::script::WScriptHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
 impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
@@ -60,6 +66,8 @@ impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::BlockHash
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::WitnessCommitment
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::ScriptHash
+impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::WScriptHash
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapLeafHash
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapNodeHash
 impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapTweakHash
@@ -84,7 +92,11 @@ impl core::clone::Clone for bitcoin_primitives::opcodes::Class
 impl core::clone::Clone for bitcoin_primitives::opcodes::ClassifyContext
 impl core::clone::Clone for bitcoin_primitives::opcodes::Opcode
 impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
+impl core::clone::Clone for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::clone::Clone for bitcoin_primitives::script::ScriptBuf
+impl core::clone::Clone for bitcoin_primitives::script::ScriptHash
+impl core::clone::Clone for bitcoin_primitives::script::WScriptHash
+impl core::clone::Clone for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::clone::Clone for bitcoin_primitives::sequence::Sequence
 impl core::clone::Clone for bitcoin_primitives::taproot::TapBranchTag
 impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafHash
@@ -118,8 +130,12 @@ impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
 impl core::cmp::Eq for bitcoin_primitives::opcodes::ClassifyContext
 impl core::cmp::Eq for bitcoin_primitives::opcodes::Opcode
 impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::Eq for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::cmp::Eq for bitcoin_primitives::script::Script
 impl core::cmp::Eq for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::Eq for bitcoin_primitives::script::ScriptHash
+impl core::cmp::Eq for bitcoin_primitives::script::WScriptHash
+impl core::cmp::Eq for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::cmp::Eq for bitcoin_primitives::sequence::Sequence
 impl core::cmp::Eq for bitcoin_primitives::taproot::TapBranchTag
 impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafHash
@@ -148,6 +164,8 @@ impl core::cmp::Ord for bitcoin_primitives::opcodes::ClassifyContext
 impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
 impl core::cmp::Ord for bitcoin_primitives::script::Script
 impl core::cmp::Ord for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::Ord for bitcoin_primitives::script::ScriptHash
+impl core::cmp::Ord for bitcoin_primitives::script::WScriptHash
 impl core::cmp::Ord for bitcoin_primitives::sequence::Sequence
 impl core::cmp::Ord for bitcoin_primitives::taproot::TapBranchTag
 impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafHash
@@ -180,8 +198,12 @@ impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
 impl core::cmp::PartialEq for bitcoin_primitives::opcodes::ClassifyContext
 impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Opcode
 impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::cmp::PartialEq for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::cmp::PartialEq for bitcoin_primitives::script::Script
 impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptHash
+impl core::cmp::PartialEq for bitcoin_primitives::script::WScriptHash
+impl core::cmp::PartialEq for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::cmp::PartialEq for bitcoin_primitives::sequence::Sequence
 impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapBranchTag
 impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafHash
@@ -214,6 +236,8 @@ impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
 impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
 impl core::cmp::PartialOrd for bitcoin_primitives::script::Script
 impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptBuf
+impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptHash
+impl core::cmp::PartialOrd for bitcoin_primitives::script::WScriptHash
 impl core::cmp::PartialOrd for bitcoin_primitives::sequence::Sequence
 impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapBranchTag
 impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafHash
@@ -235,10 +259,12 @@ impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::Script
 impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::ScriptBuf
 impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
 impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsRef<[u8; 20]> for bitcoin_primitives::script::ScriptHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::BlockHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::script::WScriptHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
 impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
@@ -250,6 +276,8 @@ impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNod
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::Script
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptHash
+impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::WScriptHash
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapLeafHash
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapNodeHash
 impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapTweakHash
@@ -266,6 +294,8 @@ impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitc
 impl core::convert::From<alloc::vec::Vec<&[u8]>> for bitcoin_primitives::witness::Witness
 impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for bitcoin_primitives::witness::Witness
 impl core::convert::From<alloc::vec::Vec<u8>> for bitcoin_primitives::script::ScriptBuf
+impl core::convert::From<bitcoin_hashes::hash160::Hash> for bitcoin_primitives::script::ScriptHash
+impl core::convert::From<bitcoin_hashes::sha256::Hash> for bitcoin_primitives::script::WScriptHash
 impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::BlockHash
 impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::WitnessCommitment
 impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::TxMerkleNode
@@ -285,6 +315,8 @@ impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for
 impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>
 impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::boxed::Box<bitcoin_primitives::script::Script>
 impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::vec::Vec<u8>
+impl core::convert::From<bitcoin_primitives::script::ScriptHash> for bitcoin_hashes::hash160::Hash
+impl core::convert::From<bitcoin_primitives::script::WScriptHash> for bitcoin_hashes::sha256::Hash
 impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
 impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
 impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_primitives::taproot::TapNodeHash
@@ -298,14 +330,22 @@ impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_
 impl core::convert::From<bitcoin_units::locktime::absolute::Time> for bitcoin_primitives::locktime::absolute::LockTime
 impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_primitives::locktime::relative::LockTime
 impl core::convert::From<bitcoin_units::locktime::relative::Time> for bitcoin_primitives::locktime::relative::LockTime
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::RedeemScriptSizeError
+impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::ParseOutPointError
 impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
+impl core::convert::TryFrom<&bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptHash
+impl core::convert::TryFrom<&bitcoin_primitives::script::Script> for bitcoin_primitives::script::WScriptHash
+impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::ScriptHash
+impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::WScriptHash
 impl core::convert::TryFrom<&str> for bitcoin_primitives::locktime::absolute::LockTime
 impl core::convert::TryFrom<&str> for bitcoin_primitives::sequence::Sequence
 impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::locktime::absolute::LockTime
 impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::sequence::Sequence
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::locktime::absolute::LockTime
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::sequence::Sequence
+impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::ScriptHash
+impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::WScriptHash
 impl core::convert::TryFrom<bitcoin_primitives::sequence::Sequence> for bitcoin_primitives::locktime::relative::LockTime
 impl core::default::Default for bitcoin_primitives::block::Version
 impl core::default::Default for bitcoin_primitives::pow::CompactTarget
@@ -332,8 +372,12 @@ impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
 impl core::fmt::Debug for bitcoin_primitives::opcodes::ClassifyContext
 impl core::fmt::Debug for bitcoin_primitives::opcodes::Opcode
 impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
+impl core::fmt::Debug for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::fmt::Debug for bitcoin_primitives::script::Script
 impl core::fmt::Debug for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::Debug for bitcoin_primitives::script::ScriptHash
+impl core::fmt::Debug for bitcoin_primitives::script::WScriptHash
+impl core::fmt::Debug for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::fmt::Debug for bitcoin_primitives::sequence::Sequence
 impl core::fmt::Debug for bitcoin_primitives::taproot::TapLeafHash
 impl core::fmt::Debug for bitcoin_primitives::taproot::TapNodeHash
@@ -357,8 +401,12 @@ impl core::fmt::Display for bitcoin_primitives::locktime::relative::LockTime
 impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
+impl core::fmt::Display for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::fmt::Display for bitcoin_primitives::script::Script
 impl core::fmt::Display for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::Display for bitcoin_primitives::script::ScriptHash
+impl core::fmt::Display for bitcoin_primitives::script::WScriptHash
+impl core::fmt::Display for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::fmt::Display for bitcoin_primitives::sequence::Sequence
 impl core::fmt::Display for bitcoin_primitives::taproot::TapLeafHash
 impl core::fmt::Display for bitcoin_primitives::taproot::TapNodeHash
@@ -375,6 +423,8 @@ impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
 impl core::fmt::LowerHex for bitcoin_primitives::script::Script
 impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptHash
+impl core::fmt::LowerHex for bitcoin_primitives::script::WScriptHash
 impl core::fmt::LowerHex for bitcoin_primitives::sequence::Sequence
 impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapLeafHash
 impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapNodeHash
@@ -388,6 +438,8 @@ impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
 impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
 impl core::fmt::UpperHex for bitcoin_primitives::script::Script
 impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptBuf
+impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptHash
+impl core::fmt::UpperHex for bitcoin_primitives::script::WScriptHash
 impl core::fmt::UpperHex for bitcoin_primitives::sequence::Sequence
 impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapLeafHash
 impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapNodeHash
@@ -408,6 +460,8 @@ impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
 impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
 impl core::hash::Hash for bitcoin_primitives::script::Script
 impl core::hash::Hash for bitcoin_primitives::script::ScriptBuf
+impl core::hash::Hash for bitcoin_primitives::script::ScriptHash
+impl core::hash::Hash for bitcoin_primitives::script::WScriptHash
 impl core::hash::Hash for bitcoin_primitives::sequence::Sequence
 impl core::hash::Hash for bitcoin_primitives::taproot::TapBranchTag
 impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafHash
@@ -436,6 +490,8 @@ impl core::marker::Copy for bitcoin_primitives::opcodes::Class
 impl core::marker::Copy for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Copy for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Copy for bitcoin_primitives::script::ScriptHash
+impl core::marker::Copy for bitcoin_primitives::script::WScriptHash
 impl core::marker::Copy for bitcoin_primitives::sequence::Sequence
 impl core::marker::Copy for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafHash
@@ -464,8 +520,12 @@ impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
 impl core::marker::Freeze for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Freeze for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Freeze for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::Freeze for bitcoin_primitives::script::Script
 impl core::marker::Freeze for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Freeze for bitcoin_primitives::script::ScriptHash
+impl core::marker::Freeze for bitcoin_primitives::script::WScriptHash
+impl core::marker::Freeze for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::Freeze for bitcoin_primitives::sequence::Sequence
 impl core::marker::Freeze for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafHash
@@ -499,8 +559,12 @@ impl core::marker::Send for bitcoin_primitives::opcodes::Class
 impl core::marker::Send for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Send for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Send for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::Send for bitcoin_primitives::script::Script
 impl core::marker::Send for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Send for bitcoin_primitives::script::ScriptHash
+impl core::marker::Send for bitcoin_primitives::script::WScriptHash
+impl core::marker::Send for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::Send for bitcoin_primitives::sequence::Sequence
 impl core::marker::Send for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Send for bitcoin_primitives::taproot::TapLeafHash
@@ -534,8 +598,12 @@ impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
 impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Opcode
 impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::StructuralPartialEq for bitcoin_primitives::script::Script
 impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBuf
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WScriptHash
+impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::StructuralPartialEq for bitcoin_primitives::sequence::Sequence
 impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafHash
@@ -569,8 +637,12 @@ impl core::marker::Sync for bitcoin_primitives::opcodes::Class
 impl core::marker::Sync for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Sync for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Sync for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::Sync for bitcoin_primitives::script::Script
 impl core::marker::Sync for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Sync for bitcoin_primitives::script::ScriptHash
+impl core::marker::Sync for bitcoin_primitives::script::WScriptHash
+impl core::marker::Sync for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::Sync for bitcoin_primitives::sequence::Sequence
 impl core::marker::Sync for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafHash
@@ -604,8 +676,12 @@ impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
 impl core::marker::Unpin for bitcoin_primitives::opcodes::ClassifyContext
 impl core::marker::Unpin for bitcoin_primitives::opcodes::Opcode
 impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
+impl core::marker::Unpin for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::marker::Unpin for bitcoin_primitives::script::Script
 impl core::marker::Unpin for bitcoin_primitives::script::ScriptBuf
+impl core::marker::Unpin for bitcoin_primitives::script::ScriptHash
+impl core::marker::Unpin for bitcoin_primitives::script::WScriptHash
+impl core::marker::Unpin for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::marker::Unpin for bitcoin_primitives::sequence::Sequence
 impl core::marker::Unpin for bitcoin_primitives::taproot::TapBranchTag
 impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafHash
@@ -649,8 +725,12 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Cl
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Opcode
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::Script
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBuf
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WScriptHash
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::sequence::Sequence
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapBranchTag
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafHash
@@ -684,8 +764,12 @@ impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Opcode
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::Script
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBuf
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WScriptHash
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::sequence::Sequence
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapBranchTag
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafHash
@@ -707,6 +791,8 @@ impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
 impl core::str::traits::FromStr for bitcoin_primitives::locktime::absolute::LockTime
 impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
 impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
+impl core::str::traits::FromStr for bitcoin_primitives::script::ScriptHash
+impl core::str::traits::FromStr for bitcoin_primitives::script::WScriptHash
 impl core::str::traits::FromStr for bitcoin_primitives::sequence::Sequence
 impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
 impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapNodeHash
@@ -788,6 +874,8 @@ pub bitcoin_primitives::relative::IncompatibleTimeError::height: bitcoin_units::
 pub bitcoin_primitives::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
 pub bitcoin_primitives::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
 pub bitcoin_primitives::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
+pub bitcoin_primitives::script::RedeemScriptSizeError::size: usize
+pub bitcoin_primitives::script::WitnessScriptSizeError::size: usize
 pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
 pub bitcoin_primitives::transaction::OutPoint::vout: u32
 pub bitcoin_primitives::transaction::ParseOutPointError::Format
@@ -1078,6 +1166,10 @@ pub const bitcoin_primitives::opcodes::all::OP_VERIFY: bitcoin_primitives::opcod
 pub const bitcoin_primitives::opcodes::all::OP_VERNOTIF: bitcoin_primitives::opcodes::Opcode
 pub const bitcoin_primitives::opcodes::all::OP_WITHIN: bitcoin_primitives::opcodes::Opcode
 pub const bitcoin_primitives::opcodes::all::OP_XOR: bitcoin_primitives::opcodes::Opcode
+pub const bitcoin_primitives::script::MAX_REDEEM_SCRIPT_SIZE: usize
+pub const bitcoin_primitives::script::MAX_WITNESS_SCRIPT_SIZE: usize
+pub const bitcoin_primitives::script::ScriptHash::DISPLAY_BACKWARD: bool
+pub const bitcoin_primitives::script::WScriptHash::DISPLAY_BACKWARD: bool
 pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
 pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
 pub const bitcoin_primitives::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
@@ -1126,6 +1218,12 @@ pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(s
 pub const fn bitcoin_primitives::opcodes::Opcode::decode_pushnum(self) -> core::option::Option<u8>
 pub const fn bitcoin_primitives::opcodes::Opcode::to_u8(self) -> u8
 pub const fn bitcoin_primitives::script::ScriptBuf::new() -> Self
+pub const fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &<bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
+pub const fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
+pub const fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
 pub const fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
 pub const fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes) -> Self
 pub const fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
@@ -1161,6 +1259,8 @@ pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: alloc:
 pub fn alloc::rc::Rc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
 pub fn alloc::sync::Arc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
 pub fn alloc::vec::Vec<u8>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
+pub fn bitcoin_hashes::hash160::Hash::from(hashtype: bitcoin_primitives::script::ScriptHash) -> bitcoin_hashes::hash160::Hash
+pub fn bitcoin_hashes::sha256::Hash::from(hashtype: bitcoin_primitives::script::WScriptHash) -> bitcoin_hashes::sha256::Hash
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
 pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
@@ -1287,8 +1387,8 @@ pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self,
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
@@ -1347,6 +1447,10 @@ pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&se
 pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
 pub fn bitcoin_primitives::pow::CompactTarget::to_hex(&self) -> alloc::string::String
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::clone(&self) -> bitcoin_primitives::script::RedeemScriptSizeError
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::eq(&self, other: &bitcoin_primitives::script::RedeemScriptSizeError) -> bool
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::RedeemScriptSizeError::from(never: core::convert::Infallible) -> Self
 pub fn bitcoin_primitives::script::Script::as_bytes(&self) -> &[u8]
 pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut [u8]
 pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
@@ -1406,6 +1510,52 @@ pub fn bitcoin_primitives::script::ScriptBuf::reserve(&mut self, additional_len:
 pub fn bitcoin_primitives::script::ScriptBuf::reserve_exact(&mut self, additional_len: usize)
 pub fn bitcoin_primitives::script::ScriptBuf::to_hex(&self) -> alloc::string::String
 pub fn bitcoin_primitives::script::ScriptBuf::with_capacity(capacity: usize) -> Self
+pub fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8; 20]
+pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8; 20]
+pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::script::ScriptHash::clone(&self) -> bitcoin_primitives::script::ScriptHash
+pub fn bitcoin_primitives::script::ScriptHash::cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::ScriptHash::eq(&self, other: &bitcoin_primitives::script::ScriptHash) -> bool
+pub fn bitcoin_primitives::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::ScriptHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin_primitives::script::ScriptHash
+pub fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::script::ScriptHash::from_script(redeem_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, bitcoin_primitives::script::RedeemScriptSizeError>
+pub fn bitcoin_primitives::script::ScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::Script) -> Self
+pub fn bitcoin_primitives::script::ScriptHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::script::ScriptHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::script::ScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::ScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &Self::Bytes
+pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8]
+pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8; 32]
+pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8]
+pub fn bitcoin_primitives::script::WScriptHash::clone(&self) -> bitcoin_primitives::script::WScriptHash
+pub fn bitcoin_primitives::script::WScriptHash::cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::cmp::Ordering
+pub fn bitcoin_primitives::script::WScriptHash::eq(&self, other: &bitcoin_primitives::script::WScriptHash) -> bool
+pub fn bitcoin_primitives::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::WScriptHash::from(inner: bitcoin_hashes::sha256::Hash) -> bitcoin_primitives::script::WScriptHash
+pub fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: Self::Bytes) -> Self
+pub fn bitcoin_primitives::script::WScriptHash::from_script(witness_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, bitcoin_primitives::script::WitnessScriptSizeError>
+pub fn bitcoin_primitives::script::WScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::Script) -> Self
+pub fn bitcoin_primitives::script::WScriptHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::script::WScriptHash, bitcoin_hashes::error::FromSliceError>
+pub fn bitcoin_primitives::script::WScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
+pub fn bitcoin_primitives::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
+pub fn bitcoin_primitives::script::WScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> Self::Bytes
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::clone(&self) -> bitcoin_primitives::script::WitnessScriptSizeError
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::eq(&self, other: &bitcoin_primitives::script::WitnessScriptSizeError) -> bool
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_primitives::script::WitnessScriptSizeError::from(never: core::convert::Infallible) -> Self
 pub fn bitcoin_primitives::sequence::Sequence::clone(&self) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::sequence::Sequence::cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::cmp::Ordering
 pub fn bitcoin_primitives::sequence::Sequence::default() -> Self
@@ -1430,7 +1580,7 @@ pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
 pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
 pub fn bitcoin_primitives::sequence::Sequence::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
@@ -1661,7 +1811,11 @@ pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
 pub struct bitcoin_primitives::opcodes::Opcode
 pub struct bitcoin_primitives::pow::CompactTarget(_)
 pub struct bitcoin_primitives::relative::DisabledLockTimeError(_)
+pub struct bitcoin_primitives::script::RedeemScriptSizeError
 pub struct bitcoin_primitives::script::ScriptBuf(_)
+pub struct bitcoin_primitives::script::ScriptHash(_)
+pub struct bitcoin_primitives::script::WScriptHash(_)
+pub struct bitcoin_primitives::script::WitnessScriptSizeError
 pub struct bitcoin_primitives::sequence::Sequence(pub u32)
 pub struct bitcoin_primitives::taproot::TapBranchTag
 pub struct bitcoin_primitives::taproot::TapLeafHash(_)
@@ -1696,6 +1850,12 @@ pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Err = hex_conservat
 pub type bitcoin_primitives::script::Script::Output = bitcoin_primitives::script::Script
 pub type bitcoin_primitives::script::Script::Owned = bitcoin_primitives::script::ScriptBuf
 pub type bitcoin_primitives::script::ScriptBuf::Target = bitcoin_primitives::script::Script
+pub type bitcoin_primitives::script::ScriptHash::Bytes = <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::script::ScriptHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::script::ScriptHash::Error = bitcoin_primitives::script::RedeemScriptSizeError
+pub type bitcoin_primitives::script::WScriptHash::Bytes = <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
+pub type bitcoin_primitives::script::WScriptHash::Err = hex_conservative::error::HexToArrayError
+pub type bitcoin_primitives::script::WScriptHash::Error = bitcoin_primitives::script::WitnessScriptSizeError
 pub type bitcoin_primitives::sequence::Sequence::Err = bitcoin_units::parse::ParseIntError
 pub type bitcoin_primitives::sequence::Sequence::Error = bitcoin_units::parse::ParseIntError
 pub type bitcoin_primitives::taproot::TapLeafHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
diff --git a/api/primitives/no-features.txt b/api/primitives/no-features.txt
index 57a15c9443..a73f56a8fd 100644
--- a/api/primitives/no-features.txt
+++ b/api/primitives/no-features.txt
@@ -995,8 +995,8 @@ pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self,
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
@@ -1076,7 +1076,7 @@ pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> b
 pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
 pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
 pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
 pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
 pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 60e32f3243..d75534c5d0 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -699,9 +699,9 @@ pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoi
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
 pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
@@ -720,12 +720,12 @@ pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) ->
 pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
 pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
 pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
 pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
@@ -756,6 +756,7 @@ pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core:
 pub fn bitcoin_units::Amount::default() -> Self
 pub fn bitcoin_units::Amount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::Amount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::Amount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
@@ -779,6 +780,8 @@ pub fn bitcoin_units::Amount::ser_btc<S: serde::ser::Serializer>(self, s: S, _:
 pub fn bitcoin_units::Amount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::sub_assign(&mut self, other: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
@@ -801,6 +804,7 @@ pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmou
 pub fn bitcoin_units::SignedAmount::default() -> Self
 pub fn bitcoin_units::SignedAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::SignedAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::SignedAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
@@ -827,6 +831,8 @@ pub fn bitcoin_units::SignedAmount::ser_btc<S: serde::ser::Serializer>(self, s:
 pub fn bitcoin_units::SignedAmount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::signum(self) -> i64
 pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, other: bitcoin_units::SignedAmount)
@@ -909,10 +915,13 @@ pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mu
 pub fn bitcoin_units::amount::error::UnknownDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
 pub fn bitcoin_units::amount::serde::SerdeAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::type_prefix(_: private::Token) -> &'static str
 pub fn bitcoin_units::amount::serde::as_btc::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::as_btc::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
@@ -922,6 +931,10 @@ pub fn bitcoin_units::amount::serde::as_sat::deserialize<'d, A: bitcoin_units::a
 pub fn bitcoin_units::amount::serde::as_sat::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::as_sat::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::as_sat::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::as_str::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::as_str::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::as_str::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::as_str::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
 pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
 pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
@@ -1132,6 +1145,8 @@ pub mod bitcoin_units::amount::serde::as_btc
 pub mod bitcoin_units::amount::serde::as_btc::opt
 pub mod bitcoin_units::amount::serde::as_sat
 pub mod bitcoin_units::amount::serde::as_sat::opt
+pub mod bitcoin_units::amount::serde::as_str
+pub mod bitcoin_units::amount::serde::as_str::opt
 pub mod bitcoin_units::block
 pub mod bitcoin_units::fee_rate
 pub mod bitcoin_units::locktime
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 0555c7d432..21cc554a19 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -657,9 +657,9 @@ pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoi
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
 pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
@@ -678,12 +678,12 @@ pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) ->
 pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
 pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
 pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
 pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index cf4fddd59b..638a07add3 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -639,9 +639,9 @@ pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoi
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
 pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
@@ -660,12 +660,12 @@ pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) ->
 pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
 pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
 pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
 pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>

From 8576d194af25dc8ea0be0d576cfc318da6019482 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 16:30:47 +1100
Subject: [PATCH 080/554] api: Run just check-api

---
 api/primitives/all-features.txt |  6 +++---
 api/primitives/alloc-only.txt   |  6 +++---
 api/primitives/no-features.txt  |  6 +++---
 api/units/all-features.txt      | 23 +++++++++++++++++++----
 api/units/alloc-only.txt        |  8 ++++----
 api/units/no-features.txt       |  8 ++++----
 6 files changed, 36 insertions(+), 21 deletions(-)

diff --git a/api/primitives/all-features.txt b/api/primitives/all-features.txt
index fddc60bcc6..4a06de070d 100644
--- a/api/primitives/all-features.txt
+++ b/api/primitives/all-features.txt
@@ -1376,8 +1376,8 @@ pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::locktime::relative::LockTime::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
@@ -1533,7 +1533,7 @@ pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoi
 pub fn bitcoin_primitives::sequence::Sequence::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
 pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
 pub fn bitcoin_primitives::sequence::Sequence::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
diff --git a/api/primitives/alloc-only.txt b/api/primitives/alloc-only.txt
index 02441de462..f88885219a 100644
--- a/api/primitives/alloc-only.txt
+++ b/api/primitives/alloc-only.txt
@@ -1287,8 +1287,8 @@ pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self,
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
@@ -1430,7 +1430,7 @@ pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
 pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
 pub fn bitcoin_primitives::sequence::Sequence::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
diff --git a/api/primitives/no-features.txt b/api/primitives/no-features.txt
index 57a15c9443..a73f56a8fd 100644
--- a/api/primitives/no-features.txt
+++ b/api/primitives/no-features.txt
@@ -995,8 +995,8 @@ pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self,
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
 pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(&self) -> bitcoin_primitives::sequence::Sequence
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
+pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
 pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
@@ -1076,7 +1076,7 @@ pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> b
 pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
 pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(&self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
+pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
 pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
 pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
 pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 60e32f3243..d75534c5d0 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -699,9 +699,9 @@ pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoi
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
 pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
@@ -720,12 +720,12 @@ pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) ->
 pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
 pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
 pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
 pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
@@ -756,6 +756,7 @@ pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core:
 pub fn bitcoin_units::Amount::default() -> Self
 pub fn bitcoin_units::Amount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::Amount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::Amount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
@@ -779,6 +780,8 @@ pub fn bitcoin_units::Amount::ser_btc<S: serde::ser::Serializer>(self, s: S, _:
 pub fn bitcoin_units::Amount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::sub_assign(&mut self, other: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
@@ -801,6 +804,7 @@ pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmou
 pub fn bitcoin_units::SignedAmount::default() -> Self
 pub fn bitcoin_units::SignedAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::SignedAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::SignedAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
@@ -827,6 +831,8 @@ pub fn bitcoin_units::SignedAmount::ser_btc<S: serde::ser::Serializer>(self, s:
 pub fn bitcoin_units::SignedAmount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::signum(self) -> i64
 pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, other: bitcoin_units::SignedAmount)
@@ -909,10 +915,13 @@ pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mu
 pub fn bitcoin_units::amount::error::UnknownDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
 pub fn bitcoin_units::amount::serde::SerdeAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::type_prefix(_: private::Token) -> &'static str
 pub fn bitcoin_units::amount::serde::as_btc::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::as_btc::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
@@ -922,6 +931,10 @@ pub fn bitcoin_units::amount::serde::as_sat::deserialize<'d, A: bitcoin_units::a
 pub fn bitcoin_units::amount::serde::as_sat::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::as_sat::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::as_sat::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::as_str::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::as_str::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::as_str::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::as_str::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
 pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
 pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
@@ -1132,6 +1145,8 @@ pub mod bitcoin_units::amount::serde::as_btc
 pub mod bitcoin_units::amount::serde::as_btc::opt
 pub mod bitcoin_units::amount::serde::as_sat
 pub mod bitcoin_units::amount::serde::as_sat::opt
+pub mod bitcoin_units::amount::serde::as_str
+pub mod bitcoin_units::amount::serde::as_str::opt
 pub mod bitcoin_units::block
 pub mod bitcoin_units::fee_rate
 pub mod bitcoin_units::locktime
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 0555c7d432..21cc554a19 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -657,9 +657,9 @@ pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoi
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
 pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
@@ -678,12 +678,12 @@ pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) ->
 pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
 pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
 pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
 pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index cf4fddd59b..638a07add3 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -639,9 +639,9 @@ pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoi
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
 pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(&self) -> u32
+pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
@@ -660,12 +660,12 @@ pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) ->
 pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
 pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
 pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
 pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
 pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(&self) -> u32
+pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
 pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>

From 55092aab47051e740c1ee43de73e367a2f9299a3 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 12:30:34 +1100
Subject: [PATCH 081/554] Use Self in amount consts

Currently the consts in the `amount` modules repeat the type. For
`Amount` this isn't a big deal but for `SignedAmount` its quite noisy.

Use `Self` as the type in const declarations inside `Amount` and
`SignedAmount`.

Internal change, no logic changes.
---
 units/src/amount/signed.rs   | 12 ++++++------
 units/src/amount/unsigned.rs | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index d88905dbae..af714b1676 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -50,17 +50,17 @@ pub struct SignedAmount(i64);
 
 impl SignedAmount {
     /// The zero amount.
-    pub const ZERO: SignedAmount = SignedAmount(0);
+    pub const ZERO: Self = SignedAmount(0);
     /// Exactly one satoshi.
-    pub const ONE_SAT: SignedAmount = SignedAmount(1);
+    pub const ONE_SAT: Self = SignedAmount(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: SignedAmount = SignedAmount(100_000_000);
+    pub const ONE_BTC: Self = 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);
+    pub const MAX_MONEY: Self = SignedAmount(21_000_000 * 100_000_000);
     /// The minimum value of an amount.
-    pub const MIN: SignedAmount = SignedAmount(-21_000_000 * 100_000_000);
+    pub const MIN: Self = SignedAmount(-21_000_000 * 100_000_000);
     /// The maximum value of an amount.
-    pub const MAX: SignedAmount = SignedAmount::MAX_MONEY;
+    pub const MAX: Self = SignedAmount::MAX_MONEY;
 
     /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
     pub const fn from_sat(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index f51ae4af35..9040fa1686 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -55,17 +55,17 @@ pub struct Amount(u64);
 
 impl Amount {
     /// The zero amount.
-    pub const ZERO: Amount = Amount(0);
+    pub const ZERO: Self = Amount(0);
     /// Exactly one satoshi.
-    pub const ONE_SAT: Amount = Amount(1);
+    pub const ONE_SAT: Self = Amount(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Amount = Self::from_int_btc_const(1);
+    pub const ONE_BTC: Self = Self::from_int_btc_const(1);
     /// The maximum value allowed as an amount. Useful for sanity checking.
-    pub const MAX_MONEY: Amount = Self::from_int_btc_const(21_000_000);
+    pub const MAX_MONEY: Self = Self::from_int_btc_const(21_000_000);
     /// The minimum value of an amount.
-    pub const MIN: Amount = Amount::ZERO;
+    pub const MIN: Self = Amount::ZERO;
     /// The maximum value of an amount.
-    pub const MAX: Amount = Amount::MAX_MONEY;
+    pub const MAX: Self = Amount::MAX_MONEY;
     /// The number of bytes that an amount contributes to the size of a transaction.
     pub const SIZE: usize = 8; // Serialized length of a u64.
 

From 99e2a9f530eced69e9df1441e15d24e626974385 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 13:30:54 +1100
Subject: [PATCH 082/554] Remove unnecessary rustdocs

The `deprecated` attribute already fully explains the status of a
deprecated function and the replacement - no need to repeat this.
---
 bitcoin/src/blockdata/transaction.rs | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 35c0ff6066..b7709c5d12 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -213,23 +213,14 @@ fn size_from_script_pubkey(script_pubkey: &Script) -> usize {
 /// Extension functionality for the [`Transaction`] type.
 pub trait TransactionExt: sealed::Sealed {
     /// Computes a "normalized TXID" which does not include any signatures.
-    ///
-    /// This method is deprecated.  `ntxid` has been renamed to `compute_ntxid` to note that it's
-    /// computationally expensive.  Use `compute_ntxid` instead.
     #[deprecated(since = "0.31.0", note = "use `compute_ntxid()` instead")]
     fn ntxid(&self) -> sha256d::Hash;
 
     /// Computes the [`Txid`].
-    ///
-    /// This method is deprecated.  `txid` has been renamed to `compute_txid` to note that it's
-    /// computationally expensive.  Use `compute_txid` instead.
     #[deprecated(since = "0.31.0", note = "use `compute_txid()` instead")]
     fn txid(&self) -> Txid;
 
     /// Computes the segwit version of the transaction id.
-    ///
-    /// This method is deprecated.  `wtxid` has been renamed to `compute_wtxid` to note that it's
-    /// computationally expensive.  Use `compute_wtxid` instead.
     #[deprecated(since = "0.31.0", note = "use `compute_wtxid()` instead")]
     fn wtxid(&self) -> Wtxid;
 

From 870bd491238f7549700231eb777d6a31bca5beea Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 13:22:12 +1100
Subject: [PATCH 083/554] readme: Fix the MSRV link

The link is broken, has the wrong date in it.
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index bf66bc65fc..d51dcd37b7 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@
     <a href="https://github.com/rust-bitcoin/rust-bitcoin/blob/master/LICENSE"><img alt="CC0 1.0 Universal Licensed" src="https://img.shields.io/badge/license-CC0--1.0-blue.svg"/></a>
     <a href="https://github.com/rust-bitcoin/rust-bitcoin/actions?query=workflow%3AContinuous%20integration"><img alt="CI Status" src="https://github.com/rust-bitcoin/rust-bitcoin/workflows/Continuous%20integration/badge.svg"></a>
     <a href="https://docs.rs/bitcoin"><img alt="API Docs" src="https://img.shields.io/badge/docs.rs-bitcoin-green"/></a>
-    <a href="https://blog.rust-lang.org/2021/11/01/Rust-1.63.0.html"><img alt="Rustc Version 1.63.0+" src="https://img.shields.io/badge/rustc-1.63.0%2B-lightgrey.svg"/></a>
+    <a href="https://blog.rust-lang.org/2022/08/11/Rust-1.63.0.html"><img alt="Rustc Version 1.63.0+" src="https://img.shields.io/badge/rustc-1.63.0%2B-lightgrey.svg"/></a>
     <a href="https://gnusha.org/bitcoin-rust/"><img alt="Chat on IRC" src="https://img.shields.io/badge/irc-%23bitcoin--rust%20on%20libera.chat-blue"></a>
     <a href="https://github.com/model-checking/kani"><img alt="kani" src="https://github.com/rust-bitcoin/rust-bitcoin/workflows/Kani%20CI/badge.svg"></a>
   </p>

From 3ac9b2ded24d5428945538c0a674301f6094df96 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 13:15:15 +1100
Subject: [PATCH 084/554] Remove unnecessary type

`hex_psbt` returns `Psbt`, no need for the explicit type.

Internal change only.
---
 bitcoin/src/psbt/mod.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 6de326a1dc..be385433e4 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -1300,7 +1300,7 @@ mod tests {
 
     #[test]
     fn psbt_uncompressed_key() {
-        let psbt: Psbt = hex_psbt("70736274ff01003302000000010000000000000000000000000000000000000000000000000000000000000000ffffffff00ffffffff000000000000420204bb0d5d0cca36e7b9c80f63bc04c1240babb83bcd2803ef7ac8b6e2af594291daec281e856c98d210c5ab14dfd5828761f8ee7d5f45ca21ad3e4c4b41b747a3a047304402204f67e2afb76142d44fae58a2495d33a3419daa26cd0db8d04f3452b63289ac0f022010762a9fb67e94cc5cad9026f6dc99ff7f070f4278d30fbc7d0c869dd38c7fe70100").unwrap();
+        let 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);
@@ -1455,7 +1455,7 @@ mod tests {
     #[test]
     fn deserialize_and_serialize_psbt_with_two_partial_sigs() {
         let hex = "70736274ff0100890200000001207ae985d787dfe6143d5c58fad79cc7105e0e799fcf033b7f2ba17e62d7b3200000000000ffffffff02563d03000000000022002019899534b9a011043c0dd57c3ff9a381c3522c5f27c6a42319085b56ca543a1d6adc020000000000220020618b47a07ebecca4e156edb1b9ea7c24bdee0139fc049237965ffdaf56d5ee73000000000001012b801a0600000000002200201148e93e9315e37dbed2121be5239257af35adc03ffdfc5d914b083afa44dab82202025fe7371376d53cf8a2783917c28bf30bd690b0a4d4a207690093ca2b920ee076473044022007e06b362e89912abd4661f47945430739b006a85d1b2a16c01dc1a4bd07acab022061576d7aa834988b7ab94ef21d8eebd996ea59ea20529a19b15f0c9cebe3d8ac01220202b3fe93530020a8294f0e527e33fbdff184f047eb6b5a1558a352f62c29972f8a473044022002787f926d6817504431ee281183b8119b6845bfaa6befae45e13b6d430c9d2f02202859f149a6cd26ae2f03a107e7f33c7d91730dade305fe077bae677b5d44952a01010547522102b3fe93530020a8294f0e527e33fbdff184f047eb6b5a1558a352f62c29972f8a21025fe7371376d53cf8a2783917c28bf30bd690b0a4d4a207690093ca2b920ee07652ae0001014752210283ef76537f2d58ae3aa3a4bd8ae41c3f230ccadffb1a0bd3ca504d871cff05e7210353d79cc0cb1396f4ce278d005f16d948e02a6aec9ed1109f13747ecb1507b37b52ae00010147522102b3937241777b6665e0d694e52f9c1b188433641df852da6fc42187b5d8a368a321034cdd474f01cc5aa7ff834ad8bcc882a87e854affc775486bc2a9f62e8f49bd7852ae00";
-        let psbt: Psbt = hex_psbt(hex).unwrap();
+        let psbt = hex_psbt(hex).unwrap();
         assert_eq!(hex, psbt.serialize_hex());
     }
 
@@ -1747,7 +1747,7 @@ mod tests {
 
         #[test]
         fn valid_vector_2() {
-            let psbt: Psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac000000000001076a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa882920001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000").unwrap();
+            let psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac000000000001076a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa882920001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000").unwrap();
 
             assert_eq!(psbt.inputs.len(), 2);
             assert_eq!(psbt.outputs.len(), 2);
@@ -1772,7 +1772,7 @@ mod tests {
 
         #[test]
         fn valid_vector_3() {
-            let psbt: Psbt = hex_psbt("70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000001030401000000000000").unwrap();
+            let psbt = hex_psbt("70736274ff0100750200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf60000000000feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e1300000100fda5010100000000010289a3c71eab4d20e0371bbba4cc698fa295c9463afa2e397f8533ccb62f9567e50100000017160014be18d152a9b012039daf3da7de4f53349eecb985ffffffff86f8aa43a71dff1448893a530a7237ef6b4608bbb2dd2d0171e63aec6a4890b40100000017160014fe3e9ef1a745e974d902c4355943abcb34bd5353ffffffff0200c2eb0b000000001976a91485cff1097fd9e008bb34af709c62197b38978a4888ac72fef84e2c00000017a914339725ba21efd62ac753a9bcd067d6c7a6a39d05870247304402202712be22e0270f394f568311dc7ca9a68970b8025fdd3b240229f07f8a5f3a240220018b38d7dcd314e734c9276bd6fb40f673325bc4baa144c800d2f2f02db2765c012103d2e15674941bad4a996372cb87e1856d3652606d98562fe39c5e9e7e413f210502483045022100d12b852d85dcd961d2f5f4ab660654df6eedcc794c0c33ce5cc309ffb5fce58d022067338a8e0e1725c197fb1a88af59f51e44e4255b20167c8684031c05d1f2592a01210223b72beef0965d10be0778efecd61fcac6f79a4ea169393380734464f84f2ab30000000001030401000000000000").unwrap();
 
             assert_eq!(psbt.inputs.len(), 1);
             assert_eq!(psbt.outputs.len(), 2);
@@ -1792,7 +1792,7 @@ mod tests {
 
         #[test]
         fn valid_vector_4() {
-            let psbt: Psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000100df0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e13000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb8230800220202ead596687ca806043edc3de116cdf29d5e9257c196cd055cf698c8d02bf24e9910b4a6ba670000008000000080020000800022020394f62be9df19952c5587768aeb7698061ad2c4a25c894f47d8c162b4d7213d0510b4a6ba6700000080010000800200008000").unwrap();
+            let psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac00000000000100df0200000001268171371edff285e937adeea4b37b78000c0566cbb3ad64641713ca42171bf6000000006a473044022070b2245123e6bf474d60c5b50c043d4c691a5d2435f09a34a7662a9dc251790a022001329ca9dacf280bdf30740ec0390422422c81cb45839457aeb76fc12edd95b3012102657d118d3357b8e0f4c2cd46db7b39f6d9c38d9a70abcb9b2de5dc8dbfe4ce31feffffff02d3dff505000000001976a914d0c59903c5bac2868760e90fd521a4665aa7652088ac00e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787b32e13000001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb8230800220202ead596687ca806043edc3de116cdf29d5e9257c196cd055cf698c8d02bf24e9910b4a6ba670000008000000080020000800022020394f62be9df19952c5587768aeb7698061ad2c4a25c894f47d8c162b4d7213d0510b4a6ba6700000080010000800200008000").unwrap();
 
             assert_eq!(psbt.inputs.len(), 2);
             assert_eq!(psbt.outputs.len(), 2);
@@ -1818,7 +1818,7 @@ mod tests {
 
         #[test]
         fn valid_vector_5() {
-            let psbt: Psbt = hex_psbt("70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000").unwrap();
+            let psbt = hex_psbt("70736274ff0100550200000001279a2323a5dfb51fc45f220fa58b0fc13e1e3342792a85d7e36cd6333b5cbc390000000000ffffffff01a05aea0b000000001976a914ffe9c0061097cc3b636f2cb0460fa4fc427d2b4588ac0000000000010120955eea0b0000000017a9146345200f68d189e1adc0df1c4d16ea8f14c0dbeb87220203b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4646304302200424b58effaaa694e1559ea5c93bbfd4a89064224055cdf070b6771469442d07021f5c8eb0fea6516d60b8acb33ad64ede60e8785bfb3aa94b99bdf86151db9a9a010104220020771fd18ad459666dd49f3d564e3dbc42f4c84774e360ada16816a8ed488d5681010547522103b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd462103de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd52ae220603b1341ccba7683b6af4f1238cd6e97e7167d569fac47f1e48d47541844355bd4610b4a6ba67000000800000008004000080220603de55d1e1dac805e3f8a58c1fbf9b94c02f3dbaafe127fefca4995f26f82083bd10b4a6ba670000008000000080050000800000").unwrap();
 
             assert_eq!(psbt.inputs.len(), 1);
             assert_eq!(psbt.outputs.len(), 1);
@@ -1840,7 +1840,7 @@ mod tests {
 
         #[test]
         fn valid_vector_6() {
-            let psbt: Psbt = hex_psbt("70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a010000000000000a0f0102030405060708090f0102030405060708090a0b0c0d0e0f0000").unwrap();
+            let psbt = hex_psbt("70736274ff01003f0200000001ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000ffffffff010000000000000000036a010000000000000a0f0102030405060708090f0102030405060708090a0b0c0d0e0f0000").unwrap();
 
             assert_eq!(psbt.inputs.len(), 1);
             assert_eq!(psbt.outputs.len(), 1);
@@ -2066,7 +2066,7 @@ mod tests {
         unserialized.inputs[0].hash160_preimages = hash160_preimages;
         unserialized.inputs[0].sha256_preimages = sha256_preimages;
 
-        let rtt: Psbt = hex_psbt(&unserialized.serialize_hex()).unwrap();
+        let rtt = hex_psbt(&unserialized.serialize_hex()).unwrap();
         assert_eq!(rtt, unserialized);
 
         // Now add an ripemd160 with incorrect preimage
@@ -2081,13 +2081,13 @@ mod tests {
 
     #[test]
     fn serialize_and_deserialize_proprietary() {
-        let mut psbt: Psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac000000000001076a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa882920001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000").unwrap();
+        let mut psbt = hex_psbt("70736274ff0100a00200000002ab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40000000000feffffffab0949a08c5af7c49b8212f417e2f15ab3f5c33dcf153821a8139f877a5b7be40100000000feffffff02603bea0b000000001976a914768a40bbd740cbe81d988e71de2a4d5c71396b1d88ac8e240000000000001976a9146f4620b553fa095e721b9ee0efe9fa039cca459788ac000000000001076a47304402204759661797c01b036b25928948686218347d89864b719e1f7fcf57d1e511658702205309eabf56aa4d8891ffd111fdf1336f3a29da866d7f8486d75546ceedaf93190121035cdc61fc7ba971c0b501a646a2a83b102cb43881217ca682dc86e2d73fa882920001012000e1f5050000000017a9143545e6e33b832c47050f24d3eeb93c9c03948bc787010416001485d13537f2e265405a34dbafa9e3dda01fb82308000000").unwrap();
         psbt.proprietary.insert(
             raw::ProprietaryKey { prefix: b"test".to_vec(), subtype: 0u64, key: b"test".to_vec() },
             b"test".to_vec(),
         );
         assert!(!psbt.proprietary.is_empty());
-        let rtt: Psbt = hex_psbt(&psbt.serialize_hex()).unwrap();
+        let rtt = hex_psbt(&psbt.serialize_hex()).unwrap();
         assert!(!rtt.proprietary.is_empty());
     }
 

From 4ef06b4f2b9945b46c190abd0cb3a6dfe234c7b5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 13:01:16 +1100
Subject: [PATCH 085/554] Remove ToU64 from rustdocs

The `ToU64` trait is not meant to be used publicly, remove the mention
of it from rustdocs.
---
 bitcoin/src/blockdata/transaction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 35c0ff6066..c9edcf741f 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -162,7 +162,7 @@ crate::internal_macros::define_extension_trait! {
         /// # Panics
         ///
         /// If output size * 4 overflows, this should never happen under normal conditions. Use
-        /// `Weght::from_vb_checked(self.size().to_u64())` if you are concerned.
+        /// `Weght::from_vb_checked(self.size() as u64)` if you are concerned.
         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().to_u64())

From a5993426fddea85c29ac6cd5a0e3096988d72b03 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 12:34:31 +1100
Subject: [PATCH 086/554] bitcoin: Improve rustdocs on extern crates

Make slight improvement to the extern crates we re-export from
`bitcoin`.
---
 bitcoin/src/lib.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index 2c4c76ae12..64c03a5be5 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -61,8 +61,8 @@ extern crate test;
 #[macro_use]
 extern crate alloc;
 
-#[cfg(feature = "base64")]
 /// Encodes and decodes base64 as bytes or utf8.
+#[cfg(feature = "base64")]
 pub extern crate base64;
 
 /// Bitcoin base58 encoding and decoding.
@@ -84,7 +84,9 @@ pub extern crate io;
 #[cfg(feature = "ordered")]
 pub extern crate ordered;
 
-/// Rust wrapper library for Pieter Wuille's libsecp256k1.  Implements ECDSA and BIP 340 signatures
+/// Re-export the `rust-secp256k1` crate.
+///
+/// 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;
 

From d066a863bf3dc522da591cc1e0e27392f2e69dc9 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 12:21:28 +1100
Subject: [PATCH 087/554] Use backticks on amount types

---
 bitcoin/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index 2c4c76ae12..a885c54b12 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -199,7 +199,7 @@ mod prelude {
 pub mod amount {
     //! Bitcoin amounts.
     //!
-    //! This module mainly introduces the [Amount] and [SignedAmount] types.
+    //! This module mainly introduces the [`Amount`] and [`SignedAmount`] types.
     //! We refer to the documentation on the types for more information.
 
     use crate::consensus::{encode, Decodable, Encodable};

From edfdd575d5af1c676c0640f1e38056d7da9168e0 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 11:43:26 +1100
Subject: [PATCH 088/554] Test all the valid denomination forms

---
 units/src/amount/tests.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index b2a0dfac45..ca2774750e 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -920,10 +920,10 @@ fn checked_sum_amounts() {
 
 #[test]
 fn denomination_string_acceptable_forms() {
-    // Non-exhaustive list of valid forms.
+    // Exhaustive list of valid forms.
     let valid = [
-        "BTC", "btc", "mBTC", "mbtc", "uBTC", "ubtc", "SATOSHI", "satoshi", "SATOSHIS", "satoshis",
-        "SAT", "sat", "SATS", "sats", "bit", "bits",
+        "BTC", "btc", "cBTC", "cbtc", "mBTC", "mbtc", "uBTC", "ubtc", "bit", "bits", "BIT", "BITS",
+        "SATOSHI", "satoshi", "SATOSHIS", "satoshis", "SAT", "sat", "SATS", "sats",
     ];
     for denom in valid.iter() {
         assert!(denom.parse::<Denomination>().is_ok());

From 66f36b304802a4954bbdbc60f43070fa8d687c92 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 12 Dec 2024 11:13:11 +0000
Subject: [PATCH 089/554] Correct doc errors and add links in `unsigned`

---
 units/src/amount/unsigned.rs | 35 ++++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index f51ae4af35..d84f1084a1 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -21,8 +21,8 @@ use crate::{FeeRate, Weight};
 /// An amount.
 ///
 /// The [`Amount`] type can be used to express Bitcoin amounts that support arithmetic and
-/// conversion to various denominations. The `Amount` type does not implement `serde` traits but we
-/// do provide modules for serializing as satoshis or bitcoin.
+/// conversion to various denominations. The [`Amount`] type does not implement [`serde`] traits
+/// but we do provide modules for serializing as satoshis or bitcoin.
 ///
 /// Warning!
 ///
@@ -75,7 +75,7 @@ impl Amount {
     /// Gets the number of satoshis in this [`Amount`].
     pub const fn to_sat(self) -> u64 { self.0 }
 
-    /// Converts from a value expressing a whole number of bitcoin to an [`Amount`].
+    /// Converts from a value expressing a decimal number of bitcoin to an [`Amount`].
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<Amount, ParseAmountError> {
         Amount::from_float_in(btc, Denomination::Bitcoin)
@@ -108,10 +108,10 @@ impl Amount {
         }
     }
 
-    /// Parses a decimal string as a value in the given denomination.
+    /// Parses 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`].
+    /// Note: This only parses the value string.  If you want to parse a string
+    /// containing the 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).map_err(|error| error.convert(false))?;
@@ -137,7 +137,7 @@ impl Amount {
         Amount::from_str_in(amt, denom).map_err(Into::into)
     }
 
-    /// Expresses this [`Amount`] as a floating-point value in the given denomination.
+    /// Expresses this [`Amount`] as a floating-point value in the given [`Denomination`].
     ///
     /// Please be aware of the risk of using floating-point numbers.
     #[cfg(feature = "alloc")]
@@ -159,8 +159,8 @@ impl Amount {
     #[cfg(feature = "alloc")]
     pub fn to_btc(self) -> f64 { self.to_float_in(Denomination::Bitcoin) }
 
-    /// Converts this [`Amount`] in floating-point notation with a given
-    /// denomination.
+    /// Converts this [`Amount`] in floating-point notation in the given
+    /// [`Denomination`].
     ///
     /// # Errors
     ///
@@ -177,7 +177,7 @@ impl Amount {
         Amount::from_str_in(&value.to_string(), denom)
     }
 
-    /// Constructs a new object that implements [`fmt::Display`] using specified denomination.
+    /// Constructs a new object that implements [`fmt::Display`] in the given [`Denomination`].
     #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
         Display {
@@ -187,7 +187,8 @@ impl Amount {
         }
     }
 
-    /// Constructs a new object that implements [`fmt::Display`] dynamically selecting denomination.
+    /// Constructs a new object that implements [`fmt::Display`] dynamically selecting
+    /// [`Denomination`].
     ///
     /// This will use BTC for values greater than or equal to 1 BTC and satoshis otherwise. To
     /// avoid confusion the denomination is always shown.
@@ -200,14 +201,14 @@ impl Amount {
         }
     }
 
-    /// Returns a formatted string representing this [`Amount`] in the given denomination.
+    /// Returns a formatted string representing this [`Amount`] in the given [`Denomination`].
     ///
-    /// Does not include the denomination.
+    /// Returned string does not include the denomination.
     #[cfg(feature = "alloc")]
     pub fn to_string_in(self, denom: Denomination) -> String { self.display_in(denom).to_string() }
 
-    /// Returns a formatted string representing this [`Amount`] in the given denomination, suffixed
-    /// with the abbreviation for the denomination.
+    /// Returns a formatted string representing this [`Amount`] in the given [`Denomination`],
+    /// suffixed with the abbreviation for the denomination.
     #[cfg(feature = "alloc")]
     pub fn to_string_with_denomination(self, denom: Denomination) -> String {
         self.display_in(denom).show_denomination().to_string()
@@ -217,7 +218,7 @@ impl Amount {
 
     /// Checked addition.
     ///
-    /// Returns [`None`] if overflow occurred.
+    /// Returns [`None`] if the sum is larger than [`Amount::MAX`].
     #[must_use]
     pub const fn checked_add(self, rhs: Amount) -> Option<Amount> {
         // No `map()` in const context.
@@ -241,7 +242,7 @@ impl Amount {
 
     /// Checked multiplication.
     ///
-    /// Returns [`None`] if overflow occurred.
+    /// Returns [`None`] if the product is larger than [`Amount::MAX`].
     #[must_use]
     pub const fn checked_mul(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.

From b881f1b54e374174281c162124f186af383b788f Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 12 Dec 2024 11:22:37 +0000
Subject: [PATCH 090/554] Add `# Errors` to rustdocs

---
 units/src/amount/unsigned.rs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index d84f1084a1..d4d799d9ea 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -76,6 +76,12 @@ impl Amount {
     pub const fn to_sat(self) -> u64 { self.0 }
 
     /// Converts from a value expressing a decimal number of bitcoin to an [`Amount`].
+    ///
+    /// # Errors
+    ///
+    /// If the amount is too big, too precise or negative.
+    ///
+    /// Please be aware of the risk of using floating-point numbers.
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<Amount, ParseAmountError> {
         Amount::from_float_in(btc, Denomination::Bitcoin)
@@ -112,6 +118,10 @@ impl Amount {
     ///
     /// Note: This only parses the value string.  If you want to parse a string
     /// containing the value with denomination, use [`FromStr`].
+    ///
+    /// # Errors
+    ///
+    /// If the amount is too big, too precise or negative.
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<Amount, ParseAmountError> {
         let (negative, satoshi) =
             parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(false))?;
@@ -132,6 +142,10 @@ impl Amount {
     /// or with [`fmt::Display`].
     ///
     /// If you want to parse only the amount without the denomination, use [`Self::from_str_in`].
+    ///
+    /// # Errors
+    ///
+    /// If the amount is too big, too precise or negative.
     pub fn from_str_with_denomination(s: &str) -> Result<Amount, ParseError> {
         let (amt, denom) = split_amount_and_denomination(s)?;
         Amount::from_str_in(amt, denom).map_err(Into::into)
@@ -342,6 +356,10 @@ impl Amount {
     pub fn unchecked_sub(self, rhs: Amount) -> Amount { Self(self.0 - rhs.0) }
 
     /// Converts to a signed amount.
+    ///
+    /// # Errors
+    ///
+    /// If the amount is too big.
     pub fn to_signed(self) -> Result<SignedAmount, OutOfRangeError> {
         if self.to_sat() > SignedAmount::MAX.to_sat() as u64 {
             Err(OutOfRangeError::too_big(true))

From 01b58d668cf03dda6aeff7c556e359436ccc4132 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 12 Dec 2024 12:14:07 +0000
Subject: [PATCH 091/554] Add rustdoc examples

---
 units/src/amount/unsigned.rs | 51 ++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index d4d799d9ea..768153e1e2 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -70,6 +70,14 @@ impl Amount {
     pub const SIZE: usize = 8; // Serialized length of a u64.
 
     /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::Amount;
+    /// let amount = Amount::from_sat(100_000);
+    /// assert_eq!(amount.to_sat(), 100_000);
+    /// ```
     pub const fn from_sat(satoshi: u64) -> Amount { Amount(satoshi) }
 
     /// Gets the number of satoshis in this [`Amount`].
@@ -146,6 +154,15 @@ impl Amount {
     /// # Errors
     ///
     /// If the amount is too big, too precise or negative.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::{amount, Amount};
+    /// let amount = Amount::from_str_with_denomination("0.1 BTC")?;
+    /// assert_eq!(amount, Amount::from_sat(10_000_000));
+    /// # Ok::<_, amount::ParseError>(())
+    /// ```
     pub fn from_str_with_denomination(s: &str) -> Result<Amount, ParseError> {
         let (amt, denom) = split_amount_and_denomination(s)?;
         Amount::from_str_in(amt, denom).map_err(Into::into)
@@ -154,6 +171,14 @@ impl Amount {
     /// Expresses this [`Amount`] as a floating-point value in the given [`Denomination`].
     ///
     /// Please be aware of the risk of using floating-point numbers.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::amount::{Amount, Denomination};
+    /// let amount = Amount::from_sat(100_000);
+    /// assert_eq!(amount.to_float_in(Denomination::Bitcoin), 0.001)
+    /// ```
     #[cfg(feature = "alloc")]
     pub fn to_float_in(self, denom: Denomination) -> f64 {
         self.to_string_in(denom).parse::<f64>().unwrap()
@@ -218,11 +243,27 @@ impl Amount {
     /// Returns a formatted string representing this [`Amount`] in the given [`Denomination`].
     ///
     /// Returned string does not include the denomination.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::amount::{Amount, Denomination};
+    /// let amount = Amount::from_sat(10_000_000);
+    /// assert_eq!(amount.to_string_in(Denomination::Bitcoin), "0.1")
+    /// ```
     #[cfg(feature = "alloc")]
     pub fn to_string_in(self, denom: Denomination) -> String { self.display_in(denom).to_string() }
 
     /// Returns a formatted string representing this [`Amount`] in the given [`Denomination`],
     /// suffixed with the abbreviation for the denomination.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::amount::{Amount, Denomination};
+    /// let amount = Amount::from_sat(10_000_000);
+    /// assert_eq!(amount.to_string_with_denomination(Denomination::Bitcoin), "0.1 BTC")
+    /// ```
     #[cfg(feature = "alloc")]
     pub fn to_string_with_denomination(self, denom: Denomination) -> String {
         self.display_in(denom).show_denomination().to_string()
@@ -287,6 +328,16 @@ impl Amount {
     /// sufficient.  See also [`Amount::checked_div_by_weight_floor`].
     ///
     /// Returns [`None`] if overflow occurred.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::{Amount, FeeRate, Weight};
+    /// let amount = Amount::from_sat(10);
+    /// let weight = Weight::from_wu(300);
+    /// let fee_rate = amount.checked_div_by_weight_ceil(weight).expect("Division by weight failed");
+    /// assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(34));
+    /// ```
     #[cfg(feature = "alloc")]
     #[must_use]
     pub const fn checked_div_by_weight_ceil(self, rhs: Weight) -> Option<FeeRate> {

From f412f2b149b73f6030fdd5565b3d5f920512f477 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 13 Dec 2024 09:03:21 +1100
Subject: [PATCH 092/554] api: Run just check-api

---
 api/units/all-features.txt | 7 ++++---
 api/units/alloc-only.txt   | 7 ++++---
 api/units/no-features.txt  | 7 ++++---
 3 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index d75534c5d0..bb04d3c075 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -208,6 +208,7 @@ impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units
 impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
 impl core::default::Default for bitcoin_units::Amount
 impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::block::BlockInterval
 impl core::default::Default for bitcoin_units::locktime::relative::Height
 impl core::default::Default for bitcoin_units::locktime::relative::Time
 impl core::error::Error for bitcoin_units::amount::error::InputTooLargeError
@@ -737,7 +738,6 @@ pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
 pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_wu_usize(wu: usize) -> Self
 pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
@@ -956,6 +956,7 @@ pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block:
 pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
 pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
 pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockInterval::default() -> bitcoin_units::block::BlockInterval
 pub fn bitcoin_units::block::BlockInterval::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
 pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
 pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -1191,10 +1192,10 @@ pub struct bitcoin_units::locktime::relative::TimeOverflowError
 pub struct bitcoin_units::parse::PrefixedHexError(_)
 pub struct bitcoin_units::parse::UnprefixedHexError(_)
 pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: private::SumSeal<R>
+pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
 pub trait bitcoin_units::amount::serde::SerdeAmount: core::marker::Copy + core::marker::Sized
 pub trait bitcoin_units::amount::serde::SerdeAmountForOpt: core::marker::Copy + core::marker::Sized + bitcoin_units::amount::serde::SerdeAmount
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
 pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 21cc554a19..da91d6a062 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -204,6 +204,7 @@ impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units
 impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
 impl core::default::Default for bitcoin_units::Amount
 impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::block::BlockInterval
 impl core::default::Default for bitcoin_units::locktime::relative::Height
 impl core::default::Default for bitcoin_units::locktime::relative::Time
 impl core::fmt::Debug for bitcoin_units::Amount
@@ -695,7 +696,6 @@ pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
 pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_wu_usize(wu: usize) -> Self
 pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
@@ -863,6 +863,7 @@ pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block:
 pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
 pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
 pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockInterval::default() -> bitcoin_units::block::BlockInterval
 pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
 pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::block::BlockInterval::from(h: bitcoin_units::locktime::relative::Height) -> Self
@@ -1069,8 +1070,8 @@ pub struct bitcoin_units::locktime::relative::TimeOverflowError
 pub struct bitcoin_units::parse::PrefixedHexError(_)
 pub struct bitcoin_units::parse::UnprefixedHexError(_)
 pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: private::SumSeal<R>
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized
+pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
 pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 638a07add3..e055093b7b 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -188,6 +188,7 @@ impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units
 impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
 impl core::default::Default for bitcoin_units::Amount
 impl core::default::Default for bitcoin_units::SignedAmount
+impl core::default::Default for bitcoin_units::block::BlockInterval
 impl core::default::Default for bitcoin_units::locktime::relative::Height
 impl core::default::Default for bitcoin_units::locktime::relative::Time
 impl core::fmt::Debug for bitcoin_units::Amount
@@ -677,7 +678,6 @@ pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
 pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_wu_usize(wu: usize) -> Self
 pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
@@ -831,6 +831,7 @@ pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block:
 pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
 pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
 pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
+pub fn bitcoin_units::block::BlockInterval::default() -> bitcoin_units::block::BlockInterval
 pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
 pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::block::BlockInterval::from(h: bitcoin_units::locktime::relative::Height) -> Self
@@ -1023,8 +1024,8 @@ pub struct bitcoin_units::locktime::relative::TimeOverflowError
 pub struct bitcoin_units::parse::PrefixedHexError(_)
 pub struct bitcoin_units::parse::UnprefixedHexError(_)
 pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: private::SumSeal<R>
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized
+pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
 pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError

From f85456a726a201b26eac58d22eb0eb6a58ad411b Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 10:15:54 +1100
Subject: [PATCH 093/554] Improve rustdocs on addresses module

These docs are stale, update them.

- Mention segwit and legacy
- Improve example code to show feature gating
- Fix headings to be as typical
---
 bitcoin/src/address/mod.rs | 25 +++++++++++--------------
 1 file changed, 11 insertions(+), 14 deletions(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 1169e631a8..2b0842fea4 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -2,28 +2,25 @@
 
 //! Bitcoin addresses.
 //!
-//! Support for ordinary base58 Bitcoin addresses and private keys.
+//! Support for segwit and legacy addresses (bech32 and base58 respectively).
 //!
-//! # Example: creating a new address from a randomly-generated key pair
+//! # Examples
+//!
+//! ### Creating a new address from a randomly-generated key pair.
 //!
 //! ```rust
-//! # #[cfg(feature = "rand-std")] {
-//! use bitcoin::{Address, PublicKey, Network};
+//! #[cfg(feature = "rand-std")] {
 //! use bitcoin::secp256k1::{rand, Secp256k1};
+//! use bitcoin::{Address, Network, PublicKey};
 //!
 //! // Generate random key pair.
-//! let s = Secp256k1::new();
-//! let public_key = PublicKey::new(s.generate_keypair(&mut rand::thread_rng()).1);
+//! let secp = Secp256k1::new();
+//! let (_sk, pk) = secp.generate_keypair(&mut rand::thread_rng());
+//! let public_key = PublicKey::new(pk); // Or `PublicKey::from(pk)`.
 //!
-//! // Generate pay-to-pubkey-hash address.
+//! // Generate a mainnet pay-to-pubkey-hash address.
 //! let address = Address::p2pkh(&public_key, Network::Bitcoin);
-//! # }
-//! ```
-//!
-//! # Note: creating a new address requires the rand-std feature flag
-//!
-//! ```toml
-//! bitcoin = { version = "...", features = ["rand-std"] }
+//! }
 //! ```
 
 pub mod error;

From 18d904d647d2f9792923279a17a9a33968d5b39b Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 15 Dec 2024 01:35:28 +0000
Subject: [PATCH 094/554] 2024-12-15 automated rustfmt nightly

---
 units/src/amount/serde.rs  | 12 +++---------
 units/src/amount/signed.rs |  6 +++---
 units/src/amount/tests.rs  |  3 ++-
 units/src/parse.rs         |  5 ++++-
 4 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index 2caa8c74e7..46fa2f92f8 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -398,9 +398,7 @@ mod tests {
             pub amount: Amount,
         }
 
-        let orig = HasAmount {
-            amount: Amount::ONE_BTC,
-        };
+        let orig = HasAmount { amount: Amount::ONE_BTC };
 
         let json = serde_json::to_string(&orig).expect("failed to ser");
         let want = "{\"amount\":100000000}";
@@ -419,9 +417,7 @@ mod tests {
             pub amount: Amount,
         }
 
-        let orig = HasAmount {
-            amount: Amount::ONE_BTC,
-        };
+        let orig = HasAmount { amount: Amount::ONE_BTC };
 
         let json = serde_json::to_string(&orig).expect("failed to ser");
         let want = "{\"amount\":1.0}";
@@ -440,9 +436,7 @@ mod tests {
             pub amount: Amount,
         }
 
-        let orig = HasAmount {
-            amount: Amount::ONE_BTC,
-        };
+        let orig = HasAmount { amount: Amount::ONE_BTC };
 
         let json = serde_json::to_string(&orig).expect("failed to ser");
         let want = "{\"amount\":\"1\"}";
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index d88905dbae..ab934c2b0e 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -112,9 +112,9 @@ impl SignedAmount {
                 ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_big(true)),
             )),
             (false, sat) => Ok(SignedAmount(sat as i64)),
-            (true, sat) if sat > SignedAmount::MIN.to_sat().unsigned_abs() => Err(ParseAmountError(
-                ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_small()),
-            )),
+            (true, sat) if sat > SignedAmount::MIN.to_sat().unsigned_abs() => Err(
+                ParseAmountError(ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_small())),
+            ),
             (true, sat) => Ok(SignedAmount(-(sat as i64))),
         }
     }
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index ca2774750e..baa1200261 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -619,7 +619,8 @@ fn to_from_string_in() {
         ua_str(&ua_sat(1_000_000_000_000).to_string_in(D::MilliBitcoin), D::MilliBitcoin),
         Ok(ua_sat(1_000_000_000_000))
     );
-    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MilliBitcoin), D::MilliBitcoin).is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MilliBitcoin), D::MilliBitcoin)
+        .is_ok());
 
     assert_eq!(sa_str(&sa_sat(-1).to_string_in(D::MicroBitcoin), D::MicroBitcoin), Ok(sa_sat(-1)));
 
diff --git a/units/src/parse.rs b/units/src/parse.rs
index 5e88fce0a3..3dc01f8b0e 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -52,7 +52,10 @@ impl AsRef<core::num::ParseIntError> for ParseIntError {
 
 /// Not strictly necessary but serves as a lint - avoids weird behavior if someone accidentally
 /// passes non-integer to the `parse()` function.
-pub trait Integer: FromStr<Err = core::num::ParseIntError> + TryFrom<i8> + Sized + sealed::Sealed {}
+pub trait Integer:
+    FromStr<Err = core::num::ParseIntError> + TryFrom<i8> + Sized + sealed::Sealed
+{
+}
 
 macro_rules! impl_integer {
     ($($type:ty),* $(,)?) => {

From 04852958b9ff9b4f52616daf975ef9e20105c70e Mon Sep 17 00:00:00 2001
From: Jose Storopoli <jose@storopoli.com>
Date: Fri, 13 Dec 2024 17:24:17 -0300
Subject: [PATCH 095/554] contrib: check if the user has cargo-public-api

---
 contrib/check-for-api-changes.sh | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/contrib/check-for-api-changes.sh b/contrib/check-for-api-changes.sh
index dc305dca05..3bfe415715 100755
--- a/contrib/check-for-api-changes.sh
+++ b/contrib/check-for-api-changes.sh
@@ -22,6 +22,7 @@ export LC_ALL=C
 
 main() {
     need_nightly
+    need_cargo_public_api
 
     generate_api_files "hashes"
     generate_api_files "io"
@@ -81,6 +82,13 @@ need_nightly() {
     fi
 }
 
+need_cargo_public_api() {
+    if command -v cargo-public-api > /dev/null; then
+        return
+    fi
+    err "cargo-public-api is not installed; please run 'cargo +nightly install cargo-public-api --locked'"
+}
+
 err() {
     echo "$1" >&2
     exit 1

From ff67eadc7fac0bd1cbe3a42fb385edd286ac9cb5 Mon Sep 17 00:00:00 2001
From: Jose Storopoli <jose@storopoli.com>
Date: Fri, 13 Dec 2024 17:30:52 -0300
Subject: [PATCH 096/554] contributing: clarify API changes

---
 CONTRIBUTING.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ff1d586650..451376049d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -157,6 +157,9 @@ running `just check-api`.
 - `primitives`
 - `units`
 
+Check the [API text files](api/README.md) for more information
+on how to install the dependencies and create the text files.
+
 ### Repository maintainers
 
 Pull request merge requirements:

From f01f071751332bb6aa8b9affa4677f913035de7f Mon Sep 17 00:00:00 2001
From: Jose Storopoli <jose@storopoli.com>
Date: Sun, 15 Dec 2024 11:42:42 -0300
Subject: [PATCH 097/554] api: document the need of cargo nightly

---
 api/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/api/README.md b/api/README.md
index 8979cd542d..f83f990b14 100644
--- a/api/README.md
+++ b/api/README.md
@@ -6,7 +6,7 @@ enabled. To create these files run `../contrib/check-for-api-changes.sh`:
 Requires `cargo-public-api`, install with:
 
 ```
-cargo +stable install cargo-public-api --locked
+cargo +nightly install cargo-public-api --locked
 ```
 
 ref: https://github.com/enselic/cargo-public-api

From 3ed4acdd434df5e9ee3b71e4e99c4693b220daf5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 16 Dec 2024 09:29:54 +1100
Subject: [PATCH 098/554] api: Run just check-api

---
 api/units/all-features.txt | 24 ++++++++++++------------
 api/units/alloc-only.txt   | 24 ++++++++++++------------
 api/units/no-features.txt  | 24 ++++++++++++------------
 3 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index bb04d3c075..66adfa66c7 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -635,19 +635,19 @@ pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_uni
 pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
 pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
 pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
-pub const bitcoin_units::Amount::MAX: bitcoin_units::Amount
-pub const bitcoin_units::Amount::MAX_MONEY: bitcoin_units::Amount
-pub const bitcoin_units::Amount::MIN: bitcoin_units::Amount
-pub const bitcoin_units::Amount::ONE_BTC: bitcoin_units::Amount
-pub const bitcoin_units::Amount::ONE_SAT: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MAX: Self
+pub const bitcoin_units::Amount::MAX_MONEY: Self
+pub const bitcoin_units::Amount::MIN: Self
+pub const bitcoin_units::Amount::ONE_BTC: Self
+pub const bitcoin_units::Amount::ONE_SAT: Self
 pub const bitcoin_units::Amount::SIZE: usize
-pub const bitcoin_units::Amount::ZERO: bitcoin_units::Amount
-pub const bitcoin_units::SignedAmount::MAX: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::MAX_MONEY: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::MIN: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ONE_BTC: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ONE_SAT: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ZERO: bitcoin_units::SignedAmount
+pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::SignedAmount::MAX: Self
+pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
+pub const bitcoin_units::SignedAmount::MIN: Self
+pub const bitcoin_units::SignedAmount::ONE_BTC: Self
+pub const bitcoin_units::SignedAmount::ONE_SAT: Self
+pub const bitcoin_units::SignedAmount::ZERO: Self
 pub const bitcoin_units::amount::Denomination::BTC: Self
 pub const bitcoin_units::amount::Denomination::SAT: Self
 pub const bitcoin_units::block::BlockHeight::MAX: Self
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index da91d6a062..79fbedd91c 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -593,19 +593,19 @@ pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_uni
 pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
 pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
 pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
-pub const bitcoin_units::Amount::MAX: bitcoin_units::Amount
-pub const bitcoin_units::Amount::MAX_MONEY: bitcoin_units::Amount
-pub const bitcoin_units::Amount::MIN: bitcoin_units::Amount
-pub const bitcoin_units::Amount::ONE_BTC: bitcoin_units::Amount
-pub const bitcoin_units::Amount::ONE_SAT: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MAX: Self
+pub const bitcoin_units::Amount::MAX_MONEY: Self
+pub const bitcoin_units::Amount::MIN: Self
+pub const bitcoin_units::Amount::ONE_BTC: Self
+pub const bitcoin_units::Amount::ONE_SAT: Self
 pub const bitcoin_units::Amount::SIZE: usize
-pub const bitcoin_units::Amount::ZERO: bitcoin_units::Amount
-pub const bitcoin_units::SignedAmount::MAX: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::MAX_MONEY: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::MIN: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ONE_BTC: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ONE_SAT: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ZERO: bitcoin_units::SignedAmount
+pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::SignedAmount::MAX: Self
+pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
+pub const bitcoin_units::SignedAmount::MIN: Self
+pub const bitcoin_units::SignedAmount::ONE_BTC: Self
+pub const bitcoin_units::SignedAmount::ONE_SAT: Self
+pub const bitcoin_units::SignedAmount::ZERO: Self
 pub const bitcoin_units::amount::Denomination::BTC: Self
 pub const bitcoin_units::amount::Denomination::SAT: Self
 pub const bitcoin_units::block::BlockHeight::MAX: Self
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index e055093b7b..e4244c9d1e 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -577,19 +577,19 @@ pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_uni
 pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
 pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
 pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
-pub const bitcoin_units::Amount::MAX: bitcoin_units::Amount
-pub const bitcoin_units::Amount::MAX_MONEY: bitcoin_units::Amount
-pub const bitcoin_units::Amount::MIN: bitcoin_units::Amount
-pub const bitcoin_units::Amount::ONE_BTC: bitcoin_units::Amount
-pub const bitcoin_units::Amount::ONE_SAT: bitcoin_units::Amount
+pub const bitcoin_units::Amount::MAX: Self
+pub const bitcoin_units::Amount::MAX_MONEY: Self
+pub const bitcoin_units::Amount::MIN: Self
+pub const bitcoin_units::Amount::ONE_BTC: Self
+pub const bitcoin_units::Amount::ONE_SAT: Self
 pub const bitcoin_units::Amount::SIZE: usize
-pub const bitcoin_units::Amount::ZERO: bitcoin_units::Amount
-pub const bitcoin_units::SignedAmount::MAX: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::MAX_MONEY: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::MIN: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ONE_BTC: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ONE_SAT: bitcoin_units::SignedAmount
-pub const bitcoin_units::SignedAmount::ZERO: bitcoin_units::SignedAmount
+pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::SignedAmount::MAX: Self
+pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
+pub const bitcoin_units::SignedAmount::MIN: Self
+pub const bitcoin_units::SignedAmount::ONE_BTC: Self
+pub const bitcoin_units::SignedAmount::ONE_SAT: Self
+pub const bitcoin_units::SignedAmount::ZERO: Self
 pub const bitcoin_units::amount::Denomination::BTC: Self
 pub const bitcoin_units::amount::Denomination::SAT: Self
 pub const bitcoin_units::block::BlockHeight::MAX: Self

From b5f553d8662836e2bf4cd8fc134e5538782b37f6 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 16:09:07 +1100
Subject: [PATCH 099/554] hashes: Bump version to 0.16.0

We need to do a quick release because it turns out I was wrong in
thinking that making `hex` an optional dependency is not a breaking
change.

```
the package `bitcoin` depends on `bitcoin_hashes`, with features: `hex`
but `bitcoin_hashes` does not have these features. It has a required
dependency with that name, but only optional dependencies can be used as
features.
```

Add a changelog, bump the version, depend on the new version repo wide,
and update the lock files - like its our job.
---
 Cargo-minimal.lock    | 8 ++++----
 Cargo-recent.lock     | 8 ++++----
 base58/Cargo.toml     | 2 +-
 bitcoin/Cargo.toml    | 2 +-
 hashes/CHANGELOG.md   | 6 ++++++
 hashes/Cargo.toml     | 2 +-
 primitives/Cargo.toml | 2 +-
 7 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 945f3d0912..4ca2d3d5bf 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -25,7 +25,7 @@ name = "base58ck"
 version = "0.2.0"
 dependencies = [
  "bitcoin-internals",
- "bitcoin_hashes 0.15.0",
+ "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
 ]
 
@@ -64,7 +64,7 @@ dependencies = [
  "bitcoin-io",
  "bitcoin-primitives",
  "bitcoin-units",
- "bitcoin_hashes 0.15.0",
+ "bitcoin_hashes 0.16.0",
  "bitcoinconsensus",
  "hex-conservative 0.3.0",
  "hex_lit",
@@ -116,7 +116,7 @@ dependencies = [
  "bitcoin-internals",
  "bitcoin-io",
  "bitcoin-units",
- "bitcoin_hashes 0.15.0",
+ "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
  "mutagen",
  "ordered",
@@ -146,7 +146,7 @@ dependencies = [
 
 [[package]]
 name = "bitcoin_hashes"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "bitcoin-io",
  "hex-conservative 0.3.0",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index 1be64cc076..c4fd9762b5 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -25,7 +25,7 @@ name = "base58ck"
 version = "0.2.0"
 dependencies = [
  "bitcoin-internals",
- "bitcoin_hashes 0.15.0",
+ "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
 ]
 
@@ -63,7 +63,7 @@ dependencies = [
  "bitcoin-io",
  "bitcoin-primitives",
  "bitcoin-units",
- "bitcoin_hashes 0.15.0",
+ "bitcoin_hashes 0.16.0",
  "bitcoinconsensus",
  "hex-conservative 0.3.0",
  "hex_lit",
@@ -115,7 +115,7 @@ dependencies = [
  "bitcoin-internals",
  "bitcoin-io",
  "bitcoin-units",
- "bitcoin_hashes 0.15.0",
+ "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
  "mutagen",
  "ordered",
@@ -145,7 +145,7 @@ dependencies = [
 
 [[package]]
 name = "bitcoin_hashes"
-version = "0.15.0"
+version = "0.16.0"
 dependencies = [
  "bitcoin-io",
  "hex-conservative 0.3.0",
diff --git a/base58/Cargo.toml b/base58/Cargo.toml
index 4cc0823013..06000bcbf9 100644
--- a/base58/Cargo.toml
+++ b/base58/Cargo.toml
@@ -18,7 +18,7 @@ std = ["alloc", "hashes/std", "internals/std"]
 alloc = ["hashes/alloc", "internals/alloc"]
 
 [dependencies]
-hashes = { package = "bitcoin_hashes", version = "0.15.0", default-features = false }
+hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false }
 internals = { package = "bitcoin-internals", version = "0.4.0" }
 
 [dev-dependencies]
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index 0429d0a6fd..46e1e4c125 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -27,7 +27,7 @@ arbitrary = ["dep:arbitrary", "units/arbitrary", "primitives/arbitrary"]
 [dependencies]
 base58 = { package = "base58ck", version = "0.2.0", default-features = false, features = ["alloc"] }
 bech32 = { version = "0.11.0", default-features = false, features = ["alloc"] }
-hashes = { package = "bitcoin_hashes", version = "0.15.0", default-features = false, features = ["alloc", "bitcoin-io", "hex"] }
+hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["alloc", "bitcoin-io", "hex"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, features = ["alloc"] }
 internals = { package = "bitcoin-internals", version = "0.4.0", features = ["alloc"] }
 io = { package = "bitcoin-io", version = "0.2.0", default-features = false, features = ["alloc"] }
diff --git a/hashes/CHANGELOG.md b/hashes/CHANGELOG.md
index eccea78f9d..ea31a9be89 100644
--- a/hashes/CHANGELOG.md
+++ b/hashes/CHANGELOG.md
@@ -1,3 +1,9 @@
+# 0.16.0 - 2024-12-12
+
+* Make `hex-conservative` an optional dependency [#3611](https://github.com/rust-bitcoin/rust-bitcoin/pull/3611)
+* Bump `hex-conservative` to `v0.3.0` [#3543](https://github.com/rust-bitcoin/rust-bitcoin/pull/3543)
+* Hide error internals [#3579](https://github.com/rust-bitcoin/rust-bitcoin/pull/3579)
+
 # 0.15.0 - 2024-10-16
 
 This release is massive. The biggest visable changes are to the `Hash` trait, which has mostly been replaced
diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
index 7cdf06300c..c34f2f04e3 100644
--- a/hashes/Cargo.toml
+++ b/hashes/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bitcoin_hashes"
-version = "0.15.0"
+version = "0.16.0"
 authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
 license = "CC0-1.0"
 repository = "https://github.com/rust-bitcoin/rust-bitcoin"
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 76ca9f6c44..3d75906eb9 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -22,7 +22,7 @@ serde = ["dep:serde", "hashes/serde", "internals/serde", "units/serde", "alloc"]
 arbitrary = ["dep:arbitrary", "units/arbitrary"]
 
 [dependencies]
-hashes = { package = "bitcoin_hashes", version = "0.15.0", default-features = false, features = ["bitcoin-io", "hex"] }
+hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["bitcoin-io", "hex"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false }
 internals = { package = "bitcoin-internals", version = "0.4.0" }
 io = { package = "bitcoin-io", version = "0.2.0", default-features = false }

From b895c9aad4e56ff7cf5420f71ae501f942a81326 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 16 Dec 2024 12:45:13 +1100
Subject: [PATCH 100/554] units: Deprecate unchecked ops

These functions do not add value because one can just call `to_sat` and
`from_sat` if doing ops in a tight loop.

Note we need to remove these deprecated functions before we release
`units v1.0`.
---
 units/src/amount/signed.rs   | 2 ++
 units/src/amount/unsigned.rs | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 0ce1214257..efe160e719 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -318,6 +318,7 @@ impl SignedAmount {
     ///
     /// On overflow, panics in debug mode, wraps in release mode.
     #[must_use]
+    #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
     pub fn unchecked_add(self, rhs: SignedAmount) -> SignedAmount { Self(self.0 + rhs.0) }
 
     /// Unchecked subtraction.
@@ -328,6 +329,7 @@ impl SignedAmount {
     ///
     /// On overflow, panics in debug mode, wraps in release mode.
     #[must_use]
+    #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
     pub fn unchecked_sub(self, rhs: SignedAmount) -> SignedAmount { Self(self.0 - rhs.0) }
 
     /// Subtraction that doesn't allow negative [`SignedAmount`]s.
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 8fa95eeced..cb39301cbd 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -394,6 +394,7 @@ impl Amount {
     ///
     /// On overflow, panics in debug mode, wraps in release mode.
     #[must_use]
+    #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
     pub fn unchecked_add(self, rhs: Amount) -> Amount { Self(self.0 + rhs.0) }
 
     /// Unchecked subtraction.
@@ -404,6 +405,7 @@ impl Amount {
     ///
     /// On overflow, panics in debug mode, wraps in release mode.
     #[must_use]
+    #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
     pub fn unchecked_sub(self, rhs: Amount) -> Amount { Self(self.0 - rhs.0) }
 
     /// Converts to a signed amount.

From 75594c72993960ba22d2bf38459f681659a9eb78 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 11:08:59 +1100
Subject: [PATCH 101/554] Add Weight::to_kwu_ceil

It is not immediately obvious why we have floor and ceil versions of
`to_vbytes` but not for `to_kwu`.

Add a conversion function to get weight by kilo weight units rounding
up.
---
 units/src/weight.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/units/src/weight.rs b/units/src/weight.rs
index 8c8827df74..c2599fb985 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -92,6 +92,9 @@ impl Weight {
     /// Converts to kilo weight units rounding down.
     pub const fn to_kwu_floor(self) -> u64 { self.0 / 1000 }
 
+    /// Converts to kilo weight units rounding up.
+    pub const fn to_kwu_ceil(self) -> u64 { (self.0 + 999) / 1000 }
+
     /// Converts to vB rounding down.
     pub const fn to_vbytes_floor(self) -> u64 { self.0 / Self::WITNESS_SCALE_FACTOR }
 
@@ -298,6 +301,13 @@ mod tests {
     #[test]
     fn to_kwu_floor() {
         assert_eq!(1, Weight(1_000).to_kwu_floor());
+        assert_eq!(1, Weight(1_999).to_kwu_floor());
+    }
+
+    #[test]
+    fn to_kwu_ceil() {
+        assert_eq!(1, Weight(1_000).to_kwu_ceil());
+        assert_eq!(2, Weight(1_001).to_kwu_ceil());
     }
 
     #[test]

From 99b32c95b834166020ce85580246dc8ff193d467 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 12:15:50 +1100
Subject: [PATCH 102/554] Change paramater type used for whole bitcoin

We have multiple constructors for `Amount`, one of which accepts an
integer representing whole bitcoin.

In an attempt to make the API crystal clear change the parameter type
used for whole bitcoin to either `Into<u64>` or `u32` instead of a
`u64` which may well be mapped to sats in the mind of developers (it
is in mine anyway).
---
 units/src/amount/signed.rs   | 8 ++++----
 units/src/amount/tests.rs    | 4 ----
 units/src/amount/unsigned.rs | 7 ++++---
 3 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 0ce1214257..2ae36f715e 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -80,8 +80,8 @@ impl SignedAmount {
     ///
     /// The function errors if the argument multiplied by the number of sats
     /// per bitcoin overflows an `i64` type.
-    pub fn from_int_btc(btc: i64) -> Result<SignedAmount, OutOfRangeError> {
-        match btc.checked_mul(100_000_000) {
+    pub fn from_int_btc<T: Into<i64>>(whole_bitcoin: T) -> Result<SignedAmount, OutOfRangeError> {
+        match whole_bitcoin.into().checked_mul(100_000_000) {
             Some(amount) => Ok(SignedAmount::from_sat(amount)),
             None => Err(OutOfRangeError { is_signed: true, is_greater_than_max: true }),
         }
@@ -94,8 +94,8 @@ impl SignedAmount {
     ///
     /// The function panics if the argument multiplied by the number of sats
     /// per bitcoin overflows an `i64` type.
-    pub const fn from_int_btc_const(btc: i64) -> SignedAmount {
-        match btc.checked_mul(100_000_000) {
+    pub const fn from_int_btc_const(whole_bitcoin: i64) -> SignedAmount {
+        match whole_bitcoin.checked_mul(100_000_000) {
             Some(amount) => SignedAmount::from_sat(amount),
             None => panic!("checked_mul overflowed"),
         }
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index baa1200261..9d3687f6a7 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -71,10 +71,6 @@ fn from_int_btc() {
     assert_eq!(Amount::from_sat(200_000_000), amt);
 }
 
-#[should_panic]
-#[test]
-fn from_int_btc_panic() { Amount::from_int_btc_const(u64::MAX); }
-
 #[test]
 fn test_signed_amount_try_from_amount() {
     let ua_positive = Amount::from_sat(123);
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 8fa95eeced..f18ea3e72f 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -101,8 +101,8 @@ impl Amount {
     ///
     /// The function errors if the argument multiplied by the number of sats
     /// per bitcoin overflows a `u64` type.
-    pub fn from_int_btc(btc: u64) -> Result<Amount, OutOfRangeError> {
-        match btc.checked_mul(100_000_000) {
+    pub fn from_int_btc<T: Into<u64>>(whole_bitcoin: T) -> Result<Amount, OutOfRangeError> {
+        match whole_bitcoin.into().checked_mul(100_000_000) {
             Some(amount) => Ok(Amount::from_sat(amount)),
             None => Err(OutOfRangeError { is_signed: false, is_greater_than_max: true }),
         }
@@ -115,7 +115,8 @@ impl Amount {
     ///
     /// The function panics if the argument multiplied by the number of sats
     /// per bitcoin overflows a `u64` type.
-    pub const fn from_int_btc_const(btc: u64) -> Amount {
+    pub const fn from_int_btc_const(whole_bitcoin: u32) -> Amount {
+        let btc = whole_bitcoin as u64; // Can't call u64::from in const context.
         match btc.checked_mul(100_000_000) {
             Some(amount) => Amount::from_sat(amount),
             None => panic!("checked_mul overflowed"),

From f97c04cf07c2ac5acb5d312b573d100afa009b57 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 16 Dec 2024 13:10:03 +1100
Subject: [PATCH 103/554] api: Run just check-api

---
 api/units/all-features.txt | 8 ++++----
 api/units/alloc-only.txt   | 8 ++++----
 api/units/no-features.txt  | 8 ++++----
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 66adfa66c7..9123a7812b 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -687,7 +687,7 @@ pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, rhs: bitco
 pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::from_int_btc_const(btc: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::to_sat(self) -> u64
 pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
@@ -696,7 +696,7 @@ pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::o
 pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
@@ -766,7 +766,7 @@ pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
 pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_int_btc(btc: u64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
 pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
 pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
@@ -813,7 +813,7 @@ pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmoun
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_int_btc(btc: i64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
 pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 79fbedd91c..18fced9e3d 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -645,7 +645,7 @@ pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, rhs: bitco
 pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::from_int_btc_const(btc: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::to_sat(self) -> u64
 pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
@@ -654,7 +654,7 @@ pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::o
 pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
@@ -720,7 +720,7 @@ pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
 pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_int_btc(btc: u64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
 pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
 pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
@@ -756,7 +756,7 @@ pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmoun
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_int_btc(btc: i64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
 pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index e4244c9d1e..17d2679a27 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -627,7 +627,7 @@ pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option:
 pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::from_int_btc_const(btc: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::to_sat(self) -> u64
 pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
@@ -636,7 +636,7 @@ pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::o
 pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::from_int_btc_const(btc: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
@@ -700,7 +700,7 @@ pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
 pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::Amount::from_int_btc(btc: u64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
 pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
 pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
@@ -730,7 +730,7 @@ pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
 pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
 pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::SignedAmount::from_int_btc(btc: i64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
 pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>

From 3f4365ee0cff3dcc6381e9fc7f40ad57a4315380 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 16 Dec 2024 13:10:55 +1100
Subject: [PATCH 104/554] api: Run just check-api

---
 api/units/all-features.txt | 1 +
 api/units/alloc-only.txt   | 1 +
 api/units/no-features.txt  | 1 +
 3 files changed, 3 insertions(+)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 66adfa66c7..d3191cd04a 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -738,6 +738,7 @@ pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
 pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::to_kwu_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 79fbedd91c..7dffd43cd5 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -696,6 +696,7 @@ pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
 pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::to_kwu_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index e4244c9d1e..d30f693caa 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -678,6 +678,7 @@ pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
 pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
+pub const fn bitcoin_units::weight::Weight::to_kwu_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64

From 815330dad2d2026ecf11c998dd560217c8d05d52 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 11:30:32 +1100
Subject: [PATCH 105/554] Clean up weight unit tests

- Within reason, do one assertion per unit test
- Use consts for checked ops
- Use conventional order in assertions (got, want)
---
 units/src/weight.rs | 97 ++++++++++++++++++++++++---------------------
 1 file changed, 51 insertions(+), 46 deletions(-)

diff --git a/units/src/weight.rs b/units/src/weight.rs
index c2599fb985..a8b1e94cbb 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -251,35 +251,37 @@ impl<'a> Arbitrary<'a> for Weight {
 mod tests {
     use super::*;
 
-    #[test]
-    fn weight_constructor() {
-        assert_eq!(Weight::ZERO, Weight::from_wu(0));
-    }
+    const ONE: Weight = Weight(1);
+    const TWO: Weight = Weight(2);
+    const FOUR: Weight = Weight(4);
 
     #[test]
-    fn kilo_weight_constructor() {
-        assert_eq!(Weight(1_000), Weight::from_kwu(1).expect("expected weight unit"));
+    fn from_kwu() {
+        let got = Weight::from_kwu(1).unwrap();
+        let want = Weight(1_000);
+        assert_eq!(got, want);
     }
 
     #[test]
-    #[should_panic]
-    fn kilo_weight_constructor_panic() {
-        Weight::from_kwu(u64::MAX).expect("expected weight unit");
-    }
+    fn from_kwu_overflows() { assert!(Weight::from_kwu(u64::MAX).is_none()) }
 
     #[test]
     fn from_vb() {
-        let w = Weight::from_vb(1).expect("expected weight unit");
-        assert_eq!(Weight(4), w);
+        let got = Weight::from_vb(1).unwrap();
+        let want = Weight(4);
+        assert_eq!(got, want);
+    }
 
-        let w = Weight::from_vb(u64::MAX);
-        assert_eq!(None, w);
+    #[test]
+    fn from_vb_overflows() {
+        assert!(Weight::from_vb(u64::MAX).is_none());
     }
 
     #[test]
     fn from_vb_unchecked() {
-        let w = Weight::from_vb_unchecked(1);
-        assert_eq!(Weight(4), w);
+        let got = Weight::from_vb_unchecked(1);
+        let want = Weight(4);
+        assert_eq!(got, want);
     }
 
     #[test]
@@ -290,71 +292,74 @@ mod tests {
     #[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));
+        let got = Weight::from_witness_data_size(witness_data_size);
+        let want = Weight(witness_data_size);
+        assert_eq!(got, want);
     }
 
     #[test]
     fn from_non_witness_data_size() {
-        assert_eq!(Weight(4), Weight::from_non_witness_data_size(1));
+        let non_witness_data_size = 1;
+        let got = Weight::from_non_witness_data_size(non_witness_data_size);
+        let want = Weight(non_witness_data_size * 4);
+        assert_eq!(got, want);
     }
 
     #[test]
     fn to_kwu_floor() {
-        assert_eq!(1, Weight(1_000).to_kwu_floor());
-        assert_eq!(1, Weight(1_999).to_kwu_floor());
+        assert_eq!(Weight(1_000).to_kwu_floor(), 1);
+        assert_eq!(Weight(1_999).to_kwu_floor(), 1);
     }
 
     #[test]
     fn to_kwu_ceil() {
-        assert_eq!(1, Weight(1_000).to_kwu_ceil());
-        assert_eq!(2, Weight(1_001).to_kwu_ceil());
+        assert_eq!(Weight(1_000).to_kwu_ceil(), 1);
+        assert_eq!(Weight(1_001).to_kwu_ceil(), 2);
     }
 
     #[test]
     fn to_vb_floor() {
-        assert_eq!(1, Weight(4).to_vbytes_floor());
-        assert_eq!(1, Weight(5).to_vbytes_floor());
+        assert_eq!(Weight(4).to_vbytes_floor(), 1);
+        assert_eq!(Weight(5).to_vbytes_floor(), 1);
     }
 
     #[test]
     fn to_vb_ceil() {
-        assert_eq!(1, Weight(4).to_vbytes_ceil());
-        assert_eq!(2, Weight(5).to_vbytes_ceil());
+        assert_eq!(Weight(4).to_vbytes_ceil(), 1);
+        assert_eq!(Weight(5).to_vbytes_ceil(), 2);
     }
 
     #[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);
+        assert_eq!(ONE.checked_add(ONE).unwrap(), TWO);
     }
 
     #[test]
-    fn checked_sub() {
-        let result = Weight(1).checked_sub(Weight(1)).expect("expected weight unit");
-        assert_eq!(Weight::ZERO, result);
+    fn checked_add_overflows() { assert!(Weight::MAX.checked_add(ONE).is_none()) }
 
-        let result = Weight::MIN.checked_sub(Weight(1));
-        assert_eq!(None, result);
+    #[test]
+    fn checked_sub() {
+        assert_eq!(TWO.checked_sub(ONE).unwrap(), ONE);
     }
 
     #[test]
-    fn checked_mul() {
-        let result = Weight(2).checked_mul(2).expect("expected weight unit");
-        assert_eq!(Weight(4), result);
+    fn checked_sub_overflows() { assert!(Weight::ZERO.checked_sub(ONE).is_none()) }
 
-        let result = Weight::MAX.checked_mul(2);
-        assert_eq!(None, result);
+    #[test]
+    fn checked_mul() {
+        assert_eq!(TWO.checked_mul(1).unwrap(), TWO);
+        assert_eq!(TWO.checked_mul(2).unwrap(), FOUR);
     }
 
     #[test]
-    fn checked_div() {
-        let result = Weight(2).checked_div(2).expect("expected weight unit");
-        assert_eq!(Weight(1), result);
+    fn checked_mul_overflows() { assert!(Weight::MAX.checked_mul(2).is_none()) }
 
-        let result = Weight(2).checked_div(0);
-        assert_eq!(None, result);
+    #[test]
+    fn checked_div() {
+        assert_eq!(FOUR.checked_div(2).unwrap(), TWO);
+        assert_eq!(TWO.checked_div(1).unwrap(), TWO);
     }
+
+    #[test]
+    fn checked_div_overflows() { assert!(TWO.checked_div(0).is_none()) }
 }

From 183ecf1fe6944187151036e36d6726fae9b64392 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 12 Dec 2024 11:03:33 +1100
Subject: [PATCH 106/554] Add units tests for cBTC

We added the "cBTC" denomination but forgot to test it.

Add units test for "cBTC" as we do for the other denominations. Put all
the tests lines of code in the same order as the enum variants so a
reader can see easily that all cases are tested.
---
 units/src/amount/tests.rs | 49 ++++++++++++++++++++++++++++++++-------
 1 file changed, 40 insertions(+), 9 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index baa1200261..b855c76e9a 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -19,7 +19,7 @@ use crate::{FeeRate, Weight};
 #[test]
 #[cfg(feature = "alloc")]
 fn from_str_zero() {
-    let denoms = ["BTC", "mBTC", "uBTC", "bits", "sats"];
+    let denoms = ["BTC", "cBTC", "mBTC", "uBTC", "bits", "sats"];
     for denom in denoms {
         for v in &["0", "000"] {
             let s = format!("{} {}", v, denom);
@@ -232,6 +232,7 @@ fn floating_point() {
 
     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::CentiBitcoin), -250.0);
     assert_eq!(btc(-2.5).to_float_in(D::MilliBitcoin), -2500.0);
     assert_eq!(btc(2.5).to_float_in(D::Satoshi), 250000000.0);
 
@@ -599,30 +600,59 @@ fn to_from_string_in() {
     let sa_str = SignedAmount::from_str_in;
     let sa_sat = SignedAmount::from_sat;
 
-    assert_eq!("0.5", Amount::from_sat(50).to_string_in(D::Bit));
-    assert_eq!("-0.5", SignedAmount::from_sat(-50).to_string_in(D::Bit));
     assert_eq!("0.00253583", Amount::from_sat(253583).to_string_in(D::Bitcoin));
-    assert_eq!("-5", SignedAmount::from_sat(-5).to_string_in(D::Satoshi));
+    assert_eq!("-0.00253583", SignedAmount::from_sat(-253583).to_string_in(D::Bitcoin));
     assert_eq!("0.1", Amount::from_sat(100_000_00).to_string_in(D::Bitcoin));
+    assert_eq!("-0.1", SignedAmount::from_sat(-100_000_00).to_string_in(D::Bitcoin));
+
+    assert_eq!("0.253583", Amount::from_sat(253583).to_string_in(D::CentiBitcoin));
+    assert_eq!("-0.253583", SignedAmount::from_sat(-253583).to_string_in(D::CentiBitcoin));
+    assert_eq!("10", Amount::from_sat(100_000_00).to_string_in(D::CentiBitcoin));
+    assert_eq!("-10", SignedAmount::from_sat(-100_000_00).to_string_in(D::CentiBitcoin));
+
+    assert_eq!("2.53583", Amount::from_sat(253583).to_string_in(D::MilliBitcoin));
+    assert_eq!("-2.53583", SignedAmount::from_sat(-253583).to_string_in(D::MilliBitcoin));
+    assert_eq!("100", Amount::from_sat(100_000_00).to_string_in(D::MilliBitcoin));
+    assert_eq!("-100", SignedAmount::from_sat(-100_000_00).to_string_in(D::MilliBitcoin));
+
+    assert_eq!("2535.83", Amount::from_sat(253583).to_string_in(D::MicroBitcoin));
+    assert_eq!("-2535.83", SignedAmount::from_sat(-253583).to_string_in(D::MicroBitcoin));
+    assert_eq!("100000", Amount::from_sat(100_000_00).to_string_in(D::MicroBitcoin));
+    assert_eq!("-100000", SignedAmount::from_sat(-100_000_00).to_string_in(D::MicroBitcoin));
+
+    assert_eq!("0.5", Amount::from_sat(50).to_string_in(D::Bit));
+    assert_eq!("100", Amount::from_sat(10_000).to_string_in(D::Bit));
+    assert_eq!("-0.5", SignedAmount::from_sat(-50).to_string_in(D::Bit));
     assert_eq!("-100", SignedAmount::from_sat(-10_000).to_string_in(D::Bit));
 
+    assert_eq!("5", Amount::from_sat(5).to_string_in(D::Satoshi));
+    assert_eq!("-5", SignedAmount::from_sat(-5).to_string_in(D::Satoshi));
+
     assert_eq!("0.50", format!("{:.2}", Amount::from_sat(50).display_in(D::Bit)));
     assert_eq!("-0.50", format!("{:.2}", SignedAmount::from_sat(-50).display_in(D::Bit)));
+
     assert_eq!("0.10000000", format!("{:.8}", Amount::from_sat(100_000_00).display_in(D::Bitcoin)));
     assert_eq!("-100.00", format!("{:.2}", SignedAmount::from_sat(-10_000).display_in(D::Bit)));
 
-    assert_eq!(ua_str(&ua_sat(0).to_string_in(D::Satoshi), D::Satoshi), Ok(ua_sat(0)));
     assert_eq!(ua_str(&ua_sat(500).to_string_in(D::Bitcoin), D::Bitcoin), Ok(ua_sat(500)));
-    assert_eq!(ua_str(&ua_sat(21_000_000).to_string_in(D::Bit), D::Bit), Ok(ua_sat(21_000_000)));
-    assert_eq!(ua_str(&ua_sat(1).to_string_in(D::MicroBitcoin), D::MicroBitcoin), Ok(ua_sat(1)));
+    assert_eq!(ua_str(&ua_sat(1).to_string_in(D::CentiBitcoin), D::CentiBitcoin), Ok(ua_sat(1)));
     assert_eq!(
         ua_str(&ua_sat(1_000_000_000_000).to_string_in(D::MilliBitcoin), D::MilliBitcoin),
         Ok(ua_sat(1_000_000_000_000))
     );
+    assert_eq!(ua_str(&ua_sat(1).to_string_in(D::MicroBitcoin), D::MicroBitcoin), Ok(ua_sat(1)));
+    assert_eq!(ua_str(&ua_sat(21_000_000).to_string_in(D::Bit), D::Bit), Ok(ua_sat(21_000_000)));
+    assert_eq!(ua_str(&ua_sat(0).to_string_in(D::Satoshi), D::Satoshi), Ok(ua_sat(0)));
+
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Bitcoin), D::Bitcoin).is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::CentiBitcoin), D::CentiBitcoin)
+        .is_ok());
     assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MilliBitcoin), D::MilliBitcoin)
         .is_ok());
-
-    assert_eq!(sa_str(&sa_sat(-1).to_string_in(D::MicroBitcoin), D::MicroBitcoin), Ok(sa_sat(-1)));
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MicroBitcoin), D::MicroBitcoin)
+        .is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Bit), D::Bit).is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Satoshi), D::Satoshi).is_ok());
 
     assert_eq!(
         sa_str(&sa_sat(i64::MAX).to_string_in(D::Satoshi), D::MicroBitcoin),
@@ -645,6 +675,7 @@ fn to_string_with_denomination_from_str_roundtrip() {
     let amt = Amount::from_sat(42);
     let denom = Amount::to_string_with_denomination;
     assert_eq!(denom(amt, D::Bitcoin).parse::<Amount>(), Ok(amt));
+    assert_eq!(denom(amt, D::CentiBitcoin).parse::<Amount>(), Ok(amt));
     assert_eq!(denom(amt, D::MilliBitcoin).parse::<Amount>(), Ok(amt));
     assert_eq!(denom(amt, D::MicroBitcoin).parse::<Amount>(), Ok(amt));
     assert_eq!(denom(amt, D::Bit).parse::<Amount>(), Ok(amt));

From cd0fa2d1dc239fce62bae48b0d2f4aa7a25890fd Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 15:37:21 +1100
Subject: [PATCH 107/554] Make FeeRate ops impls more terse

Remove all instances of `FeeRate as Add>::Output` and just use
`Self::Output`.

No logic change.
---
 units/src/fee_rate.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index d6b4c33cb2..b605b14b15 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -194,19 +194,19 @@ impl Add for FeeRate {
 impl Add<FeeRate> for &FeeRate {
     type Output = FeeRate;
 
-    fn add(self, other: FeeRate) -> <FeeRate as Add>::Output { FeeRate(self.0 + other.0) }
+    fn add(self, other: FeeRate) -> Self::Output { FeeRate(self.0 + other.0) }
 }
 
 impl Add<&FeeRate> for FeeRate {
     type Output = FeeRate;
 
-    fn add(self, other: &FeeRate) -> <FeeRate as Add>::Output { FeeRate(self.0 + other.0) }
+    fn add(self, other: &FeeRate) -> Self::Output { FeeRate(self.0 + other.0) }
 }
 
 impl<'a> Add<&'a FeeRate> for &FeeRate {
     type Output = FeeRate;
 
-    fn add(self, other: &'a FeeRate) -> <FeeRate as Add>::Output { FeeRate(self.0 + other.0) }
+    fn add(self, other: &'a FeeRate) -> Self::Output { FeeRate(self.0 + other.0) }
 }
 
 impl Sub for FeeRate {
@@ -218,19 +218,19 @@ impl Sub for FeeRate {
 impl Sub<FeeRate> for &FeeRate {
     type Output = FeeRate;
 
-    fn sub(self, other: FeeRate) -> <FeeRate as Add>::Output { FeeRate(self.0 - other.0) }
+    fn sub(self, other: FeeRate) -> Self::Output { FeeRate(self.0 - other.0) }
 }
 
 impl Sub<&FeeRate> for FeeRate {
     type Output = FeeRate;
 
-    fn sub(self, other: &FeeRate) -> <FeeRate as Add>::Output { FeeRate(self.0 - other.0) }
+    fn sub(self, other: &FeeRate) -> Self::Output { FeeRate(self.0 - other.0) }
 }
 
 impl<'a> Sub<&'a FeeRate> for &FeeRate {
     type Output = FeeRate;
 
-    fn sub(self, other: &'a FeeRate) -> <FeeRate as Add>::Output { FeeRate(self.0 - other.0) }
+    fn sub(self, other: &'a FeeRate) -> Self::Output { FeeRate(self.0 - other.0) }
 }
 
 /// Computes the ceiling so that the fee computation is conservative.

From b31ca72b3395f7ec9195e9ede8c1090b367a089b Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 15:39:22 +1100
Subject: [PATCH 108/554] units: Use rhs instead of other

Be uniform and use `rhs` for all identifiers in the ops impls.

Refactor only, no logic changes.
---
 units/src/amount/signed.rs   |  4 ++--
 units/src/amount/unsigned.rs |  4 ++--
 units/src/fee_rate.rs        | 12 ++++++------
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 4ee898d2cb..0f548ccdcf 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -390,7 +390,7 @@ impl ops::Add for SignedAmount {
 }
 
 impl ops::AddAssign for SignedAmount {
-    fn add_assign(&mut self, other: SignedAmount) { *self = *self + other }
+    fn add_assign(&mut self, rhs: SignedAmount) { *self = *self + rhs }
 }
 
 impl ops::Sub for SignedAmount {
@@ -402,7 +402,7 @@ impl ops::Sub for SignedAmount {
 }
 
 impl ops::SubAssign for SignedAmount {
-    fn sub_assign(&mut self, other: SignedAmount) { *self = *self - other }
+    fn sub_assign(&mut self, rhs: SignedAmount) { *self = *self - rhs }
 }
 
 impl ops::Rem<i64> for SignedAmount {
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 6bd45f14b9..5d31bb055c 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -459,7 +459,7 @@ impl ops::Add for Amount {
 }
 
 impl ops::AddAssign for Amount {
-    fn add_assign(&mut self, other: Amount) { *self = *self + other }
+    fn add_assign(&mut self, rhs: Amount) { *self = *self + rhs }
 }
 
 impl ops::Sub for Amount {
@@ -471,7 +471,7 @@ impl ops::Sub for Amount {
 }
 
 impl ops::SubAssign for Amount {
-    fn sub_assign(&mut self, other: Amount) { *self = *self - other }
+    fn sub_assign(&mut self, rhs: Amount) { *self = *self - rhs }
 }
 
 impl ops::Rem<u64> for Amount {
diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index b605b14b15..65fd58e776 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -194,19 +194,19 @@ impl Add for FeeRate {
 impl Add<FeeRate> for &FeeRate {
     type Output = FeeRate;
 
-    fn add(self, other: FeeRate) -> Self::Output { FeeRate(self.0 + other.0) }
+    fn add(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
 }
 
 impl Add<&FeeRate> for FeeRate {
     type Output = FeeRate;
 
-    fn add(self, other: &FeeRate) -> Self::Output { FeeRate(self.0 + other.0) }
+    fn add(self, rhs: &FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
 }
 
 impl<'a> Add<&'a FeeRate> for &FeeRate {
     type Output = FeeRate;
 
-    fn add(self, other: &'a FeeRate) -> Self::Output { FeeRate(self.0 + other.0) }
+    fn add(self, rhs: &'a FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
 }
 
 impl Sub for FeeRate {
@@ -218,19 +218,19 @@ impl Sub for FeeRate {
 impl Sub<FeeRate> for &FeeRate {
     type Output = FeeRate;
 
-    fn sub(self, other: FeeRate) -> Self::Output { FeeRate(self.0 - other.0) }
+    fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
 }
 
 impl Sub<&FeeRate> for FeeRate {
     type Output = FeeRate;
 
-    fn sub(self, other: &FeeRate) -> Self::Output { FeeRate(self.0 - other.0) }
+    fn sub(self, rhs: &FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
 }
 
 impl<'a> Sub<&'a FeeRate> for &FeeRate {
     type Output = FeeRate;
 
-    fn sub(self, other: &'a FeeRate) -> Self::Output { FeeRate(self.0 - other.0) }
+    fn sub(self, rhs: &'a FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
 }
 
 /// Computes the ceiling so that the fee computation is conservative.

From 6ce5385914269dcf968e1fb26efc012f2072ee16 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 15:49:01 +1100
Subject: [PATCH 109/554] units: Add macros for Add and Sub

Add macros for implementing `ops::Add` and `ops::Sub` for various
combinations of references. Use the macro in `fee_rate`.

These are internal macros so no need to protect `core` using
`$crate::_export::_core`.
---
 units/src/fee_rate.rs        | 38 ++-------------------
 units/src/internal_macros.rs | 65 ++++++++++++++++++++++++++++++++++++
 units/src/lib.rs             |  2 ++
 3 files changed, 69 insertions(+), 36 deletions(-)
 create mode 100644 units/src/internal_macros.rs

diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index 65fd58e776..eb3995ad4d 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -190,48 +190,14 @@ impl Add for FeeRate {
 
     fn add(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
 }
-
-impl Add<FeeRate> for &FeeRate {
-    type Output = FeeRate;
-
-    fn add(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
-}
-
-impl Add<&FeeRate> for FeeRate {
-    type Output = FeeRate;
-
-    fn add(self, rhs: &FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
-}
-
-impl<'a> Add<&'a FeeRate> for &FeeRate {
-    type Output = FeeRate;
-
-    fn add(self, rhs: &'a FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
-}
+crate::internal_macros::impl_add_for_references!(FeeRate);
 
 impl Sub for FeeRate {
     type Output = FeeRate;
 
     fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
 }
-
-impl Sub<FeeRate> for &FeeRate {
-    type Output = FeeRate;
-
-    fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
-}
-
-impl Sub<&FeeRate> for FeeRate {
-    type Output = FeeRate;
-
-    fn sub(self, rhs: &FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
-}
-
-impl<'a> Sub<&'a FeeRate> for &FeeRate {
-    type Output = FeeRate;
-
-    fn sub(self, rhs: &'a FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
-}
+crate::internal_macros::impl_sub_for_references!(FeeRate);
 
 /// Computes the ceiling so that the fee computation is conservative.
 impl Mul<FeeRate> for Weight {
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
new file mode 100644
index 0000000000..bd4ce335b0
--- /dev/null
+++ b/units/src/internal_macros.rs
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Internal macros.
+//!
+//! Macros meant to be used inside the `bitcoin-units` library.
+
+/// Implements `ops::Add` for various references.
+///
+/// Requires `$ty` it implement `Add` e.g. 'impl Add<T> for T'. Adds impls of:
+///
+/// - Add<T> for &T
+/// - Add<&T> for T
+/// - Add<&T> for &T
+macro_rules! impl_add_for_references {
+    ($ty:ident) => {
+        impl core::ops::Add<$ty> for &$ty {
+            type Output = $ty;
+
+            fn add(self, rhs: $ty) -> Self::Output { *self + rhs }
+        }
+
+        impl core::ops::Add<&$ty> for $ty {
+            type Output = $ty;
+
+            fn add(self, rhs: &$ty) -> Self::Output { self + *rhs }
+        }
+
+        impl<'a> core::ops::Add<&'a $ty> for &$ty {
+            type Output = $ty;
+
+            fn add(self, rhs: &'a $ty) -> Self::Output { *self + *rhs }
+        }
+    }
+}
+pub(crate) use impl_add_for_references;
+
+/// Implement `ops::Sub` for various references.
+///
+/// Requires `$ty` it implement `Sub` e.g. 'impl Sub<T> for T'. Adds impls of:
+///
+/// - Sub<T> for &T
+/// - Sub<&T> for T
+/// - Sub<&T> for &T
+macro_rules! impl_sub_for_references {
+    ($ty:ident) => {
+        impl core::ops::Sub<$ty> for &$ty {
+            type Output = $ty;
+
+            fn sub(self, rhs: $ty) -> Self::Output { *self - rhs }
+        }
+
+        impl core::ops::Sub<&$ty> for $ty {
+            type Output = $ty;
+
+            fn sub(self, rhs: &$ty) -> Self::Output { self - *rhs }
+        }
+
+        impl<'a> core::ops::Sub<&'a $ty> for &$ty {
+            type Output = $ty;
+
+            fn sub(self, rhs: &'a $ty) -> Self::Output { *self - *rhs }
+        }
+    }
+}
+pub(crate) use impl_sub_for_references;
diff --git a/units/src/lib.rs b/units/src/lib.rs
index f97bc430ff..ffcbfa3d7d 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -23,6 +23,8 @@ extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std;
 
+mod internal_macros;
+
 #[doc(hidden)]
 pub mod _export {
     /// A re-export of core::*

From 20a79da3443394f14b42abe5fe87b0e506e4ee97 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 16:07:48 +1100
Subject: [PATCH 110/554] units: Use one level of path for ops traits

Make all the `core::ops` impls in the `units` crate uniform by using a
single level of path for the traits.
---
 units/src/fee_rate.rs | 21 ++++++++++-----------
 units/src/weight.rs   | 23 +++++++++++------------
 2 files changed, 21 insertions(+), 23 deletions(-)

diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index eb3995ad4d..1c2daad412 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -2,8 +2,7 @@
 
 //! Implements `FeeRate` and assoctiated features.
 
-use core::fmt;
-use core::ops::{Add, AddAssign, Div, Mul, Sub, SubAssign};
+use core::{fmt, ops};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
@@ -185,14 +184,14 @@ impl From<FeeRate> for u64 {
     fn from(value: FeeRate) -> Self { value.to_sat_per_kwu() }
 }
 
-impl Add for FeeRate {
+impl ops::Add for FeeRate {
     type Output = FeeRate;
 
     fn add(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
 }
 crate::internal_macros::impl_add_for_references!(FeeRate);
 
-impl Sub for FeeRate {
+impl ops::Sub for FeeRate {
     type Output = FeeRate;
 
     fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
@@ -200,7 +199,7 @@ impl Sub for FeeRate {
 crate::internal_macros::impl_sub_for_references!(FeeRate);
 
 /// Computes the ceiling so that the fee computation is conservative.
-impl Mul<FeeRate> for Weight {
+impl ops::Mul<FeeRate> for Weight {
     type Output = Amount;
 
     fn mul(self, rhs: FeeRate) -> Self::Output {
@@ -208,13 +207,13 @@ impl Mul<FeeRate> for Weight {
     }
 }
 
-impl Mul<Weight> for FeeRate {
+impl ops::Mul<Weight> for FeeRate {
     type Output = Amount;
 
     fn mul(self, rhs: Weight) -> Self::Output { rhs * self }
 }
 
-impl Div<Weight> for Amount {
+impl ops::Div<Weight> for Amount {
     type Output = FeeRate;
 
     /// Truncating integer division.
@@ -224,19 +223,19 @@ impl Div<Weight> for Amount {
     fn div(self, rhs: Weight) -> Self::Output { FeeRate(self.to_sat() * 1000 / rhs.to_wu()) }
 }
 
-impl AddAssign for FeeRate {
+impl ops::AddAssign for FeeRate {
     fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0 }
 }
 
-impl AddAssign<&FeeRate> for FeeRate {
+impl ops::AddAssign<&FeeRate> for FeeRate {
     fn add_assign(&mut self, rhs: &FeeRate) { self.0 += rhs.0 }
 }
 
-impl SubAssign for FeeRate {
+impl ops::SubAssign for FeeRate {
     fn sub_assign(&mut self, rhs: Self) { self.0 -= rhs.0 }
 }
 
-impl SubAssign<&FeeRate> for FeeRate {
+impl ops::SubAssign<&FeeRate> for FeeRate {
     fn sub_assign(&mut self, rhs: &FeeRate) { self.0 -= rhs.0 }
 }
 
diff --git a/units/src/weight.rs b/units/src/weight.rs
index a8b1e94cbb..717b3813b5 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -2,8 +2,7 @@
 
 //! Implements `Weight` and associated features.
 
-use core::fmt;
-use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
+use core::{fmt, ops};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
@@ -167,55 +166,55 @@ impl From<Weight> for u64 {
     fn from(value: Weight) -> Self { value.to_wu() }
 }
 
-impl Add for Weight {
+impl ops::Add for Weight {
     type Output = Weight;
 
     fn add(self, rhs: Weight) -> Self::Output { Weight(self.0 + rhs.0) }
 }
 
-impl AddAssign for Weight {
+impl ops::AddAssign for Weight {
     fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0 }
 }
 
-impl Sub for Weight {
+impl ops::Sub for Weight {
     type Output = Weight;
 
     fn sub(self, rhs: Weight) -> Self::Output { Weight(self.0 - rhs.0) }
 }
 
-impl SubAssign for Weight {
+impl ops::SubAssign for Weight {
     fn sub_assign(&mut self, rhs: Self) { self.0 -= rhs.0 }
 }
 
-impl Mul<u64> for Weight {
+impl ops::Mul<u64> for Weight {
     type Output = Weight;
 
     fn mul(self, rhs: u64) -> Self::Output { Weight(self.0 * rhs) }
 }
 
-impl Mul<Weight> for u64 {
+impl ops::Mul<Weight> for u64 {
     type Output = Weight;
 
     fn mul(self, rhs: Weight) -> Self::Output { Weight(self * rhs.0) }
 }
 
-impl MulAssign<u64> for Weight {
+impl ops::MulAssign<u64> for Weight {
     fn mul_assign(&mut self, rhs: u64) { self.0 *= rhs }
 }
 
-impl Div<u64> for Weight {
+impl ops::Div<u64> for Weight {
     type Output = Weight;
 
     fn div(self, rhs: u64) -> Self::Output { Weight(self.0 / rhs) }
 }
 
-impl Div<Weight> for Weight {
+impl ops::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 {
+impl ops::DivAssign<u64> for Weight {
     fn div_assign(&mut self, rhs: u64) { self.0 /= rhs }
 }
 

From c5fbc7e117e47287c9acf5a29fef2b2402f23686 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 16:19:50 +1100
Subject: [PATCH 111/554] units: Add assign macros

Add macros for implementing `ops::AddAssign` and `ops::SubAssign`. Use
them in `fee_rate`.

Refactor only, no logic changes.
---
 units/src/fee_rate.rs        | 18 ++----------------
 units/src/internal_macros.rs | 28 ++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index 1c2daad412..6700434cd2 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -190,6 +190,7 @@ impl ops::Add for FeeRate {
     fn add(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
 }
 crate::internal_macros::impl_add_for_references!(FeeRate);
+crate::internal_macros::impl_add_assign!(FeeRate);
 
 impl ops::Sub for FeeRate {
     type Output = FeeRate;
@@ -197,6 +198,7 @@ impl ops::Sub for FeeRate {
     fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
 }
 crate::internal_macros::impl_sub_for_references!(FeeRate);
+crate::internal_macros::impl_sub_assign!(FeeRate);
 
 /// Computes the ceiling so that the fee computation is conservative.
 impl ops::Mul<FeeRate> for Weight {
@@ -223,22 +225,6 @@ impl ops::Div<Weight> for Amount {
     fn div(self, rhs: Weight) -> Self::Output { FeeRate(self.to_sat() * 1000 / rhs.to_wu()) }
 }
 
-impl ops::AddAssign for FeeRate {
-    fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0 }
-}
-
-impl ops::AddAssign<&FeeRate> for FeeRate {
-    fn add_assign(&mut self, rhs: &FeeRate) { self.0 += rhs.0 }
-}
-
-impl ops::SubAssign for FeeRate {
-    fn sub_assign(&mut self, rhs: Self) { self.0 -= rhs.0 }
-}
-
-impl ops::SubAssign<&FeeRate> for FeeRate {
-    fn sub_assign(&mut self, rhs: &FeeRate) { self.0 -= rhs.0 }
-}
-
 impl core::iter::Sum for FeeRate {
     fn sum<I>(iter: I) -> Self
     where
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
index bd4ce335b0..03536b5ec5 100644
--- a/units/src/internal_macros.rs
+++ b/units/src/internal_macros.rs
@@ -34,6 +34,20 @@ macro_rules! impl_add_for_references {
 }
 pub(crate) use impl_add_for_references;
 
+/// Implement `ops::AddAssign` for `$ty` and `&$ty`.
+macro_rules! impl_add_assign {
+    ($ty:ident) => {
+         impl core::ops::AddAssign<$ty> for $ty {
+            fn add_assign(&mut self, rhs: $ty) { *self = *self + rhs }
+        }
+
+        impl core::ops::AddAssign<&$ty> for $ty {
+            fn add_assign(&mut self, rhs: &$ty) { *self = *self + *rhs }
+        }
+    }
+}
+pub(crate) use impl_add_assign;
+
 /// Implement `ops::Sub` for various references.
 ///
 /// Requires `$ty` it implement `Sub` e.g. 'impl Sub<T> for T'. Adds impls of:
@@ -63,3 +77,17 @@ macro_rules! impl_sub_for_references {
     }
 }
 pub(crate) use impl_sub_for_references;
+
+/// Implement `ops::SubAssign` for `$ty` and `&$ty`.
+macro_rules! impl_sub_assign {
+    ($ty:ident) => {
+         impl core::ops::SubAssign<$ty> for $ty {
+            fn sub_assign(&mut self, rhs: $ty) { *self = *self - rhs }
+        }
+
+        impl core::ops::SubAssign<&$ty> for $ty {
+            fn sub_assign(&mut self, rhs: &$ty) { *self = *self - *rhs }
+        }
+   }
+}
+pub(crate) use impl_sub_assign;

From 43ef9a618c6bc94d2d9e291d92e013b946e3b72d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 16:31:03 +1100
Subject: [PATCH 112/554] units: Implement ops for Weight

Use the shiny new ops macros to implement the full set of `Add`,
`AddAssign`, `Sub`, and `SubAssign` impls we require.
---
 units/src/weight.rs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/units/src/weight.rs b/units/src/weight.rs
index 717b3813b5..4191c18ea4 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -171,20 +171,16 @@ impl ops::Add for Weight {
 
     fn add(self, rhs: Weight) -> Self::Output { Weight(self.0 + rhs.0) }
 }
-
-impl ops::AddAssign for Weight {
-    fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0 }
-}
+crate::internal_macros::impl_add_for_references!(Weight);
+crate::internal_macros::impl_add_assign!(Weight);
 
 impl ops::Sub for Weight {
     type Output = Weight;
 
     fn sub(self, rhs: Weight) -> Self::Output { Weight(self.0 - rhs.0) }
 }
-
-impl ops::SubAssign for Weight {
-    fn sub_assign(&mut self, rhs: Self) { self.0 -= rhs.0 }
-}
+crate::internal_macros::impl_sub_for_references!(Weight);
+crate::internal_macros::impl_sub_assign!(Weight);
 
 impl ops::Mul<u64> for Weight {
     type Output = Weight;

From 4a3aa4a08b5ff12cb59db0bc6124a65431bc313e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 16:29:05 +1100
Subject: [PATCH 113/554] Add ops unit tests for Weight

Copy the unit tests from `FeeRate` that prove `Add`, `AddAssign`, `Sub`,
and `SubAssign` for references.
---
 units/src/weight.rs | 48 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/units/src/weight.rs b/units/src/weight.rs
index 4191c18ea4..9c8b9d8a6c 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -357,4 +357,52 @@ mod tests {
 
     #[test]
     fn checked_div_overflows() { assert!(TWO.checked_div(0).is_none()) }
+
+    #[test]
+    #[allow(clippy::op_ref)]
+    fn addition() {
+        let one = Weight(1);
+        let two = Weight(2);
+        let three = Weight(3);
+
+        assert!(one + two == three);
+        assert!(&one + two == three);
+        assert!(one + &two == three);
+        assert!(&one + &two == three);
+    }
+
+    #[test]
+    #[allow(clippy::op_ref)]
+    fn subtract() {
+        let one = Weight(1);
+        let two = Weight(2);
+        let three = Weight(3);
+
+        assert!(three - two == one);
+        assert!(&three - two == one);
+        assert!(three - &two == one);
+        assert!(&three - &two == one);
+    }
+
+    #[test]
+    fn add_assign() {
+        let mut f = Weight(1);
+        f += Weight(2);
+        assert_eq!(f, Weight(3));
+
+        let mut f = Weight(1);
+        f += &Weight(2);
+        assert_eq!(f, Weight(3));
+    }
+
+    #[test]
+    fn sub_assign() {
+        let mut f = Weight(3);
+        f -= Weight(2);
+        assert_eq!(f, Weight(1));
+
+        let mut f = Weight(3);
+        f -= &Weight(2);
+        assert_eq!(f, Weight(1));
+    }
 }

From d88306fb6887acea96c8e26e8ae9fd34371487be Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 16:37:44 +1100
Subject: [PATCH 114/554] units: Implement ops for amount types

Use the shiny new ops macros to implement the full set of `Add`,
`AddAssign`, `Sub`, and `SubAssign` impls we require.
---
 units/src/amount/signed.rs   | 12 ++++--------
 units/src/amount/unsigned.rs | 12 ++++--------
 2 files changed, 8 insertions(+), 16 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 0f548ccdcf..ea58bf32dc 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -388,10 +388,8 @@ impl ops::Add for SignedAmount {
         self.checked_add(rhs).expect("SignedAmount addition error")
     }
 }
-
-impl ops::AddAssign for SignedAmount {
-    fn add_assign(&mut self, rhs: SignedAmount) { *self = *self + rhs }
-}
+crate::internal_macros::impl_add_for_references!(SignedAmount);
+crate::internal_macros::impl_add_assign!(SignedAmount);
 
 impl ops::Sub for SignedAmount {
     type Output = SignedAmount;
@@ -400,10 +398,8 @@ impl ops::Sub for SignedAmount {
         self.checked_sub(rhs).expect("SignedAmount subtraction error")
     }
 }
-
-impl ops::SubAssign for SignedAmount {
-    fn sub_assign(&mut self, rhs: SignedAmount) { *self = *self - rhs }
-}
+crate::internal_macros::impl_sub_for_references!(SignedAmount);
+crate::internal_macros::impl_sub_assign!(SignedAmount);
 
 impl ops::Rem<i64> for SignedAmount {
     type Output = SignedAmount;
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 5d31bb055c..87f1553c48 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -457,10 +457,8 @@ impl ops::Add for Amount {
         self.checked_add(rhs).expect("Amount addition error")
     }
 }
-
-impl ops::AddAssign for Amount {
-    fn add_assign(&mut self, rhs: Amount) { *self = *self + rhs }
-}
+crate::internal_macros::impl_add_for_references!(Amount);
+crate::internal_macros::impl_add_assign!(Amount);
 
 impl ops::Sub for Amount {
     type Output = Amount;
@@ -469,10 +467,8 @@ impl ops::Sub for Amount {
         self.checked_sub(rhs).expect("Amount subtraction error")
     }
 }
-
-impl ops::SubAssign for Amount {
-    fn sub_assign(&mut self, rhs: Amount) { *self = *self - rhs }
-}
+crate::internal_macros::impl_sub_for_references!(Amount);
+crate::internal_macros::impl_sub_assign!(Amount);
 
 impl ops::Rem<u64> for Amount {
     type Output = Amount;

From b956940a6dadce0bdcc3549e50b77d2ece6fc676 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 11 Dec 2024 16:35:18 +1100
Subject: [PATCH 115/554] Add ops unit tests for amount types

Copy the unit tests from `FeeRate` that prove `Add`, `AddAssign`, `Sub`,
and `SubAssign` for references.
---
 units/src/amount/tests.rs | 96 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 9d3687f6a7..ac4237acb4 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -977,3 +977,99 @@ fn trailing_zeros_for_amount() {
     assert_eq!(format!("{}", Amount::from_sat(400_000_000_000_010)), "4000000.0000001 BTC");
     assert_eq!(format!("{}", Amount::from_sat(400_000_000_000_000)), "4000000 BTC");
 }
+
+#[test]
+#[allow(clippy::op_ref)]
+fn unsigned_addition() {
+    let one = Amount::from_sat(1);
+    let two = Amount::from_sat(2);
+    let three = Amount::from_sat(3);
+
+    assert!(one + two == three);
+    assert!(&one + two == three);
+    assert!(one + &two == three);
+    assert!(&one + &two == three);
+}
+
+#[test]
+#[allow(clippy::op_ref)]
+fn unsigned_subtract() {
+    let one = Amount::from_sat(1);
+    let two = Amount::from_sat(2);
+    let three = Amount::from_sat(3);
+
+    assert!(three - two == one);
+    assert!(&three - two == one);
+    assert!(three - &two == one);
+    assert!(&three - &two == one);
+}
+
+#[test]
+fn unsigned_add_assign() {
+    let mut f = Amount::from_sat(1);
+    f += Amount::from_sat(2);
+    assert_eq!(f, Amount::from_sat(3));
+
+    let mut f = Amount::from_sat(1);
+    f += &Amount::from_sat(2);
+    assert_eq!(f, Amount::from_sat(3));
+}
+
+#[test]
+fn unsigned_sub_assign() {
+    let mut f = Amount::from_sat(3);
+    f -= Amount::from_sat(2);
+    assert_eq!(f, Amount::from_sat(1));
+
+    let mut f = Amount::from_sat(3);
+    f -= &Amount::from_sat(2);
+    assert_eq!(f, Amount::from_sat(1));
+}
+
+#[test]
+#[allow(clippy::op_ref)]
+fn signed_addition() {
+    let one = SignedAmount::from_sat(1);
+    let two = SignedAmount::from_sat(2);
+    let three = SignedAmount::from_sat(3);
+
+    assert!(one + two == three);
+    assert!(&one + two == three);
+    assert!(one + &two == three);
+    assert!(&one + &two == three);
+}
+
+#[test]
+#[allow(clippy::op_ref)]
+fn signed_subtract() {
+    let one = SignedAmount::from_sat(1);
+    let two = SignedAmount::from_sat(2);
+    let three = SignedAmount::from_sat(3);
+
+    assert!(three - two == one);
+    assert!(&three - two == one);
+    assert!(three - &two == one);
+    assert!(&three - &two == one);
+}
+
+#[test]
+fn signed_add_assign() {
+    let mut f = SignedAmount::from_sat(1);
+    f += SignedAmount::from_sat(2);
+    assert_eq!(f, SignedAmount::from_sat(3));
+
+    let mut f = SignedAmount::from_sat(1);
+    f += &SignedAmount::from_sat(2);
+    assert_eq!(f, SignedAmount::from_sat(3));
+}
+
+#[test]
+fn signed_sub_assign() {
+    let mut f = SignedAmount::from_sat(3);
+    f -= SignedAmount::from_sat(2);
+    assert_eq!(f, SignedAmount::from_sat(1));
+
+    let mut f = SignedAmount::from_sat(3);
+    f -= &SignedAmount::from_sat(2);
+    assert_eq!(f, SignedAmount::from_sat(1));
+}

From 68f3c3e5d728a60a4b52ca64523770bcdd32f957 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 16 Dec 2024 13:19:05 +1100
Subject: [PATCH 116/554] api: Run just check-api

---
 api/units/all-features.txt | 79 +++++++++++++++++++++++++++++++-------
 api/units/alloc-only.txt   | 79 +++++++++++++++++++++++++++++++-------
 api/units/no-features.txt  | 79 +++++++++++++++++++++++++++++++-------
 3 files changed, 195 insertions(+), 42 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 8205d61f8d..4ec25b5978 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -477,15 +477,24 @@ impl core::ops::arith::Add for bitcoin_units::SignedAmount
 impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
 impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::Add for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl core::ops::arith::AddAssign for bitcoin_units::Amount
 impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
 impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
 impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::ops::arith::Div for bitcoin_units::weight::Weight
 impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
 impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
@@ -514,15 +523,24 @@ impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
 impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::Sub for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl core::ops::arith::SubAssign for bitcoin_units::Amount
 impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
 impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
 impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::SubAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
@@ -613,8 +631,14 @@ impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bit
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockHeight
 impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockInterval
 impl<'de> serde::de::Deserialize<'de> for bitcoin_units::fee_rate::FeeRate
@@ -743,14 +767,28 @@ pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::add(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::sub(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
 pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: &bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
@@ -783,8 +821,10 @@ pub fn bitcoin_units::Amount::ser_sat<S: serde::ser::Serializer>(self, s: S, _:
 pub fn bitcoin_units::Amount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
 pub fn bitcoin_units::Amount::to_btc(self) -> f64
@@ -797,8 +837,10 @@ pub fn bitcoin_units::Amount::type_prefix(_: private::Token) -> &'static str
 pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
 pub fn bitcoin_units::SignedAmount::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
@@ -835,8 +877,10 @@ pub fn bitcoin_units::SignedAmount::ser_sat_opt<S: serde::ser::Serializer>(self,
 pub fn bitcoin_units::SignedAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
 pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
 pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
@@ -977,10 +1021,10 @@ pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::string::String) -
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
 pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
@@ -995,10 +1039,10 @@ pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, st
 pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_units::fee_rate::FeeRate::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
@@ -1103,8 +1147,10 @@ pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u
 pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
 pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: bitcoin_units::weight::Weight)
 pub fn bitcoin_units::weight::Weight::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
 pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
@@ -1122,8 +1168,10 @@ pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_units::weight::Weight::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
+pub fn bitcoin_units::weight::Weight::sub(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: bitcoin_units::weight::Weight)
 pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
 pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
 pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
@@ -1197,7 +1245,10 @@ pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
 pub trait bitcoin_units::amount::serde::SerdeAmount: core::marker::Copy + core::marker::Sized
 pub trait bitcoin_units::amount::serde::SerdeAmountForOpt: core::marker::Copy + core::marker::Sized + bitcoin_units::amount::serde::SerdeAmount
 pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
+pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
 pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 8e5fed4e90..691aeca992 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -455,15 +455,24 @@ impl core::ops::arith::Add for bitcoin_units::SignedAmount
 impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
 impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::Add for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl core::ops::arith::AddAssign for bitcoin_units::Amount
 impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
 impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
 impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::ops::arith::Div for bitcoin_units::weight::Weight
 impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
 impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
@@ -492,15 +501,24 @@ impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
 impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::Sub for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl core::ops::arith::SubAssign for bitcoin_units::Amount
 impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
 impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
 impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::SubAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
@@ -579,8 +597,14 @@ impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bit
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::Amount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::Amount>
 impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::SignedAmount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::SignedAmount>
 pub bitcoin_units::amount::Denomination::Bit
@@ -701,14 +725,28 @@ pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::add(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::sub(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
 pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: &bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
 pub fn bitcoin_units::Amount::default() -> Self
@@ -731,8 +769,10 @@ pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
 pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
 pub fn bitcoin_units::Amount::to_btc(self) -> f64
@@ -744,8 +784,10 @@ pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> co
 pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
 pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
 pub fn bitcoin_units::SignedAmount::default() -> Self
@@ -772,8 +814,10 @@ pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::Signe
 pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
 pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
 pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
 pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
 pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
@@ -882,10 +926,10 @@ pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::string::String) -
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
 pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
 pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
@@ -897,10 +941,10 @@ pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Resu
 pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
@@ -991,8 +1035,10 @@ pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u
 pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
 pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: bitcoin_units::weight::Weight)
 pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
 pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
 pub fn bitcoin_units::weight::Weight::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
@@ -1007,8 +1053,10 @@ pub fn bitcoin_units::weight::Weight::mul(self, rhs: bitcoin_units::fee_rate::Fe
 pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::weight::Weight::sub(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: bitcoin_units::weight::Weight)
 pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
 pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
 pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
@@ -1073,7 +1121,10 @@ pub struct bitcoin_units::parse::UnprefixedHexError(_)
 pub struct bitcoin_units::weight::Weight(_)
 pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
 pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
+pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
 pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 6ca6ce9ca2..86c9be5639 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -439,15 +439,24 @@ impl core::ops::arith::Add for bitcoin_units::SignedAmount
 impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
 impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::Add for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Add<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl core::ops::arith::AddAssign for bitcoin_units::Amount
 impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
 impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
 impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::AddAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::ops::arith::Div for bitcoin_units::weight::Weight
 impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
 impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
@@ -476,15 +485,24 @@ impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
 impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::Sub for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
+impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
 impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::Sub<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl core::ops::arith::SubAssign for bitcoin_units::Amount
 impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
 impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
 impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
+impl core::ops::arith::SubAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
+impl core::ops::arith::SubAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
 impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
+impl core::ops::arith::SubAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
@@ -563,8 +581,14 @@ impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bit
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Add<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
 impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
+impl<'a> core::ops::arith::Sub<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::Amount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::Amount>
 impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::SignedAmount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::SignedAmount>
 pub bitcoin_units::amount::Denomination::Bit
@@ -683,14 +707,28 @@ pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
 pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: &'a bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, other: bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::add(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::sub(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
+pub fn &bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
 pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
+pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: &bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
 pub fn bitcoin_units::Amount::default() -> Self
@@ -711,8 +749,10 @@ pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
 pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
+pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub_assign(&mut self, other: bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
+pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
 pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
@@ -720,8 +760,10 @@ pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> co
 pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
+pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
 pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
 pub fn bitcoin_units::SignedAmount::default() -> Self
@@ -746,8 +788,10 @@ pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::Signe
 pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
 pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
 pub fn bitcoin_units::SignedAmount::signum(self) -> i64
+pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, other: bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
+pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
 pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
 pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
@@ -848,10 +892,10 @@ pub fn bitcoin_units::block::BlockInterval::try_from(s: &str) -> core::result::R
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
 pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
 pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
 pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
@@ -863,10 +907,10 @@ pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Resu
 pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, other: &bitcoin_units::fee_rate::FeeRate) -> <bitcoin_units::fee_rate::FeeRate as core::ops::arith::Add>::Output
+pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
@@ -947,8 +991,10 @@ pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u
 pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
 pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
+pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: bitcoin_units::weight::Weight)
 pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
 pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
 pub fn bitcoin_units::weight::Weight::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
@@ -963,8 +1009,10 @@ pub fn bitcoin_units::weight::Weight::mul(self, rhs: bitcoin_units::fee_rate::Fe
 pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
+pub fn bitcoin_units::weight::Weight::sub(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: Self)
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
+pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: bitcoin_units::weight::Weight)
 pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
 pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
 pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
@@ -1027,7 +1075,10 @@ pub struct bitcoin_units::parse::UnprefixedHexError(_)
 pub struct bitcoin_units::weight::Weight(_)
 pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
 pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
+pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
+pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
+pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
 pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount

From bb294903086e2e317c9a7a6f298a36ec17082c39 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 13 Dec 2024 09:59:31 +0000
Subject: [PATCH 117/554] Remove double spacing in rustdocs

---
 bitcoin/src/blockdata/transaction.rs |  4 ++--
 bitcoin/src/p2p/mod.rs               |  4 ++--
 units/src/amount/mod.rs              |  4 ++--
 units/src/amount/signed.rs           |  4 ++--
 units/src/amount/unsigned.rs         | 14 +++++++-------
 5 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index a333c21975..8d1f7de0cf 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -773,11 +773,11 @@ impl Decodable for Transaction {
 
 /// Computes the value of an output accounting for the cost of spending it.
 ///
-/// The effective value is the value of an output value minus the amount to spend it.  That is, the
+/// The effective value is the value of an output value minus the amount to spend it. That is, the
 /// effective_value can be calculated as: value - (fee_rate * weight).
 ///
 /// Note: the effective value of a [`Transaction`] may increase less than the effective value of
-/// a [`TxOut`] when adding another [`TxOut`] to the transaction.  This happens when the new
+/// a [`TxOut`] when adding another [`TxOut`] to the transaction. This happens when the new
 /// [`TxOut`] added causes the output length `VarInt` to increase its encoding length.
 ///
 /// # Parameters
diff --git a/bitcoin/src/p2p/mod.rs b/bitcoin/src/p2p/mod.rs
index 074a225c23..3a881193a8 100644
--- a/bitcoin/src/p2p/mod.rs
+++ b/bitcoin/src/p2p/mod.rs
@@ -68,12 +68,12 @@ impl ServiceFlags {
     /// clients.
     pub const NETWORK: ServiceFlags = ServiceFlags(1 << 0);
 
-    /// GETUTXO means the node is capable of responding to the getutxo protocol request.  Bitcoin
+    /// 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
+    /// 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);
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index c25e78a1a0..d47410e611 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -44,7 +44,7 @@ pub use self::{
 ///
 /// # Note
 ///
-/// Due to ambiguity between mega and milli we prohibit usage of leading capital 'M'.  It is
+/// Due to ambiguity between mega and milli we prohibit usage of leading capital 'M'. It is
 /// more important to protect users from incorrectly using a capital M to mean milli than to
 /// allow Megabitcoin which is not a realistic denomination, and Megasatoshi which is
 /// equivalent to cBTC which is allowed.
@@ -124,7 +124,7 @@ impl Denomination {
     }
 }
 
-/// These form are ambigous and could have many meanings.  For example, M could denote Mega or Milli.
+/// 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; 6] = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"];
 
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index ea58bf32dc..42d15cfea5 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -27,7 +27,7 @@ use super::{
 /// 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`]
+/// start with `checked_`. The operations from [`core::ops`] that [`Amount`]
 /// implements will panic when overflow or underflow occurs.
 ///
 /// # Examples
@@ -103,7 +103,7 @@ impl SignedAmount {
 
     /// Parses a decimal string as a value in the given denomination.
     ///
-    /// Note: This only parses the value string.  If you want to parse a value
+    /// 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> {
         match parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(true))? {
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 87f1553c48..93bde1de61 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -29,8 +29,8 @@ use crate::{FeeRate, Weight};
 /// 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
+/// 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.
@@ -125,7 +125,7 @@ impl Amount {
 
     /// Parses a decimal string as a value in the given [`Denomination`].
     ///
-    /// Note: This only parses the value string.  If you want to parse a string
+    /// Note: This only parses the value string. If you want to parse a string
     /// containing the value with denomination, use [`FromStr`].
     ///
     /// # Errors
@@ -325,8 +325,8 @@ impl Amount {
     /// Checked weight ceiling division.
     ///
     /// Be aware that integer division loses the remainder if no exact division
-    /// can be made.  This method rounds up ensuring the transaction fee-rate is
-    /// sufficient.  See also [`Amount::checked_div_by_weight_floor`].
+    /// can be made. This method rounds up ensuring the transaction fee-rate is
+    /// sufficient. See also [`Amount::checked_div_by_weight_floor`].
     ///
     /// Returns [`None`] if overflow occurred.
     ///
@@ -359,7 +359,7 @@ impl Amount {
     /// Checked weight floor division.
     ///
     /// Be aware that integer division loses the remainder if no exact division
-    /// can be made.  See also [`Amount::checked_div_by_weight_ceil`].
+    /// can be made. See also [`Amount::checked_div_by_weight_ceil`].
     ///
     /// Returns [`None`] if overflow occurred.
     #[cfg(feature = "alloc")]
@@ -422,7 +422,7 @@ impl Amount {
         }
     }
 
-    /// Checks if the amount is below the maximum value.  Returns `None` if it is above.
+    /// Checks if the amount is below the maximum value. Returns `None` if it is above.
     const fn check_max(self) -> Option<Amount> {
         if self.0 > Self::MAX.0 {
             None

From 3520e832ac31d07101bc2eff259a715a8b95764e Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 17 Dec 2024 14:28:28 +0000
Subject: [PATCH 118/554] Make capitalization of SegWit uniform in rustdocs

---
 bitcoin/examples/bip32.rs                     |  2 +-
 bitcoin/examples/sighash.rs                   |  4 +-
 bitcoin/src/address/error.rs                  |  4 +-
 bitcoin/src/address/mod.rs                    | 26 +++++-----
 bitcoin/src/address/script_pubkey.rs          |  2 +-
 bitcoin/src/blockdata/script/borrowed.rs      |  2 +-
 bitcoin/src/blockdata/script/tests.rs         |  2 +-
 .../src/blockdata/script/witness_program.rs   |  4 +-
 bitcoin/src/blockdata/transaction.rs          | 48 +++++++++----------
 bitcoin/src/consensus/error.rs                |  2 +-
 bitcoin/src/crypto/key.rs                     |  2 +-
 bitcoin/src/crypto/sighash.rs                 | 20 ++++----
 bitcoin/src/policy.rs                         |  2 +-
 bitcoin/src/psbt/map/input.rs                 |  6 +--
 bitcoin/src/psbt/mod.rs                       | 10 ++--
 .../bitcoin/deserialize_transaction.rs        |  2 +-
 primitives/src/transaction.rs                 | 28 +++++------
 primitives/src/witness.rs                     |  4 +-
 18 files changed, 85 insertions(+), 85 deletions(-)

diff --git a/bitcoin/examples/bip32.rs b/bitcoin/examples/bip32.rs
index eec8eccac2..9df5ef6732 100644
--- a/bitcoin/examples/bip32.rs
+++ b/bitcoin/examples/bip32.rs
@@ -11,7 +11,7 @@ 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.
+    // calculates and prints out the first receiving SegWit address.
     // Run this example with cargo and seed(hex-encoded) argument:
     // cargo run --example bip32 7934c09359b234e076b9fa5a1abfd38e3dc2a9939745b7cc3c22a48d831d14bd
 
diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index 18e63ea6a2..1520f20221 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -13,7 +13,7 @@ use hex_lit::hex;
 
 //run with: cargo run --example sighash
 
-/// Computes segwit sighash for a transaction input that spends a p2wpkh output with "witness_v0_keyhash" scriptPubKey.type
+/// Computes SegWit sighash for a transaction input that spends a p2wpkh output with "witness_v0_keyhash" scriptPubKey.type
 ///
 /// # Parameters
 ///
@@ -98,7 +98,7 @@ fn compute_sighash_legacy(raw_tx: &[u8], inp_idx: usize, script_pubkey_bytes_opt
     }
 }
 
-/// Computes sighash for a segwit multisig transaction input that spends a p2wsh output with "witness_v0_scripthash" scriptPubKey.type
+/// Computes sighash for a SegWit multisig transaction input that spends a p2wsh output with "witness_v0_scripthash" scriptPubKey.type
 ///
 /// # Parameters
 ///
diff --git a/bitcoin/src/address/error.rs b/bitcoin/src/address/error.rs
index b972f7b124..40f4955878 100644
--- a/bitcoin/src/address/error.rs
+++ b/bitcoin/src/address/error.rs
@@ -78,7 +78,7 @@ impl std::error::Error for UnknownAddressTypeError {
 pub enum ParseError {
     /// Base58 legacy decoding error.
     Base58(Base58Error),
-    /// Bech32 segwit decoding error.
+    /// Bech32 SegWit decoding error.
     Bech32(Bech32Error),
     /// Address's network differs from required one.
     NetworkValidation(NetworkValidationError),
@@ -165,7 +165,7 @@ impl std::error::Error for NetworkValidationError {}
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Bech32Error {
-    /// Parse segwit Bech32 error.
+    /// Parse SegWit Bech32 error.
     ParseBech32(ParseBech32Error),
     /// A witness version conversion/parsing error.
     WitnessVersion(witness_version::TryFromError),
diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 2b0842fea4..54118b95a2 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -254,7 +254,7 @@ pub enum AddressData {
         /// The script hash used to encumber outputs to this address.
         script_hash: ScriptHash,
     },
-    /// Data encoded by a Segwit address.
+    /// Data encoded by a SegWit address.
     Segwit {
         /// The witness program used to encumber outputs to this address.
         witness_program: WitnessProgram,
@@ -421,7 +421,7 @@ impl Address {
 
     /// Constructs a new pay-to-witness-public-key-hash (P2WPKH) [`Address`] from a public key.
     ///
-    /// This is the native segwit address type for an output redeemable with a single signature.
+    /// This is the native SegWit address type for an output redeemable with a single signature.
     pub fn p2wpkh(pk: CompressedPublicKey, hrp: impl Into<KnownHrp>) -> Self {
         let program = WitnessProgram::p2wpkh(pk);
         Address::from_witness_program(program, hrp)
@@ -430,7 +430,7 @@ impl Address {
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] that embeds a
     /// pay-to-witness-public-key-hash (P2WPKH).
     ///
-    /// This is a segwit address type that looks familiar (as p2sh) to legacy clients.
+    /// This is a SegWit address type that looks familiar (as p2sh) to legacy clients.
     pub fn p2shwpkh(pk: CompressedPublicKey, network: impl Into<NetworkKind>) -> Address {
         let builder = script::Builder::new().push_int_unchecked(0).push_slice(pk.wpubkey_hash());
         let script_hash = builder.as_script().script_hash().expect("script is less than 520 bytes");
@@ -455,7 +455,7 @@ impl Address {
     /// Constructs a new pay-to-script-hash (P2SH) [`Address`] that embeds a
     /// pay-to-witness-script-hash (P2WSH).
     ///
-    /// This is a segwit address type that looks familiar (as p2sh) to legacy clients.
+    /// This is a SegWit address type that looks familiar (as p2sh) to legacy clients.
     pub fn p2shwsh(
         witness_script: &Script,
         network: impl Into<NetworkKind>,
@@ -546,7 +546,7 @@ impl Address {
         }
     }
 
-    /// Gets the witness program for this address if this is a segwit address.
+    /// Gets the witness program for this address if this is a SegWit address.
     pub fn witness_program(&self) -> Option<WitnessProgram> {
         use AddressInner::*;
 
@@ -642,7 +642,7 @@ impl Address {
     /// 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
+    /// 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();
@@ -684,7 +684,7 @@ impl Address {
     ///
     /// - For p2sh, the payload is the script hash.
     /// - For p2pkh, the payload is the pubkey hash.
-    /// - For segwit addresses, the payload is the witness program.
+    /// - For SegWit addresses, the payload is the witness program.
     fn payload_as_bytes(&self) -> &[u8] {
         use AddressInner::*;
         match self.0 {
@@ -868,18 +868,18 @@ impl<V: NetworkValidation> fmt::Debug for Address<V> {
 
 /// Address can be parsed only with `NetworkUnchecked`.
 ///
-/// Only segwit bech32 addresses prefixed with `bc`, `bcrt` or `tb` and legacy base58 addresses
+/// Only SegWit bech32 addresses prefixed with `bc`, `bcrt` or `tb` and legacy base58 addresses
 /// prefixed with `1`, `2, `3`, `m` or `n` are supported.
 ///
 /// # Errors
 ///
-/// - [`ParseError::Bech32`] if the segwit address begins with a `bc`, `bcrt` or `tb` and is not a
+/// - [`ParseError::Bech32`] if the SegWit address begins with a `bc`, `bcrt` or `tb` and is not a
 ///   valid bech32 address.
 ///
 /// - [`ParseError::Base58`] if the legacy address begins with a `1`, `2`, `3`, `m` or `n` and is
 ///   not a valid base58 address.
 ///
-/// - [`UnknownHrpError`] if the address does not begin with one of the above segwit or
+/// - [`UnknownHrpError`] if the address does not begin with one of the above SegWit or
 ///   legacy prifixes.
 impl FromStr for Address<NetworkUnchecked> {
     type Err = ParseError;
@@ -899,7 +899,7 @@ impl FromStr for Address<NetworkUnchecked> {
     }
 }
 
-/// Convert a byte array of a pubkey hash into a segwit redeem hash
+/// Convert a byte array of a pubkey hash into a SegWit redeem hash
 fn segwit_redeem_hash(pubkey_hash: PubkeyHash) -> hash160::Hash {
     let mut sha_engine = hash160::Hash::engine();
     sha_engine.input(&[0, 20]);
@@ -1099,9 +1099,9 @@ mod tests {
                 Some(AddressType::P2tr),
             ),
             // Related to future extensions, addresses are valid but have no type
-            // segwit v1 and len != 32
+            // SegWit v1 and len != 32
             ("bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y", None),
-            // segwit v2
+            // SegWit v2
             ("bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs", None),
         ];
         for (address, expected_type) in &addresses {
diff --git a/bitcoin/src/address/script_pubkey.rs b/bitcoin/src/address/script_pubkey.rs
index 2d801b0c87..8204675619 100644
--- a/bitcoin/src/address/script_pubkey.rs
+++ b/bitcoin/src/address/script_pubkey.rs
@@ -190,7 +190,7 @@ pub(super) fn new_witness_program_unchecked<T: AsRef<PushBytes>>(
 ) -> ScriptBuf {
     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.
+    // 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()
 }
diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs
index a922d7313d..b3a65ff964 100644
--- a/bitcoin/src/blockdata/script/borrowed.rs
+++ b/bitcoin/src/blockdata/script/borrowed.rs
@@ -172,7 +172,7 @@ crate::internal_macros::define_extension_trait! {
             instructions.next().is_none()
         }
 
-        /// Checks whether a script pubkey is a Segregated Witness (segwit) program.
+        /// Checks whether a script pubkey is a Segregated Witness (SegWit) program.
         #[inline]
         fn is_witness_program(&self) -> bool { self.witness_version().is_some() }
 
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 8d8932ce5e..fbe26348ac 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -672,7 +672,7 @@ fn script_ord() {
 fn test_bitcoinconsensus() {
     use crate::consensus_validation::ScriptExt as _;
 
-    // a random segwit transaction from the blockchain using native segwit
+    // 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");
diff --git a/bitcoin/src/blockdata/script/witness_program.rs b/bitcoin/src/blockdata/script/witness_program.rs
index 3b0cd4cad4..3fe824f499 100644
--- a/bitcoin/src/blockdata/script/witness_program.rs
+++ b/bitcoin/src/blockdata/script/witness_program.rs
@@ -31,7 +31,7 @@ pub const MAX_SIZE: usize = 40;
 /// number, therefore we carry the version number around along with the program bytes.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WitnessProgram {
-    /// The segwit version associated with this witness program.
+    /// The SegWit version associated with this witness program.
     version: WitnessVersion,
     /// The witness program (between 2 and 40 bytes).
     program: ArrayVec<u8, MAX_SIZE>,
@@ -47,7 +47,7 @@ impl WitnessProgram {
             return Err(InvalidLength(program_len));
         }
 
-        // Specific segwit v0 check. These addresses can never spend funds sent to them.
+        // 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));
         }
diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index a333c21975..a9e0cb1963 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -115,8 +115,8 @@ crate::internal_macros::define_extension_trait! {
             Weight::from_non_witness_data_size(self.base_size().to_u64())
         }
 
-        /// The weight of the TxIn when it's included in a segwit transaction (i.e., a transaction
-        /// having at least one segwit input).
+        /// 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.
@@ -125,7 +125,7 @@ crate::internal_macros::define_extension_trait! {
         /// 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
+        ///   transaction weight to take into account the SegWit marker
         fn segwit_weight(&self) -> Weight {
             Weight::from_non_witness_data_size(self.base_size().to_u64())
                 + Weight::from_witness_data_size(self.witness.size().to_u64())
@@ -220,7 +220,7 @@ pub trait TransactionExt: sealed::Sealed {
     #[deprecated(since = "0.31.0", note = "use `compute_txid()` instead")]
     fn txid(&self) -> Txid;
 
-    /// Computes the segwit version of the transaction id.
+    /// Computes the SegWit version of the transaction id.
     #[deprecated(since = "0.31.0", note = "use `compute_wtxid()` instead")]
     fn wtxid(&self) -> Wtxid;
 
@@ -234,13 +234,13 @@ pub trait TransactionExt: sealed::Sealed {
     /// 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,
+    /// 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.
+    /// 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
+    /// API. The unsigned transaction encoded within PSBT is always a non-SegWit transaction
     /// and can therefore avoid this ambiguity.
     fn weight(&self) -> Weight;
 
@@ -320,7 +320,7 @@ pub trait TransactionExt: sealed::Sealed {
     /// 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.
+    /// as well as any SegWit sigops will not be counted for that input.
     fn total_sigop_cost<S>(&self, spent: S) -> usize
     where
         S: FnMut(&OutPoint) -> Option<TxOut>;
@@ -452,12 +452,12 @@ trait TransactionExtPriv {
     /// `count_p2sh_sigops` and `count_witness_sigops` respectively).
     fn count_p2pk_p2pkh_sigops(&self) -> usize;
 
-    /// Does not include wrapped segwit (see `count_witness_sigops`).
+    /// 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>;
 
-    /// Includes wrapped segwit (returns 0 for Taproot spends).
+    /// Includes wrapped SegWit (returns 0 for Taproot spends).
     fn count_witness_sigops<S>(&self, spent: &mut S) -> usize
     where
         S: FnMut(&OutPoint) -> Option<TxOut>;
@@ -471,7 +471,7 @@ impl TransactionExtPriv for Transaction {
     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).
+            // 0 for p2wpkh, p2wsh, and p2sh (including wrapped SegWit).
             count = count.saturating_add(input.script_sig.count_sigops_legacy());
         }
         for output in &self.output {
@@ -480,7 +480,7 @@ impl TransactionExtPriv for Transaction {
         count
     }
 
-    /// Does not include wrapped segwit (see `count_witness_sigops`).
+    /// 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>,
@@ -505,7 +505,7 @@ impl TransactionExtPriv for Transaction {
         count
     }
 
-    /// Includes wrapped segwit (returns 0 for Taproot spends).
+    /// Includes wrapped SegWit (returns 0 for Taproot spends).
     fn count_witness_sigops<S>(&self, spent: &mut S) -> usize
     where
         S: FnMut(&OutPoint) -> Option<TxOut>,
@@ -712,7 +712,7 @@ impl Encodable for Transaction {
             len += self.input.consensus_encode(w)?;
             len += self.output.consensus_encode(w)?;
         } else {
-            // BIP-141 (segwit) transaction serialization also includes marker, flag, and witness data.
+            // BIP-141 (SegWit) transaction serialization also includes marker, flag, and witness data.
             len += SEGWIT_MARKER.consensus_encode(w)?;
             len += SEGWIT_FLAG.consensus_encode(w)?;
             len += self.input.consensus_encode(w)?;
@@ -732,7 +732,7 @@ impl Decodable for Transaction {
     ) -> Result<Self, encode::Error> {
         let version = Version::consensus_decode_from_finite_reader(r)?;
         let input = Vec::<TxIn>::consensus_decode_from_finite_reader(r)?;
-        // segwit
+        // SegWit
         if input.is_empty() {
             let segwit_flag = u8::consensus_decode_from_finite_reader(r)?;
             match segwit_flag {
@@ -759,7 +759,7 @@ impl Decodable for Transaction {
                 // We don't support anything else
                 x => Err(encode::ParseError::UnsupportedSegwitFlag(x).into()),
             }
-        // non-segwit
+        // non-SegWit
         } else {
             Ok(Transaction {
                 version,
@@ -1416,7 +1416,7 @@ mod tests {
 
     #[test]
     fn txid() {
-        // segwit tx from Liquid integration tests, txid/hash from Core decoderawtransaction
+        // SegWit tx from Liquid integration tests, txid/hash from Core decoderawtransaction
         let tx_bytes = hex!(
             "01000000000102ff34f95a672bb6a4f6ff4a7e90fa8c7b3be7e70ffc39bc99be3bda67942e836c00000000\
              23220020cde476664d3fa347b8d54ef3aee33dcb686a65ced2b5207cbf4ec5eda6b9b46e4f414d4c934ad8\
@@ -1460,7 +1460,7 @@ mod tests {
         assert_eq!(format!("{:.10x}", tx.compute_txid()), "9652aa62b0");
         assert_eq!(tx.weight(), Weight::from_wu(2718));
 
-        // non-segwit tx from my mempool
+        // non-SegWit tx from my mempool
         let tx_bytes = hex!(
             "01000000010c7196428403d8b0c88fcb3ee8d64f56f55c8973c9ab7dd106bb4f3527f5888d000000006a47\
              30440220503a696f55f2c00eee2ac5e65b17767cd88ed04866b5637d3c1d5d996a70656d02202c9aff698f\
@@ -1551,7 +1551,7 @@ mod tests {
         use crate::consensus_validation::{TransactionExt as _, TxVerifyError};
         use crate::witness::Witness;
 
-        // a random recent segwit transaction from blockchain using both old and segwit inputs
+        // 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")
@@ -1693,15 +1693,15 @@ mod tests {
     fn txin_txout_weight() {
         // [(is_segwit, tx_hex, expected_weight)]
         let txs = [
-                // one segwit input (P2WPKH)
+                // one SegWit input (P2WPKH)
                 (true, "020000000001018a763b78d3e17acea0625bf9e52b0dc1beb2241b2502185348ba8ff4a253176e0100000000ffffffff0280d725000000000017a914c07ed639bd46bf7087f2ae1dfde63b815a5f8b488767fda20300000000160014869ec8520fa2801c8a01bfdd2e82b19833cd0daf02473044022016243edad96b18c78b545325aaff80131689f681079fb107a67018cb7fb7830e02205520dae761d89728f73f1a7182157f6b5aecf653525855adb7ccb998c8e6143b012103b9489bde92afbcfa85129a82ffa512897105d1a27ad9806bded27e0532fc84e700000000", Weight::from_wu(565)),
-                // one segwit input (P2WSH)
+                // one SegWit input (P2WSH)
                 (true, "01000000000101a3ccad197118a2d4975fadc47b90eacfdeaf8268adfdf10ed3b4c3b7e1ad14530300000000ffffffff0200cc5501000000001976a91428ec6f21f4727bff84bb844e9697366feeb69f4d88aca2a5100d00000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220548f11130353b3a8f943d2f14260345fc7c20bde91704c9f1cbb5456355078cd0220383ed4ed39b079b618bcb279bbc1f2ca18cb028c4641cb522c9c5868c52a0dc20147304402203c332ecccb3181ca82c0600520ee51fee80d3b4a6ab110945e59475ec71e44ac0220679a11f3ca9993b04ccebda3c834876f353b065bb08f50076b25f5bb93c72ae1016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000", Weight::from_wu(766)),
-                // one segwit input (P2WPKH) and two legacy inputs (P2PKH)
+                // one SegWit input (P2WPKH) and two legacy inputs (P2PKH)
                 (true, "010000000001036b6b6ac7e34e97c53c1cc74c99c7948af2e6aac75d8778004ae458d813456764000000006a473044022001deec7d9075109306320b3754188f81a8236d0d232b44bc69f8309115638b8f02204e17a5194a519cf994d0afeea1268740bdc10616b031a521113681cc415e815c012103488d3272a9fad78ee887f0684cb8ebcfc06d0945e1401d002e590c7338b163feffffffffc75bd7aa6424aee972789ec28ba181254ee6d8311b058d165bd045154d7660b0000000006b483045022100c8641bcbee3e4c47a00417875015d8c5d5ea918fb7e96f18c6ffe51bc555b401022074e2c46f5b1109cd79e39a9aa203eadd1d75356415e51d80928a5fb5feb0efee0121033504b4c6dfc3a5daaf7c425aead4c2dbbe4e7387ce8e6be2648805939ecf7054ffffffff494df3b205cd9430a26f8e8c0dc0bb80496fbc555a524d6ea307724bc7e60eee0100000000ffffffff026d861500000000001976a9145c54ed1360072ebaf56e87693b88482d2c6a101588ace407000000000000160014761e31e2629c6e11936f2f9888179d60a5d4c1f900000247304402201fa38a67a63e58b67b6cfffd02f59121ca1c8a1b22e1efe2573ae7e4b4f06c2b022002b9b431b58f6e36b3334fb14eaecee7d2f06967a77ef50d8d5f90dda1057f0c01210257dc6ce3b1100903306f518ee8fa113d778e403f118c080b50ce079fba40e09a00000000", Weight::from_wu(1755)),
                 // three legacy inputs (P2PKH)
                 (false, "0100000003e4d7be4314204a239d8e00691128dca7927e19a7339c7948bde56f669d27d797010000006b483045022100b988a858e2982e2daaf0755b37ad46775d6132057934877a5badc91dee2f66ff022020b967c1a2f0916007662ec609987e951baafa6d4fda23faaad70715611d6a2501210254a2dccd8c8832d4677dc6f0e562eaaa5d11feb9f1de2c50a33832e7c6190796ffffffff9e22eb1b3f24c260187d716a8a6c2a7efb5af14a30a4792a6eeac3643172379c000000006a47304402207df07f0cd30dca2cf7bed7686fa78d8a37fe9c2254dfdca2befed54e06b779790220684417b8ff9f0f6b480546a9e90ecee86a625b3ea1e4ca29b080da6bd6c5f67e01210254a2dccd8c8832d4677dc6f0e562eaaa5d11feb9f1de2c50a33832e7c6190796ffffffff1123df3bfb503b59769731da103d4371bc029f57979ebce68067768b958091a1000000006a47304402207a016023c2b0c4db9a7d4f9232fcec2193c2f119a69125ad5bcedcba56dd525e02206a734b3a321286c896759ac98ebfd9d808df47f1ce1fbfbe949891cc3134294701210254a2dccd8c8832d4677dc6f0e562eaaa5d11feb9f1de2c50a33832e7c6190796ffffffff0200c2eb0b000000001976a914e5eb3e05efad136b1405f5c2f9adb14e15a35bb488ac88cfff1b000000001976a9144846db516db3130b7a3c92253599edec6bc9630b88ac00000000", Weight::from_wu(2080)),
-                // one segwit input (P2TR)
+                // one SegWit input (P2TR)
                 (true, "01000000000101b5cee87f1a60915c38bb0bc26aaf2b67be2b890bbc54bb4be1e40272e0d2fe0b0000000000ffffffff025529000000000000225120106daad8a5cb2e6fc74783714273bad554a148ca2d054e7a19250e9935366f3033760000000000002200205e6d83c44f57484fd2ef2a62b6d36cdcd6b3e06b661e33fd65588a28ad0dbe060141df9d1bfce71f90d68bf9e9461910b3716466bfe035c7dbabaa7791383af6c7ef405a3a1f481488a91d33cd90b098d13cb904323a3e215523aceaa04e1bb35cdb0100000000", Weight::from_wu(617)),
                 // one legacy input (P2PKH)
                 (false, "0100000001c336895d9fa674f8b1e294fd006b1ac8266939161600e04788c515089991b50a030000006a47304402204213769e823984b31dcb7104f2c99279e74249eacd4246dabcf2575f85b365aa02200c3ee89c84344ae326b637101a92448664a8d39a009c8ad5d147c752cbe112970121028b1b44b4903c9103c07d5a23e3c7cf7aeb0ba45ddbd2cfdce469ab197381f195fdffffff040000000000000000536a4c5058325bb7b7251cf9e36cac35d691bd37431eeea426d42cbdecca4db20794f9a4030e6cb5211fabf887642bcad98c9994430facb712da8ae5e12c9ae5ff314127d33665000bb26c0067000bb0bf00322a50c300000000000017a9145ca04fdc0a6d2f4e3f67cfeb97e438bb6287725f8750c30000000000001976a91423086a767de0143523e818d4273ddfe6d9e4bbcc88acc8465003000000001976a914c95cbacc416f757c65c942f9b6b8a20038b9b12988ac00000000", Weight::from_wu(1396)),
@@ -1724,7 +1724,7 @@ mod tests {
                 + tx.input.iter().fold(Weight::ZERO, |sum, i| sum + txin_weight(i))
                 + tx.output.iter().fold(Weight::ZERO, |sum, o| sum + o.weight());
 
-            // The empty tx uses segwit serialization but a legacy tx does not.
+            // The empty tx uses SegWit serialization but a legacy tx does not.
             if !tx.uses_segwit_serialization() {
                 calculated_weight -= Weight::from_wu(2);
             }
diff --git a/bitcoin/src/consensus/error.rs b/bitcoin/src/consensus/error.rs
index 21fd89bbe2..51b6307579 100644
--- a/bitcoin/src/consensus/error.rs
+++ b/bitcoin/src/consensus/error.rs
@@ -165,7 +165,7 @@ pub enum ParseError {
     NonMinimalVarInt,
     /// Parsing error.
     ParseFailed(&'static str),
-    /// Unsupported Segwit flag.
+    /// Unsupported SegWit flag.
     UnsupportedSegwitFlag(u8),
 }
 
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 7d0e3a95c7..a356759728 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -1093,7 +1093,7 @@ impl From<hex::HexToArrayError> for ParseCompressedPublicKeyError {
     fn from(e: hex::HexToArrayError) -> Self { Self::Hex(e) }
 }
 
-/// Segwit public keys must always be compressed.
+/// SegWit public keys must always be compressed.
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub struct UncompressedPublicKeyError;
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 5934e29348..35fe0f8f1a 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -51,7 +51,7 @@ hash_newtype! {
     #[hash_newtype(forward)]
     pub struct LegacySighash(sha256d::Hash);
 
-    /// Hash of a transaction according to the segwit version 0 signature algorithm.
+    /// Hash of a transaction according to the SegWit version 0 signature algorithm.
     #[hash_newtype(forward)]
     pub struct SegwitV0Sighash(sha256d::Hash);
 }
@@ -92,7 +92,7 @@ hashes::impl_serde_for_newtype!(TapSighash);
 
 impl_message_from_hash!(TapSighash);
 
-/// Efficiently calculates signature hash message for legacy, segwit and Taproot inputs.
+/// 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
@@ -100,17 +100,17 @@ pub struct SighashCache<T: Borrow<Transaction>> {
     /// 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 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`).
+    /// 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.
+/// Common values cached between SegWit and Taproot inputs.
 #[derive(Debug)]
 struct CommonCache {
     prevouts: sha256::Hash,
@@ -121,7 +121,7 @@ struct CommonCache {
     outputs: sha256::Hash,
 }
 
-/// Values cached for segwit inputs, equivalent to [`CommonCache`] plus another round of `sha256`.
+/// Values cached for SegWit inputs, equivalent to [`CommonCache`] plus another round of `sha256`.
 #[derive(Debug)]
 struct SegwitCache {
     prevouts: sha256d::Hash,
@@ -859,8 +859,8 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
 
     /// 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).
+    /// `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,
@@ -1150,9 +1150,9 @@ impl<R: BorrowMut<Transaction>> SighashCache<R> {
     /// *sighasher.witness_mut(input_index).unwrap() = Witness::p2wpkh(&signature, &pk);
     /// ```
     ///
-    /// For full signing code see the [`segwit v0`] and [`taproot`] signing examples.
+    /// For full signing code see the [`SegWit v0`] and [`taproot`] signing examples.
     ///
-    /// [`segwit v0`]: <https://github.com/rust-bitcoin/rust-bitcoin/blob/master/bitcoin/examples/sign-tx-segwit-v0.rs>
+    /// [`SegWit v0`]: <https://github.com/rust-bitcoin/rust-bitcoin/blob/master/bitcoin/examples/sign-tx-segwit-v0.rs>
     /// [`taproot`]: <https://github.com/rust-bitcoin/rust-bitcoin/blob/master/bitcoin/examples/sign-tx-taproot.rs>
     pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut Witness> {
         self.tx.borrow_mut().input.get_mut(input_index).map(|i| &mut i.witness)
diff --git a/bitcoin/src/policy.rs b/bitcoin/src/policy.rs
index 89eb08261e..ca1bacb0d7 100644
--- a/bitcoin/src/policy.rs
+++ b/bitcoin/src/policy.rs
@@ -18,7 +18,7 @@ use super::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)
+/// 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.
diff --git a/bitcoin/src/psbt/map/input.rs b/bitcoin/src/psbt/map/input.rs
index cfe9cfb467..401bc34b4a 100644
--- a/bitcoin/src/psbt/map/input.rs
+++ b/bitcoin/src/psbt/map/input.rs
@@ -69,11 +69,11 @@ const PSBT_IN_PROPRIETARY: u64 = 0xFC;
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Input {
     /// The non-witness transaction this input spends from. Should only be
-    /// `Option::Some` for inputs which spend non-segwit outputs or
-    /// if it is unknown whether an input spends a segwit output.
+    /// `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,
+    /// `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
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index be385433e4..1cc34dfddf 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -669,7 +669,7 @@ impl Psbt {
         let utxo = self.spend_utxo(input_index)?;
         let spk = utxo.script_pubkey.clone();
 
-        // Anything that is not segwit and is not p2sh is `Bare`.
+        // Anything that is not SegWit and is not p2sh is `Bare`.
         if !(spk.is_witness_program() || spk.is_p2sh()) {
             return Ok(OutputType::Bare);
         }
@@ -897,11 +897,11 @@ pub enum OutputType {
     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.
+    /// 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.
+    /// 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).
+    /// A pay-to-script-hash output excluding wrapped SegWit (P2SH).
     Sh,
     /// A Taproot output (P2TR).
     Tr,
@@ -954,7 +954,7 @@ pub enum SignError {
     NotEcdsa,
     /// The `scriptPubkey` is not a P2WPKH script.
     NotWpkh,
-    /// Sighash computation error (segwit v0 input).
+    /// Sighash computation error (SegWit v0 input).
     SegwitV0Sighash(transaction::InputsIndexError),
     /// Sighash computation error (p2wpkh input).
     P2wpkhSighash(sighash::P2wpkhError),
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs b/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
index 0ded475ad6..c37e8e7e21 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_transaction.rs
@@ -16,7 +16,7 @@ fn do_test(data: &[u8]) {
             }
             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
+            // we serialize as SegWit even after "stripping the witnesses". We need
             // to drop two bytes (i.e. eight weight). Similarly, calculated_weight is
             // incorrect and needs 2 wu removing for the marker/flag bytes.
             if tx.input.is_empty() {
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 4a4c6f6687..9b950da011 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -48,7 +48,7 @@ use crate::witness::Witness;
 /// ### 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
+/// 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.
 ///
@@ -58,22 +58,22 @@ use crate::witness::Witness;
 /// 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
+/// 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
+/// 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
+/// 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
+/// 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
+/// 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
@@ -150,8 +150,8 @@ impl Transaction {
 
     /// 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,
+    /// 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::compute_wtxid()`].
     #[doc(alias = "txid")]
     pub fn compute_txid(&self) -> Txid {
@@ -159,10 +159,10 @@ impl Transaction {
         Txid::from_byte_array(hash.to_byte_array())
     }
 
-    /// Computes the segwit version of the transaction id.
+    /// 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,
+    /// 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::compute_txid()`].
     #[doc(alias = "wtxid")]
     pub fn compute_wtxid(&self) -> Wtxid {
@@ -235,7 +235,7 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
     enc.input(&tx.version.0.to_le_bytes()); // Same as `encode::emit_i32`.
 
     if uses_segwit_serialization {
-        // BIP-141 (segwit) transaction serialization also includes marker and flag.
+        // BIP-141 (SegWit) transaction serialization also includes marker and flag.
         enc.input(&[SEGWIT_MARKER]);
         enc.input(&[SEGWIT_FLAG]);
     }
@@ -268,7 +268,7 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
     }
 
     if uses_segwit_serialization {
-        // BIP-141 (segwit) transaction serialization also includes the witness data.
+        // BIP-141 (SegWit) transaction serialization also includes the witness data.
         for input in &tx.input {
             // Same as `Encodable for Witness`.
             enc.input(compact_size::encode(input.witness.len()).as_slice());
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index b8f507dc59..4d0bb9bc5e 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -13,7 +13,7 @@ use internals::compact_size;
 
 use crate::prelude::Vec;
 
-/// The Witness is the data used to unlock bitcoin since the [segwit upgrade].
+/// The Witness is the data used to unlock bitcoin since the [SegWit upgrade].
 ///
 /// Can be logically seen as an array of bytestrings, i.e. `Vec<Vec<u8>>`, and it is serialized on the wire
 /// in that format. You can convert between this type and `Vec<Vec<u8>>` by using [`Witness::from_slice`]
@@ -22,7 +22,7 @@ use crate::prelude::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>
+/// [SegWit upgrade]: <https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki>
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Witness {
     /// Contains the witness `Vec<Vec<u8>>` serialization.

From e56f461916b85928139950074d0df52caf4f919b Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 17 Dec 2024 14:29:42 +0000
Subject: [PATCH 119/554] Make capitalization of SegWit uniform in strings

---
 bitcoin/examples/sighash.rs    | 4 ++--
 bitcoin/src/address/error.rs   | 2 +-
 bitcoin/src/consensus/error.rs | 2 +-
 bitcoin/src/crypto/key.rs      | 2 +-
 bitcoin/src/crypto/sighash.rs  | 2 +-
 bitcoin/src/psbt/mod.rs        | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index 1520f20221..370dd89dd5 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -45,7 +45,7 @@ fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, value: u64) {
     let sighash = cache
         .p2wpkh_signature_hash(inp_idx, &spk, Amount::from_sat(value), sig.sighash_type)
         .expect("failed to compute sighash");
-    println!("Segwit p2wpkh sighash: {:x}", sighash);
+    println!("SegWit p2wpkh sighash: {:x}", sighash);
     let msg = secp256k1::Message::from(sighash);
     println!("Message is {:x}", msg);
     let secp = secp256k1::Secp256k1::verification_only();
@@ -132,7 +132,7 @@ fn compute_sighash_p2wsh(raw_tx: &[u8], inp_idx: usize, value: u64) {
                 sig.sighash_type,
             )
             .expect("failed to compute sighash");
-        println!("Segwit p2wsh sighash: {:x} ({})", sighash, sig.sighash_type);
+        println!("SegWit p2wsh sighash: {:x} ({})", sighash, sig.sighash_type);
     }
 }
 
diff --git a/bitcoin/src/address/error.rs b/bitcoin/src/address/error.rs
index 40f4955878..1de9e7f950 100644
--- a/bitcoin/src/address/error.rs
+++ b/bitcoin/src/address/error.rs
@@ -182,7 +182,7 @@ impl fmt::Display for Bech32Error {
         use Bech32Error::*;
 
         match *self {
-            ParseBech32(ref e) => write_err!(f, "segwit parsing error"; e),
+            ParseBech32(ref e) => write_err!(f, "SegWit parsing error"; e),
             WitnessVersion(ref e) => write_err!(f, "witness version conversion/parsing error"; e),
             WitnessProgram(ref e) => write_err!(f, "witness program error"; e),
             UnknownHrp(ref e) => write_err!(f, "unknown hrp error"; e),
diff --git a/bitcoin/src/consensus/error.rs b/bitcoin/src/consensus/error.rs
index 51b6307579..e69e75b96a 100644
--- a/bitcoin/src/consensus/error.rs
+++ b/bitcoin/src/consensus/error.rs
@@ -184,7 +184,7 @@ impl fmt::Display for ParseError {
             NonMinimalVarInt => write!(f, "non-minimal varint"),
             ParseFailed(ref s) => write!(f, "parse failed: {}", s),
             UnsupportedSegwitFlag(ref swflag) =>
-                write!(f, "unsupported segwit version: {}", swflag),
+                write!(f, "unsupported SegWit version: {}", swflag),
         }
     }
 }
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index a356759728..559df1dc1d 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -1100,7 +1100,7 @@ pub struct UncompressedPublicKeyError;
 
 impl fmt::Display for UncompressedPublicKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("segwit public keys must always be compressed")
+        f.write_str("SegWit public keys must always be compressed")
     }
 }
 
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 35fe0f8f1a..abc8df43e5 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1273,7 +1273,7 @@ impl fmt::Display for P2wpkhError {
         use P2wpkhError::*;
 
         match *self {
-            Sighash(ref e) => write_err!(f, "error encoding segwit v0 signing data"; e),
+            Sighash(ref e) => write_err!(f, "error encoding SegWit v0 signing data"; e),
             NotP2wpkhScript => write!(f, "script is not a script pubkey for a p2wpkh output"),
         }
     }
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 1cc34dfddf..071b5afa34 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -986,7 +986,7 @@ impl fmt::Display for SignError {
             MismatchedAlgoKey => write!(f, "signing algorithm and key type does not match"),
             NotEcdsa => write!(f, "attempted to ECDSA sign an non-ECDSA input"),
             NotWpkh => write!(f, "the scriptPubkey is not a P2WPKH script"),
-            SegwitV0Sighash(ref e) => write_err!(f, "segwit v0 sighash"; e),
+            SegwitV0Sighash(ref e) => write_err!(f, "SegWit v0 sighash"; e),
             P2wpkhSighash(ref e) => write_err!(f, "p2wpkh sighash"; e),
             TaprootError(ref e) => write_err!(f, "Taproot sighash"; e),
             UnknownOutputType => write!(f, "unable to determine the output type"),

From f08d8741d39685b636830680bb891bd414826e88 Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Thu, 12 Dec 2024 10:29:07 -0600
Subject: [PATCH 120/554] Test types MIN/MAX instead of i64::MIN/i64::MAX

The MIN/MAX for SignedAmount recently changed from i64::MIN and
i64::MAX to MAX_MONEY/MIN_MONEY.  Update the tests to reflect this new
MIN/MAX since it is no longer valid to create a value above or bellow
MAX_MONEY/MIN_MONEY.
---
 units/src/amount/tests.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 6996dd8af1..9bc3270145 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -594,7 +594,6 @@ fn to_from_string_in() {
     let ua_str = Amount::from_str_in;
     let ua_sat = Amount::from_sat;
     let sa_str = SignedAmount::from_str_in;
-    let sa_sat = SignedAmount::from_sat;
 
     assert_eq!("0.00253583", Amount::from_sat(253583).to_string_in(D::Bitcoin));
     assert_eq!("-0.00253583", SignedAmount::from_sat(-253583).to_string_in(D::Bitcoin));
@@ -651,12 +650,12 @@ fn to_from_string_in() {
     assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Satoshi), D::Satoshi).is_ok());
 
     assert_eq!(
-        sa_str(&sa_sat(i64::MAX).to_string_in(D::Satoshi), D::MicroBitcoin),
+        sa_str(&SignedAmount::MAX.to_string_in(D::Satoshi), D::MicroBitcoin),
         Err(OutOfRangeError::too_big(true).into())
     );
     // Test an overflow bug in `abs()`
     assert_eq!(
-        sa_str(&sa_sat(i64::MIN).to_string_in(D::Satoshi), D::MicroBitcoin),
+        sa_str(&SignedAmount::MIN.to_string_in(D::Satoshi), D::MicroBitcoin),
         Err(OutOfRangeError::too_small().into())
     );
 }
@@ -931,12 +930,12 @@ fn checked_sum_amounts() {
     assert_eq!(None, sum);
 
     let amounts =
-        [SignedAmount::from_sat(i64::MIN), SignedAmount::from_sat(-1), SignedAmount::from_sat(21)];
+        [SignedAmount::MIN, SignedAmount::from_sat(-1), SignedAmount::from_sat(21)];
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 
     let amounts =
-        [SignedAmount::from_sat(i64::MAX), SignedAmount::from_sat(1), SignedAmount::from_sat(21)];
+        [SignedAmount::MAX, SignedAmount::from_sat(1), SignedAmount::from_sat(21)];
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 

From 01af2663356f9cf1f00e7aa0359aca7b9515e96a Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Tue, 17 Dec 2024 13:11:59 -0600
Subject: [PATCH 121/554] Remove deprecated tests

Unchecked methods have been removed in a previous commit, therefore the
tests are no longer applicable.
---
 units/src/amount/tests.rs | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 6996dd8af1..3663f60e11 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -168,34 +168,6 @@ fn amount_checked_div_by_weight_floor() {
     assert!(fee_rate.is_none());
 }
 
-#[test]
-#[cfg(not(debug_assertions))]
-fn unchecked_amount_add() {
-    let amt = Amount::MAX.unchecked_add(Amount::ONE_SAT);
-    assert_eq!(amt, Amount::ZERO);
-}
-
-#[test]
-#[cfg(not(debug_assertions))]
-fn unchecked_signed_amount_add() {
-    let signed_amt = SignedAmount::MAX.unchecked_add(SignedAmount::ONE_SAT);
-    assert_eq!(signed_amt, SignedAmount::MIN);
-}
-
-#[test]
-#[cfg(not(debug_assertions))]
-fn unchecked_amount_subtract() {
-    let amt = Amount::ZERO.unchecked_sub(Amount::ONE_SAT);
-    assert_eq!(amt, Amount::MAX);
-}
-
-#[test]
-#[cfg(not(debug_assertions))]
-fn unchecked_signed_amount_subtract() {
-    let signed_amt = SignedAmount::MIN.unchecked_sub(SignedAmount::ONE_SAT);
-    assert_eq!(signed_amt, SignedAmount::MAX);
-}
-
 #[cfg(feature = "alloc")]
 #[test]
 fn floating_point() {

From 5290a93a38980cac2cb9e176a1a26c7537647dc6 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 9 Dec 2024 09:31:20 +1100
Subject: [PATCH 122/554] units: Add all pedantic lints

Add all the pedantic lints to the repository by way of the repository
manifest. Then enable these lints in the `units` manifest.

Some things worth mentioning:

- Fix `needless_pass_by_value` by adding derives to `FormatOptions`.
- Fix lint `cast_lossless` using `cargo clippy --fix``
- While fixing `lint enum_glob_use` introduce a new style to the
codebase; import enums using a single character. Doing so prevents
namespace clashes, improves clarity, and maintains terseness.

Audit:

Use the following lints locally and audit all the warnings, they produce
many false positives so we can't enable them permentently.

- `cast_possible_truncation`
- `cast_possible_lint`
- `cast_sign_loss`
---
 units/Cargo.toml               | 125 +++++++++++++++++++++++++++++++++
 units/src/amount/error.rs      |  41 +++++------
 units/src/amount/mod.rs        |  27 +++----
 units/src/amount/signed.rs     |   6 +-
 units/src/amount/tests.rs      |  76 +++++++++++---------
 units/src/amount/unsigned.rs   |   5 +-
 units/src/block.rs             |   4 +-
 units/src/fee_rate.rs          |   2 +-
 units/src/lib.rs               |   4 +-
 units/src/locktime/absolute.rs |  34 ++++-----
 units/src/locktime/relative.rs |   4 +-
 units/src/parse.rs             |  28 ++++----
 units/src/weight.rs            |   4 +-
 13 files changed, 247 insertions(+), 113 deletions(-)

diff --git a/units/Cargo.toml b/units/Cargo.toml
index 21d5c9b17a..e3bd679a82 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -34,3 +34,128 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(kani)'] }
+
+[lints.clippy]
+# Exhaustive list of pedantic clippy lints
+assigning_clones = "warn"
+bool_to_int_with_if = "warn"
+borrow_as_ptr = "warn"
+case_sensitive_file_extension_comparisons = "warn"
+cast_lossless = "warn"
+cast_possible_truncation = "allow" # All casts should include a code comment (except test code).
+cast_possible_wrap = "allow" # Same as above re code comment.
+cast_precision_loss = "warn"
+cast_ptr_alignment = "warn"
+cast_sign_loss = "allow" # All casts should include a code comment (except in test code).
+checked_conversions = "warn"
+cloned_instead_of_copied = "warn"
+copy_iterator = "warn"
+default_trait_access = "warn"
+doc_link_with_quotes = "warn"
+doc_markdown = "warn"
+empty_enum = "warn"
+enum_glob_use = "warn"
+expl_impl_clone_on_copy = "warn"
+explicit_deref_methods = "warn"
+explicit_into_iter_loop = "warn"
+explicit_iter_loop = "warn"
+filter_map_next = "warn"
+flat_map_option = "warn"
+float_cmp = "allow" # Bitcoin floats are typically limited to 8 decimal places and we want them exact.
+fn_params_excessive_bools = "warn"
+from_iter_instead_of_collect = "warn"
+if_not_else = "warn"
+ignored_unit_patterns = "warn"
+implicit_clone = "warn"
+implicit_hasher = "warn"
+inconsistent_struct_constructor = "warn"
+index_refutable_slice = "warn"
+inefficient_to_string = "warn"
+inline_always = "warn"
+into_iter_without_iter = "warn"
+invalid_upcast_comparisons = "warn"
+items_after_statements = "warn"
+iter_filter_is_ok = "warn"
+iter_filter_is_some = "warn"
+iter_not_returning_iterator = "warn"
+iter_without_into_iter = "warn"
+large_digit_groups = "warn"
+large_futures = "warn"
+large_stack_arrays = "warn"
+large_types_passed_by_value = "warn"
+linkedlist = "warn"
+macro_use_imports = "warn"
+manual_assert = "warn"
+manual_instant_elapsed = "warn"
+manual_is_power_of_two = "warn"
+manual_is_variant_and = "warn"
+manual_let_else = "warn"
+manual_ok_or = "warn"
+manual_string_new = "warn"
+many_single_char_names = "warn"
+map_unwrap_or = "warn"
+match_bool = "allow" # Adds extra indentation and LOC.
+match_on_vec_items = "warn"
+match_same_arms = "allow" # Collapses things that are conceptually unrelated to each other.
+match_wild_err_arm = "warn"
+match_wildcard_for_single_variants = "warn"
+maybe_infinite_iter = "warn"
+mismatching_type_param_order = "warn"
+missing_errors_doc = "allow" # TODO: Still needs considering.
+missing_fields_in_debug = "warn"
+missing_panics_doc = "allow" # TODO: Still needs considering.
+must_use_candidate = "allow" # Useful for audit but many false positives.
+mut_mut = "warn"
+naive_bytecount = "warn"
+needless_bitwise_bool = "warn"
+needless_continue = "warn"
+needless_for_each = "warn"
+needless_pass_by_value = "warn"
+needless_raw_string_hashes = "warn"
+no_effect_underscore_binding = "warn"
+no_mangle_with_rust_abi = "warn"
+option_as_ref_cloned = "warn"
+option_option = "warn"
+ptr_as_ptr = "warn"
+ptr_cast_constness = "warn"
+pub_underscore_fields = "warn"
+range_minus_one = "warn"
+range_plus_one = "warn"
+redundant_closure_for_method_calls = "warn"
+redundant_else = "warn"
+ref_as_ptr = "warn"
+ref_binding_to_reference = "warn"
+ref_option = "allow" # TODO: Still neds considering.
+ref_option_ref = "warn"
+return_self_not_must_use = "warn"
+same_functions_in_if_condition = "warn"
+semicolon_if_nothing_returned = "warn"
+should_panic_without_expect = "warn"
+similar_names = "allow" # Too many (subjectively) false positives.
+single_char_pattern = "warn"
+single_match_else = "warn"
+stable_sort_primitive = "warn"
+str_split_at_newline = "warn"
+string_add_assign = "warn"
+struct_excessive_bools = "warn"
+struct_field_names = "warn"
+too_many_lines = "warn"
+transmute_ptr_to_ptr = "warn"
+trivially_copy_pass_by_ref = "warn"
+unchecked_duration_subtraction = "warn"
+unicode_not_nfc = "warn"
+uninlined_format_args = "allow" # This is a subjective style choice.
+unnecessary_box_returns = "warn"
+unnecessary_join = "warn"
+unnecessary_literal_bound = "warn"
+unnecessary_wraps = "warn"
+unnested_or_patterns = "warn"
+unreadable_literal = "warn"
+unsafe_derive_deserialize = "warn"
+unused_async = "warn"
+unused_self = "warn"
+used_underscore_binding = "warn"
+used_underscore_items = "warn"
+verbose_bit_mask = "warn"
+wildcard_imports = "warn"
+zero_sized_map_values = "warn"
diff --git a/units/src/amount/error.rs b/units/src/amount/error.rs
index 55939b5ae5..d90e70c5aa 100644
--- a/units/src/amount/error.rs
+++ b/units/src/amount/error.rs
@@ -119,14 +119,15 @@ internals::impl_from_infallible!(ParseAmountErrorInner);
 
 impl fmt::Display for ParseAmountError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseAmountErrorInner::*;
+        use ParseAmountErrorInner as E;
 
         match self.0 {
-            OutOfRange(ref error) => write_err!(f, "amount out of range"; error),
-            TooPrecise(ref error) => write_err!(f, "amount has a too high precision"; error),
-            MissingDigits(ref error) => write_err!(f, "the input has too few digits"; error),
-            InputTooLarge(ref error) => write_err!(f, "the input is too large"; error),
-            InvalidCharacter(ref error) => write_err!(f, "invalid character in the input"; error),
+            E::OutOfRange(ref error) => write_err!(f, "amount out of range"; error),
+            E::TooPrecise(ref error) => write_err!(f, "amount has a too high precision"; error),
+            E::MissingDigits(ref error) => write_err!(f, "the input has too few digits"; error),
+            E::InputTooLarge(ref error) => write_err!(f, "the input is too large"; error),
+            E::InvalidCharacter(ref error) =>
+                write_err!(f, "invalid character in the input"; error),
         }
     }
 }
@@ -134,14 +135,14 @@ impl fmt::Display for ParseAmountError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseAmountError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseAmountErrorInner::*;
+        use ParseAmountErrorInner as E;
 
         match self.0 {
-            TooPrecise(ref error) => Some(error),
-            InputTooLarge(ref error) => Some(error),
-            OutOfRange(ref error) => Some(error),
-            MissingDigits(ref error) => Some(error),
-            InvalidCharacter(ref error) => Some(error),
+            E::TooPrecise(ref error) => Some(error),
+            E::InputTooLarge(ref error) => Some(error),
+            E::OutOfRange(ref error) => Some(error),
+            E::MissingDigits(ref error) => Some(error),
+            E::InvalidCharacter(ref error) => Some(error),
         }
     }
 }
@@ -157,7 +158,7 @@ impl OutOfRangeError {
     /// Returns the minimum and maximum allowed values for the type that was parsed.
     ///
     /// This can be used to give a hint to the user which values are allowed.
-    pub fn valid_range(&self) -> (i64, u64) {
+    pub fn valid_range(self) -> (i64, u64) {
         match self.is_signed {
             true => (i64::MIN, i64::MAX as u64),
             false => (0, u64::MAX),
@@ -165,10 +166,10 @@ impl OutOfRangeError {
     }
 
     /// Returns true if the input value was large than the maximum allowed value.
-    pub fn is_above_max(&self) -> bool { self.is_greater_than_max }
+    pub fn is_above_max(self) -> bool { self.is_greater_than_max }
 
     /// Returns true if the input value was smaller than the minimum allowed value.
-    pub fn is_below_min(&self) -> bool { !self.is_greater_than_max }
+    pub fn is_below_min(self) -> bool { !self.is_greater_than_max }
 
     pub(crate) fn too_big(is_signed: bool) -> Self { Self { is_signed, is_greater_than_max: true } }
 
@@ -321,11 +322,11 @@ internals::impl_from_infallible!(ParseDenominationError);
 
 impl fmt::Display for ParseDenominationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseDenominationError::*;
+        use ParseDenominationError as E;
 
         match *self {
-            Unknown(ref e) => write_err!(f, "denomination parse error"; e),
-            PossiblyConfusing(ref e) => write_err!(f, "denomination parse error"; e),
+            E::Unknown(ref e) => write_err!(f, "denomination parse error"; e),
+            E::PossiblyConfusing(ref e) => write_err!(f, "denomination parse error"; e),
         }
     }
 }
@@ -333,10 +334,10 @@ impl fmt::Display for ParseDenominationError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseDenominationError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseDenominationError::*;
+        use ParseDenominationError as E;
 
         match *self {
-            Unknown(_) | PossiblyConfusing(_) => None,
+            E::Unknown(_) | E::PossiblyConfusing(_) => None,
         }
     }
 }
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index d47410e611..9a364fd083 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -124,8 +124,8 @@ impl Denomination {
     }
 }
 
-/// 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.
+/// 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; 6] = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"];
 
 impl fmt::Display for Denomination {
@@ -143,15 +143,15 @@ impl FromStr for Denomination {
     ///   letter that could be confused with centi, milli, or micro-bitcoin.
     /// - [`ParseDenominationError::Unknown`]: If an unknown denomination is used.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        use self::ParseDenominationError::*;
+        use self::ParseDenominationError as E;
 
         if CONFUSING_FORMS.contains(&s) {
-            return Err(PossiblyConfusing(PossiblyConfusingDenominationError(s.into())));
+            return Err(E::PossiblyConfusing(PossiblyConfusingDenominationError(s.into())));
         };
 
         let form = self::Denomination::forms(s);
 
-        form.ok_or_else(|| Unknown(UnknownDenominationError(s.into())))
+        form.ok_or_else(|| E::Unknown(UnknownDenominationError(s.into())))
     }
 }
 
@@ -217,7 +217,7 @@ fn parse_signed_to_satoshi(
                     Ok(0) => return Ok((is_negative, 0)),
                     _ =>
                         return Err(InnerParseError::TooPrecise(TooPreciseError {
-                            position: position + is_negative as usize,
+                            position: position + usize::from(is_negative),
                         })),
                 }
             }
@@ -236,7 +236,7 @@ fn parse_signed_to_satoshi(
                 // Do `value = 10 * value + digit`, catching overflows.
                 match 10_u64.checked_mul(value) {
                     None => return Err(InnerParseError::Overflow { is_negative }),
-                    Some(val) => match val.checked_add((c as u8 - b'0') as u64) {
+                    Some(val) => match val.checked_add(u64::from(c as u8 - b'0')) {
                         None => return Err(InnerParseError::Overflow { is_negative }),
                         Some(val) => value = val,
                     },
@@ -247,7 +247,7 @@ fn parse_signed_to_satoshi(
                     Some(d) if d < max_decimals => Some(d + 1),
                     _ =>
                         return Err(InnerParseError::TooPrecise(TooPreciseError {
-                            position: i + is_negative as usize,
+                            position: i + usize::from(is_negative),
                         })),
                 };
             }
@@ -258,13 +258,13 @@ fn parse_signed_to_satoshi(
                 _ =>
                     return Err(InnerParseError::InvalidCharacter(InvalidCharacterError {
                         invalid_char: '.',
-                        position: i + is_negative as usize,
+                        position: i + usize::from(is_negative),
                     })),
             },
             c =>
                 return Err(InnerParseError::InvalidCharacter(InvalidCharacterError {
                     invalid_char: c,
-                    position: i + is_negative as usize,
+                    position: i + usize::from(is_negative),
                 })),
         }
     }
@@ -319,6 +319,7 @@ fn split_amount_and_denomination(s: &str) -> Result<(&str, Denomination), ParseE
 }
 
 /// Options given by `fmt::Formatter`
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 struct FormatOptions {
     fill: char,
     align: Option<fmt::Alignment>,
@@ -394,7 +395,7 @@ fn fmt_satoshi_in(
         // We add the number of zeroes to the end
         Ordering::Greater => {
             if satoshi > 0 {
-                exp = precision as usize;
+                exp = precision as usize; // Cast ok, checked not negative above.
             }
             trailing_decimal_zeros = options.precision.unwrap_or(0);
         }
@@ -406,7 +407,7 @@ fn fmt_satoshi_in(
                 if usize::from(precision) > format_precision {
                     // precision is u8 so in this branch options.precision() < 255 which fits in u32
                     let rounding_divisor =
-                        10u64.pow(u32::from(precision) - format_precision as u32);
+                        10u64.pow(u32::from(precision) - format_precision as u32); // Cast ok, commented above.
                     let remainder = satoshi % rounding_divisor;
                     satoshi -= remainder;
                     if remainder / (rounding_divisor / 10) >= 5 {
@@ -424,7 +425,7 @@ fn fmt_satoshi_in(
                 norm_nb_decimals = usize::from(precision);
                 while num_after_decimal_point % 10 == 0 {
                     norm_nb_decimals -= 1;
-                    num_after_decimal_point /= 10
+                    num_after_decimal_point /= 10;
                 }
             }
             // compute requested precision
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 42d15cfea5..a817566e27 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -111,11 +111,11 @@ impl SignedAmount {
             (false, sat) if sat > SignedAmount::MAX.to_sat() as u64 => Err(ParseAmountError(
                 ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_big(true)),
             )),
-            (false, sat) => Ok(SignedAmount(sat as i64)),
+            (false, sat) => Ok(SignedAmount(sat as i64)), // Cast ok, value in this arm does not wrap.
             (true, sat) if sat > SignedAmount::MIN.to_sat().unsigned_abs() => Err(
                 ParseAmountError(ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_small())),
             ),
-            (true, sat) => Ok(SignedAmount(-(sat as i64))),
+            (true, sat) => Ok(SignedAmount(-(sat as i64))), // Cast ok, value in this arm does not wrap.
         }
     }
 
@@ -349,7 +349,7 @@ impl SignedAmount {
         if self.is_negative() {
             Err(OutOfRangeError::negative())
         } else {
-            Ok(Amount::from_sat(self.to_sat() as u64))
+            Ok(Amount::from_sat(self.to_sat() as u64)) // Cast ok, checked not negative above.
         }
     }
 
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 6996dd8af1..c5dd5330ff 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -114,7 +114,7 @@ fn test_overflows() {
     // panic on overflow
     let result = panic::catch_unwind(|| Amount::MAX + Amount::from_sat(1));
     assert!(result.is_err());
-    let result = panic::catch_unwind(|| Amount::from_sat(8446744073709551615) * 3);
+    let result = panic::catch_unwind(|| Amount::from_sat(8_446_744_073_709_551_615) * 3);
     assert!(result.is_err());
 }
 
@@ -205,16 +205,19 @@ fn floating_point() {
     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::Bitcoin), Ok(sat(1_122_000_000)));
+    assert_eq!(sf(-11.22, D::MilliBitcoin), Ok(ssat(-1_122_000)));
     assert_eq!(f(11.22, D::Bit), Ok(sat(1122)));
-    assert_eq!(f(0.0001234, D::Bitcoin), Ok(sat(12340)));
-    assert_eq!(sf(-0.00012345, D::Bitcoin), Ok(ssat(-12345)));
+    assert_eq!(f(0.000_123_4, D::Bitcoin), Ok(sat(12_340)));
+    assert_eq!(sf(-0.000_123_45, D::Bitcoin), Ok(ssat(-12_345)));
 
     assert_eq!(f(11.22, D::Satoshi), Err(TooPreciseError { position: 3 }.into()));
-    assert_eq!(f(42.123456781, D::Bitcoin), Err(TooPreciseError { position: 11 }.into()));
-    assert_eq!(sf(-184467440738.0, D::Bitcoin), Err(OutOfRangeError::too_small().into()));
-    assert_eq!(f(18446744073709551617.0, D::Satoshi), Err(OutOfRangeError::too_big(false).into()));
+    assert_eq!(f(42.123_456_781, D::Bitcoin), Err(TooPreciseError { position: 11 }.into()));
+    assert_eq!(sf(-184_467_440_738.0, D::Bitcoin), Err(OutOfRangeError::too_small().into()));
+    assert_eq!(
+        f(18_446_744_073_709_551_617.0, D::Satoshi),
+        Err(OutOfRangeError::too_big(false).into())
+    );
 
     assert_eq!(
         f(Amount::MAX.to_float_in(D::Satoshi) + 1.0, D::Satoshi),
@@ -230,10 +233,10 @@ fn floating_point() {
     assert_eq!(btc(2.5).to_float_in(D::Bitcoin), 2.5);
     assert_eq!(btc(-2.5).to_float_in(D::CentiBitcoin), -250.0);
     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::Satoshi), 250_000_000.0);
 
     let btc = move |f| Amount::from_btc(f).unwrap();
-    assert_eq!(&btc(0.0012).to_float_in(D::Bitcoin).to_string(), "0.0012")
+    assert_eq!(&btc(0.0012).to_float_in(D::Bitcoin).to_string(), "0.0012");
 }
 
 #[test]
@@ -508,6 +511,7 @@ fn test_unsigned_signed_conversion() {
 
 #[test]
 #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
+#[allow(clippy::items_after_statements)] // Define functions where we use them.
 fn from_str() {
     use ParseDenominationError::*;
 
@@ -577,7 +581,7 @@ fn from_str() {
 
     ok_case(".5 bits", Amount::from_sat(50));
     ok_scase("-.5 bits", SignedAmount::from_sat(-50));
-    ok_case("0.00253583 BTC", Amount::from_sat(253583));
+    ok_case("0.00253583 BTC", Amount::from_sat(253_583));
     ok_scase("-5 satoshi", SignedAmount::from_sat(-5));
     ok_case("0.10000000 BTC", Amount::from_sat(100_000_00));
     ok_scase("-100 bits", SignedAmount::from_sat(-10_000));
@@ -596,23 +600,25 @@ fn to_from_string_in() {
     let sa_str = SignedAmount::from_str_in;
     let sa_sat = SignedAmount::from_sat;
 
-    assert_eq!("0.00253583", Amount::from_sat(253583).to_string_in(D::Bitcoin));
-    assert_eq!("-0.00253583", SignedAmount::from_sat(-253583).to_string_in(D::Bitcoin));
+    assert_eq!("0.5", Amount::from_sat(50).to_string_in(D::Bit));
+    assert_eq!("-0.5", SignedAmount::from_sat(-50).to_string_in(D::Bit));
+    assert_eq!("0.00253583", Amount::from_sat(253_583).to_string_in(D::Bitcoin));
+    assert_eq!("-5", SignedAmount::from_sat(-5).to_string_in(D::Satoshi));
     assert_eq!("0.1", Amount::from_sat(100_000_00).to_string_in(D::Bitcoin));
     assert_eq!("-0.1", SignedAmount::from_sat(-100_000_00).to_string_in(D::Bitcoin));
 
-    assert_eq!("0.253583", Amount::from_sat(253583).to_string_in(D::CentiBitcoin));
-    assert_eq!("-0.253583", SignedAmount::from_sat(-253583).to_string_in(D::CentiBitcoin));
+    assert_eq!("0.253583", Amount::from_sat(253_583).to_string_in(D::CentiBitcoin));
+    assert_eq!("-0.253583", SignedAmount::from_sat(-253_583).to_string_in(D::CentiBitcoin));
     assert_eq!("10", Amount::from_sat(100_000_00).to_string_in(D::CentiBitcoin));
     assert_eq!("-10", SignedAmount::from_sat(-100_000_00).to_string_in(D::CentiBitcoin));
 
-    assert_eq!("2.53583", Amount::from_sat(253583).to_string_in(D::MilliBitcoin));
-    assert_eq!("-2.53583", SignedAmount::from_sat(-253583).to_string_in(D::MilliBitcoin));
+    assert_eq!("2.53583", Amount::from_sat(253_583).to_string_in(D::MilliBitcoin));
+    assert_eq!("-2.53583", SignedAmount::from_sat(-253_583).to_string_in(D::MilliBitcoin));
     assert_eq!("100", Amount::from_sat(100_000_00).to_string_in(D::MilliBitcoin));
     assert_eq!("-100", SignedAmount::from_sat(-100_000_00).to_string_in(D::MilliBitcoin));
 
-    assert_eq!("2535.83", Amount::from_sat(253583).to_string_in(D::MicroBitcoin));
-    assert_eq!("-2535.83", SignedAmount::from_sat(-253583).to_string_in(D::MicroBitcoin));
+    assert_eq!("2535.83", Amount::from_sat(253_583).to_string_in(D::MicroBitcoin));
+    assert_eq!("-2535.83", SignedAmount::from_sat(-253_583).to_string_in(D::MicroBitcoin));
     assert_eq!("100000", Amount::from_sat(100_000_00).to_string_in(D::MicroBitcoin));
     assert_eq!("-100000", SignedAmount::from_sat(-100_000_00).to_string_in(D::MicroBitcoin));
 
@@ -699,13 +705,13 @@ fn serde_as_sat() {
     }
 
     serde_test::assert_tokens(
-        &T { amt: Amount::from_sat(123456789), samt: SignedAmount::from_sat(-123456789) },
+        &T { amt: Amount::from_sat(123_456_789), samt: SignedAmount::from_sat(-123_456_789) },
         &[
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::Str("amt"),
-            serde_test::Token::U64(123456789),
+            serde_test::Token::U64(123_456_789),
             serde_test::Token::Str("samt"),
-            serde_test::Token::I64(-123456789),
+            serde_test::Token::I64(-123_456_789),
             serde_test::Token::StructEnd,
         ],
     );
@@ -763,7 +769,7 @@ fn serde_as_str() {
     }
 
     serde_test::assert_tokens(
-        &T { amt: Amount::from_sat(123456789), samt: SignedAmount::from_sat(-123456789) },
+        &T { amt: Amount::from_sat(123_456_789), samt: SignedAmount::from_sat(-123_456_789) },
         &[
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::String("amt"),
@@ -797,10 +803,10 @@ fn serde_as_btc_opt() {
     let without = T { amt: None, samt: None };
 
     // Test Roundtripping
-    for s in [&with, &without].iter() {
+    for s in [&with, &without] {
         let v = serde_json::to_string(s).unwrap();
         let w: T = serde_json::from_str(&v).unwrap();
-        assert_eq!(w, **s);
+        assert_eq!(w, *s);
     }
 
     let t: T = serde_json::from_str("{\"amt\": 2.5, \"samt\": -2.5}").unwrap();
@@ -839,10 +845,10 @@ fn serde_as_sat_opt() {
     let without = T { amt: None, samt: None };
 
     // Test Roundtripping
-    for s in [&with, &without].iter() {
+    for s in [&with, &without] {
         let v = serde_json::to_string(s).unwrap();
         let w: T = serde_json::from_str(&v).unwrap();
-        assert_eq!(w, **s);
+        assert_eq!(w, *s);
     }
 
     let t: T = serde_json::from_str("{\"amt\": 250000000, \"samt\": -250000000}").unwrap();
@@ -875,16 +881,16 @@ fn serde_as_str_opt() {
     }
 
     let with = T {
-        amt: Some(Amount::from_sat(123456789)),
-        samt: Some(SignedAmount::from_sat(-123456789)),
+        amt: Some(Amount::from_sat(123_456_789)),
+        samt: Some(SignedAmount::from_sat(-123_456_789)),
     };
     let without = T { amt: None, samt: None };
 
     // Test Roundtripping
-    for s in [&with, &without].iter() {
+    for s in [&with, &without] {
         let v = serde_json::to_string(s).unwrap();
         let w: T = serde_json::from_str(&v).unwrap();
-        assert_eq!(w, **s);
+        assert_eq!(w, *s);
     }
 
     let t: T =
@@ -953,7 +959,7 @@ fn denomination_string_acceptable_forms() {
         "BTC", "btc", "cBTC", "cbtc", "mBTC", "mbtc", "uBTC", "ubtc", "bit", "bits", "BIT", "BITS",
         "SATOSHI", "satoshi", "SATOSHIS", "satoshis", "SAT", "sat", "SATS", "sats",
     ];
-    for denom in valid.iter() {
+    for denom in valid {
         assert!(denom.parse::<Denomination>().is_ok());
     }
 }
@@ -961,7 +967,7 @@ fn denomination_string_acceptable_forms() {
 #[test]
 fn disallow_confusing_forms() {
     let confusing = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"];
-    for denom in confusing.iter() {
+    for denom in confusing {
         match denom.parse::<Denomination>() {
             Ok(_) => panic!("from_str should error for {}", denom),
             Err(ParseDenominationError::PossiblyConfusing(_)) => {}
@@ -974,7 +980,7 @@ fn disallow_confusing_forms() {
 fn disallow_unknown_denomination() {
     // Non-exhaustive list of unknown forms.
     let unknown = ["NBTC", "ABC", "abc", "mSat", "msat"];
-    for denom in unknown.iter() {
+    for denom in unknown {
         match denom.parse::<Denomination>() {
             Ok(_) => panic!("from_str should error for {}", denom),
             Err(ParseDenominationError::Unknown(_)) => (),
@@ -986,7 +992,7 @@ fn disallow_unknown_denomination() {
 #[test]
 #[cfg(feature = "alloc")]
 fn trailing_zeros_for_amount() {
-    assert_eq!(format!("{}", Amount::from_sat(1000000)), "0.01 BTC");
+    assert_eq!(format!("{}", Amount::from_sat(1_000_000)), "0.01 BTC");
     assert_eq!(format!("{}", Amount::ONE_SAT), "0.00000001 BTC");
     assert_eq!(format!("{}", Amount::ONE_BTC), "1 BTC");
     assert_eq!(format!("{}", Amount::from_sat(1)), "0.00000001 BTC");
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 93bde1de61..be18ea8f2c 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -414,11 +414,12 @@ impl Amount {
     /// # Errors
     ///
     /// If the amount is too big.
+    #[rustfmt::skip] // Moves code comments to the wrong line.
     pub fn to_signed(self) -> Result<SignedAmount, OutOfRangeError> {
-        if self.to_sat() > SignedAmount::MAX.to_sat() as u64 {
+        if self.to_sat() > SignedAmount::MAX.to_sat() as u64 { // Cast ok, signed max is positive and fits in u64.
             Err(OutOfRangeError::too_big(true))
         } else {
-            Ok(SignedAmount::from_sat(self.to_sat() as i64))
+            Ok(SignedAmount::from_sat(self.to_sat() as i64)) // Cast ok, checked not too big above.
         }
     }
 
diff --git a/units/src/block.rs b/units/src/block.rs
index bdbf886b0e..10e9208d14 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -148,10 +148,10 @@ impl TryFrom<BlockInterval> for relative::Height {
     /// [`BlockInterval`] is a thin wrapper around a `u32`, the two types are not interchangeable.
     fn try_from(h: BlockInterval) -> Result<Self, Self::Error> {
         let h = h.to_u32();
-        if h > u16::MAX as u32 {
+        if h > u32::from(u16::MAX) {
             return Err(TooBigForRelativeBlockHeightError(h));
         }
-        Ok(relative::Height::from(h as u16)) // Cast ok, value checked above
+        Ok(relative::Height::from(h as u16)) // Cast ok, value checked above.
     }
 }
 
diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index 6700434cd2..9f84a766c2 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -356,7 +356,7 @@ mod tests {
 
     #[test]
     #[cfg(debug_assertions)]
-    #[should_panic]
+    #[should_panic = "attempt to multiply with overflow"]
     fn from_sat_per_vb_unchecked_panic() { FeeRate::from_sat_per_vb_unchecked(u64::MAX); }
 
     #[test]
diff --git a/units/src/lib.rs b/units/src/lib.rs
index ffcbfa3d7d..d53bc76d0c 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -11,8 +11,6 @@
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
-// Pedantic lints that we enforce.
-#![warn(clippy::return_self_not_must_use)]
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
@@ -27,7 +25,7 @@ mod internal_macros;
 
 #[doc(hidden)]
 pub mod _export {
-    /// A re-export of core::*
+    /// A re-export of `core::*`.
     pub mod _core {
         pub use core::*;
     }
diff --git a/units/src/locktime/absolute.rs b/units/src/locktime/absolute.rs
index 4ee23e3dd8..1ab4b82cfc 100644
--- a/units/src/locktime/absolute.rs
+++ b/units/src/locktime/absolute.rs
@@ -285,11 +285,13 @@ enum LockTimeUnit {
 
 impl fmt::Display for LockTimeUnit {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTimeUnit::*;
+        use LockTimeUnit as L;
 
         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),
+            L::Blocks =>
+                write!(f, "expected lock-by-blockheight (must be < {})", LOCK_TIME_THRESHOLD),
+            L::Seconds =>
+                write!(f, "expected lock-by-blocktime (must be >= {})", LOCK_TIME_THRESHOLD),
         }
     }
 }
@@ -321,10 +323,10 @@ impl ParseError {
     ) -> fmt::Result {
         use core::num::IntErrorKind;
 
-        use ParseError::*;
+        use ParseError as E;
 
         match self {
-            ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
+            E::ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
                 if *source.kind() == IntErrorKind::PosOverflow =>
             {
                 // Outputs "failed to parse <input_string> as absolute Height/Time (<subject> is above limit <upper_bound>)"
@@ -336,7 +338,7 @@ impl ParseError {
                     upper_bound
                 )
             }
-            ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
+            E::ParseInt(ParseIntError { input, bits: _, is_signed: _, source })
                 if *source.kind() == IntErrorKind::NegOverflow =>
             {
                 // Outputs "failed to parse <input_string> as absolute Height/Time (<subject> is below limit <lower_bound>)"
@@ -348,13 +350,13 @@ impl ParseError {
                     lower_bound
                 )
             }
-            ParseInt(ParseIntError { input, bits: _, is_signed: _, source: _ }) => {
+            E::ParseInt(ParseIntError { input, bits: _, is_signed: _, source: _ }) => {
                 write!(f, "{} ({})", input.display_cannot_parse("absolute Height/Time"), subject)
             }
-            Conversion(value) if *value < i64::from(lower_bound) => {
+            E::Conversion(value) if *value < i64::from(lower_bound) => {
                 write!(f, "{} {} is below limit {}", subject, value, lower_bound)
             }
-            Conversion(value) => {
+            E::Conversion(value) => {
                 write!(f, "{} {} is above limit {}", subject, value, upper_bound)
             }
         }
@@ -365,17 +367,17 @@ impl ParseError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         use core::num::IntErrorKind;
 
-        use ParseError::*;
+        use ParseError as E;
 
         match self {
-            ParseInt(ParseIntError { source, .. })
+            E::ParseInt(ParseIntError { source, .. })
                 if *source.kind() == IntErrorKind::PosOverflow =>
                 None,
-            ParseInt(ParseIntError { source, .. })
+            E::ParseInt(ParseIntError { source, .. })
                 if *source.kind() == IntErrorKind::NegOverflow =>
                 None,
-            ParseInt(ParseIntError { source, .. }) => Some(source),
-            Conversion(_) => None,
+            E::ParseInt(ParseIntError { source, .. }) => Some(source),
+            E::Conversion(_) => None,
         }
     }
 }
@@ -394,14 +396,14 @@ mod tests {
     #[test]
     fn time_from_str_hex_happy_path() {
         let actual = Time::from_hex("0x6289C350").unwrap();
-        let expected = Time::from_consensus(0x6289C350).unwrap();
+        let expected = Time::from_consensus(0x6289_C350).unwrap();
         assert_eq!(actual, expected);
     }
 
     #[test]
     fn time_from_str_hex_no_prefix_happy_path() {
         let time = Time::from_hex("6289C350").unwrap();
-        assert_eq!(time, Time(0x6289C350));
+        assert_eq!(time, Time(0x6289_C350));
     }
 
     #[test]
diff --git a/units/src/locktime/relative.rs b/units/src/locktime/relative.rs
index 401ac2ced7..283ec1aaaa 100644
--- a/units/src/locktime/relative.rs
+++ b/units/src/locktime/relative.rs
@@ -84,7 +84,7 @@ impl Time {
     pub const fn from_seconds_floor(seconds: u32) -> Result<Self, TimeOverflowError> {
         let interval = seconds / 512;
         if interval <= u16::MAX as u32 { // infallible cast, needed by const code
-            Ok(Time::from_512_second_intervals(interval as u16)) // cast checked above, needed by const code
+            Ok(Time::from_512_second_intervals(interval as u16)) // Cast checked above, needed by const code.
         } else {
             Err(TimeOverflowError { seconds })
         }
@@ -101,7 +101,7 @@ impl Time {
     pub const fn from_seconds_ceil(seconds: u32) -> Result<Self, TimeOverflowError> {
         if seconds <= u16::MAX as u32 * 512 {
             let interval = (seconds + 511) / 512;
-            Ok(Time::from_512_second_intervals(interval as u16)) // cast checked above, needed by const code
+            Ok(Time::from_512_second_intervals(interval as u16)) // Cast checked above, needed by const code.
         } else {
             Err(TimeOverflowError { seconds })
         }
diff --git a/units/src/parse.rs b/units/src/parse.rs
index 3dc01f8b0e..ec36d4b94b 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -318,11 +318,11 @@ internals::impl_from_infallible!(PrefixedHexErrorInner);
 
 impl fmt::Display for PrefixedHexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use PrefixedHexErrorInner::*;
+        use PrefixedHexErrorInner as E;
 
         match self.0 {
-            MissingPrefix(ref e) => write_err!(f, "hex string is missing prefix"; e),
-            ParseInt(ref e) => write_err!(f, "prefixed hex string invalid int"; e),
+            E::MissingPrefix(ref e) => write_err!(f, "hex string is missing prefix"; e),
+            E::ParseInt(ref e) => write_err!(f, "prefixed hex string invalid int"; e),
         }
     }
 }
@@ -330,11 +330,11 @@ impl fmt::Display for PrefixedHexError {
 #[cfg(feature = "std")]
 impl std::error::Error for PrefixedHexError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use PrefixedHexErrorInner::*;
+        use PrefixedHexErrorInner as E;
 
         match self.0 {
-            MissingPrefix(ref e) => Some(e),
-            ParseInt(ref e) => Some(e),
+            E::MissingPrefix(ref e) => Some(e),
+            E::ParseInt(ref e) => Some(e),
         }
     }
 }
@@ -364,11 +364,11 @@ internals::impl_from_infallible!(UnprefixedHexErrorInner);
 
 impl fmt::Display for UnprefixedHexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use UnprefixedHexErrorInner::*;
+        use UnprefixedHexErrorInner as E;
 
         match self.0 {
-            ContainsPrefix(ref e) => write_err!(f, "hex string is contains prefix"; e),
-            ParseInt(ref e) => write_err!(f, "hex string parse int"; e),
+            E::ContainsPrefix(ref e) => write_err!(f, "hex string is contains prefix"; e),
+            E::ParseInt(ref e) => write_err!(f, "hex string parse int"; e),
         }
     }
 }
@@ -376,11 +376,11 @@ impl fmt::Display for UnprefixedHexError {
 #[cfg(feature = "std")]
 impl std::error::Error for UnprefixedHexError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use UnprefixedHexErrorInner::*;
+        use UnprefixedHexErrorInner as E;
 
         match self.0 {
-            ContainsPrefix(ref e) => Some(e),
-            ParseInt(ref e) => Some(e),
+            E::ContainsPrefix(ref e) => Some(e),
+            E::ParseInt(ref e) => Some(e),
         }
     }
 }
@@ -453,14 +453,14 @@ mod tests {
 
     #[test]
     fn parse_u128_from_hex_prefixed() {
-        let want = 3735928559;
+        let want = 3_735_928_559;
         let got = hex_u128("0xdeadbeef").expect("failed to parse prefixed hex");
         assert_eq!(got, want);
     }
 
     #[test]
     fn parse_u128_from_hex_no_prefix() {
-        let want = 3735928559;
+        let want = 3_735_928_559;
         let got = hex_u128("deadbeef").expect("failed to parse non-prefixed hex");
         assert_eq!(got, want);
     }
diff --git a/units/src/weight.rs b/units/src/weight.rs
index 9c8b9d8a6c..73bed18f1f 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -228,7 +228,7 @@ impl<'a> core::iter::Sum<&'a Weight> for Weight {
     where
         I: Iterator<Item = &'a Weight>,
     {
-        iter.cloned().sum()
+        iter.copied().sum()
     }
 }
 
@@ -281,7 +281,7 @@ mod tests {
 
     #[test]
     #[cfg(debug_assertions)]
-    #[should_panic]
+    #[should_panic = "attempt to multiply with overflow"]
     fn from_vb_unchecked_panic() { Weight::from_vb_unchecked(u64::MAX); }
 
     #[test]

From 9619f689566d21956ec3d14b92fa79d66434e9fe Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 17 Dec 2024 18:04:55 +1100
Subject: [PATCH 123/554] units: Move excluded lints to manifest

Might as well put these with the pedantic ones.
---
 units/Cargo.toml          | 3 +++
 units/src/amount/serde.rs | 4 ++--
 units/src/lib.rs          | 3 ---
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/units/Cargo.toml b/units/Cargo.toml
index e3bd679a82..021ed1f58b 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -36,6 +36,9 @@ rustdoc-args = ["--cfg", "docsrs"]
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(kani)'] }
 
 [lints.clippy]
+# Exclude lints we don't think are valuable.
+needless_question_mark = "allow" # https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
+manual_range_contains = "allow" # More readable than clippy's format.
 # Exhaustive list of pedantic clippy lints
 assigning_clones = "warn"
 bool_to_int_with_if = "warn"
diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index 46fa2f92f8..7eb35f6e42 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -405,7 +405,7 @@ mod tests {
         assert_eq!(json, want);
 
         let rinsed: HasAmount = serde_json::from_str(&json).expect("failed to deser");
-        assert_eq!(rinsed, orig)
+        assert_eq!(rinsed, orig);
     }
 
     #[test]
@@ -424,7 +424,7 @@ mod tests {
         assert_eq!(json, want);
 
         let rinsed: HasAmount = serde_json::from_str(&json).expect("failed to deser");
-        assert_eq!(rinsed, orig)
+        assert_eq!(rinsed, orig);
     }
 
     #[test]
diff --git a/units/src/lib.rs b/units/src/lib.rs
index d53bc76d0c..e4bd1254be 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -11,9 +11,6 @@
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
-// Exclude lints we don't think are valuable.
-#![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
-#![allow(clippy::manual_range_contains)] // More readable than clippy's format.
 
 #[cfg(feature = "alloc")]
 extern crate alloc;

From 2513e05501e3a014c097f24eb9178c291785db81 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 17 Dec 2024 18:05:19 +1100
Subject: [PATCH 124/554] api: Run just check-api

---
 api/units/all-features.txt | 6 +++---
 api/units/alloc-only.txt   | 6 +++---
 api/units/no-features.txt  | 6 +++---
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 4ec25b5978..d0c77286c2 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -917,9 +917,9 @@ pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core
 pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
 pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
 pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(&self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(&self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(&self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
 pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
 pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
 pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 691aeca992..ae1768dece 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -853,9 +853,9 @@ pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core
 pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
 pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
 pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(&self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(&self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(&self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
 pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
 pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
 pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 86c9be5639..197e438ebb 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -823,9 +823,9 @@ pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core
 pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
 pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
 pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(&self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(&self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(&self) -> (i64, u64)
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
 pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
 pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
 pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result

From 50224eecc242ddc4d67f76b0c5e28f7120b6e961 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 18 Dec 2024 09:06:51 +1100
Subject: [PATCH 125/554] kani: Don't overflow the tests

Amount add and sub now enforce the MAX_MONEY invariant when doing
addition and subtraction. We need to tell kani to assume we don't
overflow before doing actual tests.

Note also that `ops::Add` calls through to `checked_add` and
`ops::Sub` calls through to `checked_sub` so separate kani tests for
these are unnecessary.
---
 units/src/amount/verification.rs | 52 +++++++++-----------------------
 1 file changed, 14 insertions(+), 38 deletions(-)

diff --git a/units/src/amount/verification.rs b/units/src/amount/verification.rs
index 0310e19e9b..76f26ec0dc 100644
--- a/units/src/amount/verification.rs
+++ b/units/src/amount/verification.rs
@@ -23,7 +23,12 @@ use super::*;
 fn u_amount_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
+    // Assume we don't overflow in the actual tests.
+    kani::assume(n1.checked_add(n2).is_some()); // Adding u64s doesn't overflow.
+    let a1 = Amount::from_sat(n1);              // TODO: If from_sat enforces invariant assume this `is_ok()`.
+    let a2 = Amount::from_sat(n2);
+    kani::assume(a1.checked_add(a2).is_some()); // Adding amounts doesn't overflow.
+
     assert_eq!(Amount::from_sat(n1) + Amount::from_sat(n2), Amount::from_sat(n1 + n2));
 
     let mut amt = Amount::from_sat(n1);
@@ -48,28 +53,19 @@ fn u_amount_homomorphic() {
     );
 }
 
-#[kani::unwind(4)]
-#[kani::proof]
-fn u_amount_homomorphic_checked() {
-    let n1 = kani::any::<u64>();
-    let n2 = kani::any::<u64>();
-    assert_eq!(
-        Amount::from_sat(n1).checked_add(Amount::from_sat(n2)),
-        n1.checked_add(n2).map(Amount::from_sat),
-    );
-    assert_eq!(
-        Amount::from_sat(n1).checked_sub(Amount::from_sat(n2)),
-        n1.checked_sub(n2).map(Amount::from_sat),
-    );
-}
-
 #[kani::unwind(4)]
 #[kani::proof]
 fn s_amount_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
+    // Assume we don't overflow in the actual tests.
+    kani::assume(n1.checked_add(n2).is_some()); // Adding i64s doesn't overflow.
+    kani::assume(n1.checked_sub(n2).is_some()); // Subbing i64s doesn't overflow.
+    let a1 = SignedAmount::from_sat(n1); // TODO: If from_sat enforces invariant assume this `is_ok()`.
+    let a2 = SignedAmount::from_sat(n2);
+    kani::assume(a1.checked_add(a2).is_some()); // Adding amounts doesn't overflow.
+    kani::assume(a1.checked_sub(a2).is_some()); // Subbing amounts doesn't overflow.
+
     assert_eq!(
         SignedAmount::from_sat(n1) + SignedAmount::from_sat(n2),
         SignedAmount::from_sat(n1 + n2)
@@ -95,23 +91,3 @@ fn s_amount_homomorphic() {
         },
     );
 }
-
-#[kani::unwind(4)]
-#[kani::proof]
-fn s_amount_homomorphic_checked() {
-    let n1 = kani::any::<i64>();
-    let n2 = kani::any::<i64>();
-    assert_eq!(
-        SignedAmount::from_sat(n1).checked_add(SignedAmount::from_sat(n2)),
-        n1.checked_add(n2).map(SignedAmount::from_sat),
-    );
-    assert_eq!(
-        SignedAmount::from_sat(n1).checked_sub(SignedAmount::from_sat(n2)),
-        n1.checked_sub(n2).map(SignedAmount::from_sat),
-    );
-
-    assert_eq!(
-        SignedAmount::from_sat(n1).positive_sub(SignedAmount::from_sat(n2)),
-        if n1 >= 0 && n2 >= 0 && n1 >= n2 { Some(SignedAmount::from_sat(n1 - n2)) } else { None },
-    );
-}

From e378cdd8fa340469b8c9b046ea6d6f0dd4e04414 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 18 Dec 2024 09:36:54 +1100
Subject: [PATCH 126/554] kani: Don't bother checking signed to unsigned
 conversion

Now that we use MAX_MONEY a signed amount always fits in an unsigned
amount.
---
 units/src/amount/verification.rs | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/units/src/amount/verification.rs b/units/src/amount/verification.rs
index 76f26ec0dc..ae970e1868 100644
--- a/units/src/amount/verification.rs
+++ b/units/src/amount/verification.rs
@@ -42,15 +42,6 @@ fn u_amount_homomorphic() {
     let mut amt = Amount::from_sat(max);
     amt -= Amount::from_sat(min);
     assert_eq!(amt, Amount::from_sat(max - min));
-
-    assert_eq!(
-        Amount::from_sat(n1).to_signed(),
-        if n1 <= i64::MAX as u64 {
-            Ok(SignedAmount::from_sat(n1.try_into().unwrap()))
-        } else {
-            Err(OutOfRangeError::too_big(true))
-        },
-    );
 }
 
 #[kani::unwind(4)]
@@ -81,13 +72,4 @@ fn s_amount_homomorphic() {
     let mut amt = SignedAmount::from_sat(n1);
     amt -= SignedAmount::from_sat(n2);
     assert_eq!(amt, SignedAmount::from_sat(n1 - n2));
-
-    assert_eq!(
-        SignedAmount::from_sat(n1).to_unsigned(),
-        if n1 >= 0 {
-            Ok(Amount::from_sat(n1.try_into().unwrap()))
-        } else {
-            Err(OutOfRangeError { is_signed: false, is_greater_than_max: false })
-        },
-    );
 }

From f4617e71f5fd074000d1e3a9376644c744210562 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 19 Dec 2024 08:59:12 +1100
Subject: [PATCH 127/554] kani: Verify no out of bounds for ArrayVec

I'm not super confident that I know exactly what kani does but I believe
this test verifies that the `ArrayVec` can add and access elements less
than capacity and upto capacity.
---
 internals/Cargo.toml       |  2 +-
 internals/src/array_vec.rs | 42 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/internals/Cargo.toml b/internals/Cargo.toml
index 0b9b6c2520..12a5daa1dc 100644
--- a/internals/Cargo.toml
+++ b/internals/Cargo.toml
@@ -35,4 +35,4 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [lints.rust]
-unexpected_cfgs = { level = "deny" }
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(kani)'] }
diff --git a/internals/src/array_vec.rs b/internals/src/array_vec.rs
index 49fca83d80..24003e14b4 100644
--- a/internals/src/array_vec.rs
+++ b/internals/src/array_vec.rs
@@ -188,3 +188,45 @@ mod tests {
         av.extend_from_slice(b"abc");
     }
 }
+
+#[cfg(kani)]
+mod verification {
+    use super::*;
+
+    #[kani::unwind(16)]         // One greater than 15 (max number of elements).
+    #[kani::proof]
+    fn no_out_of_bounds_less_than_cap() {
+        const CAP: usize = 32;
+        let n = kani::any::<u32>();
+        let elements = (n & 0x0F) as usize; // Just use 4 bits.
+
+        let val = kani::any::<u32>();
+
+        let mut v = ArrayVec::<u32, CAP>::new();
+        for _ in 0..elements {
+            v.push(val);
+        }
+
+        for i in 0..elements {
+            assert_eq!(v[i], val);
+        }
+    }
+
+    #[kani::unwind(16)]         // One grater than 15.
+    #[kani::proof]
+    fn no_out_of_bounds_upto_cap() {
+        const CAP: usize = 15;
+        let elements = CAP;
+
+        let val = kani::any::<u32>();
+
+        let mut v = ArrayVec::<u32, CAP>::new();
+        for _ in 0..elements {
+            v.push(val);
+        }
+
+        for i in 0..elements {
+            assert_eq!(v[i], val);
+        }
+    }
+}

From 72e97c637fa0916be75aef28ea8169ffbbe2c4f5 Mon Sep 17 00:00:00 2001
From: Nick Johnson <nick@yonson.dev>
Date: Wed, 18 Dec 2024 19:24:26 -0800
Subject: [PATCH 128/554] Add a hash value to Inventory's Error variant

While the hash value of the Error variant is meaningless, the variant
still conforms to all other Inventory messages and requires a 32
byte hash to be sent over the wire. This is how bitcoin core operates.

This patch adds the 32 byte array to the Error variant in order to make
its Encoding and Decoding paths symmetrical. This also allows a reader
to discard the 32 bytes when decoding a message. The hash is still not
exposed to the caller.

This was never a problem before because the top level RawNetworkPackage
pulls all the required bytes off a reader before decoding. But this is
not as easy to do with the v2 p2p network messages.
---
 bitcoin/src/p2p/message.rs           |  2 +-
 bitcoin/src/p2p/message_blockdata.rs | 13 +++++++------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/bitcoin/src/p2p/message.rs b/bitcoin/src/p2p/message.rs
index 04eb15d618..f1315c34e0 100644
--- a/bitcoin/src/p2p/message.rs
+++ b/bitcoin/src/p2p/message.rs
@@ -583,7 +583,7 @@ mod test {
             )]),
             NetworkMessage::Inv(vec![Inventory::Block(hash([8u8; 32]).into())]),
             NetworkMessage::GetData(vec![Inventory::Transaction(hash([45u8; 32]).into())]),
-            NetworkMessage::NotFound(vec![Inventory::Error]),
+            NetworkMessage::NotFound(vec![Inventory::Error([0u8; 32])]),
             NetworkMessage::GetBlocks(GetBlocksMessage::new(
                 vec![hash([1u8; 32]).into(), hash([4u8; 32]).into()],
                 hash([5u8; 32]).into(),
diff --git a/bitcoin/src/p2p/message_blockdata.rs b/bitcoin/src/p2p/message_blockdata.rs
index 90b0bba72b..6ccff60d91 100644
--- a/bitcoin/src/p2p/message_blockdata.rs
+++ b/bitcoin/src/p2p/message_blockdata.rs
@@ -16,8 +16,9 @@ use crate::transaction::{Txid, Wtxid};
 /// An inventory item.
 #[derive(PartialEq, Eq, Clone, Debug, Copy, Hash, PartialOrd, Ord)]
 pub enum Inventory {
-    /// Error --- these inventories can be ignored
-    Error,
+    /// Error --- these inventories can be ignored.
+    /// While a 32 byte hash is expected over the wire, the value is meaningless.
+    Error([u8; 32]),
     /// Transaction
     Transaction(Txid),
     /// Block
@@ -42,10 +43,10 @@ pub enum Inventory {
 impl Inventory {
     /// Return the item value represented as a SHA256-d hash.
     ///
-    /// Returns [None] only for [Inventory::Error].
+    /// Returns [None] only for [Inventory::Error] who's hash value is meaningless.
     pub fn network_hash(&self) -> Option<[u8; 32]> {
         match self {
-            Inventory::Error => None,
+            Inventory::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()),
@@ -66,7 +67,7 @@ impl Encodable for Inventory {
             };
         }
         Ok(match *self {
-            Inventory::Error => encode_inv!(0, [0; 32]),
+            Inventory::Error(_) => encode_inv!(0, [0; 32]),
             Inventory::Transaction(ref t) => encode_inv!(1, t),
             Inventory::Block(ref b) => encode_inv!(2, b),
             Inventory::CompactBlock(ref b) => encode_inv!(4, b),
@@ -83,7 +84,7 @@ impl Decodable for Inventory {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
         let inv_type: u32 = Decodable::consensus_decode(r)?;
         Ok(match inv_type {
-            0 => Inventory::Error,
+            0 => Inventory::Error(Decodable::consensus_decode(r)?),
             1 => Inventory::Transaction(Decodable::consensus_decode(r)?),
             2 => Inventory::Block(Decodable::consensus_decode(r)?),
             4 => Inventory::CompactBlock(Decodable::consensus_decode(r)?),

From 09e184015ea1d69ea1935a30ed47ea963b64f19f Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 18 Dec 2024 15:54:43 +0000
Subject: [PATCH 129/554] Fix rustdocs in SignedAmount

---
 units/src/amount/signed.rs   | 48 +++++++++++++++++++-----------------
 units/src/amount/unsigned.rs |  9 ++++---
 2 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index a817566e27..8a0845edd2 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -19,15 +19,15 @@ use super::{
 /// A signed amount.
 ///
 /// The [`SignedAmount`] type can be used to express Bitcoin amounts that support arithmetic and
-/// conversion to various denominations. The `Amount` type does not implement `serde` traits but we
-/// do provide modules for serializing as satoshis or bitcoin.
+/// conversion to various denominations. The [`SignedAmount`] type does not implement [`serde`]
+/// traits but we do provide modules for serializing as satoshis or bitcoin.
 ///
 /// 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`]
+/// start with `checked_`. The operations from [`core::ops`] that [`SignedAmount`]
 /// implements will panic when overflow or underflow occurs.
 ///
 /// # Examples
@@ -68,7 +68,7 @@ impl SignedAmount {
     /// Gets the number of satoshis in this [`SignedAmount`].
     pub const fn to_sat(self) -> i64 { self.0 }
 
-    /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`].
+    /// Converts from a value expressing a decimal number of bitcoin to a [`SignedAmount`].
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<SignedAmount, ParseAmountError> {
         SignedAmount::from_float_in(btc, Denomination::Bitcoin)
@@ -101,10 +101,10 @@ impl SignedAmount {
         }
     }
 
-    /// Parses a decimal string as a value in the given denomination.
+    /// Parses 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`].
+    /// Note: This only parses the value string. If you want to parse a string
+    /// containing the value with denomination, use [`FromStr`].
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
         match parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(true))? {
             // (negative, amount)
@@ -128,7 +128,7 @@ impl SignedAmount {
         SignedAmount::from_str_in(amt, denom).map_err(Into::into)
     }
 
-    /// Express this [`SignedAmount`] as a floating-point value in the given denomination.
+    /// Expresses this [`SignedAmount`] as a floating-point value in the given [`Denomination`].
     ///
     /// Please be aware of the risk of using floating-point numbers.
     #[cfg(feature = "alloc")]
@@ -136,7 +136,7 @@ impl SignedAmount {
         self.to_string_in(denom).parse::<f64>().unwrap()
     }
 
-    /// Express this [`SignedAmount`] as a floating-point value in Bitcoin.
+    /// Expresses this [`SignedAmount`] as a floating-point value in Bitcoin.
     ///
     /// Please be aware of the risk of using floating-point numbers.
     ///
@@ -150,8 +150,7 @@ impl SignedAmount {
     #[cfg(feature = "alloc")]
     pub fn to_btc(self) -> f64 { self.to_float_in(Denomination::Bitcoin) }
 
-    /// Convert this [`SignedAmount`] in floating-point notation with a given
-    /// denomination.
+    /// Converts this [`SignedAmount`] in floating-point notation in the given [`Denomination`].
     ///
     /// # Errors
     ///
@@ -168,7 +167,9 @@ impl SignedAmount {
         SignedAmount::from_str_in(&value.to_string(), denom)
     }
 
-    /// Constructs a new object that implements [`fmt::Display`] using specified denomination.
+    /// Constructs a new object that implements [`fmt::Display`] in the given [`Denomination`].
+    ///
+    /// This function is useful if you do not wish to allocate. See also [`Self::to_string_in`].
     #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
         Display {
@@ -178,7 +179,8 @@ impl SignedAmount {
         }
     }
 
-    /// Constructs a new object that implements [`fmt::Display`] dynamically selecting denomination.
+    /// Constructs a new object that implements [`fmt::Display`] dynamically selecting
+    /// [`Denomination`].
     ///
     /// This will use BTC for values greater than or equal to 1 BTC and satoshis otherwise. To
     /// avoid confusion the denomination is always shown.
@@ -191,14 +193,14 @@ impl SignedAmount {
         }
     }
 
-    /// Returns a formatted string representing this [`SignedAmount`] in the given denomination.
+    /// Returns a formatted string representing this [`SignedAmount`] in the given [`Denomination`].
     ///
-    /// Does not include the denomination.
+    /// Returned string does not include the denomination.
     #[cfg(feature = "alloc")]
     pub fn to_string_in(self, denom: Denomination) -> String { self.display_in(denom).to_string() }
 
-    /// Returns a formatted string representing this [`Amount`] in the given denomination, suffixed
-    /// with the abbreviation for the denomination.
+    /// Returns a formatted string representing this [`SignedAmount`] in the given [`Denomination`],
+    /// suffixed with the abbreviation for the denomination.
     #[cfg(feature = "alloc")]
     pub fn to_string_with_denomination(self, denom: Denomination) -> String {
         self.display_in(denom).show_denomination().to_string()
@@ -206,7 +208,7 @@ impl SignedAmount {
 
     // Some arithmetic that doesn't fit in [`core::ops`] traits.
 
-    /// Get the absolute value of this [`SignedAmount`].
+    /// Gets the absolute value of this [`SignedAmount`].
     #[must_use]
     pub fn abs(self) -> SignedAmount { SignedAmount(self.0.abs()) }
 
@@ -238,7 +240,7 @@ impl SignedAmount {
     ///
     /// Consider using `unsigned_abs` which is often more practical.
     ///
-    /// Returns [`None`] if overflow occurred. (`self == MIN`)
+    /// Returns [`None`] if overflow occurred. (`self == i64::MIN`)
     #[must_use]
     pub const fn checked_abs(self) -> Option<SignedAmount> {
         // No `map()` in const context.
@@ -250,7 +252,7 @@ impl SignedAmount {
 
     /// Checked addition.
     ///
-    /// Returns [`None`] if overflow occurred.
+    /// Returns [`None`] if the sum is above [`SignedAmount::MAX`] or below [`SignedAmount::MIN`].
     #[must_use]
     pub const fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
@@ -262,7 +264,8 @@ impl SignedAmount {
 
     /// Checked subtraction.
     ///
-    /// Returns [`None`] if overflow occurred.
+    /// Returns [`None`] if the difference is above [`SignedAmount::MAX`] or below
+    /// [`SignedAmount::MIN`].
     #[must_use]
     pub const fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
@@ -274,7 +277,8 @@ impl SignedAmount {
 
     /// Checked multiplication.
     ///
-    /// Returns [`None`] if overflow occurred.
+    /// Returns [`None`] if the product is above [`SignedAmount::MAX`] or below
+    /// [`SignedAmount::MIN`].
     #[must_use]
     pub const fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index be18ea8f2c..bb2a3d3e6e 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -199,8 +199,7 @@ impl Amount {
     #[cfg(feature = "alloc")]
     pub fn to_btc(self) -> f64 { self.to_float_in(Denomination::Bitcoin) }
 
-    /// Converts this [`Amount`] in floating-point notation in the given
-    /// [`Denomination`].
+    /// Converts this [`Amount`] in floating-point notation in the given [`Denomination`].
     ///
     /// # Errors
     ///
@@ -218,6 +217,8 @@ impl Amount {
     }
 
     /// Constructs a new object that implements [`fmt::Display`] in the given [`Denomination`].
+    ///
+    /// This function is useful if you do not wish to allocate. See also [`Self::to_string_in`].
     #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
         Display {
@@ -326,7 +327,7 @@ impl Amount {
     ///
     /// Be aware that integer division loses the remainder if no exact division
     /// can be made. This method rounds up ensuring the transaction fee-rate is
-    /// sufficient. See also [`Amount::checked_div_by_weight_floor`].
+    /// sufficient. See also [`Self::checked_div_by_weight_floor`].
     ///
     /// Returns [`None`] if overflow occurred.
     ///
@@ -359,7 +360,7 @@ impl Amount {
     /// Checked weight floor division.
     ///
     /// Be aware that integer division loses the remainder if no exact division
-    /// can be made. See also [`Amount::checked_div_by_weight_ceil`].
+    /// can be made. See also [`Self::checked_div_by_weight_ceil`].
     ///
     /// Returns [`None`] if overflow occurred.
     #[cfg(feature = "alloc")]

From 78f1628bf6702c808cb769372df7742daf0e1731 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 18 Dec 2024 16:05:35 +0000
Subject: [PATCH 130/554] Add Examples to rustdocs

---
 units/src/amount/signed.rs   | 68 ++++++++++++++++++++++++++++++++++++
 units/src/amount/unsigned.rs | 27 ++++++++++++++
 2 files changed, 95 insertions(+)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 8a0845edd2..867c426344 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -63,12 +63,35 @@ impl SignedAmount {
     pub const MAX: Self = SignedAmount::MAX_MONEY;
 
     /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::SignedAmount;
+    /// let amount = SignedAmount::from_sat(-100_000);
+    /// assert_eq!(amount.to_sat(), -100_000);
+    /// ```
     pub const fn from_sat(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
 
     /// Gets the number of satoshis in this [`SignedAmount`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::SignedAmount;
+    /// assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);
+    /// ```
     pub const fn to_sat(self) -> i64 { self.0 }
 
     /// Converts from a value expressing a decimal number of bitcoin to a [`SignedAmount`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::SignedAmount;
+    /// let amount = SignedAmount::from_btc(-0.01).expect("we know 0.01 is valid");
+    /// assert_eq!(amount.to_sat(), -1_000_000);
+    /// ```
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<SignedAmount, ParseAmountError> {
         SignedAmount::from_float_in(btc, Denomination::Bitcoin)
@@ -123,6 +146,15 @@ impl SignedAmount {
     /// or with [`fmt::Display`].
     ///
     /// If you want to parse only the amount without the denomination, use [`Self::from_str_in`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::{amount, SignedAmount};
+    /// let amount = SignedAmount::from_str_with_denomination("0.1 BTC")?;
+    /// assert_eq!(amount, SignedAmount::from_sat(10_000_000));
+    /// # Ok::<_, amount::ParseError>(())
+    /// ```
     pub fn from_str_with_denomination(s: &str) -> Result<SignedAmount, ParseError> {
         let (amt, denom) = split_amount_and_denomination(s)?;
         SignedAmount::from_str_in(amt, denom).map_err(Into::into)
@@ -131,6 +163,14 @@ impl SignedAmount {
     /// Expresses this [`SignedAmount`] as a floating-point value in the given [`Denomination`].
     ///
     /// Please be aware of the risk of using floating-point numbers.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
+    /// let amount = SignedAmount::from_sat(100_000);
+    /// assert_eq!(amount.to_float_in(Denomination::Bitcoin), 0.001)
+    /// ```
     #[cfg(feature = "alloc")]
     pub fn to_float_in(self, denom: Denomination) -> f64 {
         self.to_string_in(denom).parse::<f64>().unwrap()
@@ -170,6 +210,18 @@ impl SignedAmount {
     /// Constructs a new object that implements [`fmt::Display`] in the given [`Denomination`].
     ///
     /// This function is useful if you do not wish to allocate. See also [`Self::to_string_in`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
+    /// # use std::fmt::Write;
+    /// let amount = SignedAmount::from_sat(10_000_000);
+    /// let mut output = String::new();
+    /// write!(&mut output, "{}", amount.display_in(Denomination::Bitcoin))?;
+    /// assert_eq!(output, "0.1");
+    /// # Ok::<(), std::fmt::Error>(())
+    /// ```
     #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
         Display {
@@ -196,11 +248,27 @@ impl SignedAmount {
     /// Returns a formatted string representing this [`SignedAmount`] in the given [`Denomination`].
     ///
     /// Returned string does not include the denomination.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
+    /// let amount = SignedAmount::from_sat(10_000_000);
+    /// assert_eq!(amount.to_string_in(Denomination::Bitcoin), "0.1")
+    /// ```
     #[cfg(feature = "alloc")]
     pub fn to_string_in(self, denom: Denomination) -> String { self.display_in(denom).to_string() }
 
     /// Returns a formatted string representing this [`SignedAmount`] in the given [`Denomination`],
     /// suffixed with the abbreviation for the denomination.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
+    /// let amount = SignedAmount::from_sat(10_000_000);
+    /// assert_eq!(amount.to_string_with_denomination(Denomination::Bitcoin), "0.1 BTC")
+    /// ```
     #[cfg(feature = "alloc")]
     pub fn to_string_with_denomination(self, denom: Denomination) -> String {
         self.display_in(denom).show_denomination().to_string()
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index bb2a3d3e6e..49edb71bef 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -81,6 +81,13 @@ impl Amount {
     pub const fn from_sat(satoshi: u64) -> Amount { Amount(satoshi) }
 
     /// Gets the number of satoshis in this [`Amount`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::Amount;
+    /// assert_eq!(Amount::ONE_BTC.to_sat(), 100_000_000);
+    /// ```
     pub const fn to_sat(self) -> u64 { self.0 }
 
     /// Converts from a value expressing a decimal number of bitcoin to an [`Amount`].
@@ -90,6 +97,14 @@ impl Amount {
     /// If the amount is too big, too precise or negative.
     ///
     /// Please be aware of the risk of using floating-point numbers.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::Amount;
+    /// let amount = Amount::from_btc(0.01).expect("we know 0.01 is valid");
+    /// assert_eq!(amount.to_sat(), 1_000_000);
+    /// ```
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<Amount, ParseAmountError> {
         Amount::from_float_in(btc, Denomination::Bitcoin)
@@ -219,6 +234,18 @@ impl Amount {
     /// Constructs a new object that implements [`fmt::Display`] in the given [`Denomination`].
     ///
     /// This function is useful if you do not wish to allocate. See also [`Self::to_string_in`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::amount::{Amount, Denomination};
+    /// # use std::fmt::Write;
+    /// let amount = Amount::from_sat(10_000_000);
+    /// let mut output = String::new();
+    /// write!(&mut output, "{}", amount.display_in(Denomination::Bitcoin))?;
+    /// assert_eq!(output, "0.1");
+    /// # Ok::<(), std::fmt::Error>(())
+    /// ```
     #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
         Display {

From 937a3da8dde74128f79486cf2668f9abaf133bea Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 18 Dec 2024 17:10:39 +0000
Subject: [PATCH 131/554] Add rustdoc errors

---
 units/src/amount/signed.rs | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 867c426344..2faa7e45f4 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -85,6 +85,12 @@ impl SignedAmount {
 
     /// Converts from a value expressing a decimal number of bitcoin to a [`SignedAmount`].
     ///
+    /// # Errors
+    ///
+    /// If the amount is too big (positive or negative) or too precise.
+    ///
+    /// Please be aware of the risk of using floating-point numbers.
+    ///
     /// # Examples
     ///
     /// ```
@@ -128,6 +134,10 @@ impl SignedAmount {
     ///
     /// Note: This only parses the value string. If you want to parse a string
     /// containing the value with denomination, use [`FromStr`].
+    ///
+    /// # Errors
+    ///
+    /// If the amount is too big (positive or negative) or too precise.
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
         match parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(true))? {
             // (negative, amount)
@@ -147,6 +157,10 @@ impl SignedAmount {
     ///
     /// If you want to parse only the amount without the denomination, use [`Self::from_str_in`].
     ///
+    /// # Errors
+    ///
+    /// If the amount is too big (positive or negative) or too precise.
+    ///
     /// # Examples
     ///
     /// ```
@@ -194,7 +208,7 @@ impl SignedAmount {
     ///
     /// # Errors
     ///
-    /// If the amount is too big, too precise or negative.
+    /// If the amount is too big (positive or negative) or too precise.
     ///
     /// Please be aware of the risk of using floating-point numbers.
     #[cfg(feature = "alloc")]
@@ -417,6 +431,10 @@ impl SignedAmount {
     }
 
     /// Converts to an unsigned amount.
+    ///
+    /// # Errors
+    ///
+    /// If the amount is negative.
     pub fn to_unsigned(self) -> Result<Amount, OutOfRangeError> {
         if self.is_negative() {
             Err(OutOfRangeError::negative())

From 23f75a098ca38aeb1b79473bfe231ae27e20c6df Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Thu, 19 Dec 2024 16:28:21 -0600
Subject: [PATCH 132/554] Update regex lookahead to match when there are no
 characters

---
 contrib/api.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/contrib/api.sh b/contrib/api.sh
index e4ec08116d..97bfcf1e1c 100755
--- a/contrib/api.sh
+++ b/contrib/api.sh
@@ -99,12 +99,12 @@ main() {
 
 # Print all public structs and enums.
 structs_and_enums() {
-    grep -oP 'pub (struct|enum) \K[\w:]+(?=\(|;| )' "$file" | sed "s/^${crate_full_name}:://"
+    grep -oP 'pub (struct|enum) \K[\w:]+(?=\(|;| |$)' "$file" | sed "s/^${crate_full_name}:://"
 }
 
 # Print all public structs and enums excluding error types.
 structs_and_enums_no_err() {
-    grep -oP 'pub (struct|enum) \K[\w:]+(?=\(|;| )' "$file" | sed "s/^${crate_full_name}:://" | grep -v Error
+    grep -oP 'pub (struct|enum) \K[\w:]+(?=\(|;| |$)' "$file" | sed "s/^${crate_full_name}:://" | grep -v Error
 }
 
 # Print all public traits.

From 678fc71b887f858d78c20a7399f1903c8e107611 Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Sun, 15 Dec 2024 19:19:06 -0600
Subject: [PATCH 133/554] Implement Arbitrary for units types

---
 api/units/all-features.txt     | 14 +++++++++++++
 units/src/amount/mod.rs        | 18 +++++++++++++++++
 units/src/block.rs             | 26 ++++++++++++++++++++++++
 units/src/fee_rate.rs          | 22 +++++++++++++--------
 units/src/locktime/absolute.rs | 36 ++++++++++++++++++++++++++++++++++
 units/src/locktime/relative.rs | 28 ++++++++++++++++++++++++++
 6 files changed, 136 insertions(+), 8 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 66adfa66c7..0d51f112cc 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -606,7 +606,14 @@ impl serde::ser::Serialize for bitcoin_units::locktime::relative::Time
 impl serde::ser::Serialize for bitcoin_units::weight::Weight
 impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::Amount
 impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::SignedAmount
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::amount::Denomination
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::block::BlockHeight
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::block::BlockInterval
 impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::fee_rate::FeeRate
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::absolute::Height
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::absolute::Time
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::relative::Height
+impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::relative::Time
 impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::weight::Weight
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Amount> for bitcoin_units::Amount
 impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
@@ -849,6 +856,7 @@ pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::Sign
 pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
 pub fn bitcoin_units::amount::CheckedSum::checked_sum(self) -> core::option::Option<R>
+pub fn bitcoin_units::amount::Denomination::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
 pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
 pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -936,6 +944,7 @@ pub fn bitcoin_units::amount::serde::as_str::opt::deserialize<'d, A: bitcoin_uni
 pub fn bitcoin_units::amount::serde::as_str::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::amount::serde::as_str::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
+pub fn bitcoin_units::block::BlockHeight::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
 pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
 pub fn bitcoin_units::block::BlockHeight::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
@@ -954,6 +963,7 @@ pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::boxed::Box<str>) ->
 pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
 pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
+pub fn bitcoin_units::block::BlockInterval::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
 pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
 pub fn bitcoin_units::block::BlockInterval::default() -> bitcoin_units::block::BlockInterval
@@ -1007,6 +1017,7 @@ pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitco
 pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
 pub fn bitcoin_units::locktime::absolute::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::locktime::absolute::ConversionError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::absolute::Height::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
 pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
 pub fn bitcoin_units::locktime::absolute::Height::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
@@ -1029,6 +1040,7 @@ pub fn bitcoin_units::locktime::absolute::ParseTimeError::clone(&self) -> bitcoi
 pub fn bitcoin_units::locktime::absolute::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseTimeError) -> bool
 pub fn bitcoin_units::locktime::absolute::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::locktime::absolute::ParseTimeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::locktime::absolute::Time::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::locktime::absolute::Time::clone(&self) -> bitcoin_units::locktime::absolute::Time
 pub fn bitcoin_units::locktime::absolute::Time::cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::cmp::Ordering
 pub fn bitcoin_units::locktime::absolute::Time::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
@@ -1042,6 +1054,7 @@ pub fn bitcoin_units::locktime::absolute::Time::serialize<S>(&self, serializer:
 pub fn bitcoin_units::locktime::absolute::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Height::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::locktime::relative::Height::clone(&self) -> bitcoin_units::locktime::relative::Height
 pub fn bitcoin_units::locktime::relative::Height::cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::cmp::Ordering
 pub fn bitcoin_units::locktime::relative::Height::default() -> bitcoin_units::locktime::relative::Height
@@ -1057,6 +1070,7 @@ pub fn bitcoin_units::locktime::relative::Height::try_from(h: bitcoin_units::blo
 pub fn bitcoin_units::locktime::relative::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::locktime::relative::Time::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::locktime::relative::Time::clone(&self) -> bitcoin_units::locktime::relative::Time
 pub fn bitcoin_units::locktime::relative::Time::cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::cmp::Ordering
 pub fn bitcoin_units::locktime::relative::Time::default() -> bitcoin_units::locktime::relative::Time
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index c25e78a1a0..025a866162 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -20,6 +20,9 @@ use core::cmp::Ordering;
 use core::fmt;
 use core::str::FromStr;
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+
 use self::error::{MissingDigitsKind, ParseAmountErrorInner, ParseErrorInner};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
@@ -599,3 +602,18 @@ mod sealed {
     impl<T> Sealed<Amount> for T where T: Iterator<Item = Amount> {}
     impl<T> Sealed<SignedAmount> for T where T: Iterator<Item = SignedAmount> {}
 }
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Denomination {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=5)?;
+        match choice {
+            0 => Ok(Denomination::Bitcoin),
+            1 => Ok(Denomination::CentiBitcoin),
+            2 => Ok(Denomination::MilliBitcoin),
+            3 => Ok(Denomination::MicroBitcoin),
+            4 => Ok(Denomination::Bit),
+            _ => Ok(Denomination::Satoshi),
+        }
+    }
+}
diff --git a/units/src/block.rs b/units/src/block.rs
index bdbf886b0e..f0abe5c484 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -13,6 +13,8 @@
 
 use core::{fmt, ops};
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -248,6 +250,30 @@ impl<'a> core::iter::Sum<&'a BlockInterval> for BlockInterval {
     }
 }
 
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for BlockHeight {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+        match choice {
+            0 => Ok(BlockHeight::MIN),
+            1 => Ok(BlockHeight::MAX),
+            _ => Ok(BlockHeight::from_u32(u32::arbitrary(u)?)),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for BlockInterval {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+        match choice {
+            0 => Ok(BlockInterval::MIN),
+            1 => Ok(BlockInterval::MAX),
+            _ => Ok(BlockInterval::from_u32(u32::arbitrary(u)?)),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index d6b4c33cb2..0c329ac5a1 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -162,14 +162,6 @@ impl FeeRate {
     }
 }
 
-#[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for FeeRate {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let f = u64::arbitrary(u)?;
-        Ok(FeeRate(f))
-    }
-}
-
 /// Alternative will display the unit.
 impl fmt::Display for FeeRate {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -294,6 +286,20 @@ impl<'a> core::iter::Sum<&'a FeeRate> for FeeRate {
 
 crate::impl_parse_str_from_int_infallible!(FeeRate, u64, from_sat_per_kwu);
 
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for FeeRate {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=4)?;
+        match choice {
+            0 => Ok(FeeRate::MIN),
+            1 => Ok(FeeRate::BROADCAST_MIN),
+            2 => Ok(FeeRate::DUST),
+            3 => Ok(FeeRate::MAX),
+            _ => Ok(FeeRate(u64::arbitrary(u)?)),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/units/src/locktime/absolute.rs b/units/src/locktime/absolute.rs
index 4ee23e3dd8..b9a0a9e0ec 100644
--- a/units/src/locktime/absolute.rs
+++ b/units/src/locktime/absolute.rs
@@ -4,6 +4,8 @@
 
 use core::fmt;
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 use internals::error::InputString;
 
 use crate::parse::{self, ParseIntError};
@@ -384,6 +386,40 @@ impl From<ConversionError> for ParseError {
     fn from(value: ConversionError) -> Self { Self::Conversion(value.input.into()) }
 }
 
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Height {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+        match choice {
+            0 => Ok(Height::MIN),
+            1 => Ok(Height::MAX),
+            _ => {
+                let min = Height::MIN.to_consensus_u32();
+                let max = Height::MAX.to_consensus_u32();
+                let h = u.int_in_range(min..=max)?;
+                Ok(Height::from_consensus(h).unwrap())
+            }
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Time {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+        match choice {
+            0 => Ok(Time::MIN),
+            1 => Ok(Time::MAX),
+            _ => {
+                let min = Time::MIN.to_consensus_u32();
+                let max = Time::MAX.to_consensus_u32();
+                let t = u.int_in_range(min..=max)?;
+                Ok(Time::from_consensus(t).unwrap())
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #[cfg(feature = "serde")]
diff --git a/units/src/locktime/relative.rs b/units/src/locktime/relative.rs
index 401ac2ced7..39796ab6ba 100644
--- a/units/src/locktime/relative.rs
+++ b/units/src/locktime/relative.rs
@@ -4,6 +4,8 @@
 
 use core::fmt;
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -159,6 +161,32 @@ impl fmt::Display for TimeOverflowError {
 #[cfg(feature = "std")]
 impl std::error::Error for TimeOverflowError {}
 
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Height {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+
+        match choice {
+            0 => Ok(Height::MIN),
+            1 => Ok(Height::MAX),
+            _ => Ok(Height::from_height(u16::arbitrary(u)?)),
+        }
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Time {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let choice = u.int_in_range(0..=2)?;
+
+        match choice {
+            0 => Ok(Time::MIN),
+            1 => Ok(Time::MAX),
+            _ => Ok(Time::from_512_second_intervals(u16::arbitrary(u)?)),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

From 04dfe8dd45fae9b55dacfe9eb0d73ea306db14ba Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Thu, 19 Dec 2024 15:38:03 -0600
Subject: [PATCH 134/554] Add api test to check Arbitrary impls

---
 units/tests/api.rs | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/units/tests/api.rs b/units/tests/api.rs
index 20746a3a89..44eee3d9c3 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -25,6 +25,8 @@ use bitcoin_units::{
     amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, FeeRate,
     SignedAmount, Weight,
 };
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 
 /// A struct that includes all public non-error enums.
 #[derive(Debug)] // All public types implement Debug (C-DEBUG).
@@ -263,3 +265,42 @@ fn regression_default() {
     };
     assert_eq!(got, want);
 }
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Types {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let a = Types { a: Enums::arbitrary(u)?, b: Structs::arbitrary(u)? };
+        Ok(a)
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Structs {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let a = Structs {
+            a: Amount::arbitrary(u)?,
+            // Skip the `Display` type.
+            b: Amount::MAX.display_in(amount::Denomination::Bitcoin),
+            c: SignedAmount::arbitrary(u)?,
+            d: BlockHeight::arbitrary(u)?,
+            e: BlockInterval::arbitrary(u)?,
+            f: FeeRate::arbitrary(u)?,
+            g: absolute::Height::arbitrary(u)?,
+            h: absolute::Time::arbitrary(u)?,
+            i: relative::Height::arbitrary(u)?,
+            j: relative::Time::arbitrary(u)?,
+            k: Weight::arbitrary(u)?,
+        };
+        Ok(a)
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Enums {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let a = Enums {
+            a: amount::Denomination::arbitrary(u)?,
+        };
+        Ok(a)
+    }
+}

From 73140b5fb7586965ae9f0b0961992e0ca32c44c3 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 21 Dec 2024 01:39:59 +0000
Subject: [PATCH 135/554] Automated update to Github CI to rustc
 nightly-2024-12-20

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 71ef52e171..a9dd23c12f 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2024-12-06
+nightly-2024-12-20

From 19acae716334ce2b215e4baf1cf405d05b326a9a Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 22 Dec 2024 01:21:54 +0000
Subject: [PATCH 136/554] 2024-12-22 automated rustfmt nightly

---
 internals/src/array_vec.rs       |  4 ++--
 units/src/amount/tests.rs        |  6 ++----
 units/src/amount/verification.rs |  2 +-
 units/src/internal_macros.rs     | 12 ++++++------
 units/tests/api.rs               |  8 +++-----
 5 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/internals/src/array_vec.rs b/internals/src/array_vec.rs
index 24003e14b4..bd4954aacb 100644
--- a/internals/src/array_vec.rs
+++ b/internals/src/array_vec.rs
@@ -193,7 +193,7 @@ mod tests {
 mod verification {
     use super::*;
 
-    #[kani::unwind(16)]         // One greater than 15 (max number of elements).
+    #[kani::unwind(16)] // One greater than 15 (max number of elements).
     #[kani::proof]
     fn no_out_of_bounds_less_than_cap() {
         const CAP: usize = 32;
@@ -212,7 +212,7 @@ mod verification {
         }
     }
 
-    #[kani::unwind(16)]         // One grater than 15.
+    #[kani::unwind(16)] // One grater than 15.
     #[kani::proof]
     fn no_out_of_bounds_upto_cap() {
         const CAP: usize = 15;
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index c4f6ea9fc7..d5e9394774 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -907,13 +907,11 @@ fn checked_sum_amounts() {
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 
-    let amounts =
-        [SignedAmount::MIN, SignedAmount::from_sat(-1), SignedAmount::from_sat(21)];
+    let amounts = [SignedAmount::MIN, SignedAmount::from_sat(-1), SignedAmount::from_sat(21)];
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 
-    let amounts =
-        [SignedAmount::MAX, SignedAmount::from_sat(1), SignedAmount::from_sat(21)];
+    let amounts = [SignedAmount::MAX, SignedAmount::from_sat(1), SignedAmount::from_sat(21)];
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 
diff --git a/units/src/amount/verification.rs b/units/src/amount/verification.rs
index ae970e1868..f0d7b47eb2 100644
--- a/units/src/amount/verification.rs
+++ b/units/src/amount/verification.rs
@@ -25,7 +25,7 @@ fn u_amount_homomorphic() {
     let n2 = kani::any::<u64>();
     // Assume we don't overflow in the actual tests.
     kani::assume(n1.checked_add(n2).is_some()); // Adding u64s doesn't overflow.
-    let a1 = Amount::from_sat(n1);              // TODO: If from_sat enforces invariant assume this `is_ok()`.
+    let a1 = Amount::from_sat(n1); // TODO: If from_sat enforces invariant assume this `is_ok()`.
     let a2 = Amount::from_sat(n2);
     kani::assume(a1.checked_add(a2).is_some()); // Adding amounts doesn't overflow.
 
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
index 03536b5ec5..475f9374e6 100644
--- a/units/src/internal_macros.rs
+++ b/units/src/internal_macros.rs
@@ -30,21 +30,21 @@ macro_rules! impl_add_for_references {
 
             fn add(self, rhs: &'a $ty) -> Self::Output { *self + *rhs }
         }
-    }
+    };
 }
 pub(crate) use impl_add_for_references;
 
 /// Implement `ops::AddAssign` for `$ty` and `&$ty`.
 macro_rules! impl_add_assign {
     ($ty:ident) => {
-         impl core::ops::AddAssign<$ty> for $ty {
+        impl core::ops::AddAssign<$ty> for $ty {
             fn add_assign(&mut self, rhs: $ty) { *self = *self + rhs }
         }
 
         impl core::ops::AddAssign<&$ty> for $ty {
             fn add_assign(&mut self, rhs: &$ty) { *self = *self + *rhs }
         }
-    }
+    };
 }
 pub(crate) use impl_add_assign;
 
@@ -74,20 +74,20 @@ macro_rules! impl_sub_for_references {
 
             fn sub(self, rhs: &'a $ty) -> Self::Output { *self - *rhs }
         }
-    }
+    };
 }
 pub(crate) use impl_sub_for_references;
 
 /// Implement `ops::SubAssign` for `$ty` and `&$ty`.
 macro_rules! impl_sub_assign {
     ($ty:ident) => {
-         impl core::ops::SubAssign<$ty> for $ty {
+        impl core::ops::SubAssign<$ty> for $ty {
             fn sub_assign(&mut self, rhs: $ty) { *self = *self - rhs }
         }
 
         impl core::ops::SubAssign<&$ty> for $ty {
             fn sub_assign(&mut self, rhs: &$ty) { *self = *self - *rhs }
         }
-   }
+    };
 }
 pub(crate) use impl_sub_assign;
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 44eee3d9c3..73d6fcf26d 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -20,13 +20,13 @@
 #![allow(unused_imports)]
 
 // These imports test "typical" usage by user code.
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
 use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::Height`.
 use bitcoin_units::{
     amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, FeeRate,
     SignedAmount, Weight,
 };
-#[cfg(feature = "arbitrary")]
-use arbitrary::{Arbitrary, Unstructured};
 
 /// A struct that includes all public non-error enums.
 #[derive(Debug)] // All public types implement Debug (C-DEBUG).
@@ -298,9 +298,7 @@ impl<'a> Arbitrary<'a> for Structs {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Enums {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let a = Enums {
-            a: amount::Denomination::arbitrary(u)?,
-        };
+        let a = Enums { a: amount::Denomination::arbitrary(u)? };
         Ok(a)
     }
 }

From 0a16382fa349e17e07576f7d056025fd09a332bd Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 23 Dec 2024 14:40:56 +1100
Subject: [PATCH 137/554] Rename rhs to weight

In ops functions we typically use `rhs` but for the more unconventional
`checked_*_by_*` functions lets use a more descriptive parameter name.

This is an internal change but the api files are updated because the
paramater names appear in the api text files.
---
 units/src/amount/unsigned.rs | 8 ++++----
 units/src/fee_rate.rs        | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 49edb71bef..e7b214189c 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -369,8 +369,8 @@ impl Amount {
     /// ```
     #[cfg(feature = "alloc")]
     #[must_use]
-    pub const fn checked_div_by_weight_ceil(self, rhs: Weight) -> Option<FeeRate> {
-        let wu = rhs.to_wu();
+    pub const fn checked_div_by_weight_ceil(self, weight: Weight) -> Option<FeeRate> {
+        let wu = weight.to_wu();
         // No `?` operator in const context.
         if let Some(sats) = self.0.checked_mul(1_000) {
             if let Some(wu_minus_one) = wu.checked_sub(1) {
@@ -392,10 +392,10 @@ impl Amount {
     /// Returns [`None`] if overflow occurred.
     #[cfg(feature = "alloc")]
     #[must_use]
-    pub const fn checked_div_by_weight_floor(self, rhs: Weight) -> Option<FeeRate> {
+    pub const fn checked_div_by_weight_floor(self, weight: Weight) -> Option<FeeRate> {
         // No `?` operator in const context.
         match self.0.checked_mul(1_000) {
-            Some(res) => match res.checked_div(rhs.to_wu()) {
+            Some(res) => match res.checked_div(weight.to_wu()) {
                 Some(fee_rate) => Some(FeeRate::from_sat_per_kwu(fee_rate)),
                 None => None,
             },
diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index 3429aa44aa..8c9b79d3db 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -108,9 +108,9 @@ impl FeeRate {
     ///
     /// [`None`] is returned if an overflow occurred.
     #[must_use]
-    pub const fn checked_mul_by_weight(self, rhs: Weight) -> Option<Amount> {
+    pub const fn checked_mul_by_weight(self, weight: Weight) -> Option<Amount> {
         // No `?` operator in const context.
-        match self.0.checked_mul(rhs.to_wu()) {
+        match self.0.checked_mul(weight.to_wu()) {
             Some(mul_res) => match mul_res.checked_add(999) {
                 Some(add_res) => Some(Amount::from_sat(add_res / 1000)),
                 None => None,

From 29811ba82cc598d08dc877825ecf8890c48d23b7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 23 Dec 2024 15:49:33 +1100
Subject: [PATCH 138/554] api: Run just check-api

Note that the changes here are not actually API breaking changes, they
are only changes to the parameter name.
---
 api/units/all-features.txt | 6 +++---
 api/units/alloc-only.txt   | 6 +++---
 api/units/no-features.txt  | 2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 23ad868e23..b6fe439c6e 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -713,8 +713,8 @@ pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
 pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
 pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
-pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
+pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
+pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
 pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
@@ -737,7 +737,7 @@ pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
 pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index ae1768dece..365d8d4660 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -664,8 +664,8 @@ pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
 pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
 pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
-pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
+pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
+pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
 pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
@@ -688,7 +688,7 @@ pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
 pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 197e438ebb..fa7f4538da 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -670,7 +670,7 @@ pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, rhs: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
 pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self

From 760f0715dd6df8978442ccab855fe3576e7947c7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 23 Dec 2024 14:28:14 +1100
Subject: [PATCH 139/554] units: Make amount::error module private

The `untis::error` module is just a code organisation thing it should
never have been public. We already re-export all the error types and
this is verified by the `units/tests/api.rs` test file.

Make the module private and remove it from the paths in the `api` test.
---
 units/src/amount/mod.rs |  2 +-
 units/tests/api.rs      | 31 +++++++++++--------------------
 2 files changed, 12 insertions(+), 21 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index cd16a85526..f340b90da7 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -5,7 +5,7 @@
 //! This module mainly introduces the [`Amount`] and [`SignedAmount`] types.
 //! We refer to the documentation on the types for more information.
 
-pub mod error;
+mod error;
 #[cfg(feature = "serde")]
 pub mod serde;
 
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 44eee3d9c3..6fb84cfaf5 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -124,17 +124,17 @@ struct Errors {
     i: amount::PossiblyConfusingDenominationError,
     j: amount::TooPreciseError,
     k: amount::UnknownDenominationError,
-    l: amount::error::InputTooLargeError,
-    m: amount::error::InvalidCharacterError,
-    n: amount::error::MissingDenominationError,
-    o: amount::error::MissingDigitsError,
-    p: amount::error::OutOfRangeError,
-    q: amount::error::ParseAmountError,
-    r: amount::error::ParseDenominationError,
-    s: amount::error::ParseError,
-    t: amount::error::PossiblyConfusingDenominationError,
-    u: amount::error::TooPreciseError,
-    v: amount::error::UnknownDenominationError,
+    l: amount::InputTooLargeError,
+    m: amount::InvalidCharacterError,
+    n: amount::MissingDenominationError,
+    o: amount::MissingDigitsError,
+    p: amount::OutOfRangeError,
+    q: amount::ParseAmountError,
+    r: amount::ParseDenominationError,
+    s: amount::ParseError,
+    t: amount::PossiblyConfusingDenominationError,
+    u: amount::TooPreciseError,
+    v: amount::UnknownDenominationError,
     w: block::TooBigForRelativeBlockHeightError,
     x: locktime::absolute::ConversionError,
     y: locktime::absolute::Height,
@@ -166,15 +166,6 @@ fn api_can_use_all_types_from_module_amount() {
     };
 }
 
-#[test]
-fn api_can_use_all_types_from_module_amount_error() {
-    use bitcoin_units::amount::error::{
-        InputTooLargeError, InvalidCharacterError, MissingDenominationError, MissingDigitsError,
-        OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError,
-        PossiblyConfusingDenominationError, TooPreciseError, UnknownDenominationError,
-    };
-}
-
 #[test]
 fn api_can_use_all_types_from_module_block() {
     use bitcoin_units::block::{BlockHeight, BlockInterval, TooBigForRelativeBlockHeightError};

From 6e78c05e0394773c18c1cbd6d140b9f57a6575b1 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 23 Dec 2024 14:30:12 +1100
Subject: [PATCH 140/554] api: Run just check-api

---
 api/units/all-features.txt | 480 ++++++++++++++++++-------------------
 api/units/alloc-only.txt   | 450 +++++++++++++++++-----------------
 api/units/no-features.txt  | 442 +++++++++++++++++-----------------
 3 files changed, 665 insertions(+), 707 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 23ad868e23..27369ab25c 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -1,19 +1,15 @@
 #[non_exhaustive] pub enum bitcoin_units::amount::Denomination
 #[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
-#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
 #[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
 #[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
 #[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
 #[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
 #[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
 impl bitcoin_units::Amount
 impl bitcoin_units::SignedAmount
 impl bitcoin_units::amount::Denomination
 impl bitcoin_units::amount::Display
-impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::amount::OutOfRangeError
 impl bitcoin_units::amount::serde::SerdeAmount for bitcoin_units::Amount
 impl bitcoin_units::amount::serde::SerdeAmount for bitcoin_units::SignedAmount
 impl bitcoin_units::amount::serde::SerdeAmountForOpt for bitcoin_units::Amount
@@ -41,17 +37,17 @@ impl core::clone::Clone for bitcoin_units::Amount
 impl core::clone::Clone for bitcoin_units::SignedAmount
 impl core::clone::Clone for bitcoin_units::amount::Denomination
 impl core::clone::Clone for bitcoin_units::amount::Display
-impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
-impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
-impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
-impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseError
-impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
-impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::amount::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::ParseError
+impl core::clone::Clone for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::UnknownDenominationError
 impl core::clone::Clone for bitcoin_units::block::BlockHeight
 impl core::clone::Clone for bitcoin_units::block::BlockInterval
 impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -71,17 +67,17 @@ impl core::clone::Clone for bitcoin_units::weight::Weight
 impl core::cmp::Eq for bitcoin_units::Amount
 impl core::cmp::Eq for bitcoin_units::SignedAmount
 impl core::cmp::Eq for bitcoin_units::amount::Denomination
-impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
-impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
-impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
-impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
-impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::UnknownDenominationError
 impl core::cmp::Eq for bitcoin_units::block::BlockHeight
 impl core::cmp::Eq for bitcoin_units::block::BlockInterval
 impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -111,17 +107,17 @@ impl core::cmp::Ord for bitcoin_units::weight::Weight
 impl core::cmp::PartialEq for bitcoin_units::Amount
 impl core::cmp::PartialEq for bitcoin_units::SignedAmount
 impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
-impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::UnknownDenominationError
 impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
 impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
 impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -149,18 +145,18 @@ impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
 impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
 impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
 impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
-impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::ParseAmountError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::ParseDenominationError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseError
 impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
 impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
 impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
@@ -170,9 +166,9 @@ impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units:
 impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
 impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
 impl core::convert::From<bitcoin_units::weight::Weight> for u64
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
 impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
@@ -211,16 +207,16 @@ impl core::default::Default for bitcoin_units::SignedAmount
 impl core::default::Default for bitcoin_units::block::BlockInterval
 impl core::default::Default for bitcoin_units::locktime::relative::Height
 impl core::default::Default for bitcoin_units::locktime::relative::Time
-impl core::error::Error for bitcoin_units::amount::error::InputTooLargeError
-impl core::error::Error for bitcoin_units::amount::error::InvalidCharacterError
-impl core::error::Error for bitcoin_units::amount::error::MissingDigitsError
-impl core::error::Error for bitcoin_units::amount::error::OutOfRangeError
-impl core::error::Error for bitcoin_units::amount::error::ParseAmountError
-impl core::error::Error for bitcoin_units::amount::error::ParseDenominationError
-impl core::error::Error for bitcoin_units::amount::error::ParseError
-impl core::error::Error for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::error::Error for bitcoin_units::amount::error::TooPreciseError
-impl core::error::Error for bitcoin_units::amount::error::UnknownDenominationError
+impl core::error::Error for bitcoin_units::amount::InputTooLargeError
+impl core::error::Error for bitcoin_units::amount::InvalidCharacterError
+impl core::error::Error for bitcoin_units::amount::MissingDigitsError
+impl core::error::Error for bitcoin_units::amount::OutOfRangeError
+impl core::error::Error for bitcoin_units::amount::ParseAmountError
+impl core::error::Error for bitcoin_units::amount::ParseDenominationError
+impl core::error::Error for bitcoin_units::amount::ParseError
+impl core::error::Error for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::error::Error for bitcoin_units::amount::TooPreciseError
+impl core::error::Error for bitcoin_units::amount::UnknownDenominationError
 impl core::error::Error for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::error::Error for bitcoin_units::locktime::absolute::ConversionError
 impl core::error::Error for bitcoin_units::locktime::absolute::ParseHeightError
@@ -233,17 +229,17 @@ impl core::fmt::Debug for bitcoin_units::Amount
 impl core::fmt::Debug for bitcoin_units::SignedAmount
 impl core::fmt::Debug for bitcoin_units::amount::Denomination
 impl core::fmt::Debug for bitcoin_units::amount::Display
-impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
-impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
-impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
-impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
-impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
-impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::UnknownDenominationError
 impl core::fmt::Debug for bitcoin_units::block::BlockHeight
 impl core::fmt::Debug for bitcoin_units::block::BlockInterval
 impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -264,16 +260,16 @@ impl core::fmt::Display for bitcoin_units::Amount
 impl core::fmt::Display for bitcoin_units::SignedAmount
 impl core::fmt::Display for bitcoin_units::amount::Denomination
 impl core::fmt::Display for bitcoin_units::amount::Display
-impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
-impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
-impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
-impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseError
-impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
-impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::amount::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::ParseError
+impl core::fmt::Display for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::UnknownDenominationError
 impl core::fmt::Display for bitcoin_units::block::BlockHeight
 impl core::fmt::Display for bitcoin_units::block::BlockInterval
 impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -309,7 +305,7 @@ impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
 impl core::marker::Copy for bitcoin_units::Amount
 impl core::marker::Copy for bitcoin_units::SignedAmount
 impl core::marker::Copy for bitcoin_units::amount::Denomination
-impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::amount::OutOfRangeError
 impl core::marker::Copy for bitcoin_units::block::BlockHeight
 impl core::marker::Copy for bitcoin_units::block::BlockInterval
 impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
@@ -322,17 +318,17 @@ impl core::marker::Freeze for bitcoin_units::Amount
 impl core::marker::Freeze for bitcoin_units::SignedAmount
 impl core::marker::Freeze for bitcoin_units::amount::Denomination
 impl core::marker::Freeze for bitcoin_units::amount::Display
-impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
-impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Freeze for bitcoin_units::block::BlockHeight
 impl core::marker::Freeze for bitcoin_units::block::BlockInterval
 impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -353,17 +349,17 @@ impl core::marker::Send for bitcoin_units::Amount
 impl core::marker::Send for bitcoin_units::SignedAmount
 impl core::marker::Send for bitcoin_units::amount::Denomination
 impl core::marker::Send for bitcoin_units::amount::Display
-impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::ParseError
-impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::ParseError
+impl core::marker::Send for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Send for bitcoin_units::block::BlockHeight
 impl core::marker::Send for bitcoin_units::block::BlockInterval
 impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -383,17 +379,17 @@ impl core::marker::Send for bitcoin_units::weight::Weight
 impl core::marker::StructuralPartialEq for bitcoin_units::Amount
 impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
 impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
 impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
 impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -414,17 +410,17 @@ impl core::marker::Sync for bitcoin_units::Amount
 impl core::marker::Sync for bitcoin_units::SignedAmount
 impl core::marker::Sync for bitcoin_units::amount::Denomination
 impl core::marker::Sync for bitcoin_units::amount::Display
-impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseError
-impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::ParseError
+impl core::marker::Sync for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Sync for bitcoin_units::block::BlockHeight
 impl core::marker::Sync for bitcoin_units::block::BlockInterval
 impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -445,17 +441,17 @@ impl core::marker::Unpin for bitcoin_units::Amount
 impl core::marker::Unpin for bitcoin_units::SignedAmount
 impl core::marker::Unpin for bitcoin_units::amount::Denomination
 impl core::marker::Unpin for bitcoin_units::amount::Display
-impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
-impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Unpin for bitcoin_units::block::BlockHeight
 impl core::marker::Unpin for bitcoin_units::block::BlockInterval
 impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -545,17 +541,17 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::UnknownDenominationError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -576,17 +572,17 @@ impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::UnknownDenominationError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -662,10 +658,8 @@ pub bitcoin_units::amount::Denomination::CentiBitcoin
 pub bitcoin_units::amount::Denomination::MicroBitcoin
 pub bitcoin_units::amount::Denomination::MilliBitcoin
 pub bitcoin_units::amount::Denomination::Satoshi
-pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
-pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
 pub const bitcoin_units::Amount::MAX: Self
 pub const bitcoin_units::Amount::MAX_MONEY: Self
 pub const bitcoin_units::Amount::MIN: Self
@@ -810,12 +804,12 @@ pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
 pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseError>
 pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
@@ -836,7 +830,7 @@ pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
 pub fn bitcoin_units::Amount::to_btc(self) -> f64
 pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
-pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
@@ -861,12 +855,12 @@ pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
 pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
 pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseError>
 pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
 pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
@@ -894,7 +888,7 @@ pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
 pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
 pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::SignedAmount::type_prefix(_: private::Token) -> &'static str
 pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
@@ -910,62 +904,62 @@ pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self,
 pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
-pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
-pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
-pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
-pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
-pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
-pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
-pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
-pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
-pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
-pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
-pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
-pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
-pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
-pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
-pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::ParseDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
-pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
-pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::ParseError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
-pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
-pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
-pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
-pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::UnknownDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::InputTooLargeError::clone(&self) -> bitcoin_units::amount::InputTooLargeError
+pub fn bitcoin_units::amount::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::InvalidCharacterError
+pub fn bitcoin_units::amount::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::MissingDenominationError::clone(&self) -> bitcoin_units::amount::MissingDenominationError
+pub fn bitcoin_units::amount::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::MissingDigitsError::clone(&self) -> bitcoin_units::amount::MissingDigitsError
+pub fn bitcoin_units::amount::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::OutOfRangeError::clone(&self) -> bitcoin_units::amount::OutOfRangeError
+pub fn bitcoin_units::amount::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::valid_range(self) -> (i64, u64)
+pub fn bitcoin_units::amount::ParseAmountError::clone(&self) -> bitcoin_units::amount::ParseAmountError
+pub fn bitcoin_units::amount::ParseAmountError::eq(&self, other: &bitcoin_units::amount::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::ParseDenominationError::clone(&self) -> bitcoin_units::amount::ParseDenominationError
+pub fn bitcoin_units::amount::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::ParseDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::ParseError::clone(&self) -> bitcoin_units::amount::ParseError
+pub fn bitcoin_units::amount::ParseError::eq(&self, other: &bitcoin_units::amount::ParseError) -> bool
+pub fn bitcoin_units::amount::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::ParseError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
+pub fn bitcoin_units::amount::TooPreciseError::clone(&self) -> bitcoin_units::amount::TooPreciseError
+pub fn bitcoin_units::amount::TooPreciseError::eq(&self, other: &bitcoin_units::amount::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::UnknownDenominationError
+pub fn bitcoin_units::amount::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::UnknownDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
 pub fn bitcoin_units::amount::serde::SerdeAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::SerdeAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
@@ -1203,7 +1197,6 @@ pub macro bitcoin_units::impl_tryfrom_str!
 pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
-pub mod bitcoin_units::amount::error
 pub mod bitcoin_units::amount::serde
 pub mod bitcoin_units::amount::serde::as_btc
 pub mod bitcoin_units::amount::serde::as_btc::opt
@@ -1234,13 +1227,6 @@ pub struct bitcoin_units::amount::ParseAmountError(_)
 pub struct bitcoin_units::amount::ParseError(_)
 pub struct bitcoin_units::amount::SignedAmount(_)
 pub struct bitcoin_units::amount::TooPreciseError
-pub struct bitcoin_units::amount::error::InputTooLargeError
-pub struct bitcoin_units::amount::error::InvalidCharacterError
-pub struct bitcoin_units::amount::error::MissingDigitsError
-pub struct bitcoin_units::amount::error::OutOfRangeError
-pub struct bitcoin_units::amount::error::ParseAmountError(_)
-pub struct bitcoin_units::amount::error::ParseError(_)
-pub struct bitcoin_units::amount::error::TooPreciseError
 pub struct bitcoin_units::block::BlockHeight(pub u32)
 pub struct bitcoin_units::block::BlockInterval(pub u32)
 pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
@@ -1263,14 +1249,14 @@ pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
 pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
-pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
-pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
+pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
 pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
 pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
 pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index ae1768dece..bfe3a73d19 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -1,19 +1,15 @@
 #[non_exhaustive] pub enum bitcoin_units::amount::Denomination
 #[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
-#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
 #[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
 #[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
 #[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
 #[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
 #[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
 impl bitcoin_units::Amount
 impl bitcoin_units::SignedAmount
 impl bitcoin_units::amount::Denomination
 impl bitcoin_units::amount::Display
-impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::amount::OutOfRangeError
 impl bitcoin_units::block::BlockHeight
 impl bitcoin_units::block::BlockInterval
 impl bitcoin_units::fee_rate::FeeRate
@@ -37,17 +33,17 @@ impl core::clone::Clone for bitcoin_units::Amount
 impl core::clone::Clone for bitcoin_units::SignedAmount
 impl core::clone::Clone for bitcoin_units::amount::Denomination
 impl core::clone::Clone for bitcoin_units::amount::Display
-impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
-impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
-impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
-impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseError
-impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
-impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::amount::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::ParseError
+impl core::clone::Clone for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::UnknownDenominationError
 impl core::clone::Clone for bitcoin_units::block::BlockHeight
 impl core::clone::Clone for bitcoin_units::block::BlockInterval
 impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -67,17 +63,17 @@ impl core::clone::Clone for bitcoin_units::weight::Weight
 impl core::cmp::Eq for bitcoin_units::Amount
 impl core::cmp::Eq for bitcoin_units::SignedAmount
 impl core::cmp::Eq for bitcoin_units::amount::Denomination
-impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
-impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
-impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
-impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
-impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::UnknownDenominationError
 impl core::cmp::Eq for bitcoin_units::block::BlockHeight
 impl core::cmp::Eq for bitcoin_units::block::BlockInterval
 impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -107,17 +103,17 @@ impl core::cmp::Ord for bitcoin_units::weight::Weight
 impl core::cmp::PartialEq for bitcoin_units::Amount
 impl core::cmp::PartialEq for bitcoin_units::SignedAmount
 impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
-impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::UnknownDenominationError
 impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
 impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
 impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -145,18 +141,18 @@ impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
 impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
 impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
 impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
-impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::ParseAmountError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::ParseDenominationError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseError
 impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
 impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
 impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
@@ -166,9 +162,9 @@ impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units:
 impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
 impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
 impl core::convert::From<bitcoin_units::weight::Weight> for u64
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
 impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
@@ -211,17 +207,17 @@ impl core::fmt::Debug for bitcoin_units::Amount
 impl core::fmt::Debug for bitcoin_units::SignedAmount
 impl core::fmt::Debug for bitcoin_units::amount::Denomination
 impl core::fmt::Debug for bitcoin_units::amount::Display
-impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
-impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
-impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
-impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
-impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
-impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::UnknownDenominationError
 impl core::fmt::Debug for bitcoin_units::block::BlockHeight
 impl core::fmt::Debug for bitcoin_units::block::BlockInterval
 impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -242,16 +238,16 @@ impl core::fmt::Display for bitcoin_units::Amount
 impl core::fmt::Display for bitcoin_units::SignedAmount
 impl core::fmt::Display for bitcoin_units::amount::Denomination
 impl core::fmt::Display for bitcoin_units::amount::Display
-impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
-impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
-impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
-impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseError
-impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
-impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::amount::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::ParseError
+impl core::fmt::Display for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::UnknownDenominationError
 impl core::fmt::Display for bitcoin_units::block::BlockHeight
 impl core::fmt::Display for bitcoin_units::block::BlockInterval
 impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -287,7 +283,7 @@ impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
 impl core::marker::Copy for bitcoin_units::Amount
 impl core::marker::Copy for bitcoin_units::SignedAmount
 impl core::marker::Copy for bitcoin_units::amount::Denomination
-impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::amount::OutOfRangeError
 impl core::marker::Copy for bitcoin_units::block::BlockHeight
 impl core::marker::Copy for bitcoin_units::block::BlockInterval
 impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
@@ -300,17 +296,17 @@ impl core::marker::Freeze for bitcoin_units::Amount
 impl core::marker::Freeze for bitcoin_units::SignedAmount
 impl core::marker::Freeze for bitcoin_units::amount::Denomination
 impl core::marker::Freeze for bitcoin_units::amount::Display
-impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
-impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Freeze for bitcoin_units::block::BlockHeight
 impl core::marker::Freeze for bitcoin_units::block::BlockInterval
 impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -331,17 +327,17 @@ impl core::marker::Send for bitcoin_units::Amount
 impl core::marker::Send for bitcoin_units::SignedAmount
 impl core::marker::Send for bitcoin_units::amount::Denomination
 impl core::marker::Send for bitcoin_units::amount::Display
-impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::ParseError
-impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::ParseError
+impl core::marker::Send for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Send for bitcoin_units::block::BlockHeight
 impl core::marker::Send for bitcoin_units::block::BlockInterval
 impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -361,17 +357,17 @@ impl core::marker::Send for bitcoin_units::weight::Weight
 impl core::marker::StructuralPartialEq for bitcoin_units::Amount
 impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
 impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
 impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
 impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -392,17 +388,17 @@ impl core::marker::Sync for bitcoin_units::Amount
 impl core::marker::Sync for bitcoin_units::SignedAmount
 impl core::marker::Sync for bitcoin_units::amount::Denomination
 impl core::marker::Sync for bitcoin_units::amount::Display
-impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseError
-impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::ParseError
+impl core::marker::Sync for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Sync for bitcoin_units::block::BlockHeight
 impl core::marker::Sync for bitcoin_units::block::BlockInterval
 impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -423,17 +419,17 @@ impl core::marker::Unpin for bitcoin_units::Amount
 impl core::marker::Unpin for bitcoin_units::SignedAmount
 impl core::marker::Unpin for bitcoin_units::amount::Denomination
 impl core::marker::Unpin for bitcoin_units::amount::Display
-impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
-impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Unpin for bitcoin_units::block::BlockHeight
 impl core::marker::Unpin for bitcoin_units::block::BlockInterval
 impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -523,17 +519,17 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::UnknownDenominationError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -554,17 +550,17 @@ impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::UnknownDenominationError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -613,10 +609,8 @@ pub bitcoin_units::amount::Denomination::CentiBitcoin
 pub bitcoin_units::amount::Denomination::MicroBitcoin
 pub bitcoin_units::amount::Denomination::MilliBitcoin
 pub bitcoin_units::amount::Denomination::Satoshi
-pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
-pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
 pub const bitcoin_units::Amount::MAX: Self
 pub const bitcoin_units::Amount::MAX_MONEY: Self
 pub const bitcoin_units::Amount::MIN: Self
@@ -757,12 +751,12 @@ pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
 pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseError>
 pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
@@ -777,7 +771,7 @@ pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
 pub fn bitcoin_units::Amount::to_btc(self) -> f64
 pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
-pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
@@ -797,12 +791,12 @@ pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
 pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
 pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseError>
 pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
 pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
@@ -824,7 +818,7 @@ pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
 pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
 pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
@@ -838,57 +832,57 @@ pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self,
 pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
-pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
-pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
-pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
-pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
-pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
-pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
-pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
-pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
-pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
-pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
-pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
-pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
-pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
-pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
-pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
-pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
-pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
-pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
-pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
-pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
-pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::InputTooLargeError::clone(&self) -> bitcoin_units::amount::InputTooLargeError
+pub fn bitcoin_units::amount::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::InvalidCharacterError
+pub fn bitcoin_units::amount::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::MissingDenominationError::clone(&self) -> bitcoin_units::amount::MissingDenominationError
+pub fn bitcoin_units::amount::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::MissingDigitsError::clone(&self) -> bitcoin_units::amount::MissingDigitsError
+pub fn bitcoin_units::amount::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::OutOfRangeError::clone(&self) -> bitcoin_units::amount::OutOfRangeError
+pub fn bitcoin_units::amount::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::valid_range(self) -> (i64, u64)
+pub fn bitcoin_units::amount::ParseAmountError::clone(&self) -> bitcoin_units::amount::ParseAmountError
+pub fn bitcoin_units::amount::ParseAmountError::eq(&self, other: &bitcoin_units::amount::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::ParseDenominationError::clone(&self) -> bitcoin_units::amount::ParseDenominationError
+pub fn bitcoin_units::amount::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::ParseError::clone(&self) -> bitcoin_units::amount::ParseError
+pub fn bitcoin_units::amount::ParseError::eq(&self, other: &bitcoin_units::amount::ParseError) -> bool
+pub fn bitcoin_units::amount::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::TooPreciseError::clone(&self) -> bitcoin_units::amount::TooPreciseError
+pub fn bitcoin_units::amount::TooPreciseError::eq(&self, other: &bitcoin_units::amount::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::UnknownDenominationError
+pub fn bitcoin_units::amount::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
 pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
 pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
@@ -1074,7 +1068,6 @@ pub macro bitcoin_units::impl_tryfrom_str!
 pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
-pub mod bitcoin_units::amount::error
 pub mod bitcoin_units::block
 pub mod bitcoin_units::fee_rate
 pub mod bitcoin_units::locktime
@@ -1098,13 +1091,6 @@ pub struct bitcoin_units::amount::ParseAmountError(_)
 pub struct bitcoin_units::amount::ParseError(_)
 pub struct bitcoin_units::amount::SignedAmount(_)
 pub struct bitcoin_units::amount::TooPreciseError
-pub struct bitcoin_units::amount::error::InputTooLargeError
-pub struct bitcoin_units::amount::error::InvalidCharacterError
-pub struct bitcoin_units::amount::error::MissingDigitsError
-pub struct bitcoin_units::amount::error::OutOfRangeError
-pub struct bitcoin_units::amount::error::ParseAmountError(_)
-pub struct bitcoin_units::amount::error::ParseError(_)
-pub struct bitcoin_units::amount::error::TooPreciseError
 pub struct bitcoin_units::block::BlockHeight(pub u32)
 pub struct bitcoin_units::block::BlockInterval(pub u32)
 pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
@@ -1125,14 +1111,14 @@ pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
 pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
-pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
-pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
+pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
 pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
 pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
 pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 197e438ebb..60c1ac1b84 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -1,19 +1,15 @@
 #[non_exhaustive] pub enum bitcoin_units::amount::Denomination
 #[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
-#[non_exhaustive] pub enum bitcoin_units::amount::error::ParseDenominationError
 #[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
 #[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
 #[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::error::MissingDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::error::PossiblyConfusingDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::error::UnknownDenominationError(_)
 #[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
 #[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
 impl bitcoin_units::Amount
 impl bitcoin_units::SignedAmount
 impl bitcoin_units::amount::Denomination
 impl bitcoin_units::amount::Display
-impl bitcoin_units::amount::error::OutOfRangeError
+impl bitcoin_units::amount::OutOfRangeError
 impl bitcoin_units::block::BlockHeight
 impl bitcoin_units::block::BlockInterval
 impl bitcoin_units::fee_rate::FeeRate
@@ -37,17 +33,17 @@ impl core::clone::Clone for bitcoin_units::Amount
 impl core::clone::Clone for bitcoin_units::SignedAmount
 impl core::clone::Clone for bitcoin_units::amount::Denomination
 impl core::clone::Clone for bitcoin_units::amount::Display
-impl core::clone::Clone for bitcoin_units::amount::error::InputTooLargeError
-impl core::clone::Clone for bitcoin_units::amount::error::InvalidCharacterError
-impl core::clone::Clone for bitcoin_units::amount::error::MissingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::MissingDigitsError
-impl core::clone::Clone for bitcoin_units::amount::error::OutOfRangeError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseAmountError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::ParseError
-impl core::clone::Clone for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::error::TooPreciseError
-impl core::clone::Clone for bitcoin_units::amount::error::UnknownDenominationError
+impl core::clone::Clone for bitcoin_units::amount::InputTooLargeError
+impl core::clone::Clone for bitcoin_units::amount::InvalidCharacterError
+impl core::clone::Clone for bitcoin_units::amount::MissingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::MissingDigitsError
+impl core::clone::Clone for bitcoin_units::amount::OutOfRangeError
+impl core::clone::Clone for bitcoin_units::amount::ParseAmountError
+impl core::clone::Clone for bitcoin_units::amount::ParseDenominationError
+impl core::clone::Clone for bitcoin_units::amount::ParseError
+impl core::clone::Clone for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::clone::Clone for bitcoin_units::amount::TooPreciseError
+impl core::clone::Clone for bitcoin_units::amount::UnknownDenominationError
 impl core::clone::Clone for bitcoin_units::block::BlockHeight
 impl core::clone::Clone for bitcoin_units::block::BlockInterval
 impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -67,17 +63,17 @@ impl core::clone::Clone for bitcoin_units::weight::Weight
 impl core::cmp::Eq for bitcoin_units::Amount
 impl core::cmp::Eq for bitcoin_units::SignedAmount
 impl core::cmp::Eq for bitcoin_units::amount::Denomination
-impl core::cmp::Eq for bitcoin_units::amount::error::InputTooLargeError
-impl core::cmp::Eq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::cmp::Eq for bitcoin_units::amount::error::MissingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::MissingDigitsError
-impl core::cmp::Eq for bitcoin_units::amount::error::OutOfRangeError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseAmountError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::ParseError
-impl core::cmp::Eq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::error::TooPreciseError
-impl core::cmp::Eq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::InputTooLargeError
+impl core::cmp::Eq for bitcoin_units::amount::InvalidCharacterError
+impl core::cmp::Eq for bitcoin_units::amount::MissingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::MissingDigitsError
+impl core::cmp::Eq for bitcoin_units::amount::OutOfRangeError
+impl core::cmp::Eq for bitcoin_units::amount::ParseAmountError
+impl core::cmp::Eq for bitcoin_units::amount::ParseDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::ParseError
+impl core::cmp::Eq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::cmp::Eq for bitcoin_units::amount::TooPreciseError
+impl core::cmp::Eq for bitcoin_units::amount::UnknownDenominationError
 impl core::cmp::Eq for bitcoin_units::block::BlockHeight
 impl core::cmp::Eq for bitcoin_units::block::BlockInterval
 impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -107,17 +103,17 @@ impl core::cmp::Ord for bitcoin_units::weight::Weight
 impl core::cmp::PartialEq for bitcoin_units::Amount
 impl core::cmp::PartialEq for bitcoin_units::SignedAmount
 impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
-impl core::cmp::PartialEq for bitcoin_units::amount::error::InputTooLargeError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::MissingDigitsError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::OutOfRangeError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseAmountError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::ParseError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::TooPreciseError
-impl core::cmp::PartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::InputTooLargeError
+impl core::cmp::PartialEq for bitcoin_units::amount::InvalidCharacterError
+impl core::cmp::PartialEq for bitcoin_units::amount::MissingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::MissingDigitsError
+impl core::cmp::PartialEq for bitcoin_units::amount::OutOfRangeError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseAmountError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::ParseError
+impl core::cmp::PartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::cmp::PartialEq for bitcoin_units::amount::TooPreciseError
+impl core::cmp::PartialEq for bitcoin_units::amount::UnknownDenominationError
 impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
 impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
 impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -145,18 +141,18 @@ impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
 impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
 impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
 impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
-impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::InputTooLargeError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::InvalidCharacterError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::MissingDigitsError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::OutOfRangeError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::ParseAmountError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::ParseDenominationError> for bitcoin_units::amount::error::ParseError
-impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::error::TooPreciseError> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::ParseAmountError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::ParseDenominationError> for bitcoin_units::amount::ParseError
+impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseError
 impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
 impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
 impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
@@ -166,9 +162,9 @@ impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units:
 impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
 impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
 impl core::convert::From<bitcoin_units::weight::Weight> for u64
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseAmountError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseDenominationError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::error::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseAmountError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseDenominationError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
 impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
@@ -195,17 +191,17 @@ impl core::fmt::Debug for bitcoin_units::Amount
 impl core::fmt::Debug for bitcoin_units::SignedAmount
 impl core::fmt::Debug for bitcoin_units::amount::Denomination
 impl core::fmt::Debug for bitcoin_units::amount::Display
-impl core::fmt::Debug for bitcoin_units::amount::error::InputTooLargeError
-impl core::fmt::Debug for bitcoin_units::amount::error::InvalidCharacterError
-impl core::fmt::Debug for bitcoin_units::amount::error::MissingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::MissingDigitsError
-impl core::fmt::Debug for bitcoin_units::amount::error::OutOfRangeError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseAmountError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::ParseError
-impl core::fmt::Debug for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::error::TooPreciseError
-impl core::fmt::Debug for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::InputTooLargeError
+impl core::fmt::Debug for bitcoin_units::amount::InvalidCharacterError
+impl core::fmt::Debug for bitcoin_units::amount::MissingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::MissingDigitsError
+impl core::fmt::Debug for bitcoin_units::amount::OutOfRangeError
+impl core::fmt::Debug for bitcoin_units::amount::ParseAmountError
+impl core::fmt::Debug for bitcoin_units::amount::ParseDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::ParseError
+impl core::fmt::Debug for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::fmt::Debug for bitcoin_units::amount::TooPreciseError
+impl core::fmt::Debug for bitcoin_units::amount::UnknownDenominationError
 impl core::fmt::Debug for bitcoin_units::block::BlockHeight
 impl core::fmt::Debug for bitcoin_units::block::BlockInterval
 impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -226,16 +222,16 @@ impl core::fmt::Display for bitcoin_units::Amount
 impl core::fmt::Display for bitcoin_units::SignedAmount
 impl core::fmt::Display for bitcoin_units::amount::Denomination
 impl core::fmt::Display for bitcoin_units::amount::Display
-impl core::fmt::Display for bitcoin_units::amount::error::InputTooLargeError
-impl core::fmt::Display for bitcoin_units::amount::error::InvalidCharacterError
-impl core::fmt::Display for bitcoin_units::amount::error::MissingDigitsError
-impl core::fmt::Display for bitcoin_units::amount::error::OutOfRangeError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseAmountError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseDenominationError
-impl core::fmt::Display for bitcoin_units::amount::error::ParseError
-impl core::fmt::Display for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::fmt::Display for bitcoin_units::amount::error::TooPreciseError
-impl core::fmt::Display for bitcoin_units::amount::error::UnknownDenominationError
+impl core::fmt::Display for bitcoin_units::amount::InputTooLargeError
+impl core::fmt::Display for bitcoin_units::amount::InvalidCharacterError
+impl core::fmt::Display for bitcoin_units::amount::MissingDigitsError
+impl core::fmt::Display for bitcoin_units::amount::OutOfRangeError
+impl core::fmt::Display for bitcoin_units::amount::ParseAmountError
+impl core::fmt::Display for bitcoin_units::amount::ParseDenominationError
+impl core::fmt::Display for bitcoin_units::amount::ParseError
+impl core::fmt::Display for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::fmt::Display for bitcoin_units::amount::TooPreciseError
+impl core::fmt::Display for bitcoin_units::amount::UnknownDenominationError
 impl core::fmt::Display for bitcoin_units::block::BlockHeight
 impl core::fmt::Display for bitcoin_units::block::BlockInterval
 impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -271,7 +267,7 @@ impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
 impl core::marker::Copy for bitcoin_units::Amount
 impl core::marker::Copy for bitcoin_units::SignedAmount
 impl core::marker::Copy for bitcoin_units::amount::Denomination
-impl core::marker::Copy for bitcoin_units::amount::error::OutOfRangeError
+impl core::marker::Copy for bitcoin_units::amount::OutOfRangeError
 impl core::marker::Copy for bitcoin_units::block::BlockHeight
 impl core::marker::Copy for bitcoin_units::block::BlockInterval
 impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
@@ -284,17 +280,17 @@ impl core::marker::Freeze for bitcoin_units::Amount
 impl core::marker::Freeze for bitcoin_units::SignedAmount
 impl core::marker::Freeze for bitcoin_units::amount::Denomination
 impl core::marker::Freeze for bitcoin_units::amount::Display
-impl core::marker::Freeze for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Freeze for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Freeze for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Freeze for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::ParseError
-impl core::marker::Freeze for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Freeze for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Freeze for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Freeze for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Freeze for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Freeze for bitcoin_units::amount::ParseAmountError
+impl core::marker::Freeze for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::ParseError
+impl core::marker::Freeze for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Freeze for bitcoin_units::amount::TooPreciseError
+impl core::marker::Freeze for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Freeze for bitcoin_units::block::BlockHeight
 impl core::marker::Freeze for bitcoin_units::block::BlockInterval
 impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -315,17 +311,17 @@ impl core::marker::Send for bitcoin_units::Amount
 impl core::marker::Send for bitcoin_units::SignedAmount
 impl core::marker::Send for bitcoin_units::amount::Denomination
 impl core::marker::Send for bitcoin_units::amount::Display
-impl core::marker::Send for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Send for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Send for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Send for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Send for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Send for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::ParseError
-impl core::marker::Send for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Send for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Send for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Send for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Send for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Send for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Send for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Send for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Send for bitcoin_units::amount::ParseAmountError
+impl core::marker::Send for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Send for bitcoin_units::amount::ParseError
+impl core::marker::Send for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Send for bitcoin_units::amount::TooPreciseError
+impl core::marker::Send for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Send for bitcoin_units::block::BlockHeight
 impl core::marker::Send for bitcoin_units::block::BlockInterval
 impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -345,17 +341,17 @@ impl core::marker::Send for bitcoin_units::weight::Weight
 impl core::marker::StructuralPartialEq for bitcoin_units::Amount
 impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
 impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::ParseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::InputTooLargeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDigitsError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::OutOfRangeError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseAmountError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::TooPreciseError
+impl core::marker::StructuralPartialEq for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
 impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
 impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -376,17 +372,17 @@ impl core::marker::Sync for bitcoin_units::Amount
 impl core::marker::Sync for bitcoin_units::SignedAmount
 impl core::marker::Sync for bitcoin_units::amount::Denomination
 impl core::marker::Sync for bitcoin_units::amount::Display
-impl core::marker::Sync for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Sync for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Sync for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Sync for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::ParseError
-impl core::marker::Sync for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Sync for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Sync for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Sync for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Sync for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Sync for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Sync for bitcoin_units::amount::ParseAmountError
+impl core::marker::Sync for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Sync for bitcoin_units::amount::ParseError
+impl core::marker::Sync for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Sync for bitcoin_units::amount::TooPreciseError
+impl core::marker::Sync for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Sync for bitcoin_units::block::BlockHeight
 impl core::marker::Sync for bitcoin_units::block::BlockInterval
 impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -407,17 +403,17 @@ impl core::marker::Unpin for bitcoin_units::Amount
 impl core::marker::Unpin for bitcoin_units::SignedAmount
 impl core::marker::Unpin for bitcoin_units::amount::Denomination
 impl core::marker::Unpin for bitcoin_units::amount::Display
-impl core::marker::Unpin for bitcoin_units::amount::error::InputTooLargeError
-impl core::marker::Unpin for bitcoin_units::amount::error::InvalidCharacterError
-impl core::marker::Unpin for bitcoin_units::amount::error::MissingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::MissingDigitsError
-impl core::marker::Unpin for bitcoin_units::amount::error::OutOfRangeError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseAmountError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::ParseError
-impl core::marker::Unpin for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::error::TooPreciseError
-impl core::marker::Unpin for bitcoin_units::amount::error::UnknownDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::InputTooLargeError
+impl core::marker::Unpin for bitcoin_units::amount::InvalidCharacterError
+impl core::marker::Unpin for bitcoin_units::amount::MissingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::MissingDigitsError
+impl core::marker::Unpin for bitcoin_units::amount::OutOfRangeError
+impl core::marker::Unpin for bitcoin_units::amount::ParseAmountError
+impl core::marker::Unpin for bitcoin_units::amount::ParseDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::ParseError
+impl core::marker::Unpin for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::marker::Unpin for bitcoin_units::amount::TooPreciseError
+impl core::marker::Unpin for bitcoin_units::amount::UnknownDenominationError
 impl core::marker::Unpin for bitcoin_units::block::BlockHeight
 impl core::marker::Unpin for bitcoin_units::block::BlockInterval
 impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -507,17 +503,17 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InputTooLargeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::MissingDigitsError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::OutOfRangeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseAmountError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::ParseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::TooPreciseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InputTooLargeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InvalidCharacterError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDigitsError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::OutOfRangeError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseAmountError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::TooPreciseError
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::UnknownDenominationError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -538,17 +534,17 @@ impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InputTooLargeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::InvalidCharacterError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::MissingDigitsError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::OutOfRangeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseAmountError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::ParseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::TooPreciseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::error::UnknownDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InputTooLargeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InvalidCharacterError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDigitsError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::OutOfRangeError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseAmountError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::TooPreciseError
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::UnknownDenominationError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
@@ -597,10 +593,8 @@ pub bitcoin_units::amount::Denomination::CentiBitcoin
 pub bitcoin_units::amount::Denomination::MicroBitcoin
 pub bitcoin_units::amount::Denomination::MilliBitcoin
 pub bitcoin_units::amount::Denomination::Satoshi
-pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
-pub bitcoin_units::amount::error::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::error::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::error::ParseDenominationError::Unknown(bitcoin_units::amount::error::UnknownDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
+pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
 pub const bitcoin_units::Amount::MAX: Self
 pub const bitcoin_units::Amount::MAX_MONEY: Self
 pub const bitcoin_units::Amount::MIN: Self
@@ -739,10 +733,10 @@ pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
 pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseError>
 pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
@@ -755,7 +749,7 @@ pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
-pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
@@ -773,10 +767,10 @@ pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
 pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
 pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::error::ParseError>
+pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
+pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseError>
 pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
 pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
@@ -794,7 +788,7 @@ pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: &bitcoin_units::S
 pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
 pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
-pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::error::OutOfRangeError>
+pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
@@ -808,57 +802,57 @@ pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self,
 pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
-pub fn bitcoin_units::amount::error::InputTooLargeError::clone(&self) -> bitcoin_units::amount::error::InputTooLargeError
-pub fn bitcoin_units::amount::error::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::error::InputTooLargeError) -> bool
-pub fn bitcoin_units::amount::error::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::error::InvalidCharacterError
-pub fn bitcoin_units::amount::error::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::error::InvalidCharacterError) -> bool
-pub fn bitcoin_units::amount::error::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::MissingDenominationError::clone(&self) -> bitcoin_units::amount::error::MissingDenominationError
-pub fn bitcoin_units::amount::error::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::error::MissingDenominationError) -> bool
-pub fn bitcoin_units::amount::error::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::MissingDigitsError::clone(&self) -> bitcoin_units::amount::error::MissingDigitsError
-pub fn bitcoin_units::amount::error::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::error::MissingDigitsError) -> bool
-pub fn bitcoin_units::amount::error::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::clone(&self) -> bitcoin_units::amount::error::OutOfRangeError
-pub fn bitcoin_units::amount::error::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::error::OutOfRangeError) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_above_max(self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::is_below_min(self) -> bool
-pub fn bitcoin_units::amount::error::OutOfRangeError::valid_range(self) -> (i64, u64)
-pub fn bitcoin_units::amount::error::ParseAmountError::clone(&self) -> bitcoin_units::amount::error::ParseAmountError
-pub fn bitcoin_units::amount::error::ParseAmountError::eq(&self, other: &bitcoin_units::amount::error::ParseAmountError) -> bool
-pub fn bitcoin_units::amount::error::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseAmountError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::error::ParseAmountError::from(value: bitcoin_units::amount::error::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::error::ParseDenominationError::clone(&self) -> bitcoin_units::amount::error::ParseDenominationError
-pub fn bitcoin_units::amount::error::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::error::ParseDenominationError) -> bool
-pub fn bitcoin_units::amount::error::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseDenominationError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::ParseError::clone(&self) -> bitcoin_units::amount::error::ParseError
-pub fn bitcoin_units::amount::error::ParseError::eq(&self, other: &bitcoin_units::amount::error::ParseError) -> bool
-pub fn bitcoin_units::amount::error::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseAmountError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::ParseDenominationError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(e: bitcoin_units::amount::error::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::error::ParseError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::error::PossiblyConfusingDenominationError
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::error::PossiblyConfusingDenominationError) -> bool
-pub fn bitcoin_units::amount::error::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::TooPreciseError::clone(&self) -> bitcoin_units::amount::error::TooPreciseError
-pub fn bitcoin_units::amount::error::TooPreciseError::eq(&self, other: &bitcoin_units::amount::error::TooPreciseError) -> bool
-pub fn bitcoin_units::amount::error::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::error::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::error::UnknownDenominationError
-pub fn bitcoin_units::amount::error::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::error::UnknownDenominationError) -> bool
-pub fn bitcoin_units::amount::error::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::InputTooLargeError::clone(&self) -> bitcoin_units::amount::InputTooLargeError
+pub fn bitcoin_units::amount::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::InputTooLargeError) -> bool
+pub fn bitcoin_units::amount::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::InvalidCharacterError
+pub fn bitcoin_units::amount::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::InvalidCharacterError) -> bool
+pub fn bitcoin_units::amount::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::MissingDenominationError::clone(&self) -> bitcoin_units::amount::MissingDenominationError
+pub fn bitcoin_units::amount::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::MissingDenominationError) -> bool
+pub fn bitcoin_units::amount::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::MissingDigitsError::clone(&self) -> bitcoin_units::amount::MissingDigitsError
+pub fn bitcoin_units::amount::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::MissingDigitsError) -> bool
+pub fn bitcoin_units::amount::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::OutOfRangeError::clone(&self) -> bitcoin_units::amount::OutOfRangeError
+pub fn bitcoin_units::amount::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::OutOfRangeError) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::OutOfRangeError::is_above_max(self) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::is_below_min(self) -> bool
+pub fn bitcoin_units::amount::OutOfRangeError::valid_range(self) -> (i64, u64)
+pub fn bitcoin_units::amount::ParseAmountError::clone(&self) -> bitcoin_units::amount::ParseAmountError
+pub fn bitcoin_units::amount::ParseAmountError::eq(&self, other: &bitcoin_units::amount::ParseAmountError) -> bool
+pub fn bitcoin_units::amount::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseAmountError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::ParseDenominationError::clone(&self) -> bitcoin_units::amount::ParseDenominationError
+pub fn bitcoin_units::amount::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::ParseDenominationError) -> bool
+pub fn bitcoin_units::amount::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseDenominationError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::ParseError::clone(&self) -> bitcoin_units::amount::ParseError
+pub fn bitcoin_units::amount::ParseError::eq(&self, other: &bitcoin_units::amount::ParseError) -> bool
+pub fn bitcoin_units::amount::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InputTooLargeError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InvalidCharacterError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::MissingDigitsError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::OutOfRangeError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseAmountError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseDenominationError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::TooPreciseError) -> Self
+pub fn bitcoin_units::amount::ParseError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::PossiblyConfusingDenominationError
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::PossiblyConfusingDenominationError) -> bool
+pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::TooPreciseError::clone(&self) -> bitcoin_units::amount::TooPreciseError
+pub fn bitcoin_units::amount::TooPreciseError::eq(&self, other: &bitcoin_units::amount::TooPreciseError) -> bool
+pub fn bitcoin_units::amount::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::amount::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::UnknownDenominationError
+pub fn bitcoin_units::amount::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::UnknownDenominationError) -> bool
+pub fn bitcoin_units::amount::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
 pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
 pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
@@ -1028,7 +1022,6 @@ pub macro bitcoin_units::impl_tryfrom_str!
 pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
-pub mod bitcoin_units::amount::error
 pub mod bitcoin_units::block
 pub mod bitcoin_units::fee_rate
 pub mod bitcoin_units::locktime
@@ -1052,13 +1045,6 @@ pub struct bitcoin_units::amount::ParseAmountError(_)
 pub struct bitcoin_units::amount::ParseError(_)
 pub struct bitcoin_units::amount::SignedAmount(_)
 pub struct bitcoin_units::amount::TooPreciseError
-pub struct bitcoin_units::amount::error::InputTooLargeError
-pub struct bitcoin_units::amount::error::InvalidCharacterError
-pub struct bitcoin_units::amount::error::MissingDigitsError
-pub struct bitcoin_units::amount::error::OutOfRangeError
-pub struct bitcoin_units::amount::error::ParseAmountError(_)
-pub struct bitcoin_units::amount::error::ParseError(_)
-pub struct bitcoin_units::amount::error::TooPreciseError
 pub struct bitcoin_units::block::BlockHeight(pub u32)
 pub struct bitcoin_units::block::BlockInterval(pub u32)
 pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
@@ -1079,14 +1065,14 @@ pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
 pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::Amount::Err = bitcoin_units::amount::error::ParseError
-pub type bitcoin_units::Amount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
+pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::error::ParseError
-pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::error::OutOfRangeError
+pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
+pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::error::ParseDenominationError
+pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
 pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
 pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
 pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight

From bfac2372878a9c7d98c18cdca5881dd64fdc0e16 Mon Sep 17 00:00:00 2001
From: calciumbe <192480234+calciumbe@users.noreply.github.com>
Date: Mon, 23 Dec 2024 20:34:36 +0800
Subject: [PATCH 141/554] base58: fix typo

---
 base58/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base58/src/lib.rs b/base58/src/lib.rs
index b5b977ebc5..df2c151039 100644
--- a/base58/src/lib.rs
+++ b/base58/src/lib.rs
@@ -337,7 +337,7 @@ mod benches {
 
     #[bench]
     pub fn bench_encode_check_xpub(bh: &mut Bencher) {
-        let data: alloc::vec::Vec<_> = (0u8..78).collect(); // lenght of xpub
+        let data: alloc::vec::Vec<_> = (0u8..78).collect(); // length of xpub
 
         bh.iter(|| {
             let r = super::encode_check(&data);

From bcf85809133a6017b309c731b04a7f02e8229f33 Mon Sep 17 00:00:00 2001
From: calciumbe <192480234+calciumbe@users.noreply.github.com>
Date: Mon, 23 Dec 2024 20:34:54 +0800
Subject: [PATCH 142/554] bitcoin: fix typo

---
 bitcoin/src/merkle_tree/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/merkle_tree/mod.rs b/bitcoin/src/merkle_tree/mod.rs
index b656ce7e78..82801fdd43 100644
--- a/bitcoin/src/merkle_tree/mod.rs
+++ b/bitcoin/src/merkle_tree/mod.rs
@@ -41,7 +41,7 @@ impl_hashencode!(WitnessMerkleNode);
 /// Other Merkle trees in Bitcoin, such as those used in Taproot commitments,
 /// do not use this algorithm and cannot use this trait.
 pub trait MerkleNode: Copy {
-    /// The hash (TXID or WTXID) of a transaciton in the tree.
+    /// The hash (TXID or WTXID) of a transaction in the tree.
     type Leaf: TxIdentifier;
 
     /// Convert a hash to a leaf node of the tree.

From 9a5970dbfe9e084debb38935c942a9002bc363a9 Mon Sep 17 00:00:00 2001
From: calciumbe <192480234+calciumbe@users.noreply.github.com>
Date: Mon, 23 Dec 2024 20:35:01 +0800
Subject: [PATCH 143/554] chacha20_poly1305: fix typo

---
 chacha20_poly1305/src/chacha20.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/chacha20_poly1305/src/chacha20.rs b/chacha20_poly1305/src/chacha20.rs
index 51d0e4b88d..0a73ca368e 100644
--- a/chacha20_poly1305/src/chacha20.rs
+++ b/chacha20_poly1305/src/chacha20.rs
@@ -45,7 +45,7 @@ impl Nonce {
 ///
 /// This type is attempting to be as close as possible to the experimental [`core::simd::u32x4`]
 /// which at this time is feature gated and well beyond the project's MSRV. But ideally
-/// an easy transistion can be made in the future.
+/// an easy transition can be made in the future.
 ///
 /// A few SIMD relevant design choices:
 ///    * Heavy use of inline functions to help the compiler recognize vectorizable sections.

From a6a746b8c07a54e45c9056cf502267d5d1278fc1 Mon Sep 17 00:00:00 2001
From: calciumbe <192480234+calciumbe@users.noreply.github.com>
Date: Mon, 23 Dec 2024 20:35:08 +0800
Subject: [PATCH 144/554] hashes: fix typo

---
 hashes/CHANGELOG.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hashes/CHANGELOG.md b/hashes/CHANGELOG.md
index ea31a9be89..bd9aed7337 100644
--- a/hashes/CHANGELOG.md
+++ b/hashes/CHANGELOG.md
@@ -6,7 +6,7 @@
 
 # 0.15.0 - 2024-10-16
 
-This release is massive. The biggest visable changes are to the `Hash` trait, which has mostly been replaced
+This release is massive. The biggest visible changes are to the `Hash` trait, which has mostly been replaced
 by inherent functions. You should not need to import it at all anymore for normal usage. Check out how we are
 using `hashes` in `rust-bitcoin` to see an example. Enjoy!
 
@@ -52,7 +52,7 @@ using `hashes` in `rust-bitcoin` to see an example. Enjoy!
 
 * Bump MSRV to Rust version 1.56.1 [#2188](https://github.com/rust-bitcoin/rust-bitcoin/pull/2188)
 
-## API improvemnts
+## API improvements
 
 * Add support for SHA384 [#2538](https://github.com/rust-bitcoin/rust-bitcoin/pull/2538)
 * Make from_hex inherent for byte-like types [#2491](https://github.com/rust-bitcoin/rust-bitcoin/pull/2491)

From 589dd025df938da3efac277511836cda5c53aa06 Mon Sep 17 00:00:00 2001
From: calciumbe <192480234+calciumbe@users.noreply.github.com>
Date: Mon, 23 Dec 2024 20:35:14 +0800
Subject: [PATCH 145/554] units: fix typo

---
 units/src/fee_rate.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/units/src/fee_rate.rs b/units/src/fee_rate.rs
index 3429aa44aa..c85b91db9b 100644
--- a/units/src/fee_rate.rs
+++ b/units/src/fee_rate.rs
@@ -121,7 +121,7 @@ impl FeeRate {
 
     /// Checked addition.
     ///
-    /// Computes `self + rhs` returning [`None`] if overflow occured.
+    /// Computes `self + rhs` returning [`None`] if overflow occurred.
     #[must_use]
     pub const fn checked_add(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
@@ -133,7 +133,7 @@ impl FeeRate {
 
     /// Checked subtraction.
     ///
-    /// Computes `self - rhs` returning [`None`] if overflow occured.
+    /// Computes `self - rhs` returning [`None`] if overflow occurred.
     #[must_use]
     pub const fn checked_sub(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.

From 774f066879c8ad1af81c7e46b404fa63682a0b4c Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Sat, 21 Dec 2024 10:20:11 -0600
Subject: [PATCH 146/554] refactor: Change from u64 to Amount

The Amount type provides better type safety and is more appropriate in
this context than u64.  Currently the checked arithmetic operations for
Amount and u64 are identical in behavior.  Therefore, this refactor does
not result in any behavior change and is purely cosmetic.
---
 bitcoin/src/psbt/mod.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 071b5afa34..098e853e21 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -712,15 +712,15 @@ impl Psbt {
     /// - [`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;
+        let mut inputs = Amount::ZERO;
         for utxo in self.iter_funding_utxos() {
-            inputs = inputs.checked_add(utxo?.value.to_sat()).ok_or(Error::FeeOverflow)?;
+            inputs = inputs.checked_add(utxo?.value).ok_or(Error::FeeOverflow)?;
         }
-        let mut outputs: u64 = 0;
+        let mut outputs = Amount::ZERO;
         for out in &self.unsigned_tx.output {
-            outputs = outputs.checked_add(out.value.to_sat()).ok_or(Error::FeeOverflow)?;
+            outputs = outputs.checked_add(out.value).ok_or(Error::FeeOverflow)?;
         }
-        inputs.checked_sub(outputs).map(Amount::from_sat).ok_or(Error::NegativeFee)
+        inputs.checked_sub(outputs).ok_or(Error::NegativeFee)
     }
 }
 

From fdf3336ed5952bd0ed961c2a4df6e5a91e2be6ba Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Mon, 23 Dec 2024 14:59:58 -0600
Subject: [PATCH 147/554] Add unchecked variant

This variant is supplied in cases where a Result type does not need to
be handled.
---
 api/units/all-features.txt | 1 +
 api/units/alloc-only.txt   | 1 +
 api/units/no-features.txt  | 1 +
 units/src/amount/signed.rs | 9 +++++++++
 4 files changed, 12 insertions(+)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 27369ab25c..8822fa7e71 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -723,6 +723,7 @@ pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::o
 pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_sat_unchecked(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
 pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index bfe3a73d19..847e589cf7 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -674,6 +674,7 @@ pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::o
 pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_sat_unchecked(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
 pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 60c1ac1b84..4da1851223 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -656,6 +656,7 @@ pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::o
 pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
+pub const fn bitcoin_units::SignedAmount::from_sat_unchecked(satoshi: i64) -> bitcoin_units::SignedAmount
 pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
 pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
 pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 2faa7e45f4..1c93bd1986 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -83,6 +83,15 @@ impl SignedAmount {
     /// ```
     pub const fn to_sat(self) -> i64 { self.0 }
 
+    /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
+    ///
+    /// Caller to guarantee that `satoshi` is within valid range.
+    ///
+    /// See [`Self::MIN`] and [`Self::MAX_MONEY`].
+    pub const fn from_sat_unchecked(satoshi: i64) -> SignedAmount {
+        SignedAmount(satoshi)
+    }
+
     /// Converts from a value expressing a decimal number of bitcoin to a [`SignedAmount`].
     ///
     /// # Errors

From 364e9ff775ca0b482576d6dbc3a3621c68b56ea9 Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Sat, 14 Dec 2024 14:17:24 -0600
Subject: [PATCH 148/554] Change method return type

Any SignedAmount can now be cast to Amount since the range is the same.
Specifically, the range for SignedAmount is (- 21 million, 21 million)
while the range for Amount is (0, 21 million).  Therefore any value from
Amount can be cast to a SignedAmount and it will work.  Note it's not
the same and still requires checking when going from SignedAmount to
Amount since Amount can't handle the negative range.

As a side effect of changing the return type, TryFrom is no longer valid
and does not compile.  Therefore in addition to changing the return
type, TryFrom is also removed.
---
 api/units/all-features.txt           |  5 +----
 api/units/alloc-only.txt             |  5 +----
 api/units/no-features.txt            |  5 +----
 bitcoin/src/blockdata/transaction.rs |  6 +++---
 units/src/amount/signed.rs           |  6 ------
 units/src/amount/tests.rs            | 12 ++----------
 units/src/amount/unsigned.rs         | 12 ++----------
 7 files changed, 10 insertions(+), 41 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 8822fa7e71..086f2c1729 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -198,7 +198,6 @@ impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Height
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Time
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<bitcoin_units::Amount> for bitcoin_units::SignedAmount
 impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
 impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
 impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
@@ -831,7 +830,7 @@ pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
 pub fn bitcoin_units::Amount::to_btc(self) -> f64
 pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
-pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
+pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
@@ -890,7 +889,6 @@ pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amou
 pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::SignedAmount::type_prefix(_: private::Token) -> &'static str
 pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
@@ -1255,7 +1253,6 @@ pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
 pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
 pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 847e589cf7..220ed90061 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -194,7 +194,6 @@ impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Height
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Time
 impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<bitcoin_units::Amount> for bitcoin_units::SignedAmount
 impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
 impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
 impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
@@ -772,7 +771,7 @@ pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
 pub fn bitcoin_units::Amount::to_btc(self) -> f64
 pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
-pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
+pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
@@ -820,7 +819,6 @@ pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amou
 pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
@@ -1117,7 +1115,6 @@ pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
 pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
 pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 4da1851223..31f49267d2 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -178,7 +178,6 @@ impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Time
 impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Height
 impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Time
 impl core::convert::TryFrom<&str> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<bitcoin_units::Amount> for bitcoin_units::SignedAmount
 impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
 impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
 impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
@@ -750,7 +749,7 @@ pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: bitcoin_units::Amount)
 pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
-pub fn bitcoin_units::Amount::to_signed(self) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
+pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
@@ -790,7 +789,6 @@ pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: bitcoin_units::Si
 pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
 pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
 pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::try_from(value: bitcoin_units::Amount) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
@@ -1071,7 +1069,6 @@ pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
 pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::SignedAmount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
 pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 84c53de7ee..5dea49ba93 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -790,8 +790,8 @@ pub fn effective_value(
     value: Amount,
 ) -> Option<SignedAmount> {
     let weight = satisfaction_weight.checked_add(TX_IN_BASE_WEIGHT)?;
-    let signed_input_fee = fee_rate.checked_mul_by_weight(weight)?.to_signed().ok()?;
-    value.to_signed().ok()?.checked_sub(signed_input_fee)
+    let signed_input_fee = fee_rate.checked_mul_by_weight(weight)?.to_signed();
+    value.to_signed().checked_sub(signed_input_fee)
 }
 
 /// Predicts the weight of a to-be-constructed transaction.
@@ -1673,7 +1673,7 @@ mod tests {
 
         // 10 sat/kwu * (204wu + BASE_WEIGHT) = 4 sats
         let expected_fee = "4 sats".parse::<SignedAmount>().unwrap();
-        let expected_effective_value = value.to_signed().unwrap() - expected_fee;
+        let expected_effective_value = value.to_signed() - expected_fee;
         assert_eq!(effective_value, expected_effective_value);
     }
 
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 1c93bd1986..717d599172 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -566,12 +566,6 @@ impl FromStr for SignedAmount {
     }
 }
 
-impl TryFrom<Amount> for SignedAmount {
-    type Error = OutOfRangeError;
-
-    fn try_from(value: Amount) -> Result<Self, Self::Error> { value.to_signed() }
-}
-
 impl core::iter::Sum for SignedAmount {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
         let sats: i64 = iter.map(|amt| amt.0).sum();
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index c4f6ea9fc7..a7f08efbb3 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -71,13 +71,6 @@ fn from_int_btc() {
     assert_eq!(Amount::from_sat(200_000_000), amt);
 }
 
-#[test]
-fn test_signed_amount_try_from_amount() {
-    let ua_positive = Amount::from_sat(123);
-    let sa_positive = SignedAmount::try_from(ua_positive).unwrap();
-    assert_eq!(sa_positive, SignedAmount::from_sat(123));
-}
-
 #[test]
 fn test_amount_try_from_signed_amount() {
     let sa_positive = SignedAmount::from_sat(123);
@@ -473,12 +466,11 @@ fn test_unsigned_signed_conversion() {
     let ua = Amount::from_sat;
     let max_sats: u64 = Amount::MAX.to_sat();
 
-    assert_eq!(ua(max_sats).to_signed(), Ok(sa(max_sats as i64)));
-    assert_eq!(ua(i64::MAX as u64 + 1).to_signed(), Err(OutOfRangeError::too_big(true)));
+    assert_eq!(ua(max_sats).to_signed(), sa(max_sats as i64));
 
     assert_eq!(sa(max_sats as i64).to_unsigned(), Ok(ua(max_sats)));
 
-    assert_eq!(sa(max_sats as i64).to_unsigned().unwrap().to_signed(), Ok(sa(max_sats as i64)));
+    assert_eq!(sa(max_sats as i64).to_unsigned().unwrap().to_signed(), sa(max_sats as i64));
 }
 
 #[test]
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 49edb71bef..718c6e478b 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -438,17 +438,9 @@ impl Amount {
     pub fn unchecked_sub(self, rhs: Amount) -> Amount { Self(self.0 - rhs.0) }
 
     /// Converts to a signed amount.
-    ///
-    /// # Errors
-    ///
-    /// If the amount is too big.
     #[rustfmt::skip] // Moves code comments to the wrong line.
-    pub fn to_signed(self) -> Result<SignedAmount, OutOfRangeError> {
-        if self.to_sat() > SignedAmount::MAX.to_sat() as u64 { // Cast ok, signed max is positive and fits in u64.
-            Err(OutOfRangeError::too_big(true))
-        } else {
-            Ok(SignedAmount::from_sat(self.to_sat() as i64)) // Cast ok, checked not too big above.
-        }
+    pub fn to_signed(self) -> SignedAmount {
+        SignedAmount::from_sat_unchecked(self.to_sat() as i64) // Cast ok, signed amount and amount share positive range.
     }
 
     /// Checks if the amount is below the maximum value. Returns `None` if it is above.

From e13355318e61e341e7cf3f17257e44d19029c6eb Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Mon, 23 Dec 2024 15:48:16 -0600
Subject: [PATCH 149/554] Add From impl

SignedAmount and Amount both share the same MAX, therefore the From impl
is added in place of TryFrom.
---
 api/units/all-features.txt | 2 ++
 api/units/alloc-only.txt   | 2 ++
 api/units/no-features.txt  | 2 ++
 units/src/amount/signed.rs | 7 +++++++
 4 files changed, 13 insertions(+)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 086f2c1729..fe35099094 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -145,6 +145,7 @@ impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
 impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
 impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
 impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
 impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
 impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
 impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
@@ -855,6 +856,7 @@ pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
 pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
 pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
 pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 220ed90061..f729d550a2 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -141,6 +141,7 @@ impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
 impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
 impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
 impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
 impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
 impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
 impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
@@ -791,6 +792,7 @@ pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
 pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
 pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
 pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
 pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 31f49267d2..dfcb91f364 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -141,6 +141,7 @@ impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
 impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
 impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
 impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
+impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
 impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
 impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
 impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
@@ -767,6 +768,7 @@ pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
 pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
 pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
 pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
 pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
 pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
 pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 717d599172..3c9df7f607 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -566,6 +566,13 @@ impl FromStr for SignedAmount {
     }
 }
 
+impl From<Amount> for SignedAmount {
+    fn from(value: Amount) -> Self {
+        let v = value.to_sat() as i64; // Cast ok, signed amount and amount share positive range.
+        SignedAmount::from_sat_unchecked(v)
+    }
+}
+
 impl core::iter::Sum for SignedAmount {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
         let sats: i64 = iter.map(|amt| amt.0).sum();

From 2e482f0fddb55da897f0ba8ea4d3fa5bb0fba1b5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 27 Dec 2024 11:28:51 +1100
Subject: [PATCH 150/554] Remove unnecessary floating code comment

Code comments that comment and arbitrary block "section" of code are
almost always pointless and almost always go stale over time.

These particular code comments add almost no value.

Remove code comments.
---
 units/src/amount/signed.rs   | 2 --
 units/src/amount/unsigned.rs | 2 --
 2 files changed, 4 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 2faa7e45f4..b58b9b16da 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -288,8 +288,6 @@ impl SignedAmount {
         self.display_in(denom).show_denomination().to_string()
     }
 
-    // Some arithmetic that doesn't fit in [`core::ops`] traits.
-
     /// Gets the absolute value of this [`SignedAmount`].
     #[must_use]
     pub fn abs(self) -> SignedAmount { SignedAmount(self.0.abs()) }
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index e7b214189c..bce5f49c24 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -298,8 +298,6 @@ impl Amount {
         self.display_in(denom).show_denomination().to_string()
     }
 
-    // Some arithmetic that doesn't fit in [`core::ops`] traits.
-
     /// Checked addition.
     ///
     /// Returns [`None`] if the sum is larger than [`Amount::MAX`].

From c3c1f6f82d15755600478100324a2a1b01251f83 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 27 Nov 2024 15:38:49 +1100
Subject: [PATCH 151/554] Add missing license comment to test file

---
 units/tests/api.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/units/tests/api.rs b/units/tests/api.rs
index 3737808331..b4dc3aa6e3 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: CC0-1.0
+
 //! Test the API surface of `units`.
 //!
 //! The point of these tests are to check the API surface as opposed to test the API functionality.

From d94e5f03e63d7a32d6319129ca65bf8d86781c4a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 27 Nov 2024 14:45:35 +1100
Subject: [PATCH 152/554] Move fee_rate.rs to module

In preparation for adding `serde` modules to the `fee_rate` module
create a sub directory.

Create a directory and move `fee_rate.rs` to `fee_rate/mod.rs`.
---
 units/src/{fee_rate.rs => fee_rate/mod.rs} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename units/src/{fee_rate.rs => fee_rate/mod.rs} (100%)

diff --git a/units/src/fee_rate.rs b/units/src/fee_rate/mod.rs
similarity index 100%
rename from units/src/fee_rate.rs
rename to units/src/fee_rate/mod.rs

From dedae8acf2b1ee644005048f295e945242f464ae Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 13:08:08 +1100
Subject: [PATCH 153/554] Implement custom serde modules for FeeRate

The `FeeRate` type wraps a `u64` but the inner value implicitly contains
information about the unit. As such when serializing and deserializing
the unit information is not explicit and if users try to deserialize
with a different unit their code will be silently buggy.

As we do for Amount; add custom serde modules so that users can
serialize in an explicit unit. Furthermore remove the derived impls
forcing users to make the decision. This is as we do for `Amount`.

With this applied one can write

```rust
    #[derive(Serialize, Deserialize)]
    pub struct Foo {
        #[serde(with = "bitcoin_units::fee_rate::serde::as_sat_per_kwu")]
        pub fee_rate: FeeRate,
    }
```
---
 units/src/fee_rate/mod.rs   |   7 +-
 units/src/fee_rate/serde.rs | 255 ++++++++++++++++++++++++++++++++++++
 2 files changed, 258 insertions(+), 4 deletions(-)
 create mode 100644 units/src/fee_rate/serde.rs

diff --git a/units/src/fee_rate/mod.rs b/units/src/fee_rate/mod.rs
index 2483bd091b..b12c08f45d 100644
--- a/units/src/fee_rate/mod.rs
+++ b/units/src/fee_rate/mod.rs
@@ -2,12 +2,13 @@
 
 //! Implements `FeeRate` and assoctiated features.
 
+#[cfg(feature = "serde")]
+pub mod serde;
+
 use core::{fmt, ops};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
 
 use crate::amount::Amount;
 use crate::weight::Weight;
@@ -17,8 +18,6 @@ use crate::weight::Weight;
 /// This is an integer newtype representing fee rate in `sat/kwu`. It provides protection against mixing
 /// up the types as well as basic formatting features.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(transparent))]
 pub struct FeeRate(u64);
 
 impl FeeRate {
diff --git a/units/src/fee_rate/serde.rs b/units/src/fee_rate/serde.rs
new file mode 100644
index 0000000000..281680053f
--- /dev/null
+++ b/units/src/fee_rate/serde.rs
@@ -0,0 +1,255 @@
+// SPDX-License-Identifier: CC0-1.0
+
+// Module implements standardized serde-specific trait methods.
+#![allow(missing_docs)]
+#![allow(clippy::trivially_copy_pass_by_ref)]
+
+//! 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:
+//!
+//! ```
+//! use serde::{Serialize, Deserialize};
+//! use bitcoin_units::FeeRate;
+//!
+//! #[derive(Serialize, Deserialize)]
+//! pub struct Foo {
+//!     #[serde(with = "bitcoin_units::fee_rate::serde::as_sat_per_kwu")]
+//!     pub fee_rate: FeeRate,
+//! }
+//! ```
+
+use core::fmt;
+
+pub mod as_sat_per_kwu {
+    //! Serialize and deserialize [`FeeRate`] denominated in satoshis per 1000 weight units.
+    //!
+    //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_kwu")]`.
+
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    use crate::FeeRate;
+
+    pub fn serialize<S: Serializer>(f: &FeeRate, s: S) -> Result<S::Ok, S::Error> {
+        u64::serialize(&f.to_sat_per_kwu(), s)
+    }
+
+    pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<FeeRate, D::Error> {
+        Ok(FeeRate::from_sat_per_kwu(u64::deserialize(d)?))
+    }
+
+    pub mod opt {
+        //! Serialize and deserialize [`Option<FeeRate>`] denominated in satoshis per 1000 weight units.
+        //!
+        //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_kwu::opt")]`.
+
+        use core::fmt;
+
+        use serde::{de, Deserialize, Deserializer, Serializer};
+
+        use crate::FeeRate;
+
+        pub fn serialize<S: Serializer>(f: &Option<FeeRate>, s: S) -> Result<S::Ok, S::Error> {
+            match *f {
+                Some(f) => s.serialize_some(&f.to_sat_per_kwu()),
+                None => s.serialize_none(),
+            }
+        }
+
+        pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<Option<FeeRate>, D::Error> {
+            struct VisitOpt;
+
+            impl<'de> de::Visitor<'de> for VisitOpt {
+                type Value = Option<FeeRate>;
+
+                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    write!(f, "An Option<FeeRate>")
+                }
+
+                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(FeeRate::from_sat_per_kwu(u64::deserialize(d)?)))
+                }
+            }
+            d.deserialize_option(VisitOpt)
+        }
+    }
+}
+
+pub mod as_sat_per_vb_floor {
+    //! Serialize and deserialize [`FeeRate`] denominated in satoshis per virtual byte.
+    //!
+    //! When serializing use floor division to convert per kwu to per virtual byte.
+    //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_vb_floor")]`.
+
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    use crate::fee_rate::serde::OverflowError;
+    use crate::fee_rate::FeeRate;
+
+    pub fn serialize<S: Serializer>(f: &FeeRate, s: S) -> Result<S::Ok, S::Error> {
+        u64::serialize(&f.to_sat_per_vb_floor(), s)
+    }
+
+    // Errors on overflow.
+    pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<FeeRate, D::Error> {
+        Ok(FeeRate::from_sat_per_vb(u64::deserialize(d)?)
+            .ok_or(OverflowError)
+            .map_err(serde::de::Error::custom)?)
+    }
+
+    pub mod opt {
+        //! Serialize and deserialize [`Option<FeeRate>`] denominated in satoshis per virtual byte.
+        //!
+        //! When serializing use floor division to convert per kwu to per virtual byte.
+        //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_vb_floor::opt")]`.
+
+        use core::fmt;
+
+        use serde::{de, Deserialize, Deserializer, Serializer};
+
+        use crate::fee_rate::serde::OverflowError;
+        use crate::fee_rate::FeeRate;
+
+        pub fn serialize<S: Serializer>(f: &Option<FeeRate>, s: S) -> Result<S::Ok, S::Error> {
+            match *f {
+                Some(f) => s.serialize_some(&f.to_sat_per_vb_floor()),
+                None => s.serialize_none(),
+            }
+        }
+
+        pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<Option<FeeRate>, D::Error> {
+            struct VisitOpt;
+
+            impl<'de> de::Visitor<'de> for VisitOpt {
+                type Value = Option<FeeRate>;
+
+                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    write!(f, "An Option<FeeRate>")
+                }
+
+                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(
+                        FeeRate::from_sat_per_vb(u64::deserialize(d)?)
+                            .ok_or(OverflowError)
+                            .map_err(serde::de::Error::custom)?,
+                    ))
+                }
+            }
+            d.deserialize_option(VisitOpt)
+        }
+    }
+}
+
+pub mod as_sat_per_vb_ceil {
+    //! Serialize and deserialize [`FeeRate`] denominated in satoshis per virtual byte.
+    //!
+    //! When serializing use ceil division to convert per kwu to per virtual byte.
+    //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_vb")]`.
+
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    use crate::fee_rate::serde::OverflowError;
+    use crate::fee_rate::FeeRate;
+
+    pub fn serialize<S: Serializer>(f: &FeeRate, s: S) -> Result<S::Ok, S::Error> {
+        u64::serialize(&f.to_sat_per_vb_ceil(), s)
+    }
+
+    // Errors on overflow.
+    pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<FeeRate, D::Error> {
+        Ok(FeeRate::from_sat_per_vb(u64::deserialize(d)?)
+            .ok_or(OverflowError)
+            .map_err(serde::de::Error::custom)?)
+    }
+
+    pub mod opt {
+        //! Serialize and deserialize [`Option<FeeRate>`] denominated in satoshis per virtual byte.
+        //!
+        //! When serializing use ceil division to convert per kwu to per virtual byte.
+        //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_vb_ceil::opt")]`.
+
+        use core::fmt;
+
+        use serde::{de, Deserialize, Deserializer, Serializer};
+
+        use crate::fee_rate::serde::OverflowError;
+        use crate::fee_rate::FeeRate;
+
+        pub fn serialize<S: Serializer>(f: &Option<FeeRate>, s: S) -> Result<S::Ok, S::Error> {
+            match *f {
+                Some(f) => s.serialize_some(&f.to_sat_per_vb_ceil()),
+                None => s.serialize_none(),
+            }
+        }
+
+        pub fn deserialize<'d, D: Deserializer<'d>>(d: D) -> Result<Option<FeeRate>, D::Error> {
+            struct VisitOpt;
+
+            impl<'de> de::Visitor<'de> for VisitOpt {
+                type Value = Option<FeeRate>;
+
+                fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    write!(f, "An Option<FeeRate>")
+                }
+
+                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(
+                        FeeRate::from_sat_per_vb(u64::deserialize(d)?)
+                            .ok_or(OverflowError)
+                            .map_err(serde::de::Error::custom)?,
+                    ))
+                }
+            }
+            d.deserialize_option(VisitOpt)
+        }
+    }
+}
+
+/// Overflow occurred while deserializing fee rate per virtual byte.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct OverflowError;
+
+internals::impl_from_infallible!(OverflowError);
+
+impl fmt::Display for OverflowError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "overflow occurred while deserializing fee rate per virtual byte")
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for OverflowError {}

From 472b1d3ff34d3aae95736b378330df1b0f54acbf Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 28 Nov 2024 13:13:02 +1100
Subject: [PATCH 154/554] units: Add serde regression test

Add an integration test the verifies we have serde traits implemented
for all the main crate types (excl. errors and helper structs).

This also acts as a regression test.
---
 Cargo-minimal.lock             |   1 +
 Cargo-recent.lock              |   1 +
 units/Cargo.toml               |   1 +
 units/tests/data/serde_bincode | Bin 0 -> 147 bytes
 units/tests/serde.rs           |  97 +++++++++++++++++++++++++++++++++
 5 files changed, 100 insertions(+)
 create mode 100644 units/tests/data/serde_bincode
 create mode 100644 units/tests/serde.rs

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 4ca2d3d5bf..322bc5dfe9 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -129,6 +129,7 @@ name = "bitcoin-units"
 version = "0.2.0"
 dependencies = [
  "arbitrary",
+ "bincode",
  "bitcoin-internals",
  "serde",
  "serde_json",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index c4fd9762b5..95a076c6ef 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -128,6 +128,7 @@ name = "bitcoin-units"
 version = "0.2.0"
 dependencies = [
  "arbitrary",
+ "bincode",
  "bitcoin-internals",
  "serde",
  "serde_json",
diff --git a/units/Cargo.toml b/units/Cargo.toml
index 021ed1f58b..d0368dace9 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -25,6 +25,7 @@ arbitrary = { version = "1.4", optional = true }
 
 [dev-dependencies]
 internals = { package = "bitcoin-internals", version = "0.4.0", features = ["test-serde"] }
+bincode = "1.3.1"
 serde_test = "1.0"
 serde_json = "1.0"
 
diff --git a/units/tests/data/serde_bincode b/units/tests/data/serde_bincode
new file mode 100644
index 0000000000000000000000000000000000000000..51d7dc1d09ea388238a66e571ba6b609e2685997
GIT binary patch
literal 147
zcmZQ@V2}Dx%FX}+U)V|<85y7gj4%<H0E~~R0<07$4Woa7lmY=GOaQ@vN&Sa`l(Vuh
HCX5CEc@HZk

literal 0
HcmV?d00001

diff --git a/units/tests/serde.rs b/units/tests/serde.rs
new file mode 100644
index 0000000000..d807bcc76f
--- /dev/null
+++ b/units/tests/serde.rs
@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Test the `serde` implementations for types in `units`.
+
+#![cfg(feature = "alloc")]
+#![cfg(feature = "serde")]
+
+use bincode::serialize;
+use bitcoin_units::locktime::{absolute, relative};
+use bitcoin_units::{Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Weight};
+use serde::{Deserialize, Serialize};
+
+/// A struct that includes all the types that implement or support `serde` traits.
+#[derive(Debug, Serialize, Deserialize)]
+struct Serde {
+    #[serde(with = "bitcoin_units::amount::serde::as_sat")]
+    unsigned_as_sat: Amount,
+    #[serde(with = "bitcoin_units::amount::serde::as_btc")]
+    unsigned_as_btc: Amount,
+    #[serde(with = "bitcoin_units::amount::serde::as_sat::opt")]
+    unsigned_opt_as_sat: Option<Amount>,
+    #[serde(with = "bitcoin_units::amount::serde::as_btc::opt")]
+    unsigned_opt_as_btc: Option<Amount>,
+
+    #[serde(with = "bitcoin_units::amount::serde::as_sat")]
+    signed_as_sat: SignedAmount,
+    #[serde(with = "bitcoin_units::amount::serde::as_btc")]
+    signed_as_btc: SignedAmount,
+    #[serde(with = "bitcoin_units::amount::serde::as_sat::opt")]
+    signed_opt_as_sat: Option<SignedAmount>,
+    #[serde(with = "bitcoin_units::amount::serde::as_btc::opt")]
+    signed_opt_as_btc: Option<SignedAmount>,
+
+    #[serde(with = "bitcoin_units::fee_rate::serde::as_sat_per_vb_floor")]
+    vb_floor: FeeRate,
+    #[serde(with = "bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil")]
+    vb_ceil: FeeRate,
+    #[serde(with = "bitcoin_units::fee_rate::serde::as_sat_per_kwu")]
+    kwu: FeeRate,
+    #[serde(with = "bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt")]
+    opt_vb_floor: Option<FeeRate>,
+    #[serde(with = "bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt")]
+    opt_vb_ceil: Option<FeeRate>,
+    #[serde(with = "bitcoin_units::fee_rate::serde::as_sat_per_kwu::opt")]
+    opt_kwu: Option<FeeRate>,
+
+    a: BlockHeight,
+    b: BlockInterval,
+    c: absolute::Height,
+    d: absolute::Time,
+    e: relative::Height,
+    f: relative::Time,
+    g: Weight,
+}
+
+impl Serde {
+    /// Constructs an arbitrary instance.
+    fn new() -> Self {
+        Self {
+            unsigned_as_sat: Amount::MAX,
+            unsigned_as_btc: Amount::MAX,
+
+            unsigned_opt_as_sat: Some(Amount::MAX),
+            unsigned_opt_as_btc: Some(Amount::MAX),
+
+            signed_as_sat: SignedAmount::MAX,
+            signed_as_btc: SignedAmount::MAX,
+
+            signed_opt_as_sat: Some(SignedAmount::MAX),
+            signed_opt_as_btc: Some(SignedAmount::MAX),
+
+            vb_floor: FeeRate::BROADCAST_MIN,
+            vb_ceil: FeeRate::BROADCAST_MIN,
+            kwu: FeeRate::BROADCAST_MIN,
+
+            opt_vb_floor: Some(FeeRate::BROADCAST_MIN),
+            opt_vb_ceil: Some(FeeRate::BROADCAST_MIN),
+            opt_kwu: Some(FeeRate::BROADCAST_MIN),
+
+            a: BlockHeight::MAX,
+            b: BlockInterval::MAX,
+            c: absolute::Height::MAX,
+            d: absolute::Time::MAX,
+            e: relative::Height::MAX,
+            f: relative::Time::MAX,
+            g: Weight::MAX,
+        }
+    }
+}
+
+#[test]
+fn serde_regression() {
+    let t = Serde::new();
+    let got = serialize(&t).unwrap();
+    let want = include_bytes!("data/serde_bincode");
+    assert_eq!(got, want);
+}

From f5eb8f4747a7cd303cad2b7f8f442bb31862c52a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 28 Dec 2024 08:38:46 +1100
Subject: [PATCH 155/554] api: Run just check-api

---
 api/units/all-features.txt | 42 ++++++++++++++++++++++++++++++++++----
 1 file changed, 38 insertions(+), 4 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 6217193ebe..b16f9d0743 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -3,6 +3,7 @@
 #[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
 #[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
 #[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
+#[non_exhaustive] pub struct bitcoin_units::fee_rate::serde::OverflowError
 #[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
 #[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
 impl bitcoin_units::Amount
@@ -52,6 +53,7 @@ impl core::clone::Clone for bitcoin_units::block::BlockHeight
 impl core::clone::Clone for bitcoin_units::block::BlockInterval
 impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::clone::Clone for bitcoin_units::fee_rate::FeeRate
+impl core::clone::Clone for bitcoin_units::fee_rate::serde::OverflowError
 impl core::clone::Clone for bitcoin_units::locktime::absolute::ConversionError
 impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
 impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseHeightError
@@ -82,6 +84,7 @@ impl core::cmp::Eq for bitcoin_units::block::BlockHeight
 impl core::cmp::Eq for bitcoin_units::block::BlockInterval
 impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::cmp::Eq for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::Eq for bitcoin_units::fee_rate::serde::OverflowError
 impl core::cmp::Eq for bitcoin_units::locktime::absolute::ConversionError
 impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
 impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseHeightError
@@ -122,6 +125,7 @@ impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
 impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
 impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::cmp::PartialEq for bitcoin_units::fee_rate::FeeRate
+impl core::cmp::PartialEq for bitcoin_units::fee_rate::serde::OverflowError
 impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ConversionError
 impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
 impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseHeightError
@@ -169,6 +173,7 @@ impl core::convert::From<bitcoin_units::weight::Weight> for u64
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseAmountError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseDenominationError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseError
+impl core::convert::From<core::convert::Infallible> for bitcoin_units::fee_rate::serde::OverflowError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
 impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
 impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
@@ -218,6 +223,7 @@ impl core::error::Error for bitcoin_units::amount::PossiblyConfusingDenomination
 impl core::error::Error for bitcoin_units::amount::TooPreciseError
 impl core::error::Error for bitcoin_units::amount::UnknownDenominationError
 impl core::error::Error for bitcoin_units::block::TooBigForRelativeBlockHeightError
+impl core::error::Error for bitcoin_units::fee_rate::serde::OverflowError
 impl core::error::Error for bitcoin_units::locktime::absolute::ConversionError
 impl core::error::Error for bitcoin_units::locktime::absolute::ParseHeightError
 impl core::error::Error for bitcoin_units::locktime::absolute::ParseTimeError
@@ -244,6 +250,7 @@ impl core::fmt::Debug for bitcoin_units::block::BlockHeight
 impl core::fmt::Debug for bitcoin_units::block::BlockInterval
 impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::fmt::Debug for bitcoin_units::fee_rate::FeeRate
+impl core::fmt::Debug for bitcoin_units::fee_rate::serde::OverflowError
 impl core::fmt::Debug for bitcoin_units::locktime::absolute::ConversionError
 impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
 impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseHeightError
@@ -274,6 +281,7 @@ impl core::fmt::Display for bitcoin_units::block::BlockHeight
 impl core::fmt::Display for bitcoin_units::block::BlockInterval
 impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::fmt::Display for bitcoin_units::fee_rate::FeeRate
+impl core::fmt::Display for bitcoin_units::fee_rate::serde::OverflowError
 impl core::fmt::Display for bitcoin_units::locktime::absolute::ConversionError
 impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
 impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseHeightError
@@ -333,6 +341,7 @@ impl core::marker::Freeze for bitcoin_units::block::BlockHeight
 impl core::marker::Freeze for bitcoin_units::block::BlockInterval
 impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::marker::Freeze for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Freeze for bitcoin_units::fee_rate::serde::OverflowError
 impl core::marker::Freeze for bitcoin_units::locktime::absolute::ConversionError
 impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
 impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseHeightError
@@ -364,6 +373,7 @@ impl core::marker::Send for bitcoin_units::block::BlockHeight
 impl core::marker::Send for bitcoin_units::block::BlockInterval
 impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::marker::Send for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Send for bitcoin_units::fee_rate::serde::OverflowError
 impl core::marker::Send for bitcoin_units::locktime::absolute::ConversionError
 impl core::marker::Send for bitcoin_units::locktime::absolute::Height
 impl core::marker::Send for bitcoin_units::locktime::absolute::ParseHeightError
@@ -394,6 +404,7 @@ impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
 impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
 impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::FeeRate
+impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::serde::OverflowError
 impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ConversionError
 impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
 impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseHeightError
@@ -425,6 +436,7 @@ impl core::marker::Sync for bitcoin_units::block::BlockHeight
 impl core::marker::Sync for bitcoin_units::block::BlockInterval
 impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::marker::Sync for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Sync for bitcoin_units::fee_rate::serde::OverflowError
 impl core::marker::Sync for bitcoin_units::locktime::absolute::ConversionError
 impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
 impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseHeightError
@@ -456,6 +468,7 @@ impl core::marker::Unpin for bitcoin_units::block::BlockHeight
 impl core::marker::Unpin for bitcoin_units::block::BlockInterval
 impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::marker::Unpin for bitcoin_units::fee_rate::FeeRate
+impl core::marker::Unpin for bitcoin_units::fee_rate::serde::OverflowError
 impl core::marker::Unpin for bitcoin_units::locktime::absolute::ConversionError
 impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
 impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseHeightError
@@ -556,6 +569,7 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeig
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::serde::OverflowError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ConversionError
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
@@ -587,6 +601,7 @@ impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::FeeRate
+impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::serde::OverflowError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ConversionError
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
@@ -612,7 +627,6 @@ impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Time
 impl core::str::traits::FromStr for bitcoin_units::weight::Weight
 impl serde::ser::Serialize for bitcoin_units::block::BlockHeight
 impl serde::ser::Serialize for bitcoin_units::block::BlockInterval
-impl serde::ser::Serialize for bitcoin_units::fee_rate::FeeRate
 impl serde::ser::Serialize for bitcoin_units::locktime::absolute::Height
 impl serde::ser::Serialize for bitcoin_units::locktime::absolute::Time
 impl serde::ser::Serialize for bitcoin_units::locktime::relative::Height
@@ -644,7 +658,6 @@ impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoi
 impl<'a> core::ops::arith::Sub<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
 impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockHeight
 impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockInterval
-impl<'de> serde::de::Deserialize<'de> for bitcoin_units::fee_rate::FeeRate
 impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::absolute::Height
 impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::absolute::Time
 impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::relative::Height
@@ -1032,7 +1045,6 @@ pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: bitcoin_unit
 pub fn bitcoin_units::fee_rate::FeeRate::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
 pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
 pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
-pub fn bitcoin_units::fee_rate::FeeRate::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
 pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
 pub fn bitcoin_units::fee_rate::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
 pub fn bitcoin_units::fee_rate::FeeRate::fee_wu(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
@@ -1042,7 +1054,6 @@ pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Resu
 pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
 pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::fee_rate::FeeRate::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
 pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
@@ -1052,6 +1063,22 @@ pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
+pub fn bitcoin_units::fee_rate::serde::OverflowError::clone(&self) -> bitcoin_units::fee_rate::serde::OverflowError
+pub fn bitcoin_units::fee_rate::serde::OverflowError::eq(&self, other: &bitcoin_units::fee_rate::serde::OverflowError) -> bool
+pub fn bitcoin_units::fee_rate::serde::OverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+pub fn bitcoin_units::fee_rate::serde::OverflowError::from(never: core::convert::Infallible) -> Self
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::fee_rate::FeeRate, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::fee_rate::FeeRate>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::fee_rate::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::fee_rate::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::fee_rate::FeeRate, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::fee_rate::FeeRate>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::fee_rate::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::fee_rate::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::fee_rate::FeeRate, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::fee_rate::FeeRate>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::fee_rate::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::fee_rate::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::ConversionError
 pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
 pub fn bitcoin_units::locktime::absolute::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
@@ -1206,6 +1233,13 @@ pub mod bitcoin_units::amount::serde::as_str
 pub mod bitcoin_units::amount::serde::as_str::opt
 pub mod bitcoin_units::block
 pub mod bitcoin_units::fee_rate
+pub mod bitcoin_units::fee_rate::serde
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_kwu
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_kwu::opt
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_floor
+pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt
 pub mod bitcoin_units::locktime
 pub mod bitcoin_units::locktime::absolute
 pub mod bitcoin_units::locktime::relative

From 79791e7444326d284bdf42c40926f6b05a6b65f7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 28 Dec 2024 09:03:42 +1100
Subject: [PATCH 156/554] primitives: Add core re-exports

This is not strictly needed but we would like to copy the public macros
from `units` to primitives and they use `$crate::_export` paths.
---
 primitives/src/lib.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index d629344e79..a25d422e71 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -33,6 +33,14 @@ extern crate std;
 #[macro_use]
 extern crate serde;
 
+#[doc(hidden)]
+pub mod _export {
+    /// A re-export of `core::*`.
+    pub mod _core {
+        pub use core::*;
+    }
+}
+
 pub mod block;
 pub mod locktime;
 pub mod merkle_tree;

From de0f940b90336ddd9d0495d5b830ccddee78c32a Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 28 Dec 2024 01:38:59 +0000
Subject: [PATCH 157/554] Automated update to Github CI to rustc
 nightly-2024-12-26

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index a9dd23c12f..5de8e30254 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2024-12-20
+nightly-2024-12-26

From ed387e5f1d4b3bd4a4a442f8a048a608e69d73c1 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 29 Dec 2024 08:23:39 +1100
Subject: [PATCH 158/554] hashes: Hide both macros

We have two macro definitions feature gated on `serde`. At some stage we
added the `doc(hidden)` attribute to one of them but forgot to add it to
the other. This technically makes our features non-additive. This macro
is "internal" so its unlikely that this is being used in the wild.

Add `doc(hidden)` to the `serde_impl` macro that is missing it.

Found by `cargo semver-checks` after recent upgrade to 0.38
---
 hashes/src/macros.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/hashes/src/macros.rs b/hashes/src/macros.rs
index 3d5382aec8..dc134577a2 100644
--- a/hashes/src/macros.rs
+++ b/hashes/src/macros.rs
@@ -533,6 +533,7 @@ macro_rules! serde_impl(
 ));
 
 /// Does an "empty" serde implementation for the configuration without serde feature.
+#[doc(hidden)]
 #[macro_export]
 #[cfg(not(feature = "serde"))]
 macro_rules! serde_impl(

From 87293dfdd38be71938ae9d6a9981eb4569de3521 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 29 Dec 2024 08:42:34 +1100
Subject: [PATCH 159/554] api: Run just check-api

---
 api/hashes/alloc-only.txt  | 1 -
 api/hashes/no-features.txt | 1 -
 2 files changed, 2 deletions(-)

diff --git a/api/hashes/alloc-only.txt b/api/hashes/alloc-only.txt
index 50246e2d43..93d5bf78e1 100644
--- a/api/hashes/alloc-only.txt
+++ b/api/hashes/alloc-only.txt
@@ -859,7 +859,6 @@ pub fn bitcoin_hashes::siphash24::State::fmt(&self, f: &mut core::fmt::Formatter
 pub macro bitcoin_hashes::hash_newtype!
 pub macro bitcoin_hashes::impl_debug_only_for_newtype!
 pub macro bitcoin_hashes::impl_hex_for_newtype!
-pub macro bitcoin_hashes::serde_impl!
 pub macro bitcoin_hashes::sha256t_hash_newtype!
 pub macro bitcoin_hashes::sha256t_tag!
 pub mod bitcoin_hashes
diff --git a/api/hashes/no-features.txt b/api/hashes/no-features.txt
index 5283250bd7..e1ce225513 100644
--- a/api/hashes/no-features.txt
+++ b/api/hashes/no-features.txt
@@ -806,7 +806,6 @@ pub fn bitcoin_hashes::siphash24::State::clone(&self) -> bitcoin_hashes::siphash
 pub fn bitcoin_hashes::siphash24::State::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub macro bitcoin_hashes::hash_newtype!
 pub macro bitcoin_hashes::impl_debug_only_for_newtype!
-pub macro bitcoin_hashes::serde_impl!
 pub macro bitcoin_hashes::sha256t_hash_newtype!
 pub macro bitcoin_hashes::sha256t_tag!
 pub mod bitcoin_hashes

From 7f2cf1dce8236c60931f729748c487d401878067 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 29 Dec 2024 09:01:27 +1100
Subject: [PATCH 160/554] api: Include generics in regex

The regex is still wrong, it misses structs with generics.

Currently `contrib/api.sh io types` returns:

ErrorKind
Error
Sink

But with this patch applied it returns:

FromStd<T>
ToStd<T>
ErrorKind
Cursor<T>
Error
Sink
Take<'a, R: bitcoin_io::Read + ?core::marker::Sized>
---
 contrib/api.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/contrib/api.sh b/contrib/api.sh
index 97bfcf1e1c..03bfe1203b 100755
--- a/contrib/api.sh
+++ b/contrib/api.sh
@@ -99,12 +99,12 @@ main() {
 
 # Print all public structs and enums.
 structs_and_enums() {
-    grep -oP 'pub (struct|enum) \K[\w:]+(?=\(|;| |$)' "$file" | sed "s/^${crate_full_name}:://"
+    grep -oP 'pub (struct|enum) \K[\w:]+(?:<[^>]+>)?(?=\(|;| |$)' "$file" | sed "s/^${crate_full_name}:://"
 }
 
 # Print all public structs and enums excluding error types.
 structs_and_enums_no_err() {
-    grep -oP 'pub (struct|enum) \K[\w:]+(?=\(|;| |$)' "$file" | sed "s/^${crate_full_name}:://" | grep -v Error
+    grep -oP 'pub (struct|enum) \K[\w:]+(?:<[^>]+>)?(?=\(|;| |$)' "$file" | sed "s/^${crate_full_name}:://" | grep -v Error
 }
 
 # Print all public traits.

From 3f433f1cde54f8be56ff20b5e4a7ff509de126b7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 29 Dec 2024 09:17:25 +1100
Subject: [PATCH 161/554] Improve Cursor ref API

Our `Cursor` is a replacement of sorts for the `std::io::Cursor`. Users
of the `Cursor` are likely to expect the same API so to get a reference
and/or mutable reference users will likely reach for `get_ref` and
`get_mut`. We should provide these.

Deprecate `inner` since it is the same as `get_ref` but less
idiomatically named (should have been `as_inner`).

Add `get_ref` and `get_mut` methods to the `Cursor` type.
---
 io/src/lib.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/io/src/lib.rs b/io/src/lib.rs
index 9770f6ce84..35e12b6311 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -224,6 +224,19 @@ impl<T: AsRef<[u8]>> Cursor<T> {
     ///
     /// This is the whole wrapped buffer, including the bytes already read.
     #[inline]
+    pub fn get_ref(&self) -> &T { &self.inner }
+
+    /// Returns a mutable reference to the inner buffer.
+    ///
+    /// This is the whole wrapped buffer, including the bytes already read.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
+
+    /// Returns a reference to the inner buffer.
+    ///
+    /// This is the whole wrapped buffer, including the bytes already read.
+    #[inline]
+    #[deprecated(since = "TBD", note = "use `get_ref()` instead")]
     pub fn inner(&self) -> &T { &self.inner }
 }
 

From ae129d84ace03fba57bb980cace5aa60ff6bc10e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 29 Dec 2024 09:20:39 +1100
Subject: [PATCH 162/554] api: Run just check-api

---
 api/io/all-features.txt | 2 ++
 api/io/alloc-only.txt   | 2 ++
 api/io/no-features.txt  | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/api/io/all-features.txt b/api/io/all-features.txt
index aef13ac563..af10dd8871 100644
--- a/api/io/all-features.txt
+++ b/api/io/all-features.txt
@@ -214,6 +214,8 @@ pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
+pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
 pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
diff --git a/api/io/alloc-only.txt b/api/io/alloc-only.txt
index b0aaeff4e2..572cb17e19 100644
--- a/api/io/alloc-only.txt
+++ b/api/io/alloc-only.txt
@@ -91,6 +91,8 @@ pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
+pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
 pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
diff --git a/api/io/no-features.txt b/api/io/no-features.txt
index facd4c3ef6..93613d4e6d 100644
--- a/api/io/no-features.txt
+++ b/api/io/no-features.txt
@@ -87,6 +87,8 @@ pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
+pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
 pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self

From 940a244132aa28af20facc2a425fbd583a26d3e5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 27 Dec 2024 11:36:20 +1100
Subject: [PATCH 163/554] Replace Amount::from_sat(0) with ZERO

We have a const for zero amount, use it.

Internal change only.
---
 units/src/amount/tests.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 19b32ffec0..64ab1957f7 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -25,7 +25,7 @@ fn from_str_zero() {
             let s = format!("{} {}", v, denom);
             match s.parse::<Amount>() {
                 Err(e) => panic!("failed to crate amount from {}: {:?}", s, e),
-                Ok(amount) => assert_eq!(amount, Amount::from_sat(0)),
+                Ok(amount) => assert_eq!(amount, Amount::ZERO),
             }
         }
 
@@ -41,7 +41,7 @@ fn from_str_zero() {
         }
         match s.parse::<SignedAmount>() {
             Err(e) => panic!("failed to crate amount from {}: {:?}", s, e),
-            Ok(amount) => assert_eq!(amount, SignedAmount::from_sat(0)),
+            Ok(amount) => assert_eq!(amount, SignedAmount::ZERO),
         }
     }
 }
@@ -873,8 +873,8 @@ fn serde_as_str_opt() {
 
 #[test]
 fn sum_amounts() {
-    assert_eq!(Amount::from_sat(0), [].iter().sum::<Amount>());
-    assert_eq!(SignedAmount::from_sat(0), [].iter().sum::<SignedAmount>());
+    assert_eq!(Amount::ZERO, [].iter().sum::<Amount>());
+    assert_eq!(SignedAmount::ZERO, [].iter().sum::<SignedAmount>());
 
     let amounts = [Amount::from_sat(42), Amount::from_sat(1337), Amount::from_sat(21)];
     let sum = amounts.into_iter().sum::<Amount>();
@@ -888,8 +888,8 @@ fn sum_amounts() {
 
 #[test]
 fn checked_sum_amounts() {
-    assert_eq!(Some(Amount::from_sat(0)), [].into_iter().checked_sum());
-    assert_eq!(Some(SignedAmount::from_sat(0)), [].into_iter().checked_sum());
+    assert_eq!(Some(Amount::ZERO), [].into_iter().checked_sum());
+    assert_eq!(Some(SignedAmount::ZERO), [].into_iter().checked_sum());
 
     let amounts = [Amount::from_sat(42), Amount::from_sat(1337), Amount::from_sat(21)];
     let sum = amounts.into_iter().checked_sum();

From 75f0afd0a3d8c9946cd3509a4388e0624a41e222 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 28 Dec 2024 07:46:08 +1100
Subject: [PATCH 164/554] Add local variable to use as constructor

As we already do in this test function for other constructors; add a
local variable and bind it to the `SignedAmount::from_sat` constructor.

Refactor only, no logic change.
---
 units/src/amount/tests.rs | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 64ab1957f7..aa0984c20c 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -562,42 +562,43 @@ fn to_from_string_in() {
     let ua_str = Amount::from_str_in;
     let ua_sat = Amount::from_sat;
     let sa_str = SignedAmount::from_str_in;
+    let sa_sat = SignedAmount::from_sat;
 
     assert_eq!("0.5", Amount::from_sat(50).to_string_in(D::Bit));
-    assert_eq!("-0.5", SignedAmount::from_sat(-50).to_string_in(D::Bit));
+    assert_eq!("-0.5", sa_sat(-50).to_string_in(D::Bit));
     assert_eq!("0.00253583", Amount::from_sat(253_583).to_string_in(D::Bitcoin));
-    assert_eq!("-5", SignedAmount::from_sat(-5).to_string_in(D::Satoshi));
+    assert_eq!("-5", sa_sat(-5).to_string_in(D::Satoshi));
     assert_eq!("0.1", Amount::from_sat(100_000_00).to_string_in(D::Bitcoin));
-    assert_eq!("-0.1", SignedAmount::from_sat(-100_000_00).to_string_in(D::Bitcoin));
+    assert_eq!("-0.1", sa_sat(-100_000_00).to_string_in(D::Bitcoin));
 
     assert_eq!("0.253583", Amount::from_sat(253_583).to_string_in(D::CentiBitcoin));
-    assert_eq!("-0.253583", SignedAmount::from_sat(-253_583).to_string_in(D::CentiBitcoin));
+    assert_eq!("-0.253583", sa_sat(-253_583).to_string_in(D::CentiBitcoin));
     assert_eq!("10", Amount::from_sat(100_000_00).to_string_in(D::CentiBitcoin));
-    assert_eq!("-10", SignedAmount::from_sat(-100_000_00).to_string_in(D::CentiBitcoin));
+    assert_eq!("-10", sa_sat(-100_000_00).to_string_in(D::CentiBitcoin));
 
     assert_eq!("2.53583", Amount::from_sat(253_583).to_string_in(D::MilliBitcoin));
-    assert_eq!("-2.53583", SignedAmount::from_sat(-253_583).to_string_in(D::MilliBitcoin));
+    assert_eq!("-2.53583", sa_sat(-253_583).to_string_in(D::MilliBitcoin));
     assert_eq!("100", Amount::from_sat(100_000_00).to_string_in(D::MilliBitcoin));
-    assert_eq!("-100", SignedAmount::from_sat(-100_000_00).to_string_in(D::MilliBitcoin));
+    assert_eq!("-100", sa_sat(-100_000_00).to_string_in(D::MilliBitcoin));
 
     assert_eq!("2535.83", Amount::from_sat(253_583).to_string_in(D::MicroBitcoin));
-    assert_eq!("-2535.83", SignedAmount::from_sat(-253_583).to_string_in(D::MicroBitcoin));
+    assert_eq!("-2535.83", sa_sat(-253_583).to_string_in(D::MicroBitcoin));
     assert_eq!("100000", Amount::from_sat(100_000_00).to_string_in(D::MicroBitcoin));
-    assert_eq!("-100000", SignedAmount::from_sat(-100_000_00).to_string_in(D::MicroBitcoin));
+    assert_eq!("-100000", sa_sat(-100_000_00).to_string_in(D::MicroBitcoin));
 
     assert_eq!("0.5", Amount::from_sat(50).to_string_in(D::Bit));
     assert_eq!("100", Amount::from_sat(10_000).to_string_in(D::Bit));
-    assert_eq!("-0.5", SignedAmount::from_sat(-50).to_string_in(D::Bit));
-    assert_eq!("-100", SignedAmount::from_sat(-10_000).to_string_in(D::Bit));
+    assert_eq!("-0.5", sa_sat(-50).to_string_in(D::Bit));
+    assert_eq!("-100", sa_sat(-10_000).to_string_in(D::Bit));
 
     assert_eq!("5", Amount::from_sat(5).to_string_in(D::Satoshi));
-    assert_eq!("-5", SignedAmount::from_sat(-5).to_string_in(D::Satoshi));
+    assert_eq!("-5", sa_sat(-5).to_string_in(D::Satoshi));
 
     assert_eq!("0.50", format!("{:.2}", Amount::from_sat(50).display_in(D::Bit)));
-    assert_eq!("-0.50", format!("{:.2}", SignedAmount::from_sat(-50).display_in(D::Bit)));
+    assert_eq!("-0.50", format!("{:.2}", sa_sat(-50).display_in(D::Bit)));
 
     assert_eq!("0.10000000", format!("{:.8}", Amount::from_sat(100_000_00).display_in(D::Bitcoin)));
-    assert_eq!("-100.00", format!("{:.2}", SignedAmount::from_sat(-10_000).display_in(D::Bit)));
+    assert_eq!("-100.00", format!("{:.2}", sa_sat(-10_000).display_in(D::Bit)));
 
     assert_eq!(ua_str(&ua_sat(500).to_string_in(D::Bitcoin), D::Bitcoin), Ok(ua_sat(500)));
     assert_eq!(ua_str(&ua_sat(1).to_string_in(D::CentiBitcoin), D::CentiBitcoin), Ok(ua_sat(1)));

From f32af7dac6a3797b983cd200695d2ab3776bf736 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 28 Dec 2024 07:48:47 +1100
Subject: [PATCH 165/554] Use ua_sat throughout test function

We have a local variable `ua_sat` already that is bound to the
`Amount::from_sat` constructor. Use it.

Refactor only, no logic change.
---
 units/src/amount/tests.rs | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index aa0984c20c..adc1f63520 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -564,40 +564,40 @@ fn to_from_string_in() {
     let sa_str = SignedAmount::from_str_in;
     let sa_sat = SignedAmount::from_sat;
 
-    assert_eq!("0.5", Amount::from_sat(50).to_string_in(D::Bit));
+    assert_eq!("0.5", ua_sat(50).to_string_in(D::Bit));
     assert_eq!("-0.5", sa_sat(-50).to_string_in(D::Bit));
-    assert_eq!("0.00253583", Amount::from_sat(253_583).to_string_in(D::Bitcoin));
+    assert_eq!("0.00253583", ua_sat(253_583).to_string_in(D::Bitcoin));
     assert_eq!("-5", sa_sat(-5).to_string_in(D::Satoshi));
-    assert_eq!("0.1", Amount::from_sat(100_000_00).to_string_in(D::Bitcoin));
+    assert_eq!("0.1", ua_sat(100_000_00).to_string_in(D::Bitcoin));
     assert_eq!("-0.1", sa_sat(-100_000_00).to_string_in(D::Bitcoin));
 
-    assert_eq!("0.253583", Amount::from_sat(253_583).to_string_in(D::CentiBitcoin));
+    assert_eq!("0.253583", ua_sat(253_583).to_string_in(D::CentiBitcoin));
     assert_eq!("-0.253583", sa_sat(-253_583).to_string_in(D::CentiBitcoin));
-    assert_eq!("10", Amount::from_sat(100_000_00).to_string_in(D::CentiBitcoin));
+    assert_eq!("10", ua_sat(100_000_00).to_string_in(D::CentiBitcoin));
     assert_eq!("-10", sa_sat(-100_000_00).to_string_in(D::CentiBitcoin));
 
-    assert_eq!("2.53583", Amount::from_sat(253_583).to_string_in(D::MilliBitcoin));
+    assert_eq!("2.53583", ua_sat(253_583).to_string_in(D::MilliBitcoin));
     assert_eq!("-2.53583", sa_sat(-253_583).to_string_in(D::MilliBitcoin));
-    assert_eq!("100", Amount::from_sat(100_000_00).to_string_in(D::MilliBitcoin));
+    assert_eq!("100", ua_sat(100_000_00).to_string_in(D::MilliBitcoin));
     assert_eq!("-100", sa_sat(-100_000_00).to_string_in(D::MilliBitcoin));
 
-    assert_eq!("2535.83", Amount::from_sat(253_583).to_string_in(D::MicroBitcoin));
+    assert_eq!("2535.83", ua_sat(253_583).to_string_in(D::MicroBitcoin));
     assert_eq!("-2535.83", sa_sat(-253_583).to_string_in(D::MicroBitcoin));
-    assert_eq!("100000", Amount::from_sat(100_000_00).to_string_in(D::MicroBitcoin));
+    assert_eq!("100000", ua_sat(100_000_00).to_string_in(D::MicroBitcoin));
     assert_eq!("-100000", sa_sat(-100_000_00).to_string_in(D::MicroBitcoin));
 
-    assert_eq!("0.5", Amount::from_sat(50).to_string_in(D::Bit));
-    assert_eq!("100", Amount::from_sat(10_000).to_string_in(D::Bit));
+    assert_eq!("0.5", ua_sat(50).to_string_in(D::Bit));
+    assert_eq!("100", ua_sat(10_000).to_string_in(D::Bit));
     assert_eq!("-0.5", sa_sat(-50).to_string_in(D::Bit));
     assert_eq!("-100", sa_sat(-10_000).to_string_in(D::Bit));
 
-    assert_eq!("5", Amount::from_sat(5).to_string_in(D::Satoshi));
+    assert_eq!("5", ua_sat(5).to_string_in(D::Satoshi));
     assert_eq!("-5", sa_sat(-5).to_string_in(D::Satoshi));
 
-    assert_eq!("0.50", format!("{:.2}", Amount::from_sat(50).display_in(D::Bit)));
+    assert_eq!("0.50", format!("{:.2}", ua_sat(50).display_in(D::Bit)));
     assert_eq!("-0.50", format!("{:.2}", sa_sat(-50).display_in(D::Bit)));
 
-    assert_eq!("0.10000000", format!("{:.8}", Amount::from_sat(100_000_00).display_in(D::Bitcoin)));
+    assert_eq!("0.10000000", format!("{:.8}", ua_sat(100_000_00).display_in(D::Bitcoin)));
     assert_eq!("-100.00", format!("{:.2}", sa_sat(-10_000).display_in(D::Bit)));
 
     assert_eq!(ua_str(&ua_sat(500).to_string_in(D::Bitcoin), D::Bitcoin), Ok(ua_sat(500)));

From 8e6784dd417dfb06b985407a60f3aeea4ec99db9 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 28 Dec 2024 07:55:19 +1100
Subject: [PATCH 166/554] Introduce Amount::from_sat_unchecked

As we did for `SignedAmount` add a constructor to the `Amount` type that
does no checks on its argument.

(This is in preparation for enforcing the MAX_MONEY invariant.)

Use the `_unchecked` version in a single unit test. The rest of the unit
tests will be refactored later to minimise the size of this patch.
---
 units/src/amount/signed.rs   | 4 +---
 units/src/amount/tests.rs    | 4 ++--
 units/src/amount/unsigned.rs | 5 +++++
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 2d3846ab57..4580af033a 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -88,9 +88,7 @@ impl SignedAmount {
     /// Caller to guarantee that `satoshi` is within valid range.
     ///
     /// See [`Self::MIN`] and [`Self::MAX_MONEY`].
-    pub const fn from_sat_unchecked(satoshi: i64) -> SignedAmount {
-        SignedAmount(satoshi)
-    }
+    pub const fn from_sat_unchecked(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
 
     /// Converts from a value expressing a decimal number of bitcoin to a [`SignedAmount`].
     ///
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index adc1f63520..ecb5f3885b 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -560,9 +560,9 @@ fn from_str() {
 fn to_from_string_in() {
     use super::Denomination as D;
     let ua_str = Amount::from_str_in;
-    let ua_sat = Amount::from_sat;
+    let ua_sat = Amount::from_sat_unchecked;
     let sa_str = SignedAmount::from_str_in;
-    let sa_sat = SignedAmount::from_sat;
+    let sa_sat = SignedAmount::from_sat_unchecked;
 
     assert_eq!("0.5", ua_sat(50).to_string_in(D::Bit));
     assert_eq!("-0.5", sa_sat(-50).to_string_in(D::Bit));
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index db70177928..f6cb57eb57 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -90,6 +90,11 @@ impl Amount {
     /// ```
     pub const fn to_sat(self) -> u64 { self.0 }
 
+    /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
+    ///
+    /// Caller to guarantee that `satoshi` is within valid range. See [`Self::MAX_MONEY`].
+    pub const fn from_sat_unchecked(satoshi: u64) -> Amount { Self(satoshi) }
+
     /// Converts from a value expressing a decimal number of bitcoin to an [`Amount`].
     ///
     /// # Errors

From 04bae4bb914b1173d7c300174505a0c34592cab5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 27 Dec 2024 11:54:43 +1100
Subject: [PATCH 167/554] Use _unchecked in unit tests

We now have both `Amount::from_sat_unchecked` and
`SignedAmount::from_sat_unchecked`. These constructors are explicitly
for ignoring any invariant (implied or otherwise) especially in test
code.

Note we do not enforce an invariant currently. This patch is a baby step
towards getting the `amount` module in order.

Replace all calls to `from_sat` for const int values with the
`_unchecked` constructor. Done in `amount::tests` only.
---
 units/src/amount/tests.rs | 63 ++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 30 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index ecb5f3885b..a5626c24c1 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -68,16 +68,16 @@ fn from_str_zero_without_denomination() {
 #[test]
 fn from_int_btc() {
     let amt = Amount::from_int_btc_const(2);
-    assert_eq!(Amount::from_sat(200_000_000), amt);
+    assert_eq!(Amount::from_sat_unchecked(200_000_000), amt);
 }
 
 #[test]
 fn test_amount_try_from_signed_amount() {
-    let sa_positive = SignedAmount::from_sat(123);
+    let sa_positive = SignedAmount::from_sat_unchecked(123);
     let ua_positive = Amount::try_from(sa_positive).unwrap();
-    assert_eq!(ua_positive, Amount::from_sat(123));
+    assert_eq!(ua_positive, Amount::from_sat_unchecked(123));
 
-    let sa_negative = SignedAmount::from_sat(-123);
+    let sa_negative = SignedAmount::from_sat_unchecked(-123);
     let result = Amount::try_from(sa_negative);
     assert_eq!(result, Err(OutOfRangeError { is_signed: false, is_greater_than_max: false }));
 }
@@ -105,9 +105,9 @@ fn mul_div() {
 #[test]
 fn test_overflows() {
     // panic on overflow
-    let result = panic::catch_unwind(|| Amount::MAX + Amount::from_sat(1));
+    let result = panic::catch_unwind(|| Amount::MAX + Amount::from_sat_unchecked(1));
     assert!(result.is_err());
-    let result = panic::catch_unwind(|| Amount::from_sat(8_446_744_073_709_551_615) * 3);
+    let result = panic::catch_unwind(|| Amount::from_sat_unchecked(8_446_744_073_709_551_615) * 3);
     assert!(result.is_err());
 }
 
@@ -129,12 +129,12 @@ fn checked_arithmetic() {
 #[test]
 fn amount_checked_div_by_weight_ceil() {
     let weight = Weight::from_kwu(1).unwrap();
-    let fee_rate = Amount::from_sat(1).checked_div_by_weight_ceil(weight).unwrap();
+    let fee_rate = Amount::from_sat_unchecked(1).checked_div_by_weight_ceil(weight).unwrap();
     // 1 sats / 1,000 wu = 1 sats/kwu
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(1));
 
     let weight = Weight::from_wu(381);
-    let fee_rate = Amount::from_sat(329).checked_div_by_weight_ceil(weight).unwrap();
+    let fee_rate = Amount::from_sat_unchecked(329).checked_div_by_weight_ceil(weight).unwrap();
     // 329 sats / 381 wu = 863.5 sats/kwu
     // round up to 864
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(864));
@@ -147,12 +147,12 @@ fn amount_checked_div_by_weight_ceil() {
 #[test]
 fn amount_checked_div_by_weight_floor() {
     let weight = Weight::from_kwu(1).unwrap();
-    let fee_rate = Amount::from_sat(1).checked_div_by_weight_floor(weight).unwrap();
+    let fee_rate = Amount::from_sat_unchecked(1).checked_div_by_weight_floor(weight).unwrap();
     // 1 sats / 1,000 wu = 1 sats/kwu
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(1));
 
     let weight = Weight::from_wu(381);
-    let fee_rate = Amount::from_sat(329).checked_div_by_weight_floor(weight).unwrap();
+    let fee_rate = Amount::from_sat_unchecked(329).checked_div_by_weight_floor(weight).unwrap();
     // 329 sats / 381 wu = 863.5 sats/kwu
     // round down to 863
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
@@ -239,22 +239,22 @@ fn parsing() {
     #[cfg(feature = "alloc")]
     assert_eq!(p(&more_than_max, btc), Err(OutOfRangeError::too_big(false).into()));
     assert_eq!(p("0.000000042", btc), Err(TooPreciseError { position: 10 }.into()));
-    assert_eq!(p("1.0000000", sat), Ok(Amount::from_sat(1)));
+    assert_eq!(p("1.0000000", sat), Ok(Amount::from_sat_unchecked(1)));
     assert_eq!(p("1.1", sat), Err(TooPreciseError { position: 2 }.into()));
     assert_eq!(p("1000.1", sat), Err(TooPreciseError { position: 5 }.into()));
-    assert_eq!(p("1001.0000000", sat), Ok(Amount::from_sat(1001)));
+    assert_eq!(p("1001.0000000", sat), Ok(Amount::from_sat_unchecked(1001)));
     assert_eq!(p("1000.0000001", sat), Err(TooPreciseError { position: 11 }.into()));
 
-    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", btc), Ok(Amount::from_sat_unchecked(1_000_000_00)));
+    assert_eq!(sp("-.5", btc), Ok(SignedAmount::from_sat_unchecked(-500_000_00)));
     #[cfg(feature = "alloc")]
     assert_eq!(sp(&SignedAmount::MIN.to_sat().to_string(), sat), Ok(SignedAmount::MIN));
-    assert_eq!(p("1.1", btc), Ok(Amount::from_sat(1_100_000_00)));
-    assert_eq!(p("100", sat), Ok(Amount::from_sat(100)));
-    assert_eq!(p("55", sat), Ok(Amount::from_sat(55)));
-    assert_eq!(p("2100000000000000", sat), Ok(Amount::from_sat(21_000_000__000_000_00)));
-    assert_eq!(p("2100000000000000.", sat), Ok(Amount::from_sat(21_000_000__000_000_00)));
-    assert_eq!(p("21000000", btc), Ok(Amount::from_sat(21_000_000__000_000_00)));
+    assert_eq!(p("1.1", btc), Ok(Amount::from_sat_unchecked(1_100_000_00)));
+    assert_eq!(p("100", sat), Ok(Amount::from_sat_unchecked(100)));
+    assert_eq!(p("55", sat), Ok(Amount::from_sat_unchecked(55)));
+    assert_eq!(p("2100000000000000", sat), Ok(Amount::from_sat_unchecked(21_000_000__000_000_00)));
+    assert_eq!(p("2100000000000000.", sat), Ok(Amount::from_sat_unchecked(21_000_000__000_000_00)));
+    assert_eq!(p("21000000", btc), Ok(Amount::from_sat_unchecked(21_000_000__000_000_00)));
 
     // exactly 50 chars.
     assert_eq!(
@@ -277,13 +277,13 @@ fn to_string() {
     assert_eq!(format!("{:.8}", Amount::ONE_BTC.display_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!(SignedAmount::from_sat_unchecked(-42).to_string_in(D::Bitcoin), "-0.00000042");
 
     assert_eq!(Amount::ONE_BTC.to_string_with_denomination(D::Bitcoin), "1 BTC");
     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),
+        SignedAmount::from_sat_unchecked(-42).to_string_with_denomination(D::Bitcoin),
         "-0.00000042 BTC"
     );
 }
@@ -543,12 +543,12 @@ fn from_str() {
     case("21000001 BTC", Err(OutOfRangeError::too_big(false)));
     case("18446744073709551616 sat", Err(OutOfRangeError::too_big(false)));
 
-    ok_case(".5 bits", Amount::from_sat(50));
-    ok_scase("-.5 bits", SignedAmount::from_sat(-50));
-    ok_case("0.00253583 BTC", Amount::from_sat(253_583));
-    ok_scase("-5 satoshi", SignedAmount::from_sat(-5));
-    ok_case("0.10000000 BTC", Amount::from_sat(100_000_00));
-    ok_scase("-100 bits", SignedAmount::from_sat(-10_000));
+    ok_case(".5 bits", Amount::from_sat_unchecked(50));
+    ok_scase("-.5 bits", SignedAmount::from_sat_unchecked(-50));
+    ok_case("0.00253583 BTC", Amount::from_sat_unchecked(253_583));
+    ok_scase("-5 satoshi", SignedAmount::from_sat_unchecked(-5));
+    ok_case("0.10000000 BTC", Amount::from_sat_unchecked(100_000_00));
+    ok_scase("-100 bits", SignedAmount::from_sat_unchecked(-10_000));
     ok_case("21000000 BTC", Amount::MAX);
     ok_scase("21000000 BTC", SignedAmount::MAX);
     ok_scase("-21000000 BTC", SignedAmount::MIN);
@@ -638,7 +638,7 @@ fn to_string_with_denomination_from_str_roundtrip() {
 
     use super::Denomination as D;
 
-    let amt = Amount::from_sat(42);
+    let amt = Amount::from_sat_unchecked(42);
     let denom = Amount::to_string_with_denomination;
     assert_eq!(denom(amt, D::Bitcoin).parse::<Amount>(), Ok(amt));
     assert_eq!(denom(amt, D::CentiBitcoin).parse::<Amount>(), Ok(amt));
@@ -669,7 +669,10 @@ fn serde_as_sat() {
     }
 
     serde_test::assert_tokens(
-        &T { amt: Amount::from_sat(123_456_789), samt: SignedAmount::from_sat(-123_456_789) },
+        &T {
+            amt: Amount::from_sat_unchecked(123_456_789),
+            samt: SignedAmount::from_sat_unchecked(-123_456_789),
+        },
         &[
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::Str("amt"),

From 2042d91be59a1d47afb986cef0152f9b5250f476 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 27 Dec 2024 12:06:29 +1100
Subject: [PATCH 168/554] api: Run just check-api

---
 api/units/all-features.txt | 1 +
 api/units/alloc-only.txt   | 1 +
 api/units/no-features.txt  | 1 +
 3 files changed, 3 insertions(+)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 0024bfd514..f084694c58 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -714,6 +714,7 @@ pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option:
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_sat_unchecked(satoshi: u64) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::to_sat(self) -> u64
 pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 79871eefc8..d64e17e23a 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -665,6 +665,7 @@ pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option:
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_sat_unchecked(satoshi: u64) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::to_sat(self) -> u64
 pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 48178dccca..db86722ee2 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -647,6 +647,7 @@ pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option:
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
+pub const fn bitcoin_units::Amount::from_sat_unchecked(satoshi: u64) -> bitcoin_units::Amount
 pub const fn bitcoin_units::Amount::to_sat(self) -> u64
 pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
 pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>

From 20b798175c23e40988f821c9a90e28e216df2937 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 30 Dec 2024 08:35:01 +1100
Subject: [PATCH 169/554] Update to latest rust-ordered

I just went to town on the `rust-ordered` crate to get it ready for
releasing a `1.0` version. None of the changes effect our usage here in
`rust-bitcoin`.

Upgrade to the latest version of `rust-ordered` - `v0.3.0`.
---
 Cargo-minimal.lock    | 4 ++--
 Cargo-recent.lock     | 4 ++--
 bitcoin/Cargo.toml    | 2 +-
 primitives/Cargo.toml | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 4ca2d3d5bf..67b68fc9f4 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -303,9 +303,9 @@ dependencies = [
 
 [[package]]
 name = "ordered"
-version = "0.2.2"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f0642533dea0bb58bd5cae31bafc1872429f0f12ac8c61fe2b4ba44f80b959b"
+checksum = "3cd8ca7e3c0ec0f0ae705488e2df4ea2eae87e97de8c8abd2bda12b23324cac9"
 
 [[package]]
 name = "ppv-lite86"
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index c4fd9762b5..3a1d1b3978 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -311,9 +311,9 @@ dependencies = [
 
 [[package]]
 name = "ordered"
-version = "0.2.2"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f0642533dea0bb58bd5cae31bafc1872429f0f12ac8c61fe2b4ba44f80b959b"
+checksum = "3cd8ca7e3c0ec0f0ae705488e2df4ea2eae87e97de8c8abd2bda12b23324cac9"
 
 [[package]]
 name = "ppv-lite86"
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index 46e1e4c125..04cc450135 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -39,7 +39,7 @@ arbitrary = { version = "1.4", optional = true }
 base64 = { version = "0.22.0", optional = true }
 # `bitcoinconsensus` version includes metadata which indicates the version of Core. Use `cargo tree` to see it.
 bitcoinconsensus = { version = "0.106.0", default-features = false, optional = true }
-ordered = { version = "0.2.0", optional = true }
+ordered = { version = "0.3.0", optional = true }
 serde = { version = "1.0.103", default-features = false, features = [ "derive", "alloc" ], optional = true }
 
 [dev-dependencies]
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 3d75906eb9..c82622656f 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -29,7 +29,7 @@ io = { package = "bitcoin-io", version = "0.2.0", default-features = false }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false }
 
 arbitrary = { version = "1.4", optional = true }
-ordered = { version = "0.2.0", optional = true }
+ordered = { version = "0.3.0", optional = true }
 serde = { version = "1.0.103", default-features = false, features = ["derive", "alloc"], optional = true }
 
 [dev-dependencies]

From 1a8f5b19fbc37c74bbdd7dcee55b3294046ef88e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 31 Dec 2024 10:41:09 +1100
Subject: [PATCH 170/554] Update to rust-ordered 0.4.0

We just released a version of `ordered` that makes `ArbitraryOrd` object
safe - use it.

Upgrade to the latest version of `rust-ordered` - `v0.4.0`.
---
 Cargo-minimal.lock    | 4 ++--
 Cargo-recent.lock     | 4 ++--
 bitcoin/Cargo.toml    | 2 +-
 primitives/Cargo.toml | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 67b68fc9f4..44e21f7e26 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -303,9 +303,9 @@ dependencies = [
 
 [[package]]
 name = "ordered"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cd8ca7e3c0ec0f0ae705488e2df4ea2eae87e97de8c8abd2bda12b23324cac9"
+checksum = "79c12388aac4f817eae0359011d67d4072ed84cfc63b0d9a7958ef476fb74bec"
 
 [[package]]
 name = "ppv-lite86"
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index 3a1d1b3978..00ef2b11c5 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -311,9 +311,9 @@ dependencies = [
 
 [[package]]
 name = "ordered"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cd8ca7e3c0ec0f0ae705488e2df4ea2eae87e97de8c8abd2bda12b23324cac9"
+checksum = "79c12388aac4f817eae0359011d67d4072ed84cfc63b0d9a7958ef476fb74bec"
 
 [[package]]
 name = "ppv-lite86"
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index 04cc450135..34ca0755ee 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -39,7 +39,7 @@ arbitrary = { version = "1.4", optional = true }
 base64 = { version = "0.22.0", optional = true }
 # `bitcoinconsensus` version includes metadata which indicates the version of Core. Use `cargo tree` to see it.
 bitcoinconsensus = { version = "0.106.0", default-features = false, optional = true }
-ordered = { version = "0.3.0", optional = true }
+ordered = { version = "0.4.0", optional = true }
 serde = { version = "1.0.103", default-features = false, features = [ "derive", "alloc" ], optional = true }
 
 [dev-dependencies]
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index c82622656f..199a9d808a 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -29,7 +29,7 @@ io = { package = "bitcoin-io", version = "0.2.0", default-features = false }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false }
 
 arbitrary = { version = "1.4", optional = true }
-ordered = { version = "0.3.0", optional = true }
+ordered = { version = "0.4.0", optional = true }
 serde = { version = "1.0.103", default-features = false, features = ["derive", "alloc"], optional = true }
 
 [dev-dependencies]

From fc9e40ab1a3582b29d553da73ac5a445a902a015 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 18 Dec 2024 11:22:32 +1100
Subject: [PATCH 171/554] units: Re-order impl_parse_str_from_int_infallible

We have a public macro `impl_parse_str_from_int_infallible` and a helper
macro used by it, both pubicly exported.

To assist readers understanding what is going on put the helper below
the other.

Code move only, no logic change.
---
 units/src/parse.rs | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index ec36d4b94b..34cbfaba32 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -91,23 +91,6 @@ pub fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, Par
     })
 }
 
-/// Implements `TryFrom<$from> for $to` using `parse::int`, mapping the output using infallible
-/// conversion function `fn`.
-#[macro_export]
-macro_rules! impl_tryfrom_str_from_int_infallible {
-    ($($from:ty, $to:ident, $inner:ident, $fn:ident);*) => {
-        $(
-        impl $crate::_export::_core::convert::TryFrom<$from> for $to {
-            type Error = $crate::parse::ParseIntError;
-
-            fn try_from(s: $from) -> $crate::_export::_core::result::Result<Self, Self::Error> {
-                $crate::parse::int::<$inner, $from>(s).map($to::$fn)
-            }
-        }
-        )*
-    }
-}
-
 /// Implements `FromStr` and `TryFrom<{&str, String, Box<str>}> for $to` using `parse::int`, mapping
 /// the output using infallible conversion function `fn`.
 ///
@@ -130,6 +113,23 @@ macro_rules! impl_parse_str_from_int_infallible {
     }
 }
 
+/// Implements `TryFrom<$from> for $to` using `parse::int`, mapping the output using infallible
+/// conversion function `fn`.
+#[macro_export]
+macro_rules! impl_tryfrom_str_from_int_infallible {
+    ($($from:ty, $to:ident, $inner:ident, $fn:ident);*) => {
+        $(
+        impl $crate::_export::_core::convert::TryFrom<$from> for $to {
+            type Error = $crate::parse::ParseIntError;
+
+            fn try_from(s: $from) -> $crate::_export::_core::result::Result<Self, Self::Error> {
+                $crate::parse::int::<$inner, $from>(s).map($to::$fn)
+            }
+        }
+        )*
+    }
+}
+
 /// Implements `TryFrom<$from> for $to`.
 #[macro_export]
 macro_rules! impl_tryfrom_str {

From 4cc7aae6b925ad6e8a853e6d2741b2a862c29e05 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 31 Dec 2024 13:00:10 +1100
Subject: [PATCH 172/554] Hide impl_tryfrom_str_from_int_infallible

This macro is a helper for `impl_parse_str_from_int_infallible` used to
reduce code duplication. It does not, and should not, need to be part of
the public API - hide it.
---
 api/units/all-features.txt | 1 -
 api/units/alloc-only.txt   | 1 -
 api/units/no-features.txt  | 1 -
 units/src/parse.rs         | 1 +
 4 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index f084694c58..00fdd5dd66 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -1196,7 +1196,6 @@ pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub macro bitcoin_units::impl_parse_str!
 pub macro bitcoin_units::impl_parse_str_from_int_infallible!
 pub macro bitcoin_units::impl_tryfrom_str!
-pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::amount::serde
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index d64e17e23a..679646265f 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -1067,7 +1067,6 @@ pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub macro bitcoin_units::impl_parse_str!
 pub macro bitcoin_units::impl_parse_str_from_int_infallible!
 pub macro bitcoin_units::impl_tryfrom_str!
-pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::block
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index db86722ee2..db9ed7378f 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -1021,7 +1021,6 @@ pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub macro bitcoin_units::impl_parse_str!
 pub macro bitcoin_units::impl_parse_str_from_int_infallible!
 pub macro bitcoin_units::impl_tryfrom_str!
-pub macro bitcoin_units::impl_tryfrom_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::block
diff --git a/units/src/parse.rs b/units/src/parse.rs
index 34cbfaba32..398a87798f 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -116,6 +116,7 @@ macro_rules! impl_parse_str_from_int_infallible {
 /// Implements `TryFrom<$from> for $to` using `parse::int`, mapping the output using infallible
 /// conversion function `fn`.
 #[macro_export]
+#[doc(hidden)]                  // Helper macro called by `impl_parse_str_from_int_infallible`.
 macro_rules! impl_tryfrom_str_from_int_infallible {
     ($($from:ty, $to:ident, $inner:ident, $fn:ident);*) => {
         $(

From 2675cd1040cfe254a9258c080a65ab253c8f9250 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 18 Dec 2024 11:24:39 +1100
Subject: [PATCH 173/554] units: Re-order impl_parse_str

We have a public macro `impl_parse_str` and a helper macro used by it,
both pubicly exported.

As we did for `impl_parse_str_from_int_infallible`; to assist readers
understanding what is going on put the helper below the other.

Done as a separate patch to make the diff easier to read.

Internal change only, no logic change.
---
 units/src/parse.rs | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 398a87798f..d1f402decf 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -131,22 +131,6 @@ macro_rules! impl_tryfrom_str_from_int_infallible {
     }
 }
 
-/// Implements `TryFrom<$from> for $to`.
-#[macro_export]
-macro_rules! impl_tryfrom_str {
-    ($($from:ty, $to:ty, $err:ty, $inner_fn:expr);*) => {
-        $(
-            impl $crate::_export::_core::convert::TryFrom<$from> for $to {
-                type Error = $err;
-
-                fn try_from(s: $from) -> $crate::_export::_core::result::Result<Self, Self::Error> {
-                    $inner_fn(s)
-                }
-            }
-        )*
-    }
-}
-
 /// Implements standard parsing traits for `$type` by calling into `$inner_fn`.
 #[macro_export]
 macro_rules! impl_parse_str {
@@ -165,6 +149,22 @@ macro_rules! impl_parse_str {
     }
 }
 
+/// Implements `TryFrom<$from> for $to`.
+#[macro_export]
+macro_rules! impl_tryfrom_str {
+    ($($from:ty, $to:ty, $err:ty, $inner_fn:expr);*) => {
+        $(
+            impl $crate::_export::_core::convert::TryFrom<$from> for $to {
+                type Error = $err;
+
+                fn try_from(s: $from) -> $crate::_export::_core::result::Result<Self, Self::Error> {
+                    $inner_fn(s)
+                }
+            }
+        )*
+    }
+}
+
 /// Removes the prefix `0x` (or `0X`) from a hex string.
 ///
 /// # Errors

From 706c7c9f5fca175226c09ec9e8f3431ab4999833 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 31 Dec 2024 13:02:36 +1100
Subject: [PATCH 174/554] Hide impl_tryfrom_str

This macro is a helper for `impl_parse_str` used to reduce code
duplication. It does not, and should not, need to be part of the public
API - hide it.
---
 api/units/all-features.txt | 1 -
 api/units/alloc-only.txt   | 1 -
 api/units/no-features.txt  | 1 -
 units/src/parse.rs         | 1 +
 4 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 00fdd5dd66..a788adba0a 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -1195,7 +1195,6 @@ pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
 pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub macro bitcoin_units::impl_parse_str!
 pub macro bitcoin_units::impl_parse_str_from_int_infallible!
-pub macro bitcoin_units::impl_tryfrom_str!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::amount::serde
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 679646265f..61e5afbfdb 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -1066,7 +1066,6 @@ pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
 pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub macro bitcoin_units::impl_parse_str!
 pub macro bitcoin_units::impl_parse_str_from_int_infallible!
-pub macro bitcoin_units::impl_tryfrom_str!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::block
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index db9ed7378f..367d8501ac 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -1020,7 +1020,6 @@ pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
 pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub macro bitcoin_units::impl_parse_str!
 pub macro bitcoin_units::impl_parse_str_from_int_infallible!
-pub macro bitcoin_units::impl_tryfrom_str!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::block
diff --git a/units/src/parse.rs b/units/src/parse.rs
index d1f402decf..35c880f371 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -151,6 +151,7 @@ macro_rules! impl_parse_str {
 
 /// Implements `TryFrom<$from> for $to`.
 #[macro_export]
+#[doc(hidden)]                  // Helper macro called by `impl_parse_str`.
 macro_rules! impl_tryfrom_str {
     ($($from:ty, $to:ty, $err:ty, $inner_fn:expr);*) => {
         $(

From b1399d193fcb20c09457a1f22c5c1dd8009c84b1 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 18 Dec 2024 11:26:14 +1100
Subject: [PATCH 175/554] units: Improve rustdocs on macros

Extensively document the two _real_ public macros (not the helpers) in
`units::parse`.
---
 units/src/parse.rs | 48 ++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 44 insertions(+), 4 deletions(-)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 35c880f371..ec927716f4 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -91,10 +91,30 @@ pub fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, Par
     })
 }
 
-/// Implements `FromStr` and `TryFrom<{&str, String, Box<str>}> for $to` using `parse::int`, mapping
-/// the output using infallible conversion function `fn`.
+/// Implements standard parsing traits for `$type` by calling `parse::int`.
 ///
-/// The `Error` type is `ParseIntError`
+/// Once the string is converted to an integer the infallible conversion function `fn` is used to
+/// create the type `to`.
+///
+/// Implements:
+///
+/// * `FromStr`
+/// * `TryFrom<&str>`
+///
+/// And if `alloc` feature is enabled in calling crate:
+///
+/// * `TryFrom<Box<str>>`
+/// * `TryFrom<String>`
+///
+/// # Arguments
+///
+/// * `to` - the type converted to e.g., `impl From<&str> for $to`.
+/// * `err` - the error type returned by `$inner_fn` (implies returned by `FromStr` and `TryFrom`).
+/// * `fn`: The infallible conversion function to call to convert from an integer.
+///
+/// # Errors
+///
+/// If parsing the string fails then a `units::parse::ParseIntError` is returned.
 #[macro_export]
 macro_rules! impl_parse_str_from_int_infallible {
     ($to:ident, $inner:ident, $fn:ident) => {
@@ -131,7 +151,27 @@ macro_rules! impl_tryfrom_str_from_int_infallible {
     }
 }
 
-/// Implements standard parsing traits for `$type` by calling into `$inner_fn`.
+/// Implements standard parsing traits for `$type` by calling through to `$inner_fn`.
+///
+/// Implements:
+///
+/// * `FromStr`
+/// * `TryFrom<&str>`
+///
+/// And if `alloc` feature is enabled in calling crate:
+///
+/// * `TryFrom<Box<str>>`
+/// * `TryFrom<String>`
+///
+/// # Arguments
+///
+/// * `to` - the type converted to e.g., `impl From<&str> for $to`.
+/// * `err` - the error type returned by `$inner_fn` (implies returned by `FromStr` and `TryFrom`).
+/// * `inner_fn`: The fallible conversion function to call to convert from a string reference.
+///
+/// # Errors
+///
+/// All functions use the error returned by `$inner_fn`.
 #[macro_export]
 macro_rules! impl_parse_str {
     ($to:ty, $err:ty, $inner_fn:expr) => {

From fd8d563b873c87a996d82062285169e16e3f0c13 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 2 Jan 2025 07:29:15 +1100
Subject: [PATCH 176/554] Remove macro debug_from_display

Rust macros, while at times useful, are a maintenance nightmare. And
we have been bitten by calling macros from other crates multiple times
in the past.

In a push to just use less macros remove the `debug_from_display`
macro and just write the code.

This is an API breaking change to `internals` but an internal change
only to any of the _real_ crates.
---
 bitcoin/src/blockdata/script/builder.rs |  6 +++++-
 bitcoin/src/p2p/mod.rs                  |  9 +++++++--
 internals/src/macros.rs                 | 15 ---------------
 primitives/src/opcodes.rs               |  8 +++++---
 4 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/bitcoin/src/blockdata/script/builder.rs b/bitcoin/src/blockdata/script/builder.rs
index 6e0c7875c5..ea86581347 100644
--- a/bitcoin/src/blockdata/script/builder.rs
+++ b/bitcoin/src/blockdata/script/builder.rs
@@ -150,4 +150,8 @@ impl fmt::Display for Builder {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
 
-internals::debug_from_display!(Builder);
+impl fmt::Debug for Builder {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        fmt::Display::fmt(self, f)
+    }
+}
diff --git a/bitcoin/src/p2p/mod.rs b/bitcoin/src/p2p/mod.rs
index 3a881193a8..040e2dfc4e 100644
--- a/bitcoin/src/p2p/mod.rs
+++ b/bitcoin/src/p2p/mod.rs
@@ -24,7 +24,7 @@ use core::str::FromStr;
 use core::{fmt, ops};
 
 use hex::FromHex;
-use internals::{debug_from_display, impl_to_hex_from_lower_hex, write_err};
+use internals::{impl_to_hex_from_lower_hex, write_err};
 use io::{BufRead, Write};
 
 use crate::consensus::encode::{self, Decodable, Encodable};
@@ -291,7 +291,12 @@ impl fmt::Display for Magic {
         Ok(())
     }
 }
-debug_from_display!(Magic);
+
+impl fmt::Debug for Magic {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        fmt::Display::fmt(self, f)
+    }
+}
 
 impl fmt::LowerHex for Magic {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
diff --git a/internals/src/macros.rs b/internals/src/macros.rs
index d0bad52d77..ef0addd6fc 100644
--- a/internals/src/macros.rs
+++ b/internals/src/macros.rs
@@ -2,21 +2,6 @@
 
 //! Various macros used by the Rust Bitcoin ecosystem.
 
-/// 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,
-            ) -> core::result::Result<(), core::fmt::Error> {
-                core::fmt::Display::fmt(self, f)
-            }
-        }
-    };
-}
-
 /// Asserts a boolean expression at compile time.
 #[macro_export]
 macro_rules! const_assert {
diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index bd922e22c0..d1ab77b735 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -9,8 +9,6 @@
 
 use core::fmt;
 
-use internals::debug_from_display;
-
 #[cfg(feature = "serde")]
 use crate::prelude::ToString;
 
@@ -441,7 +439,11 @@ impl From<u8> for Opcode {
     fn from(b: u8) -> Opcode { Opcode { code: b } }
 }
 
-debug_from_display!(Opcode);
+impl fmt::Debug for Opcode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        fmt::Display::fmt(self, f)
+    }
+}
 
 #[cfg(feature = "serde")]
 impl serde::Serialize for Opcode {

From 0d8e9ef096fd60fcdb7928697c8f554bf428b754 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 2 Jan 2025 07:51:21 +1100
Subject: [PATCH 177/554] Remove usage of impl_from_infallible in leaf crates

Rust macros, while at times useful, are a maintenance nightmare. And
we have been bitten by calling macros from other crates multiple times
in the past.

In a push to just use less macros remove the usage of the
`impl_from_infallible` macro in all the leaf crates and just write the
code.
---
 hashes/src/error.rs            | 25 +++++++------------------
 primitives/src/script/mod.rs   |  9 +++++++--
 primitives/src/transaction.rs  |  5 ++++-
 units/src/amount/error.rs      | 23 ++++++++++++++++++-----
 units/src/amount/mod.rs        |  5 ++++-
 units/src/locktime/absolute.rs |  5 ++++-
 units/src/parse.rs             | 19 +++++++++++++++----
 7 files changed, 59 insertions(+), 32 deletions(-)

diff --git a/hashes/src/error.rs b/hashes/src/error.rs
index bac9ba6492..ce2c82af2d 100644
--- a/hashes/src/error.rs
+++ b/hashes/src/error.rs
@@ -2,13 +2,16 @@
 
 //! Error code for the `hashes` crate.
 
+use core::convert::Infallible;
 use core::fmt;
 
 /// Attempted to create a hash from an invalid length slice.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FromSliceError(pub(crate) FromSliceErrorInner);
 
-impl_from_infallible!(FromSliceError);
+impl From<Infallible> for FromSliceError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl FromSliceError {
     /// Returns the expected slice length.
@@ -25,7 +28,9 @@ pub(crate) struct FromSliceErrorInner {
     pub(crate) got: usize,
 }
 
-impl_from_infallible!(FromSliceErrorInner);
+impl From<Infallible> for FromSliceErrorInner {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for FromSliceError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -35,19 +40,3 @@ impl fmt::Display for FromSliceError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for FromSliceError {}
-
-/// Derives `From<core::convert::Infallible>` for the given type.
-// This is a duplicate of `internals::impl_from_infallible`, see there for complete docs.
-#[doc(hidden)]
-macro_rules! impl_from_infallible {
-    ( $name:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? ) => {
-        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
-            From<core::convert::Infallible>
-        for $name
-            $(< $( $lt ),+ >)?
-        {
-            fn from(never: core::convert::Infallible) -> Self { match never {} }
-        }
-    }
-}
-pub(crate) use impl_from_infallible;
diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index 2045d01ebf..8c240ddc32 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -8,6 +8,7 @@ mod borrowed;
 mod owned;
 
 use core::cmp::Ordering;
+use core::convert::Infallible;
 use core::fmt;
 use core::ops::{Deref, DerefMut};
 
@@ -158,7 +159,9 @@ pub struct RedeemScriptSizeError {
     pub size: usize,
 }
 
-internals::impl_from_infallible!(RedeemScriptSizeError);
+impl From<Infallible> for RedeemScriptSizeError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for RedeemScriptSizeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -176,7 +179,9 @@ pub struct WitnessScriptSizeError {
     pub size: usize,
 }
 
-internals::impl_from_infallible!(WitnessScriptSizeError);
+impl From<Infallible> for WitnessScriptSizeError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for WitnessScriptSizeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 9b950da011..4424103f44 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -12,6 +12,7 @@
 
 #[cfg(feature = "alloc")]
 use core::cmp;
+use core::convert::Infallible;
 use core::fmt;
 
 #[cfg(feature = "arbitrary")]
@@ -444,7 +445,9 @@ pub enum ParseOutPointError {
 }
 
 #[cfg(feature = "alloc")]
-internals::impl_from_infallible!(ParseOutPointError);
+impl From<Infallible> for ParseOutPointError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 #[cfg(feature = "alloc")]
 impl fmt::Display for ParseOutPointError {
diff --git a/units/src/amount/error.rs b/units/src/amount/error.rs
index d90e70c5aa..62e03a3062 100644
--- a/units/src/amount/error.rs
+++ b/units/src/amount/error.rs
@@ -2,6 +2,7 @@
 
 //! Error types for bitcoin amounts.
 
+use core::convert::Infallible;
 use core::fmt;
 
 use internals::error::InputString;
@@ -23,8 +24,13 @@ pub(crate) enum ParseErrorInner {
     MissingDenomination(MissingDenominationError),
 }
 
-internals::impl_from_infallible!(ParseError);
-internals::impl_from_infallible!(ParseErrorInner);
+impl From<Infallible> for ParseError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<Infallible> for ParseErrorInner {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl From<ParseAmountError> for ParseError {
     fn from(e: ParseAmountError) -> Self { Self(ParseErrorInner::Amount(e)) }
@@ -114,8 +120,13 @@ impl From<InvalidCharacterError> for ParseAmountError {
     }
 }
 
-internals::impl_from_infallible!(ParseAmountError);
-internals::impl_from_infallible!(ParseAmountErrorInner);
+impl From<Infallible> for ParseAmountError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<Infallible> for ParseAmountErrorInner {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ParseAmountError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -318,7 +329,9 @@ pub enum ParseDenominationError {
     PossiblyConfusing(PossiblyConfusingDenominationError),
 }
 
-internals::impl_from_infallible!(ParseDenominationError);
+impl From<Infallible> for ParseDenominationError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ParseDenominationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index f340b90da7..79d2e7ec07 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -17,6 +17,7 @@ mod unsigned;
 mod verification;
 
 use core::cmp::Ordering;
+use core::convert::Infallible;
 use core::fmt;
 use core::str::FromStr;
 
@@ -292,7 +293,9 @@ enum InnerParseError {
     InvalidCharacter(InvalidCharacterError),
 }
 
-internals::impl_from_infallible!(InnerParseError);
+impl From<Infallible> for InnerParseError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl InnerParseError {
     fn convert(self, is_signed: bool) -> ParseAmountError {
diff --git a/units/src/locktime/absolute.rs b/units/src/locktime/absolute.rs
index 25de4f7971..966f6e129e 100644
--- a/units/src/locktime/absolute.rs
+++ b/units/src/locktime/absolute.rs
@@ -2,6 +2,7 @@
 
 //! Provides [`Height`] and [`Time`] types used by the `rust-bitcoin` `absolute::LockTime` type.
 
+use core::convert::Infallible;
 use core::fmt;
 
 #[cfg(feature = "arbitrary")]
@@ -307,7 +308,9 @@ enum ParseError {
     Conversion(i64),
 }
 
-internals::impl_from_infallible!(ParseError);
+impl From<Infallible> for ParseError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl ParseError {
     fn invalid_int<S: Into<InputString>>(s: S) -> impl FnOnce(core::num::ParseIntError) -> Self {
diff --git a/units/src/parse.rs b/units/src/parse.rs
index ec36d4b94b..6d3b156b63 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -2,6 +2,7 @@
 
 //! Parsing utilities.
 
+use core::convert::Infallible;
 use core::fmt;
 use core::str::FromStr;
 
@@ -313,8 +314,13 @@ enum PrefixedHexErrorInner {
     ParseInt(ParseIntError),
 }
 
-internals::impl_from_infallible!(PrefixedHexError);
-internals::impl_from_infallible!(PrefixedHexErrorInner);
+impl From<Infallible> for PrefixedHexError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<Infallible> for PrefixedHexErrorInner {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for PrefixedHexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -359,8 +365,13 @@ enum UnprefixedHexErrorInner {
     ParseInt(ParseIntError),
 }
 
-internals::impl_from_infallible!(UnprefixedHexError);
-internals::impl_from_infallible!(UnprefixedHexErrorInner);
+impl From<Infallible> for UnprefixedHexError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<Infallible> for UnprefixedHexErrorInner {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for UnprefixedHexError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

From 85e04315d5eb90075ce55bf18fab8876a4583def Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 2 Jan 2025 10:05:00 +1100
Subject: [PATCH 178/554] Remove test_ prefix from unit tests

There is a loose convention in Rust to not use `test_` prefix. The
reason being that `cargo test` outputs 'test <test name>' using the
prefix makes the output stutter.

This patch smells a bit like code-churn but having the prefix in some
places and not others is confusing to new contributors and is leading me
to explain this many times now. Lets just fix it.

Remove the prefix unless doing so breaks the code.
---
 base58/src/lib.rs                     |  6 ++--
 bitcoin/src/address/mod.rs            | 44 +++++++++++++--------------
 bitcoin/src/bip152.rs                 |  8 ++---
 bitcoin/src/bip158.rs                 |  6 ++--
 bitcoin/src/bip32.rs                  | 12 ++++----
 bitcoin/src/blockdata/block.rs        |  2 +-
 bitcoin/src/blockdata/script/tests.rs | 10 +++---
 bitcoin/src/blockdata/witness.rs      | 12 ++++----
 bitcoin/src/crypto/key.rs             |  8 ++---
 bitcoin/src/crypto/sighash.rs         | 16 +++++-----
 bitcoin/src/p2p/address.rs            |  2 +-
 bitcoin/src/psbt/mod.rs               |  6 ++--
 bitcoin/src/sign_message.rs           |  4 +--
 bitcoin/src/taproot/mod.rs            |  8 ++---
 chacha20_poly1305/src/chacha20.rs     | 12 ++++----
 chacha20_poly1305/src/lib.rs          |  2 +-
 chacha20_poly1305/src/poly1305.rs     |  2 +-
 hashes/src/hkdf.rs                    | 10 +++---
 hashes/src/siphash24.rs               |  2 +-
 primitives/src/block.rs               |  8 ++---
 units/src/amount/tests.rs             |  6 ++--
 units/tests/api.rs                    |  4 +--
 22 files changed, 95 insertions(+), 95 deletions(-)

diff --git a/base58/src/lib.rs b/base58/src/lib.rs
index df2c151039..312e9c5644 100644
--- a/base58/src/lib.rs
+++ b/base58/src/lib.rs
@@ -258,7 +258,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_base58_encode() {
+    fn base58_encode() {
         // Basics
         assert_eq!(&encode(&[0][..]), "1");
         assert_eq!(&encode(&[1][..]), "2");
@@ -287,7 +287,7 @@ mod tests {
     }
 
     #[test]
-    fn test_base58_decode() {
+    fn base58_decode() {
         // Basics
         assert_eq!(decode("1").ok(), Some(vec![0u8]));
         assert_eq!(decode("2").ok(), Some(vec![1u8]));
@@ -308,7 +308,7 @@ mod tests {
     }
 
     #[test]
-    fn test_base58_roundtrip() {
+    fn base58_roundtrip() {
         let s = "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs";
         let v: Vec<u8> = decode_check(s).unwrap();
         assert_eq!(encode_check(&v[..]), s);
diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 54118b95a2..50453e6bec 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -941,7 +941,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2pkh_address_58() {
+    fn p2pkh_address_58() {
         let hash = "162c5ea71c0b23f5b9022ef047c4a86470a5b070".parse::<PubkeyHash>().unwrap();
         let addr = Address::p2pkh(hash, NetworkKind::Main);
 
@@ -955,7 +955,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2pkh_from_key() {
+    fn p2pkh_from_key() {
         let key = "048d5141948c1702e8c95f438815794b87f706a8d4cd2bffad1dc1570971032c9b6042a0431ded2478b5c9cf2d81c124a5e57347a3c63ef0e7716cf54d613ba183".parse::<PublicKey>().unwrap();
         let addr = Address::p2pkh(key, NetworkKind::Main);
         assert_eq!(&addr.to_string(), "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY");
@@ -970,7 +970,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2sh_address_58() {
+    fn p2sh_address_58() {
         let hash = "162c5ea71c0b23f5b9022ef047c4a86470a5b070".parse::<ScriptHash>().unwrap();
         let addr = Address::p2sh_from_hash(hash, NetworkKind::Main);
 
@@ -984,7 +984,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2sh_parse() {
+    fn p2sh_parse() {
         let script = ScriptBuf::from_hex("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae").unwrap();
         let addr = Address::p2sh(&script, NetworkKind::Test).unwrap();
         assert_eq!(&addr.to_string(), "2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr");
@@ -993,7 +993,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2sh_parse_for_large_script() {
+    fn p2sh_parse_for_large_script() {
         let script = ScriptBuf::from_hex("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123").unwrap();
         assert_eq!(
             Address::p2sh(&script, NetworkKind::Test),
@@ -1002,7 +1002,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2wpkh() {
+    fn p2wpkh() {
         // stolen from Bitcoin transaction: b3c8c2b6cfc335abbcb2c7823a8453f55d64b2b5125a9a61e8737230cdb8ce20
         let key = "033bc8c83c52df5712229a2f72206d90192366c36428cb0c12b6af98324d97bfbc"
             .parse::<CompressedPublicKey>()
@@ -1014,7 +1014,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2wsh() {
+    fn p2wsh() {
         // stolen from Bitcoin transaction 5df912fda4becb1c29e928bec8d64d93e9ba8efa9b5b405bd683c86fd2c65667
         let script = ScriptBuf::from_hex("52210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae").unwrap();
         let addr = Address::p2wsh(&script, KnownHrp::Mainnet).expect("script is valid");
@@ -1027,7 +1027,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2shwpkh() {
+    fn p2shwpkh() {
         // stolen from Bitcoin transaction: ad3fd9c6b52e752ba21425435ff3dd361d6ac271531fc1d2144843a9f550ad01
         let key = "026c468be64d22761c30cd2f12cbc7de255d592d7904b1bab07236897cc4c2e766"
             .parse::<CompressedPublicKey>()
@@ -1039,7 +1039,7 @@ mod tests {
     }
 
     #[test]
-    fn test_p2shwsh() {
+    fn p2shwsh() {
         // stolen from Bitcoin transaction f9ee2be4df05041d0e0a35d7caa3157495ca4f93b233234c9967b6901dacf7a9
         let script = ScriptBuf::from_hex("522103e5529d8eaa3d559903adb2e881eb06c86ac2574ffa503c45f4e942e2a693b33e2102e5f10fcdcdbab211e0af6a481f5532536ec61a5fdbf7183770cf8680fe729d8152ae").unwrap();
         let addr = Address::p2shwsh(&script, NetworkKind::Main).expect("script is valid");
@@ -1049,7 +1049,7 @@ mod tests {
     }
 
     #[test]
-    fn test_non_existent_segwit_version() {
+    fn non_existent_segwit_version() {
         // 40-byte program
         let program = hex!(
             "654f6ea368e0acdfd92976b7c2103a1b26313f430654f6ea368e0acdfd92976b7c2103a1b26313f4"
@@ -1061,7 +1061,7 @@ mod tests {
     }
 
     #[test]
-    fn test_address_debug() {
+    fn 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)]
@@ -1085,7 +1085,7 @@ mod tests {
     }
 
     #[test]
-    fn test_address_type() {
+    fn address_type() {
         let addresses = [
             ("1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY", Some(AddressType::P2pkh)),
             ("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k", Some(AddressType::P2sh)),
@@ -1116,7 +1116,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "serde")]
-    fn test_json_serialize() {
+    fn json_serialize() {
         use serde_json;
 
         let addr =
@@ -1198,7 +1198,7 @@ mod tests {
     }
 
     #[test]
-    fn test_qr_string() {
+    fn qr_string() {
         for el in
             ["132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM", "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k"].iter()
         {
@@ -1238,7 +1238,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_related_to_pubkey_p2wpkh() {
+    fn is_related_to_pubkey_p2wpkh() {
         let address_string = "bc1qhvd6suvqzjcu9pxjhrwhtrlj85ny3n2mqql5w4";
         let address = address_string
             .parse::<Address<_>>()
@@ -1259,7 +1259,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_related_to_pubkey_p2shwpkh() {
+    fn is_related_to_pubkey_p2shwpkh() {
         let address_string = "3EZQk4F8GURH5sqVMLTFisD17yNeKa7Dfs";
         let address = address_string
             .parse::<Address<_>>()
@@ -1280,7 +1280,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_related_to_pubkey_p2pkh() {
+    fn is_related_to_pubkey_p2pkh() {
         let address_string = "1J4LVanjHMu3JkXbVrahNuQCTGCRRgfWWx";
         let address = address_string
             .parse::<Address<_>>()
@@ -1301,7 +1301,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_related_to_pubkey_p2pkh_uncompressed_key() {
+    fn is_related_to_pubkey_p2pkh_uncompressed_key() {
         let address_string = "msvS7KzhReCDpQEJaV2hmGNvuQqVUDuC6p";
         let address = address_string
             .parse::<Address<_>>()
@@ -1322,7 +1322,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_related_to_pubkey_p2tr() {
+    fn is_related_to_pubkey_p2tr() {
         let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
         let pubkey = pubkey_string.parse::<PublicKey>().expect("pubkey");
         let xonly_pubkey = XOnlyPublicKey::from(pubkey.inner);
@@ -1348,7 +1348,7 @@ mod tests {
     }
 
     #[test]
-    fn test_is_related_to_xonly_pubkey() {
+    fn is_related_to_xonly_pubkey() {
         let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
         let pubkey = pubkey_string.parse::<PublicKey>().expect("pubkey");
         let xonly_pubkey = XOnlyPublicKey::from(pubkey.inner);
@@ -1369,7 +1369,7 @@ mod tests {
     }
 
     #[test]
-    fn test_fail_address_from_script() {
+    fn fail_address_from_script() {
         use crate::witness_program;
 
         let bad_p2wpkh = ScriptBuf::from_hex("0014dbc5b0a8f9d4353b4b54c3db48846bb15abfec").unwrap();
@@ -1403,7 +1403,7 @@ mod tests {
     }
 
     #[test]
-    fn test_matches_script_pubkey() {
+    fn matches_script_pubkey() {
         let addresses = [
             "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY",
             "1J4LVanjHMu3JkXbVrahNuQCTGCRRgfWWx",
diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs
index 7fcfe38fca..e515e3281b 100644
--- a/bitcoin/src/bip152.rs
+++ b/bitcoin/src/bip152.rs
@@ -443,7 +443,7 @@ mod test {
     }
 
     #[test]
-    fn test_header_and_short_ids_from_block() {
+    fn header_and_short_ids_from_block() {
         let block = dummy_block();
 
         let compact = HeaderAndShortIds::from_block(&block, 42, 2, &[]).unwrap();
@@ -463,7 +463,7 @@ mod test {
     }
 
     #[test]
-    fn test_compact_block_vector() {
+    fn 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();
@@ -478,7 +478,7 @@ mod test {
     }
 
     #[test]
-    fn test_getblocktx_differential_encoding_de_and_serialization() {
+    fn getblocktx_differential_encoding_de_and_serialization() {
         let testcases = vec![
             // differentially encoded VarInts, indicies
             (vec![4, 0, 5, 1, 10], vec![0, 6, 8, 19]),
@@ -523,7 +523,7 @@ mod test {
     #[test]
     #[cfg(debug_assertions)]
     #[should_panic] // 'attempt to add with overflow' in consensus_encode()
-    fn test_getblocktx_panic_when_encoding_u64_max() {
+    fn getblocktx_panic_when_encoding_u64_max() {
         serialize(&BlockTransactionsRequest {
             block_hash: BlockHash::from_byte_array([0; 32]),
             indexes: vec![u64::MAX],
diff --git a/bitcoin/src/bip158.rs b/bitcoin/src/bip158.rs
index 8a9188a2ce..8af3cd7846 100644
--- a/bitcoin/src/bip158.rs
+++ b/bitcoin/src/bip158.rs
@@ -582,7 +582,7 @@ mod test {
     use crate::ScriptBuf;
 
     #[test]
-    fn test_blockfilters() {
+    fn blockfilters() {
         // test vectors from: https://github.com/jimpo/bitcoin/blob/c7efb652f3543b001b4dd22186a354605b14f47e/src/test/data/blockfilters.json
         let data = include_str!("../tests/data/blockfilters.json");
 
@@ -649,7 +649,7 @@ mod test {
     }
 
     #[test]
-    fn test_filter() {
+    fn filter() {
         let mut patterns = BTreeSet::new();
 
         patterns.insert(hex!("000000"));
@@ -718,7 +718,7 @@ mod test {
     }
 
     #[test]
-    fn test_bit_stream() {
+    fn bit_stream() {
         let mut out = Vec::new();
         {
             let mut writer = BitStreamWriter::new(&mut out);
diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index e65195b085..885c500d50 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -974,7 +974,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_parse_derivation_path() {
+    fn parse_derivation_path() {
         assert_eq!("n/0'/0".parse::<DerivationPath>(), Err(Error::InvalidChildNumberFormat));
         assert_eq!("4/m/5".parse::<DerivationPath>(), Err(Error::InvalidChildNumberFormat));
         assert_eq!("//3/0'".parse::<DerivationPath>(), Err(Error::InvalidChildNumberFormat));
@@ -1036,7 +1036,7 @@ mod tests {
     }
 
     #[test]
-    fn test_derivation_path_conversion_index() {
+    fn derivation_path_conversion_index() {
         let path = "0h/1/2'".parse::<DerivationPath>().unwrap();
         let numbers: Vec<ChildNumber> = path.clone().into();
         let path2: DerivationPath = numbers.into();
@@ -1096,7 +1096,7 @@ mod tests {
     }
 
     #[test]
-    fn test_increment() {
+    fn 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()));
@@ -1139,7 +1139,7 @@ mod tests {
     }
 
     #[test]
-    fn test_vector_1() {
+    fn vector_1() {
         let secp = Secp256k1::new();
         let seed = hex!("000102030405060708090a0b0c0d0e0f");
 
@@ -1175,7 +1175,7 @@ mod tests {
     }
 
     #[test]
-    fn test_vector_2() {
+    fn vector_2() {
         let secp = Secp256k1::new();
         let seed = hex!("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542");
 
@@ -1211,7 +1211,7 @@ mod tests {
     }
 
     #[test]
-    fn test_vector_3() {
+    fn vector_3() {
         let secp = Secp256k1::new();
         let seed = hex!("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be");
 
diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs
index f83cb413e7..d32e742131 100644
--- a/bitcoin/src/blockdata/block.rs
+++ b/bitcoin/src/blockdata/block.rs
@@ -508,7 +508,7 @@ mod tests {
     }
 
     #[test]
-    fn test_coinbase_and_bip34() {
+    fn coinbase_and_bip34() {
         // testnet block 100,000
         const BLOCK_HEX: &str = "0200000035ab154183570282ce9afc0b494c9fc6a3cfea05aa8c1add2ecc56490000000038ba3d78e4500a5a7570dbe61960398add4410d278b21cd9708e6d9743f374d544fc055227f1001c29c1ea3b0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff3703a08601000427f1001c046a510100522cfabe6d6d0000000000000000000068692066726f6d20706f6f6c7365727665726aac1eeeed88ffffffff0100f2052a010000001976a914912e2b234f941f30b18afbb4fa46171214bf66c888ac00000000";
         let block: Block = deserialize(&hex!(BLOCK_HEX)).unwrap();
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index fbe26348ac..38577db866 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -591,7 +591,7 @@ macro_rules! unwrap_all {
 }
 
 #[test]
-fn test_iterator() {
+fn iterator() {
     let zero = ScriptBuf::from_hex("00").unwrap();
     let zeropush = ScriptBuf::from_hex("0100").unwrap();
 
@@ -669,7 +669,7 @@ fn script_ord() {
 
 #[test]
 #[cfg(feature = "bitcoinconsensus")]
-fn test_bitcoinconsensus() {
+fn bitcoinconsensus() {
     use crate::consensus_validation::ScriptExt as _;
 
     // a random SegWit transaction from the blockchain using native SegWit
@@ -707,7 +707,7 @@ fn default_dust_value() {
 }
 
 #[test]
-fn test_script_get_sigop_count() {
+fn script_get_sigop_count() {
     assert_eq!(
         Builder::new()
             .push_opcode(OP_DUP)
@@ -784,7 +784,7 @@ fn test_script_get_sigop_count() {
 
 #[test]
 #[cfg(feature = "serde")]
-fn test_script_serde_human_and_not() {
+fn script_serde_human_and_not() {
     let script = ScriptBuf::from(vec![0u8, 1u8, 2u8]);
 
     // Serialize
@@ -799,7 +799,7 @@ fn test_script_serde_human_and_not() {
 }
 
 #[test]
-fn test_instructions_are_fused() {
+fn instructions_are_fused() {
     let script = ScriptBuf::new();
     let mut instructions = script.instructions();
     assert!(instructions.next().is_none());
diff --git a/bitcoin/src/blockdata/witness.rs b/bitcoin/src/blockdata/witness.rs
index 318baaf508..d6b67a7381 100644
--- a/bitcoin/src/blockdata/witness.rs
+++ b/bitcoin/src/blockdata/witness.rs
@@ -246,7 +246,7 @@ mod test {
     }
 
     #[test]
-    fn test_push_ecdsa_sig() {
+    fn push_ecdsa_sig() {
         // The very first signature in block 734,958
         let sig_bytes =
             hex!("304402207c800d698f4b0298c5aac830b822f011bb02df41eb114ade9a6702f364d5e39c0220366900d2a60cab903e77ef7dd415d46509b1f78ac78906e3296f495aa1b1b541");
@@ -286,7 +286,7 @@ mod test {
     }
 
     #[test]
-    fn test_get_tapscript() {
+    fn get_tapscript() {
         let tapscript = hex!("deadbeef");
         let control_block = hex!("02");
         // annex starting with 0x50 causes the branching logic.
@@ -307,7 +307,7 @@ mod test {
     }
 
     #[test]
-    fn test_get_tapscript_from_keypath() {
+    fn get_tapscript_from_keypath() {
         let signature = hex!("deadbeef");
         // annex starting with 0x50 causes the branching logic.
         let annex = hex!("50");
@@ -327,7 +327,7 @@ mod test {
     }
 
     #[test]
-    fn test_get_control_block() {
+    fn get_control_block() {
         let tapscript = hex!("deadbeef");
         let control_block = hex!("02");
         // annex starting with 0x50 causes the branching logic.
@@ -348,7 +348,7 @@ mod test {
     }
 
     #[test]
-    fn test_get_annex() {
+    fn get_annex() {
         let tapscript = hex!("deadbeef");
         let control_block = hex!("02");
         // annex starting with 0x50 causes the branching logic.
@@ -387,7 +387,7 @@ mod test {
     }
 
     #[test]
-    fn test_tx() {
+    fn tx() {
         const S: &str = "02000000000102b44f26b275b8ad7b81146ba3dbecd081f9c1ea0dc05b97516f56045cfcd3df030100000000ffffffff1cb4749ae827c0b75f3d0a31e63efc8c71b47b5e3634a4c698cd53661cab09170100000000ffffffff020b3a0500000000001976a9143ea74de92762212c96f4dd66c4d72a4deb20b75788ac630500000000000016001493a8dfd1f0b6a600ab01df52b138cda0b82bb7080248304502210084622878c94f4c356ce49c8e33a063ec90f6ee9c0208540888cfab056cd1fca9022014e8dbfdfa46d318c6887afd92dcfa54510e057565e091d64d2ee3a66488f82c0121026e181ffb98ebfe5a64c983073398ea4bcd1548e7b971b4c175346a25a1c12e950247304402203ef00489a0d549114977df2820fab02df75bebb374f5eee9e615107121658cfa02204751f2d1784f8e841bff6d3bcf2396af2f1a5537c0e4397224873fbd3bfbe9cf012102ae6aa498ce2dd204e9180e71b4fb1260fe3d1a95c8025b34e56a9adf5f278af200000000";
         let tx_bytes = hex!(S);
         let tx: Transaction = deserialize(&tx_bytes).unwrap();
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 559df1dc1d..c6900f046c 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -1157,7 +1157,7 @@ mod tests {
     use crate::address::Address;
 
     #[test]
-    fn test_key_derivation() {
+    fn key_derivation() {
         // testnet compressed
         let sk =
             PrivateKey::from_wif("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();
@@ -1204,7 +1204,7 @@ mod tests {
     }
 
     #[test]
-    fn test_pubkey_hash() {
+    fn pubkey_hash() {
         let pk = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"
             .parse::<PublicKey>()
             .unwrap();
@@ -1215,7 +1215,7 @@ mod tests {
     }
 
     #[test]
-    fn test_wpubkey_hash() {
+    fn wpubkey_hash() {
         let pk = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"
             .parse::<PublicKey>()
             .unwrap();
@@ -1229,7 +1229,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "serde")]
-    fn test_key_serde() {
+    fn skey_serde() {
         use serde_test::{assert_tokens, Configure, Token};
 
         static KEY_WIF: &str = "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy";
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index abc8df43e5..808b64cafb 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1586,7 +1586,7 @@ mod tests {
     }
 
     #[test]
-    fn test_tap_sighash_hash() {
+    fn tap_sighash_hash() {
         let bytes = hex!("00011b96877db45ffa23b307e9f0ac87b80ef9a80b4c5f0db3fbe734422453e83cc5576f3d542c5d4898fb2b696c15d43332534a7c1d1255fda38993545882df92c3e353ff6d36fbfadc4d168452afd8467f02fe53d71714fcea5dfe2ea759bd00185c4cb02bc76d42620393ca358a1a713f4997f9fc222911890afb3fe56c6a19b202df7bffdcfad08003821294279043746631b00e2dc5e52a111e213bbfe6ef09a19428d418dab0d50000000000");
         let expected = hex!("04e808aad07a40b3767a1442fead79af6ef7e7c9316d82dec409bb31e77699b0");
         let mut enc = sha256t::Hash::<TapSighashTag>::engine();
@@ -1596,7 +1596,7 @@ mod tests {
     }
 
     #[test]
-    fn test_sighashes_keyspending() {
+    fn sighashes_keyspending() {
         // following test case has been taken from Bitcoin Core test framework
 
         test_taproot_sighash(
@@ -1657,7 +1657,7 @@ mod tests {
     }
 
     #[test]
-    fn test_sighashes_with_annex() {
+    fn sighashes_with_annex() {
         test_taproot_sighash(
             "0200000001df8123752e8f37d132c4e9f1ff7e4f9b986ade9211267e9ebd5fd22a5e718dec6d01000000ce4023b903cb7b23000000000017a914a18b36ea7a094db2f4940fc09edf154e86de7bd787580200000000000017a914afd0d512a2c5c2b40e25669e9cc460303c325b8b87580200000000000017a914a18b36ea7a094db2f4940fc09edf154e86de7bd787f6020000",
             "01ea49260000000000225120ab5e9800806bf18cb246edcf5fe63441208fe955a4b5a35bbff65f5db622a010",
@@ -1671,7 +1671,7 @@ mod tests {
     }
 
     #[test]
-    fn test_sighashes_with_script_path() {
+    fn sighashes_with_script_path() {
         test_taproot_sighash(
             "020000000189fc651483f9296b906455dd939813bf086b1bbe7c77635e157c8e14ae29062195010000004445b5c7044561320000000000160014331414dbdada7fb578f700f38fb69995fc9b5ab958020000000000001976a914268db0a8104cc6d8afd91233cc8b3d1ace8ac3ef88ac580200000000000017a914ec00dcb368d6a693e11986d265f659d2f59e8be2875802000000000000160014c715799a49a0bae3956df9c17cb4440a673ac0df6f010000",
             "011bec34000000000022512028055142ea437db73382e991861446040b61dd2185c4891d7daf6893d79f7182",
@@ -1685,7 +1685,7 @@ mod tests {
     }
 
     #[test]
-    fn test_sighashes_with_script_path_raw_hash() {
+    fn sighashes_with_script_path_raw_hash() {
         test_taproot_sighash(
             "020000000189fc651483f9296b906455dd939813bf086b1bbe7c77635e157c8e14ae29062195010000004445b5c7044561320000000000160014331414dbdada7fb578f700f38fb69995fc9b5ab958020000000000001976a914268db0a8104cc6d8afd91233cc8b3d1ace8ac3ef88ac580200000000000017a914ec00dcb368d6a693e11986d265f659d2f59e8be2875802000000000000160014c715799a49a0bae3956df9c17cb4440a673ac0df6f010000",
             "011bec34000000000022512028055142ea437db73382e991861446040b61dd2185c4891d7daf6893d79f7182",
@@ -1699,7 +1699,7 @@ mod tests {
     }
 
     #[test]
-    fn test_sighashes_with_annex_and_script() {
+    fn sighashes_with_annex_and_script() {
         test_taproot_sighash(
             "020000000132fb72cb8fba496755f027a9743e2d698c831fdb8304e4d1a346ac92cbf51acba50100000026bdc7df044aad34000000000017a9144fa2554ed6174586854fa3bc01de58dcf33567d0875802000000000000160014950367e1e62cdf240b35b883fc2f5e39f0eb9ab95802000000000000160014950367e1e62cdf240b35b883fc2f5e39f0eb9ab958020000000000001600141b31217d48ccc8760dcc0710fade5866d628e733a02d5122",
             "011458360000000000225120a7baec3fb9f84614e3899fcc010c638f80f13539344120e1f4d8b68a9a011a13",
@@ -1714,7 +1714,7 @@ mod tests {
 
     #[test]
     #[rustfmt::skip] // Allow long function call `taproot_signature_hash`.
-    fn test_sighash_errors() {
+    fn sighash_errors() {
         use crate::transaction::{IndexOutOfBoundsError, InputsIndexError};
 
         let dumb_tx = Transaction {
@@ -1773,7 +1773,7 @@ mod tests {
     }
 
     #[test]
-    fn test_annex_errors() {
+    fn annex_errors() {
         assert_eq!(Annex::new(&[]), Err(AnnexError::Empty));
         assert_eq!(Annex::new(&[0x51]), Err(AnnexError::IncorrectPrefix(0x51)));
         assert_eq!(Annex::new(&[0x51, 0x50]), Err(AnnexError::IncorrectPrefix(0x51)));
diff --git a/bitcoin/src/p2p/address.rs b/bitcoin/src/p2p/address.rs
index d761d95437..accb7cc345 100644
--- a/bitcoin/src/p2p/address.rs
+++ b/bitcoin/src/p2p/address.rs
@@ -363,7 +363,7 @@ mod test {
     }
 
     #[test]
-    fn test_socket_addr() {
+    fn socket_addr() {
         let s4 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(111, 222, 123, 4)), 5555);
         let a4 = Address::new(&s4, ServiceFlags::NETWORK | ServiceFlags::WITNESS);
         assert_eq!(a4.socket_addr().unwrap(), s4);
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 098e853e21..370bd61bfc 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -1461,7 +1461,7 @@ mod tests {
 
     #[cfg(feature = "serde")]
     #[test]
-    fn test_serde_psbt() {
+    fn serde_psbt() {
         //! Create a full PSBT value with various fields filled and make sure it can be JSONized.
         use hashes::sha256d;
 
@@ -2118,7 +2118,7 @@ mod tests {
 
     // https://github.com/rust-bitcoin/rust-bitcoin/issues/3628
     #[test]
-    fn test_combine_psbt_fuzz_3628() {
+    fn combine_psbt_fuzz_3628() {
         let mut psbt1 = hex_psbt(include_str!("../../tests/data/psbt_fuzz1.hex")).unwrap();
         let psbt2 = hex_psbt(include_str!("../../tests/data/psbt_fuzz2.hex")).unwrap();
 
@@ -2154,7 +2154,7 @@ mod tests {
     }
 
     #[test]
-    fn test_fee() {
+    fn fee() {
         let output_0_val = Amount::from_sat(99_999_699);
         let output_1_val = Amount::from_sat(100_000_000);
         let prev_output_val = Amount::from_sat(200_000_000);
diff --git a/bitcoin/src/sign_message.rs b/bitcoin/src/sign_message.rs
index bbc2b44de9..b931757789 100644
--- a/bitcoin/src/sign_message.rs
+++ b/bitcoin/src/sign_message.rs
@@ -240,7 +240,7 @@ mod tests {
 
     #[test]
     #[cfg(all(feature = "secp-recovery", feature = "base64", feature = "rand-std"))]
-    fn test_message_signature() {
+    fn message_signature() {
         use secp256k1;
 
         use crate::{Address, AddressType, Network, NetworkKind};
@@ -286,7 +286,7 @@ mod tests {
 
     #[test]
     #[cfg(all(feature = "secp-recovery", feature = "base64"))]
-    fn test_incorrect_message_signature() {
+    fn incorrect_message_signature() {
         use base64::prelude::{Engine as _, BASE64_STANDARD};
         use secp256k1;
 
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 88a6f1c556..ca5cbe1157 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -1572,7 +1572,7 @@ mod test {
     }
 
     #[test]
-    fn test_midstates() {
+    fn midstates() {
         use sha256t::Hash;
         // test that engine creation roundtrips
         assert_eq!(tag_engine("TapLeaf").midstate(), TapLeafTag::engine().midstate());
@@ -1593,7 +1593,7 @@ mod test {
     }
 
     #[test]
-    fn test_vectors_core() {
+    fn vectors_core() {
         //! Test vectors taken from Core
         use sha256t::Hash;
 
@@ -1840,7 +1840,7 @@ mod test {
 
     #[test]
     #[cfg(feature = "serde")]
-    fn test_leaf_version_serde() {
+    fn leaf_version_serde() {
         let leaf_version = LeafVersion::TapScript;
         // use serde_test to test serialization and deserialization
         assert_tokens(&leaf_version, &[Token::U8(192)]);
@@ -1852,7 +1852,7 @@ mod test {
 
     #[test]
     #[cfg(feature = "serde")]
-    fn test_merkle_branch_serde() {
+    fn merkle_branch_serde() {
         let hash1 = TapNodeHash::from_byte_array(
             "03ba2a4dcd914fed29a1c630c7e811271b081a0e2f2f52cf1c197583dfd46c1b"
                 .parse::<sha256t::Hash<TapBranchTag>>()
diff --git a/chacha20_poly1305/src/chacha20.rs b/chacha20_poly1305/src/chacha20.rs
index 0a73ca368e..bf0013192f 100644
--- a/chacha20_poly1305/src/chacha20.rs
+++ b/chacha20_poly1305/src/chacha20.rs
@@ -333,7 +333,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_chacha_block() {
+    fn chacha_block() {
         let mut state = State {
             matrix: [
                 U32x4([0x61707865, 0x3320646e, 0x79622d32, 0x6b206574]),
@@ -357,7 +357,7 @@ mod tests {
     }
 
     #[test]
-    fn test_prepare_state() {
+    fn prepare_state() {
         let key =
             Key(Vec::from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
                 .unwrap()
@@ -374,7 +374,7 @@ mod tests {
     }
 
     #[test]
-    fn test_small_plaintext() {
+    fn small_plaintext() {
         let key =
             Key(Vec::from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
                 .unwrap()
@@ -391,7 +391,7 @@ mod tests {
     }
 
     #[test]
-    fn test_modulo_64() {
+    fn modulo_64() {
         let key =
             Key(Vec::from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
                 .unwrap()
@@ -408,7 +408,7 @@ mod tests {
     }
 
     #[test]
-    fn test_rfc_standard() {
+    fn rfc_standard() {
         let key =
             Key(Vec::from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
                 .unwrap()
@@ -428,7 +428,7 @@ mod tests {
     }
 
     #[test]
-    fn test_new_from_block() {
+    fn new_from_block() {
         let key =
             Key(Vec::from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
                 .unwrap()
diff --git a/chacha20_poly1305/src/lib.rs b/chacha20_poly1305/src/lib.rs
index 330f5389e8..3058913ae4 100644
--- a/chacha20_poly1305/src/lib.rs
+++ b/chacha20_poly1305/src/lib.rs
@@ -165,7 +165,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_rfc7539() {
+    fn rfc7539() {
         let mut message = *b"Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.";
         let aad = Vec::from_hex("50515253c0c1c2c3c4c5c6c7").unwrap();
         let key = Key::new(
diff --git a/chacha20_poly1305/src/poly1305.rs b/chacha20_poly1305/src/poly1305.rs
index 39e4e7a83c..a064feb7ec 100644
--- a/chacha20_poly1305/src/poly1305.rs
+++ b/chacha20_poly1305/src/poly1305.rs
@@ -230,7 +230,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_rfc7539() {
+    fn rfc7539() {
         let key = Vec::from_hex("85d6be7857556d337f4452fe42d506a80103808afb0db2fd4abff6af4149f51b")
             .unwrap()
             .as_slice()
diff --git a/hashes/src/hkdf.rs b/hashes/src/hkdf.rs
index cfe641f690..f9f027857c 100644
--- a/hashes/src/hkdf.rs
+++ b/hashes/src/hkdf.rs
@@ -114,7 +114,7 @@ mod tests {
     use crate::sha256;
 
     #[test]
-    fn test_rfc5869_basic() {
+    fn rfc5869_basic() {
         let salt = Vec::from_hex("000102030405060708090a0b0c").unwrap();
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
         let info = Vec::from_hex("f0f1f2f3f4f5f6f7f8f9").unwrap();
@@ -130,7 +130,7 @@ mod tests {
     }
 
     #[test]
-    fn test_rfc5869_longer_inputs_outputs() {
+    fn rfc5869_longer_inputs_outputs() {
         let salt = Vec::from_hex(
             "606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
         ).unwrap();
@@ -152,7 +152,7 @@ mod tests {
     }
 
     #[test]
-    fn test_too_long_okm() {
+    fn too_long_okm() {
         let salt = Vec::from_hex("000102030405060708090a0b0c").unwrap();
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
         let info = Vec::from_hex("f0f1f2f3f4f5f6f7f8f9").unwrap();
@@ -165,7 +165,7 @@ mod tests {
     }
 
     #[test]
-    fn test_short_okm() {
+    fn short_okm() {
         let salt = Vec::from_hex("000102030405060708090a0b0c").unwrap();
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
         let info = Vec::from_hex("f0f1f2f3f4f5f6f7f8f9").unwrap();
@@ -178,7 +178,7 @@ mod tests {
     }
 
     #[test]
-    fn test_alloc_wrapper() {
+    fn alloc_wrapper() {
         let salt = Vec::from_hex("000102030405060708090a0b0c").unwrap();
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
         let info = Vec::from_hex("f0f1f2f3f4f5f6f7f8f9").unwrap();
diff --git a/hashes/src/siphash24.rs b/hashes/src/siphash24.rs
index b751604b64..5781e52ffd 100644
--- a/hashes/src/siphash24.rs
+++ b/hashes/src/siphash24.rs
@@ -242,7 +242,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_siphash_2_4() {
+    fn siphash_2_4() {
         #[rustfmt::skip]
         let vecs: [[u8; 8]; 64] = [
             [0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72],
diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index 7736fcf8f0..cfc322c15f 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -348,27 +348,27 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_version_is_not_signalling_with_invalid_bit() {
+    fn version_is_not_signalling_with_invalid_bit() {
         let arbitrary_version = Version::from_consensus(1234567890);
         // The max bit number to signal is 28.
         assert!(!Version::is_signalling_soft_fork(&arbitrary_version, 29));
     }
 
     #[test]
-    fn test_version_is_not_signalling_when_use_version_bit_not_set() {
+    fn version_is_not_signalling_when_use_version_bit_not_set() {
         let version = Version::from_consensus(0b01000000000000000000000000000000);
         // Top three bits must be 001 to signal.
         assert!(!Version::is_signalling_soft_fork(&version, 1));
     }
 
     #[test]
-    fn test_version_is_signalling() {
+    fn version_is_signalling() {
         let version = Version::from_consensus(0b00100000000000000000000000000010);
         assert!(Version::is_signalling_soft_fork(&version, 1));
     }
 
     #[test]
-    fn test_version_is_not_signalling() {
+    fn version_is_not_signalling() {
         let version = Version::from_consensus(0b00100000000000000000000000000010);
         assert!(!Version::is_signalling_soft_fork(&version, 0));
     }
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index a5626c24c1..4f85f1347d 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -72,7 +72,7 @@ fn from_int_btc() {
 }
 
 #[test]
-fn test_amount_try_from_signed_amount() {
+fn amount_try_from_signed_amount() {
     let sa_positive = SignedAmount::from_sat_unchecked(123);
     let ua_positive = Amount::try_from(sa_positive).unwrap();
     assert_eq!(ua_positive, Amount::from_sat_unchecked(123));
@@ -103,7 +103,7 @@ fn mul_div() {
 
 #[cfg(feature = "std")]
 #[test]
-fn test_overflows() {
+fn overflows() {
     // panic on overflow
     let result = panic::catch_unwind(|| Amount::MAX + Amount::from_sat_unchecked(1));
     assert!(result.is_err());
@@ -461,7 +461,7 @@ check_format_non_negative_show_denom! {
 }
 
 #[test]
-fn test_unsigned_signed_conversion() {
+fn unsigned_signed_conversion() {
     let sa = SignedAmount::from_sat;
     let ua = Amount::from_sat;
     let max_sats: u64 = Amount::MAX.to_sat();
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 3737808331..6dc8891d6d 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -231,14 +231,14 @@ fn api_all_non_error_types_have_non_empty_debug() {
 }
 
 #[test]
-fn test_send() {
+fn send() {
     fn assert_send<T: Send>() {}
     assert_send::<Types>();
     assert_send::<Errors>();
 }
 
 #[test]
-fn test_sync() {
+fn sync() {
     fn assert_sync<T: Sync>() {}
     assert_sync::<Types>();
     assert_sync::<Errors>();

From 945fcd09209120ef8869a2e4165e866328cc9bd5 Mon Sep 17 00:00:00 2001
From: Innocent Onyemaenu <rockcoolsaint@gmail.com>
Date: Wed, 1 Jan 2025 22:26:26 +0100
Subject: [PATCH 179/554] fix ParsePublicKeyError using hex::InvalidCharError

What:
- Replaced the InvalidChar variant u8 with hex::InvalidCharError

Why:
- hex::InvalidCharError includes both the invalid character and its position.
- This improves debugging and makes error messages more actionable.
---
 bitcoin/src/crypto/key.rs | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 559df1dc1d..e81828e05a 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -241,14 +241,14 @@ impl FromStr for PublicKey {
         match s.len() {
             66 => {
                 let bytes = <[u8; 33]>::from_hex(s).map_err(|e| match e {
-                    InvalidChar(e) => ParsePublicKeyError::InvalidChar(e.invalid_char()),
+                    InvalidChar(e) => ParsePublicKeyError::InvalidChar(e),
                     InvalidLength(_) => unreachable!("length checked already"),
                 })?;
                 Ok(PublicKey::from_slice(&bytes)?)
             }
             130 => {
                 let bytes = <[u8; 65]>::from_hex(s).map_err(|e| match e {
-                    InvalidChar(e) => ParsePublicKeyError::InvalidChar(e.invalid_char()),
+                    InvalidChar(e) => ParsePublicKeyError::InvalidChar(e),
                     InvalidLength(_) => unreachable!("length checked already"),
                 })?;
                 Ok(PublicKey::from_slice(&bytes)?)
@@ -1017,7 +1017,7 @@ pub enum ParsePublicKeyError {
     /// Error originated while parsing string.
     Encoding(FromSliceError),
     /// Hex decoding error.
-    InvalidChar(u8),
+    InvalidChar(hex::InvalidCharError),
     /// `PublicKey` hex should be 66 or 130 digits long.
     InvalidHexLength(usize),
 }
@@ -1520,12 +1520,22 @@ mod tests {
         assert_eq!(s.len(), 130);
         let res = s.parse::<PublicKey>();
         assert!(res.is_err());
-        assert_eq!(res.unwrap_err(), ParsePublicKeyError::InvalidChar(103));
+        if let Err(ParsePublicKeyError::InvalidChar(err)) = res {
+            assert_eq!(err.invalid_char(), b'g');
+            assert_eq!(err.pos(), 129);
+        } else {
+            panic!("Expected Invalid char error");
+        }
 
         let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1ag";
         assert_eq!(s.len(), 66);
         let res = s.parse::<PublicKey>();
         assert!(res.is_err());
-        assert_eq!(res.unwrap_err(), ParsePublicKeyError::InvalidChar(103));
+        if let Err(ParsePublicKeyError::InvalidChar(err)) = res {
+            assert_eq!(err.invalid_char(), b'g');
+            assert_eq!(err.pos(), 65);
+        } else {
+            panic!("Expected Invalid char error");
+        }
     }
 }

From d5de89259b64ed6d4756973073f06172d1d14090 Mon Sep 17 00:00:00 2001
From: Jesus Christ <120573631+Gudnessuche@users.noreply.github.com>
Date: Fri, 3 Jan 2025 21:00:13 +0000
Subject: [PATCH 180/554] Fix typo in MerkleBlock::from_block_with_predicate
 comment

- Corrected a grammatical error by adding "are" to the comment in MerkleBlock::from_block_with_predicate.
---
 bitcoin/src/merkle_tree/block.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/merkle_tree/block.rs b/bitcoin/src/merkle_tree/block.rs
index 4410c8a942..74b2b6c745 100644
--- a/bitcoin/src/merkle_tree/block.rs
+++ b/bitcoin/src/merkle_tree/block.rs
@@ -146,7 +146,7 @@ impl Decodable for MerkleBlock {
 /// 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.
+/// hashes as they are written during encoding.
 ///
 /// The serialization is fixed and provides a hard guarantee about the
 /// encoded size:

From ab8017d6b38e4890a580de9f4667da90055dad98 Mon Sep 17 00:00:00 2001
From: Update cargo-semver-checks Bot <bot@example.com>
Date: Sat, 4 Jan 2025 01:04:22 +0000
Subject: [PATCH 181/554] Automated update to Github CI to cargo-semver-checks
 version-0.38.0

---
 .github/workflows/cargo-semver-checks-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/cargo-semver-checks-version b/.github/workflows/cargo-semver-checks-version
index 0f1a7dfc7c..ca75280b09 100644
--- a/.github/workflows/cargo-semver-checks-version
+++ b/.github/workflows/cargo-semver-checks-version
@@ -1 +1 @@
-0.37.0
+0.38.0

From 286bf900b1c100d2f5d0a0d45f31a5bf5a0a26ce Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Mon, 30 Dec 2024 09:18:05 -0600
Subject: [PATCH 182/554] Address mutants in units

Preemptively addressing these mutants before introducing the
cargo-mutants workflow

There are several types of changes:
- Changes that address mutants that were actually missing
- Changes that address test values that cause `cargo-mutants` to think
  mutants were missed. For example, `cargo-mutants` will replace the
return values for unsigned integer types with 0 and 1. While a function
might be tested, the test might be testing the function with a call that
results in 0 or 1. When `cargo-mutants` substitutes the function call
with `Ok(1)`, the test will still pass, and it will consider this a
mutant.  `cargo-mutants` also replaces operations (+, -, /, %), bitwise
operations (&, |, ^, etc), so an operation such as `3 - 2` results in a
mutant because changing it to `3 / 2` yields the same result
- TODOs to ignore functions/impls in the future
---
 units/src/amount/mod.rs        |  1 +
 units/src/amount/serde.rs      |  6 +++
 units/src/amount/tests.rs      | 63 ++++++++++++++++++++++++
 units/src/block.rs             | 31 ++++++++++--
 units/src/fee_rate/mod.rs      | 60 ++++++++++++++++++-----
 units/src/locktime/absolute.rs |  9 ++++
 units/src/locktime/relative.rs |  9 ++++
 units/src/parse.rs             | 88 +++++++++++++++++++++++++++++++++-
 units/src/weight.rs            | 58 ++++++++++++++++++----
 9 files changed, 298 insertions(+), 27 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 79d2e7ec07..2c7f59f2b6 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -285,6 +285,7 @@ fn parse_signed_to_satoshi(
     Ok((is_negative, value))
 }
 
+#[derive(Debug)]
 enum InnerParseError {
     Overflow { is_negative: bool },
     TooPrecise(TooPreciseError),
diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index 7eb35f6e42..f022ba1594 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -390,6 +390,12 @@ pub mod as_str {
 mod tests {
     use super::*;
 
+    #[test]
+    fn sanity_check() {
+        assert_eq!(Amount::type_prefix(private::Token), "u");
+        assert_eq!(SignedAmount::type_prefix(private::Token), "i");
+    }
+
     #[test]
     fn can_serde_as_sat() {
         #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 4f85f1347d..f6b8888406 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -16,6 +16,32 @@ use super::*;
 #[cfg(feature = "alloc")]
 use crate::{FeeRate, Weight};
 
+#[test]
+fn sanity_check() {
+    assert_eq!(SignedAmount::from_sat(-100).abs(), SignedAmount::from_sat(100));
+    assert_eq!(SignedAmount::from_sat(i64::MIN + 1).checked_abs().unwrap(), SignedAmount::from_sat(i64::MAX));
+    assert_eq!(SignedAmount::from_sat(-100).signum(), -1);
+    assert_eq!(SignedAmount::from_sat(0).signum(), 0);
+    assert_eq!(SignedAmount::from_sat(100).signum(), 1);
+    assert_eq!(SignedAmount::from(Amount::from_sat(100)), SignedAmount::from_sat(100));
+    assert!(SignedAmount::from_sat(i64::MIN).checked_abs().is_none());
+    assert!(!SignedAmount::from_sat(-100).is_positive());
+    assert!(SignedAmount::from_sat(100).is_positive());
+
+    #[cfg(feature = "alloc")]
+    {
+        assert_eq!(Amount::from_float_in(0_f64, Denomination::Bitcoin).unwrap(), Amount::from_sat(0));
+        assert_eq!(Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(), Amount::from_sat(200_000_000));
+        assert!(Amount::from_float_in(-100_f64, Denomination::Bitcoin).is_err());
+    }
+}
+
+#[test]
+fn check_if_num_is_too_precise() {
+    assert_eq!(is_too_precise("1234", 3).unwrap(), 3);
+    assert_eq!(is_too_precise("1234.1234", 3).unwrap(), 3);
+}
+
 #[test]
 #[cfg(feature = "alloc")]
 fn from_str_zero() {
@@ -94,11 +120,27 @@ fn mul_div() {
     assert_eq!(ssat(-14) / 2, ssat(-7));
     assert_eq!(ssat(-14) % 3, ssat(-2));
 
+    let mut a = sat(30);
+    a /= 3;
+    assert_eq!(a, sat(10));
+    a %= 3;
+    assert_eq!(a, sat(1));
+    a *= 3;
+    assert_eq!(a, Amount::from_sat(3));
+
     let mut b = ssat(30);
     b /= 3;
     assert_eq!(b, ssat(10));
     b %= 3;
     assert_eq!(b, ssat(1));
+    b *= 3;
+    assert_eq!(b, SignedAmount::from_sat(3));
+}
+
+#[test]
+fn neg() {
+    let amount = -SignedAmount::from_sat(2);
+    assert_eq!(amount.to_sat(), -2);
 }
 
 #[cfg(feature = "std")]
@@ -125,6 +167,23 @@ fn checked_arithmetic() {
     assert_eq!(ssat(-6).checked_div(2), Some(ssat(-3)));
 }
 
+#[test]
+#[allow(deprecated_in_future)]
+fn unchecked_arithmetic() {
+    assert_eq!(SignedAmount::from_sat(10).unchecked_add(SignedAmount::from_sat(20)), SignedAmount::from_sat(30));
+    assert_eq!(SignedAmount::from_sat(50).unchecked_sub(SignedAmount::from_sat(10)), SignedAmount::from_sat(40));
+    assert_eq!(Amount::from_sat(5).unchecked_add(Amount::from_sat(7)), Amount::from_sat(12));
+    assert_eq!(Amount::from_sat(10).unchecked_sub(Amount::from_sat(7)), Amount::from_sat(3));
+}
+
+#[test]
+fn positive_sub() {
+    assert_eq!(SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(7)).unwrap(), SignedAmount::from_sat(3));
+    assert!(SignedAmount::from_sat(-10).positive_sub(SignedAmount::from_sat(7)).is_none());
+    assert!(SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(-7)).is_none());
+    assert!(SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(11)).is_none());
+}
+
 #[cfg(feature = "alloc")]
 #[test]
 fn amount_checked_div_by_weight_ceil() {
@@ -881,11 +940,15 @@ fn sum_amounts() {
     assert_eq!(SignedAmount::ZERO, [].iter().sum::<SignedAmount>());
 
     let amounts = [Amount::from_sat(42), Amount::from_sat(1337), Amount::from_sat(21)];
+    assert_eq!(amounts.iter().sum::<Amount>(), Amount::from_sat(1400));
+
     let sum = amounts.into_iter().sum::<Amount>();
     assert_eq!(Amount::from_sat(1400), sum);
 
     let amounts =
         [SignedAmount::from_sat(-42), SignedAmount::from_sat(1337), SignedAmount::from_sat(21)];
+    assert_eq!(amounts.iter().sum::<SignedAmount>(), SignedAmount::from_sat(1316));
+
     let sum = amounts.into_iter().sum::<SignedAmount>();
     assert_eq!(SignedAmount::from_sat(1316), sum);
 }
diff --git a/units/src/block.rs b/units/src/block.rs
index 9e8efa5211..8eaca0da48 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -278,11 +278,29 @@ impl<'a> Arbitrary<'a> for BlockInterval {
 mod tests {
     use super::*;
 
+    #[test]
+    fn sanity_check() {
+        let height: u32 = BlockHeight(100).into();
+        assert_eq!(height, 100);
+
+        let interval: u32 = BlockInterval(100).into();
+        assert_eq!(interval, 100);
+
+        let interval_from_height: BlockInterval = relative::Height::from(10u16).into();
+        assert_eq!(interval_from_height.to_u32(), 10u32);
+
+        let invalid_height_greater = relative::Height::try_from(BlockInterval(u32::from(u16::MAX) + 1));
+        assert!(invalid_height_greater.is_err());
+
+        let valid_height = relative::Height::try_from(BlockInterval(u32::from(u16::MAX)));
+        assert!(valid_height.is_ok());
+    }
+
     // These tests are supposed to comprise an exhaustive list of available operations.
     #[test]
     fn all_available_ops() {
         // height - height = interval
-        assert!(BlockHeight(100) - BlockHeight(99) == BlockInterval(1));
+        assert!(BlockHeight(10) - BlockHeight(7) == BlockInterval(3));
 
         // height + interval = height
         assert!(BlockHeight(100) + BlockInterval(1) == BlockHeight(101));
@@ -294,7 +312,10 @@ mod tests {
         assert!(BlockInterval(1) + BlockInterval(2) == BlockInterval(3));
 
         // interval - interval = interval
-        assert!(BlockInterval(3) - BlockInterval(2) == BlockInterval(1));
+        assert!(BlockInterval(10) - BlockInterval(7) == BlockInterval(3));
+
+        assert!([BlockInterval(1), BlockInterval(2), BlockInterval(3)].iter().sum::<BlockInterval>() == BlockInterval(6));
+        assert!([BlockInterval(4), BlockInterval(5), BlockInterval(6)].into_iter().sum::<BlockInterval>() == BlockInterval(15));
 
         // interval += interval
         let mut int = BlockInterval(1);
@@ -302,8 +323,8 @@ mod tests {
         assert_eq!(int, BlockInterval(3));
 
         // interval -= interval
-        let mut int = BlockInterval(3);
-        int -= BlockInterval(2);
-        assert_eq!(int, BlockInterval(1));
+        let mut int = BlockInterval(10);
+        int -= BlockInterval(7);
+        assert_eq!(int, BlockInterval(3));
     }
 }
diff --git a/units/src/fee_rate/mod.rs b/units/src/fee_rate/mod.rs
index b12c08f45d..2b5fe82058 100644
--- a/units/src/fee_rate/mod.rs
+++ b/units/src/fee_rate/mod.rs
@@ -72,6 +72,9 @@ impl FeeRate {
     pub const fn to_sat_per_vb_floor(self) -> u64 { self.0 / (1000 / 4) }
 
     /// Converts to sat/vB rounding up.
+    /// TODO: cargo-mutants will try to replace - with /, which results in 1000 / 4 / 1 which is also 250.
+    /// Since we're addressing the mutants before introducing the cargo-mutants workflow, come back later
+    /// and skip this function in the mutants.toml config file
     pub const fn to_sat_per_vb_ceil(self) -> u64 { (self.0 + (1000 / 4 - 1)) / (1000 / 4) }
 
     /// Checked multiplication.
@@ -254,6 +257,12 @@ impl<'a> Arbitrary<'a> for FeeRate {
 mod tests {
     use super::*;
 
+    #[test]
+    fn sanity_check() {
+        let fee_rate: u64 = u64::from(FeeRate(100));
+        assert_eq!(fee_rate, 100_u64);
+    }
+
     #[test]
     #[allow(clippy::op_ref)]
     fn addition() {
@@ -270,14 +279,24 @@ mod tests {
     #[test]
     #[allow(clippy::op_ref)]
     fn subtract() {
-        let one = FeeRate(1);
-        let two = FeeRate(2);
         let three = FeeRate(3);
+        let seven = FeeRate(7);
+        let ten = FeeRate(10);
+
+        assert_eq!(ten - seven, three);
+        assert_eq!(&ten - seven, three);
+        assert_eq!(ten - &seven, three);
+        assert_eq!(&ten - &seven, three);
+    }
+
+    #[test]
+    #[allow(clippy::op_ref)]
+    fn multiply() {
+        let two = FeeRate::from_sat_per_vb(2).unwrap();
+        let three = Weight::from_vb(3).unwrap();
+        let six = Amount::from_sat(6);
 
-        assert!(three - two == one);
-        assert!(&three - two == one);
-        assert!(three - &two == one);
-        assert!(&three - &two == one);
+        assert_eq!(two * three, six);
     }
 
     #[test]
@@ -343,7 +362,7 @@ mod tests {
 
     #[test]
     fn fee_rate_from_sat_per_kvb() {
-        let fee_rate = FeeRate::from_sat_per_kvb(10);
+        let fee_rate = FeeRate::from_sat_per_kvb(11);
         assert_eq!(FeeRate(2), fee_rate);
     }
 
@@ -366,10 +385,10 @@ mod tests {
 
     #[test]
     fn raw_feerate() {
-        let fee_rate = FeeRate(333);
-        assert_eq!(333, fee_rate.to_sat_per_kwu());
-        assert_eq!(1, fee_rate.to_sat_per_vb_floor());
-        assert_eq!(2, fee_rate.to_sat_per_vb_ceil());
+        let fee_rate = FeeRate(749);
+        assert_eq!(749, fee_rate.to_sat_per_kwu());
+        assert_eq!(2, fee_rate.to_sat_per_vb_floor());
+        assert_eq!(3, fee_rate.to_sat_per_vb_ceil());
     }
 
     #[test]
@@ -381,6 +400,25 @@ mod tests {
         assert!(fee_rate.is_none());
     }
 
+    #[test]
+    fn fee_wu() {
+        let fee_overflow = FeeRate(10).fee_wu(Weight::MAX);
+        assert!(fee_overflow.is_none());
+
+        let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
+        let weight = Weight::from_vb(3).unwrap();
+        assert_eq!(fee_rate.fee_wu(weight).unwrap(), Amount::from_sat(6));
+    }
+
+    #[test]
+    fn fee_vb() {
+        let fee_overflow = FeeRate(10).fee_vb(Weight::MAX.to_wu());
+        assert!(fee_overflow.is_none());
+
+        let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
+        assert_eq!(fee_rate.fee_vb(3).unwrap(), Amount::from_sat(6));
+    }
+
     #[test]
     fn checked_weight_mul() {
         let weight = Weight::from_vb(10).unwrap();
diff --git a/units/src/locktime/absolute.rs b/units/src/locktime/absolute.rs
index 966f6e129e..b7ee722e6a 100644
--- a/units/src/locktime/absolute.rs
+++ b/units/src/locktime/absolute.rs
@@ -472,6 +472,15 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn is_block_height_or_time() {
+        assert!(is_block_height(499_999_999));
+        assert!(!is_block_height(500_000_000));
+
+        assert!(!is_block_time(499_999_999));
+        assert!(is_block_time(500_000_000));
+    }
+
     #[test]
     #[cfg(feature = "serde")]
     pub fn encode_decode_height() {
diff --git a/units/src/locktime/relative.rs b/units/src/locktime/relative.rs
index 25c875ee05..a217391dab 100644
--- a/units/src/locktime/relative.rs
+++ b/units/src/locktime/relative.rs
@@ -116,6 +116,8 @@ impl Time {
 
     /// Returns the `u32` value used to encode this locktime in an nSequence field or
     /// argument to `OP_CHECKSEQUENCEVERIFY`.
+    /// TODO: Skip this in cargo-mutants. It will replace | with ^, which will return the same
+    /// value since the XOR is always taken against the u16 and an all-zero bitmask
     #[inline]
     pub const fn to_consensus_u32(self) -> u32 {
         (1u32 << 22) | self.0 as u32 // cast safety: u32 is wider than u16 on all architectures
@@ -193,6 +195,13 @@ mod tests {
 
     const MAXIMUM_ENCODABLE_SECONDS: u32 = u16::MAX as u32 * 512;
 
+    #[test]
+    fn sanity_check() {
+        assert_eq!(Height::MAX.to_consensus_u32(), u32::from(u16::MAX));
+        assert_eq!(Time::from_512_second_intervals(100).value(), 100u16);
+        assert_eq!(Time::from_512_second_intervals(100).to_consensus_u32(), 4_194_404u32); // 0x400064
+    }
+
     #[test]
     fn from_seconds_ceil_success() {
         let actual = Time::from_seconds_ceil(100).unwrap();
diff --git a/units/src/parse.rs b/units/src/parse.rs
index b51b60fea5..22401cc5d1 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -24,7 +24,7 @@ pub struct ParseIntError {
     pub(crate) input: InputString,
     // for displaying - see Display impl with nice error message below
     pub(crate) bits: u8,
-    // We could represent this as a single bit but it wouldn't actually derease the cost of moving
+    // We could represent this as a single bit, but it wouldn't actually decrease 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.
     pub(crate) is_signed: bool,
@@ -488,8 +488,64 @@ impl std::error::Error for ContainsPrefixError {}
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "std")]
+    use std::panic;
+
     use super::*;
 
+    #[test]
+    fn parse_int() {
+        assert!(int::<u8, _>("1").is_ok());
+        let _ = int::<i8, _>("not a number").map_err(|e| assert!(e.is_signed));
+        let _ = int::<u8, _>("not a number").map_err(|e| assert!(!e.is_signed));
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn parse_int_panic_when_populating_bits() {
+        // Fields in the test type are never used
+        #[allow(dead_code)]
+        struct TestTypeLargerThanU128(u128, u128);
+        impl_integer!(TestTypeLargerThanU128);
+        impl FromStr for TestTypeLargerThanU128 {
+            type Err = core::num::ParseIntError;
+
+            fn from_str(_: &str) -> Result<Self, Self::Err> {
+                "Always invalid for testing".parse::<u32>().map(|_| TestTypeLargerThanU128(0, 0))
+            }
+        }
+        impl From<i8> for TestTypeLargerThanU128 {
+            fn from(_: i8) -> Self { TestTypeLargerThanU128(0, 0) }
+        }
+
+        let result = panic::catch_unwind(|| int::<TestTypeLargerThanU128, _>("not a number"));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn remove_prefix() {
+        let lower = "0xhello";
+        assert_eq!(hex_remove_prefix(lower).unwrap(), "hello");
+
+        let upper = "0Xhello";
+        assert_eq!(hex_remove_prefix(upper).unwrap(), "hello");
+
+        let err = "error";
+        assert!(hex_remove_prefix(err).is_err());
+    }
+
+    #[test]
+    fn check_unprefixed() {
+        let lower = "0xhello";
+        assert!(hex_check_unprefixed(lower).is_err());
+
+        let upper = "0Xhello";
+        assert!(hex_check_unprefixed(upper).is_err());
+
+        let valid = "hello";
+        assert_eq!(hex_check_unprefixed(valid).unwrap(), "hello");
+    }
+
     #[test]
     fn parse_u32_from_hex_prefixed() {
         let want = 171;
@@ -504,6 +560,21 @@ mod tests {
         assert_eq!(got, want);
     }
 
+    #[test]
+    fn parse_hex_u32_prefixed() {
+        let want = 171; // 0xab
+        assert_eq!(hex_u32_prefixed("0xab").unwrap(), want);
+        assert!(hex_u32_unprefixed("0xab").is_err());
+
+    }
+
+    #[test]
+    fn parse_hex_u32_unprefixed() {
+        let want = 171; // 0xab
+        assert_eq!(hex_u32_unprefixed("ab").unwrap(), want);
+        assert!(hex_u32_prefixed("ab").is_err());
+    }
+
     #[test]
     fn parse_u128_from_hex_prefixed() {
         let want = 3_735_928_559;
@@ -518,6 +589,21 @@ mod tests {
         assert_eq!(got, want);
     }
 
+    #[test]
+    fn parse_hex_u128_prefixed() {
+        let want = 3_735_928_559;
+        assert_eq!(hex_u128_prefixed("0xdeadbeef").unwrap(), want);
+        assert!(hex_u128_unprefixed("0xdeadbeef").is_err());
+
+    }
+
+    #[test]
+    fn parse_hex_u128_unprefixed() {
+        let want = 3_735_928_559;
+        assert_eq!(hex_u128_unprefixed("deadbeef").unwrap(), want);
+        assert!(hex_u128_prefixed("deadbeef").is_err());
+    }
+
     #[test]
     fn parse_u32_from_hex_unchecked_errors_on_prefix() {
         assert!(hex_u32_unchecked("0xab").is_err());
diff --git a/units/src/weight.rs b/units/src/weight.rs
index 73bed18f1f..df654e9d41 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -250,6 +250,11 @@ mod tests {
     const TWO: Weight = Weight(2);
     const FOUR: Weight = Weight(4);
 
+    #[test]
+    fn sanity_check() {
+        assert_eq!(Weight::MIN_TRANSACTION, Weight(240));
+    }
+
     #[test]
     fn from_kwu() {
         let got = Weight::from_kwu(1).unwrap();
@@ -302,8 +307,8 @@ mod tests {
 
     #[test]
     fn to_kwu_floor() {
-        assert_eq!(Weight(1_000).to_kwu_floor(), 1);
-        assert_eq!(Weight(1_999).to_kwu_floor(), 1);
+        assert_eq!(Weight(5_000).to_kwu_floor(), 5);
+        assert_eq!(Weight(5_999).to_kwu_floor(), 5);
     }
 
     #[test]
@@ -314,8 +319,8 @@ mod tests {
 
     #[test]
     fn to_vb_floor() {
-        assert_eq!(Weight(4).to_vbytes_floor(), 1);
-        assert_eq!(Weight(5).to_vbytes_floor(), 1);
+        assert_eq!(Weight(8).to_vbytes_floor(), 2);
+        assert_eq!(Weight(9).to_vbytes_floor(), 2);
     }
 
     #[test]
@@ -374,14 +379,33 @@ mod tests {
     #[test]
     #[allow(clippy::op_ref)]
     fn subtract() {
-        let one = Weight(1);
-        let two = Weight(2);
+        let ten = Weight(10);
+        let seven = Weight(7);
         let three = Weight(3);
 
-        assert!(three - two == one);
-        assert!(&three - two == one);
-        assert!(three - &two == one);
-        assert!(&three - &two == one);
+        assert_eq!(ten - seven, three);
+        assert_eq!(&ten - seven, three);
+        assert_eq!(ten - &seven, three);
+        assert_eq!(&ten - &seven, three);
+    }
+
+    #[test]
+    #[allow(clippy::op_ref)]
+    fn multiply() {
+        let two = Weight(2);
+        let six = Weight(6);
+
+        assert_eq!(3_u64 * two, six);
+        assert_eq!(two * 3_u64, six);
+    }
+
+    #[test]
+    fn divide() {
+        let eight = Weight(8);
+        let four = Weight(4);
+
+        assert_eq!(eight / four, 2_u64);
+        assert_eq!(eight / 4_u64, Weight(2));
     }
 
     #[test]
@@ -405,4 +429,18 @@ mod tests {
         f -= &Weight(2);
         assert_eq!(f, Weight(1));
     }
+
+    #[test]
+    fn mul_assign() {
+        let mut w = Weight(3);
+        w *= 2_u64;
+        assert_eq!(w, Weight(6));
+    }
+
+    #[test]
+    fn div_assign() {
+        let mut w = Weight(8);
+        w /= Weight(4).into();
+        assert_eq!(w, Weight(2));
+    }
 }

From 2c9fda413572e251fe3fd07f679b6c786da137b3 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 4 Jan 2025 15:22:27 +1100
Subject: [PATCH 183/554] Add parenthesis to explicitly show precedence

Recent clippy nightly update introduces warnings about precedence. While
ours are, IMO, clear the lint docs have some cases that are not so I
don't think we should ignore this lint. Specifically I could easily miss
this one

  1 << 2 + 3 equals 32, while (1 << 2) + 3 equals 7

ref: https://rust-lang.github.io/rust-clippy/master/#/precede

Add parenthesis to explicitly show precedence. Refactor only no logic
changes.
---
 bitcoin/src/blockdata/block.rs    |  4 ++--
 bitcoin/src/pow.rs                | 14 +++++++-------
 chacha20_poly1305/src/poly1305.rs | 24 ++++++++++++------------
 3 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs
index d32e742131..569a8b7d59 100644
--- a/bitcoin/src/blockdata/block.rs
+++ b/bitcoin/src/blockdata/block.rs
@@ -723,7 +723,7 @@ mod tests {
     #[test]
     fn soft_fork_signalling() {
         for i in 0..31 {
-            let version_int = (0x20000000u32 ^ 1 << i) as i32;
+            let version_int = (0x20000000u32 ^ (1 << i)) as i32;
             let version = Version::from_consensus(version_int);
             if i < 29 {
                 assert!(version.is_signalling_soft_fork(i));
@@ -732,7 +732,7 @@ mod tests {
             }
         }
 
-        let segwit_signal = Version::from_consensus(0x20000000 ^ 1 << 1);
+        let segwit_signal = Version::from_consensus(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));
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index b6d531cb24..63a5c854ac 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -618,8 +618,8 @@ impl U256 {
             carry = n >> 64; // and carry the high bits.
         }
 
-        let low = u128::from(split_le[0]) | u128::from(split_le[1]) << 64;
-        let high = u128::from(split_le[2]) | u128::from(split_le[3]) << 64;
+        let low = u128::from(split_le[0]) | (u128::from(split_le[1]) << 64);
+        let high = u128::from(split_le[2]) | (u128::from(split_le[3]) << 64);
         (Self(high, low), carry != 0)
     }
 
@@ -872,7 +872,7 @@ impl U256 {
         // (This is why we only care if the other non-msb dropped bits are all 0 or not,
         // so we can just OR them to make sure any bits show up somewhere.)
         let mantissa =
-            (mantissa + ((dropped_bits - (dropped_bits >> 127 & !mantissa)) >> 127)) as u64;
+            (mantissa + ((dropped_bits - ((dropped_bits >> 127) & !mantissa)) >> 127)) as u64;
         // Step 6: Calculate the exponent
         // If self is 0, exponent should be 0 (special meaning) and mantissa will end up 0 too
         // Otherwise, (255 - n) + 1022 so it simplifies to 1277 - n
@@ -1115,8 +1115,8 @@ mod tests {
         /// Constructs a new U256 from a big-endian array of u64's
         fn from_array(a: [u64; 4]) -> Self {
             let mut ret = U256::ZERO;
-            ret.0 = (a[0] as u128) << 64 ^ (a[1] as u128);
-            ret.1 = (a[2] as u128) << 64 ^ (a[3] as u128);
+            ret.0 = ((a[0] as u128) << 64) ^ (a[1] as u128);
+            ret.1 = ((a[2] as u128) << 64) ^ (a[3] as u128);
             ret
         }
     }
@@ -1559,11 +1559,11 @@ mod tests {
     #[test]
     fn u256_multiplication_bits_in_each_word() {
         // Put a digit in the least significant bit of each 64 bit word.
-        let u = 1_u128 << 64 | 1_u128;
+        let u = (1_u128 << 64) | 1_u128;
         let x = U256(u, u);
 
         // Put a digit in the second least significant bit of each 64 bit word.
-        let u = 2_u128 << 64 | 2_u128;
+        let u = (2_u128 << 64) | 2_u128;
         let y = U256(u, u);
 
         let (got, overflow) = x.overflowing_mul(y);
diff --git a/chacha20_poly1305/src/poly1305.rs b/chacha20_poly1305/src/poly1305.rs
index a064feb7ec..0b277b01f1 100644
--- a/chacha20_poly1305/src/poly1305.rs
+++ b/chacha20_poly1305/src/poly1305.rs
@@ -134,10 +134,10 @@ impl Poly1305 {
             self.acc[i] = t & mask | self.acc[i] & !mask;
         }
         // Voodoo from donna to convert to [u32; 4].
-        let a0 = self.acc[0] | self.acc[1] << 26;
-        let a1 = self.acc[1] >> 6 | self.acc[2] << 20;
-        let a2 = self.acc[2] >> 12 | self.acc[3] << 14;
-        let a3 = self.acc[3] >> 18 | self.acc[4] << 8;
+        let a0 = self.acc[0] | (self.acc[1] << 26);
+        let a1 = (self.acc[1] >> 6) | (self.acc[2] << 20);
+        let a2 = (self.acc[2] >> 12) | (self.acc[3] << 14);
+        let a3 = (self.acc[3] >> 18) | (self.acc[4] << 8);
         let a = [a0, a1, a2, a3];
         // a + s
         let mut tag: [u64; 4] = [0; 4];
@@ -196,21 +196,21 @@ fn prepare_padded_message_slice(msg: &[u8], is_last: bool) -> [u32; 5] {
     // Encode number in five 26-bit limbs.
     let m0 = u32::from_le_bytes(fmt_msg[0..4].try_into().expect("Valid subset of 32.")) & BITMASK;
     let m1 =
-        u32::from_le_bytes(fmt_msg[3..7].try_into().expect("Valid subset of 32.")) >> 2 & BITMASK;
+        (u32::from_le_bytes(fmt_msg[3..7].try_into().expect("Valid subset of 32.")) >> 2) & BITMASK;
     let m2 =
-        u32::from_le_bytes(fmt_msg[6..10].try_into().expect("Valid subset of 32.")) >> 4 & BITMASK;
+        (u32::from_le_bytes(fmt_msg[6..10].try_into().expect("Valid subset of 32.")) >> 4) & BITMASK;
     let m3 =
-        u32::from_le_bytes(fmt_msg[9..13].try_into().expect("Valid subset of 32.")) >> 6 & BITMASK;
+        (u32::from_le_bytes(fmt_msg[9..13].try_into().expect("Valid subset of 32.")) >> 6) & BITMASK;
     let m4 =
-        u32::from_le_bytes(fmt_msg[12..16].try_into().expect("Valid subset of 32.")) >> 8 | hi_bit;
+        (u32::from_le_bytes(fmt_msg[12..16].try_into().expect("Valid subset of 32.")) >> 8) | hi_bit;
     [m0, m1, m2, m3, m4]
 }
 
 fn _print_acc(num: &[u32; 5]) {
-    let a0 = num[0] | num[1] << 26;
-    let a1 = num[1] >> 6 | num[2] << 20;
-    let a2 = num[2] >> 12 | num[3] << 14;
-    let a3 = num[3] >> 18 | num[4] << 8;
+    let a0 = num[0] | (num[1] << 26);
+    let a1 = (num[1] >> 6) | (num[2] << 20);
+    let a2 = (num[2] >> 12) | (num[3] << 14);
+    let a3 = (num[3] >> 18) | (num[4] << 8);
     let a = [a0, a1, a2, a3];
     let mut ret: [u8; 16] = [0; 16];
     for i in 0..a.len() {

From b7fdb359e76a2ec170d7b9abc704a7a29a0890c6 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 4 Jan 2025 15:38:03 +1100
Subject: [PATCH 184/554] io: Move constructors

Put all the constructors together.

Internal change only.
---
 io/src/bridge.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/io/src/bridge.rs b/io/src/bridge.rs
index 204a77a51e..182f770c9b 100644
--- a/io/src/bridge.rs
+++ b/io/src/bridge.rs
@@ -12,18 +12,6 @@ impl<T> FromStd<T> {
     #[inline]
     pub const fn new(inner: T) -> Self { Self(inner) }
 
-    /// Returns the wrapped value.
-    #[inline]
-    pub fn into_inner(self) -> T { self.0 }
-
-    /// Returns a reference to the wrapped value.
-    #[inline]
-    pub fn inner(&self) -> &T { &self.0 }
-
-    /// Returns a mutable reference to the wrapped value.
-    #[inline]
-    pub fn inner_mut(&mut self) -> &mut T { &mut self.0 }
-
     /// Wraps a mutable reference to IO type.
     #[inline]
     pub fn new_mut(inner: &mut T) -> &mut Self {
@@ -38,6 +26,18 @@ impl<T> FromStd<T> {
         // SAFETY: the type is repr(transparent) and the pointer is created from Box
         unsafe { Box::from_raw(Box::into_raw(inner) as *mut Self) }
     }
+
+    /// Returns the wrapped value.
+    #[inline]
+    pub fn into_inner(self) -> T { self.0 }
+
+    /// Returns a reference to the wrapped value.
+    #[inline]
+    pub fn inner(&self) -> &T { &self.0 }
+
+    /// Returns a mutable reference to the wrapped value.
+    #[inline]
+    pub fn inner_mut(&mut self) -> &mut T { &mut self.0 }
 }
 
 impl<T: std::io::Read> super::Read for FromStd<T> {

From 88dfd4e8f2b12f5e50caab16481c4e0a8935c9f7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 4 Jan 2025 15:39:50 +1100
Subject: [PATCH 185/554] io: Use get_ref / get_mut API

Currently in the `bridge` module to get a reference and mutable
reference we provide the `as_inner` and `inner_mut` functions. These
names are not in line with the `std::io` module which favours `get_ref`
and `get_mut`.

Add inherent functions `get_ref` and `get_mut` for accessing the wrapped
value in `bridge::ToStd` and deprecate `as_inner` and `inner_mut`.

To convince yourself this API is correct grep the stdlib `io` module for
`fn get_ref` as opposed to `fn as_ref`.

Close: #3832
---
 io/src/bridge.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/io/src/bridge.rs b/io/src/bridge.rs
index 182f770c9b..a979f73870 100644
--- a/io/src/bridge.rs
+++ b/io/src/bridge.rs
@@ -33,10 +33,20 @@ impl<T> FromStd<T> {
 
     /// Returns a reference to the wrapped value.
     #[inline]
+    pub fn get_ref(&self) -> &T { &self.0 }
+
+    /// Returns a mutable reference to the wrapped value.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut T { &mut self.0 }
+
+    /// Returns a reference to the wrapped value.
+    #[inline]
+    #[deprecated(since = "TBD", note = "use `get_ref()` instead")]
     pub fn inner(&self) -> &T { &self.0 }
 
     /// Returns a mutable reference to the wrapped value.
     #[inline]
+    #[deprecated(since = "TBD", note = "use `get_ref()` instead")]
     pub fn inner_mut(&mut self) -> &mut T { &mut self.0 }
 }
 

From 12a83e1bf3b7c8ef8ddfee028b62b2a74ee50585 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 4 Jan 2025 15:53:12 +1100
Subject: [PATCH 186/554] api: Run just check-api

---
 api/io/all-features.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/api/io/all-features.txt b/api/io/all-features.txt
index af10dd8871..055e6305d9 100644
--- a/api/io/all-features.txt
+++ b/api/io/all-features.txt
@@ -242,6 +242,8 @@ pub fn bitcoin_io::FromStd<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::FromStd<T>::fill_buf(&mut self) -> std::io::error::Result<&[u8]>
 pub fn bitcoin_io::FromStd<T>::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::FromStd<T>::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_io::FromStd<T>::get_mut(&mut self) -> &mut T
+pub fn bitcoin_io::FromStd<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::FromStd<T>::inner(&self) -> &T
 pub fn bitcoin_io::FromStd<T>::inner_mut(&mut self) -> &mut T
 pub fn bitcoin_io::FromStd<T>::into_inner(self) -> T

From 762f6630fe22e54e5a8b2839054e2e09a5a2db64 Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 5 Jan 2025 01:22:00 +0000
Subject: [PATCH 187/554] 2025-01-05 automated rustfmt nightly

---
 bitcoin/src/blockdata/script/builder.rs | 4 +---
 bitcoin/src/p2p/mod.rs                  | 4 +---
 primitives/src/opcodes.rs               | 4 +---
 units/src/parse.rs                      | 4 ++--
 4 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/bitcoin/src/blockdata/script/builder.rs b/bitcoin/src/blockdata/script/builder.rs
index ea86581347..b8a52ea91a 100644
--- a/bitcoin/src/blockdata/script/builder.rs
+++ b/bitcoin/src/blockdata/script/builder.rs
@@ -151,7 +151,5 @@ impl fmt::Display for Builder {
 }
 
 impl fmt::Debug for Builder {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        fmt::Display::fmt(self, f)
-    }
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fmt::Display::fmt(self, f) }
 }
diff --git a/bitcoin/src/p2p/mod.rs b/bitcoin/src/p2p/mod.rs
index 040e2dfc4e..b594a6693d 100644
--- a/bitcoin/src/p2p/mod.rs
+++ b/bitcoin/src/p2p/mod.rs
@@ -293,9 +293,7 @@ impl fmt::Display for Magic {
 }
 
 impl fmt::Debug for Magic {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        fmt::Display::fmt(self, f)
-    }
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fmt::Display::fmt(self, f) }
 }
 
 impl fmt::LowerHex for Magic {
diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index d1ab77b735..bd9e8ce862 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -440,9 +440,7 @@ impl From<u8> for Opcode {
 }
 
 impl fmt::Debug for Opcode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        fmt::Display::fmt(self, f)
-    }
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fmt::Display::fmt(self, f) }
 }
 
 #[cfg(feature = "serde")]
diff --git a/units/src/parse.rs b/units/src/parse.rs
index b51b60fea5..21a674220e 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -137,7 +137,7 @@ macro_rules! impl_parse_str_from_int_infallible {
 /// Implements `TryFrom<$from> for $to` using `parse::int`, mapping the output using infallible
 /// conversion function `fn`.
 #[macro_export]
-#[doc(hidden)]                  // Helper macro called by `impl_parse_str_from_int_infallible`.
+#[doc(hidden)] // Helper macro called by `impl_parse_str_from_int_infallible`.
 macro_rules! impl_tryfrom_str_from_int_infallible {
     ($($from:ty, $to:ident, $inner:ident, $fn:ident);*) => {
         $(
@@ -192,7 +192,7 @@ macro_rules! impl_parse_str {
 
 /// Implements `TryFrom<$from> for $to`.
 #[macro_export]
-#[doc(hidden)]                  // Helper macro called by `impl_parse_str`.
+#[doc(hidden)] // Helper macro called by `impl_parse_str`.
 macro_rules! impl_tryfrom_str {
     ($($from:ty, $to:ty, $err:ty, $inner_fn:expr);*) => {
         $(

From cf455d3a063079916f0bff8ee0335cce00a50f8e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 5 Jan 2025 12:36:11 +1100
Subject: [PATCH 188/554] Fix typo in prifixes

Close: #3856
---
 bitcoin/src/address/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 50453e6bec..8f570979eb 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -880,7 +880,7 @@ impl<V: NetworkValidation> fmt::Debug for Address<V> {
 ///   not a valid base58 address.
 ///
 /// - [`UnknownHrpError`] if the address does not begin with one of the above SegWit or
-///   legacy prifixes.
+///   legacy prefixes.
 impl FromStr for Address<NetworkUnchecked> {
     type Err = ParseError;
 

From f94c7185fdd62e1ed98ed4016486406146c4d4f3 Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Sat, 4 Jan 2025 23:25:16 -0600
Subject: [PATCH 189/554] Remove usage of impl_from_infallible in crates

Rust macros, while at times useful, are a maintenance nightmare. And
we have been bitten by calling macros from other crates multiple times
in the past.

In a push to just use less macros remove the usage of the
`impl_from_infallible` macro in the bitcoin, units, and internals crates
and just write the code.
---
 base58/src/error.rs                           | 28 ++++++---
 bitcoin/src/address/error.rs                  | 21 +++++--
 bitcoin/src/bip152.rs                         |  5 +-
 bitcoin/src/bip158.rs                         |  5 +-
 bitcoin/src/bip32.rs                          |  5 +-
 bitcoin/src/blockdata/block.rs                | 13 +++-
 bitcoin/src/blockdata/script/mod.rs           |  5 +-
 .../src/blockdata/script/witness_program.rs   |  5 +-
 .../src/blockdata/script/witness_version.rs   |  9 ++-
 bitcoin/src/consensus/error.rs                | 17 ++++--
 bitcoin/src/consensus_validation.rs           |  5 +-
 bitcoin/src/crypto/ecdsa.rs                   |  9 ++-
 bitcoin/src/crypto/key.rs                     | 17 ++++--
 bitcoin/src/crypto/sighash.rs                 | 21 +++++--
 bitcoin/src/crypto/taproot.rs                 |  5 +-
 bitcoin/src/merkle_tree/block.rs              |  5 +-
 bitcoin/src/psbt/error.rs                     |  5 +-
 bitcoin/src/psbt/mod.rs                       | 22 +++++--
 bitcoin/src/sign_message.rs                   |  5 +-
 bitcoin/src/taproot/mod.rs                    | 33 ++++++++---
 internals/src/macros.rs                       | 59 -------------------
 units/src/fee_rate/serde.rs                   |  5 +-
 22 files changed, 189 insertions(+), 115 deletions(-)

diff --git a/base58/src/error.rs b/base58/src/error.rs
index 6257056ecc..c86e6daccc 100644
--- a/base58/src/error.rs
+++ b/base58/src/error.rs
@@ -3,6 +3,7 @@
 //! Error code for the `base58` crate.
 
 use core::fmt;
+use core::convert::Infallible;
 
 use internals::write_err;
 
@@ -20,8 +21,13 @@ pub(super) enum ErrorInner {
     TooShort(TooShortError),
 }
 
-internals::impl_from_infallible!(Error);
-internals::impl_from_infallible!(ErrorInner);
+impl From<Infallible> for Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<Infallible> for ErrorInner {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl Error {
     /// Returns the invalid base58 ssscharacter, if encountered.
@@ -95,7 +101,9 @@ pub(super) struct IncorrectChecksumError {
     pub(super) expected: u32,
 }
 
-internals::impl_from_infallible!(IncorrectChecksumError);
+impl From<Infallible> for IncorrectChecksumError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for IncorrectChecksumError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -116,8 +124,9 @@ pub(super) struct TooShortError {
     /// The length of the decoded data.
     pub(super) length: usize,
 }
-
-internals::impl_from_infallible!(TooShortError);
+impl From<Infallible> for TooShortError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for TooShortError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -141,8 +150,13 @@ pub(super) struct InvalidCharacterErrorInner {
     pub(super) invalid: u8,
 }
 
-internals::impl_from_infallible!(InvalidCharacterError);
-internals::impl_from_infallible!(InvalidCharacterErrorInner);
+impl From<Infallible> for InvalidCharacterError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
+
+impl From<Infallible> for InvalidCharacterErrorInner {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl InvalidCharacterError {
     pub(super) fn new(invalid: u8) -> Self { Self(InvalidCharacterErrorInner { invalid }) }
diff --git a/bitcoin/src/address/error.rs b/bitcoin/src/address/error.rs
index 1de9e7f950..65eb34f4d2 100644
--- a/bitcoin/src/address/error.rs
+++ b/bitcoin/src/address/error.rs
@@ -1,6 +1,7 @@
 //! Error code for the address module.
 
 use core::fmt;
+use core::convert::Infallible;
 
 use internals::write_err;
 
@@ -21,7 +22,9 @@ pub enum FromScriptError {
     WitnessVersion(witness_version::TryFromError),
 }
 
-internals::impl_from_infallible!(FromScriptError);
+impl From<Infallible> for FromScriptError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for FromScriptError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -84,7 +87,9 @@ pub enum ParseError {
     NetworkValidation(NetworkValidationError),
 }
 
-internals::impl_from_infallible!(ParseError);
+impl From<Infallible> for ParseError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -175,7 +180,9 @@ pub enum Bech32Error {
     UnknownHrp(UnknownHrpError),
 }
 
-internals::impl_from_infallible!(Bech32Error);
+impl From<Infallible> for Bech32Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Bech32Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -221,7 +228,9 @@ impl From<UnknownHrpError> for Bech32Error {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ParseBech32Error(pub(crate) bech32::segwit::DecodeError);
 
-internals::impl_from_infallible!(ParseBech32Error);
+impl From<Infallible> for ParseBech32Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ParseBech32Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -248,7 +257,9 @@ pub enum Base58Error {
     InvalidLegacyPrefix(InvalidLegacyPrefixError),
 }
 
-internals::impl_from_infallible!(Base58Error);
+impl From<Infallible> for Base58Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Base58Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs
index e515e3281b..d2cdcaf8ec 100644
--- a/bitcoin/src/bip152.rs
+++ b/bitcoin/src/bip152.rs
@@ -5,6 +5,7 @@
 //! Implementation of compact blocks data structure and algorithms.
 
 use core::{convert, fmt, mem};
+use core::convert::Infallible;
 #[cfg(feature = "std")]
 use std::error;
 
@@ -30,7 +31,9 @@ pub enum Error {
     InvalidPrefill,
 }
 
-internals::impl_from_infallible!(Error);
+impl From<Infallible> for Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/bip158.rs b/bitcoin/src/bip158.rs
index 8af3cd7846..8933767033 100644
--- a/bitcoin/src/bip158.rs
+++ b/bitcoin/src/bip158.rs
@@ -39,6 +39,7 @@
 
 use core::cmp::{self, Ordering};
 use core::fmt;
+use core::convert::Infallible;
 
 use hashes::{sha256d, siphash24, HashEngine as _};
 use internals::{write_err, ToU64 as _};
@@ -79,7 +80,9 @@ pub enum Error {
     Io(io::Error),
 }
 
-internals::impl_from_infallible!(Error);
+impl From<Infallible> for Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 885c500d50..b029004358 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -8,6 +8,7 @@
 use core::ops::Index;
 use core::str::FromStr;
 use core::{fmt, slice};
+use core::convert::Infallible;
 
 use hashes::{hash160, hash_newtype, sha512, GeneralHash, HashEngine, Hmac, HmacEngine};
 use internals::write_err;
@@ -519,7 +520,9 @@ pub enum Error {
     InvalidBase58PayloadLength(InvalidBase58PayloadLengthError),
 }
 
-internals::impl_from_infallible!(Error);
+impl From<Infallible> for Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs
index d32e742131..e2e7935657 100644
--- a/bitcoin/src/blockdata/block.rs
+++ b/bitcoin/src/blockdata/block.rs
@@ -8,6 +8,7 @@
 //! these blocks and the blockchain.
 
 use core::fmt;
+use core::convert::Infallible;
 
 use hashes::{sha256d, HashEngine};
 use internals::{compact_size, ToU64};
@@ -383,7 +384,9 @@ pub enum InvalidBlockError {
     InvalidWitnessCommitment,
 }
 
-internals::impl_from_infallible!(InvalidBlockError);
+impl From<Infallible> for InvalidBlockError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for InvalidBlockError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -413,7 +416,9 @@ pub enum Bip34Error {
     NegativeHeight,
 }
 
-internals::impl_from_infallible!(Bip34Error);
+impl From<Infallible> for Bip34Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Bip34Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -457,7 +462,9 @@ pub enum ValidationError {
     BadTarget,
 }
 
-internals::impl_from_infallible!(ValidationError);
+impl From<Infallible> for ValidationError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ValidationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/blockdata/script/mod.rs b/bitcoin/src/blockdata/script/mod.rs
index 9f9284cb19..ac2a018427 100644
--- a/bitcoin/src/blockdata/script/mod.rs
+++ b/bitcoin/src/blockdata/script/mod.rs
@@ -58,6 +58,7 @@ pub mod witness_program;
 pub mod witness_version;
 
 use core::fmt;
+use core::convert::Infallible;
 
 use io::{BufRead, Write};
 use primitives::opcodes::all::*;
@@ -234,7 +235,9 @@ pub enum Error {
     Serialization,
 }
 
-internals::impl_from_infallible!(Error);
+impl From<Infallible> for Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/blockdata/script/witness_program.rs b/bitcoin/src/blockdata/script/witness_program.rs
index 3fe824f499..9f1448da3d 100644
--- a/bitcoin/src/blockdata/script/witness_program.rs
+++ b/bitcoin/src/blockdata/script/witness_program.rs
@@ -8,6 +8,7 @@
 //! [BIP141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
 
 use core::fmt;
+use core::convert::Infallible;
 
 use internals::array_vec::ArrayVec;
 use secp256k1::{Secp256k1, Verification};
@@ -139,7 +140,9 @@ pub enum Error {
     InvalidSegwitV0Length(usize),
 }
 
-internals::impl_from_infallible!(Error);
+impl From<Infallible> for Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/blockdata/script/witness_version.rs b/bitcoin/src/blockdata/script/witness_version.rs
index e9a1126d33..98b6edc16c 100644
--- a/bitcoin/src/blockdata/script/witness_version.rs
+++ b/bitcoin/src/blockdata/script/witness_version.rs
@@ -9,6 +9,7 @@
 
 use core::fmt;
 use core::str::FromStr;
+use core::convert::Infallible;
 
 use internals::write_err;
 use units::parse::{self, ParseIntError};
@@ -159,7 +160,9 @@ pub enum FromStrError {
     Invalid(TryFromError),
 }
 
-internals::impl_from_infallible!(FromStrError);
+impl From<Infallible> for FromStrError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for FromStrError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -202,7 +205,9 @@ pub enum TryFromInstructionError {
     DataPush,
 }
 
-internals::impl_from_infallible!(TryFromInstructionError);
+impl From<Infallible> for TryFromInstructionError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for TryFromInstructionError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/consensus/error.rs b/bitcoin/src/consensus/error.rs
index e69e75b96a..500e9ecef2 100644
--- a/bitcoin/src/consensus/error.rs
+++ b/bitcoin/src/consensus/error.rs
@@ -3,6 +3,7 @@
 //! Consensus encoding errors.
 
 use core::fmt;
+use core::convert::Infallible;
 
 use hex::error::{InvalidCharError, OddLengthStringError};
 use hex::DisplayHex as _;
@@ -21,7 +22,9 @@ pub enum DeserializeError {
     Unconsumed,
 }
 
-internals::impl_from_infallible!(DeserializeError);
+impl From<Infallible> for DeserializeError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for DeserializeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -64,7 +67,9 @@ pub enum DecodeError<E> {
     Other(E), // Yielded by the inner iterator.
 }
 
-internals::impl_from_infallible!(DecodeError<E>);
+impl<E> From<Infallible> for DecodeError<E> {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl<E: fmt::Debug> fmt::Display for DecodeError<E> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -101,7 +106,9 @@ pub enum Error {
     Parse(ParseError),
 }
 
-internals::impl_from_infallible!(Error);
+impl From<Infallible> for Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -169,7 +176,9 @@ pub enum ParseError {
     UnsupportedSegwitFlag(u8),
 }
 
-internals::impl_from_infallible!(ParseError);
+impl From<Infallible> for ParseError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/consensus_validation.rs b/bitcoin/src/consensus_validation.rs
index 4f814c904b..d3d67f0ea3 100644
--- a/bitcoin/src/consensus_validation.rs
+++ b/bitcoin/src/consensus_validation.rs
@@ -5,6 +5,7 @@
 //! Relies on the `bitcoinconsensus` crate that uses Bitcoin Core libconsensus to perform validation.
 
 use core::fmt;
+use core::convert::Infallible;
 
 use internals::write_err;
 
@@ -237,7 +238,9 @@ pub enum TxVerifyError {
     UnknownSpentOutput(OutPoint),
 }
 
-internals::impl_from_infallible!(TxVerifyError);
+impl From<Infallible> for TxVerifyError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for TxVerifyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/crypto/ecdsa.rs b/bitcoin/src/crypto/ecdsa.rs
index 2755f0b511..90e6d105e1 100644
--- a/bitcoin/src/crypto/ecdsa.rs
+++ b/bitcoin/src/crypto/ecdsa.rs
@@ -6,6 +6,7 @@
 
 use core::str::FromStr;
 use core::{fmt, iter};
+use core::convert::Infallible;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
@@ -213,7 +214,9 @@ pub enum DecodeError {
     Secp256k1(secp256k1::Error),
 }
 
-internals::impl_from_infallible!(DecodeError);
+impl From<Infallible> for DecodeError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for DecodeError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -258,7 +261,9 @@ pub enum ParseSignatureError {
     Decode(DecodeError),
 }
 
-internals::impl_from_infallible!(ParseSignatureError);
+impl From<Infallible> for ParseSignatureError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ParseSignatureError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index ac5c8a7c34..e51350afab 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -8,6 +8,7 @@
 use core::fmt::{self, Write as _};
 use core::ops;
 use core::str::FromStr;
+use core::convert::Infallible;
 
 use hashes::hash160;
 use hex::{FromHex, HexToArrayError};
@@ -918,7 +919,9 @@ pub enum FromSliceError {
     InvalidLength(usize),
 }
 
-internals::impl_from_infallible!(FromSliceError);
+impl From<Infallible> for FromSliceError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for FromSliceError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -962,7 +965,9 @@ pub enum FromWifError {
     Secp256k1(secp256k1::Error),
 }
 
-internals::impl_from_infallible!(FromWifError);
+impl From<Infallible> for FromWifError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for FromWifError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -1022,7 +1027,9 @@ pub enum ParsePublicKeyError {
     InvalidHexLength(usize),
 }
 
-internals::impl_from_infallible!(ParsePublicKeyError);
+impl From<Infallible> for ParsePublicKeyError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ParsePublicKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -1061,7 +1068,9 @@ pub enum ParseCompressedPublicKeyError {
     Hex(hex::HexToArrayError),
 }
 
-internals::impl_from_infallible!(ParseCompressedPublicKeyError);
+impl From<Infallible> for ParseCompressedPublicKeyError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ParseCompressedPublicKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 808b64cafb..22999fd1a2 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -12,6 +12,7 @@
 //! [`SighashCache`] and calling its methods.
 
 use core::{fmt, str};
+use core::convert::Infallible;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
@@ -302,7 +303,9 @@ pub enum PrevoutsIndexError {
     InvalidAllIndex,
 }
 
-internals::impl_from_infallible!(PrevoutsIndexError);
+impl From<Infallible> for PrevoutsIndexError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for PrevoutsIndexError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1203,7 +1206,9 @@ pub enum TaprootError {
     InvalidSighashType(u32),
 }
 
-internals::impl_from_infallible!(TaprootError);
+impl From<Infallible> for TaprootError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for TaprootError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1262,7 +1267,9 @@ pub enum P2wpkhError {
     NotP2wpkhScript,
 }
 
-internals::impl_from_infallible!(P2wpkhError);
+impl From<Infallible> for P2wpkhError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl From<transaction::InputsIndexError> for P2wpkhError {
     fn from(value: transaction::InputsIndexError) -> Self { P2wpkhError::Sighash(value) }
@@ -1327,7 +1334,9 @@ pub enum AnnexError {
     IncorrectPrefix(u8),
 }
 
-internals::impl_from_infallible!(AnnexError);
+impl From<Infallible> for AnnexError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for AnnexError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1438,7 +1447,9 @@ pub enum SigningDataError<E> {
     Sighash(E),
 }
 
-internals::impl_from_infallible!(SigningDataError<E>);
+impl<E> From<Infallible> for SigningDataError<E> {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl<E> SigningDataError<E> {
     /// Returns the sighash variant, panicking if it's IO.
diff --git a/bitcoin/src/crypto/taproot.rs b/bitcoin/src/crypto/taproot.rs
index f050a9ec33..fed166e303 100644
--- a/bitcoin/src/crypto/taproot.rs
+++ b/bitcoin/src/crypto/taproot.rs
@@ -5,6 +5,7 @@
 //! This module provides Taproot keys used in Bitcoin (including reexporting secp256k1 keys).
 
 use core::fmt;
+use core::convert::Infallible;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
@@ -96,7 +97,9 @@ pub enum SigFromSliceError {
     InvalidSignatureSize(usize),
 }
 
-internals::impl_from_infallible!(SigFromSliceError);
+impl From<Infallible> for SigFromSliceError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for SigFromSliceError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/merkle_tree/block.rs b/bitcoin/src/merkle_tree/block.rs
index 4410c8a942..d2f6bdacd8 100644
--- a/bitcoin/src/merkle_tree/block.rs
+++ b/bitcoin/src/merkle_tree/block.rs
@@ -10,6 +10,7 @@
 //! Support proofs that transaction(s) belong to a block.
 
 use core::fmt;
+use core::convert::Infallible;
 
 use internals::ToU64 as _;
 use io::{BufRead, Write};
@@ -473,7 +474,9 @@ pub enum MerkleBlockError {
     IdenticalHashesFound,
 }
 
-internals::impl_from_infallible!(MerkleBlockError);
+impl From<Infallible> for MerkleBlockError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for MerkleBlockError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/psbt/error.rs b/bitcoin/src/psbt/error.rs
index 26da3e4f67..35f38146fd 100644
--- a/bitcoin/src/psbt/error.rs
+++ b/bitcoin/src/psbt/error.rs
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use core::fmt;
+use core::convert::Infallible;
 
 use internals::write_err;
 
@@ -107,7 +108,9 @@ pub enum Error {
     Io(io::Error),
 }
 
-internals::impl_from_infallible!(Error);
+impl From<Infallible> for Error {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 370bd61bfc..dfec08fa0a 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -14,6 +14,7 @@ pub mod raw;
 pub mod serialize;
 
 use core::{cmp, fmt};
+use core::convert::Infallible;
 #[cfg(feature = "std")]
 use std::collections::{HashMap, HashSet};
 
@@ -857,7 +858,9 @@ pub enum GetKeyError {
     NotSupported,
 }
 
-internals::impl_from_infallible!(GetKeyError);
+impl From<Infallible> for GetKeyError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for GetKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -970,7 +973,9 @@ pub enum SignError {
     Unsupported,
 }
 
-internals::impl_from_infallible!(SignError);
+impl From<Infallible> for SignError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for SignError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1059,7 +1064,9 @@ pub enum ExtractTxError {
     },
 }
 
-internals::impl_from_infallible!(ExtractTxError);
+impl From<Infallible> for ExtractTxError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for ExtractTxError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1111,7 +1118,9 @@ pub enum IndexOutOfBoundsError {
     },
 }
 
-internals::impl_from_infallible!(IndexOutOfBoundsError);
+impl From<Infallible> for IndexOutOfBoundsError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for IndexOutOfBoundsError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1147,6 +1156,7 @@ impl std::error::Error for IndexOutOfBoundsError {
 mod display_from_str {
     use core::fmt;
     use core::str::FromStr;
+    use core::convert::Infallible;
 
     use base64::display::Base64Display;
     use base64::prelude::{Engine as _, BASE64_STANDARD};
@@ -1164,7 +1174,9 @@ mod display_from_str {
         Base64Encoding(::base64::DecodeError),
     }
 
-    internals::impl_from_infallible!(PsbtParseError);
+    impl From<Infallible> for PsbtParseError {
+        fn from(never: Infallible) -> Self { match never {} }
+    }
 
     impl fmt::Display for PsbtParseError {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/bitcoin/src/sign_message.rs b/bitcoin/src/sign_message.rs
index b931757789..979a174c97 100644
--- a/bitcoin/src/sign_message.rs
+++ b/bitcoin/src/sign_message.rs
@@ -22,6 +22,7 @@ pub const BITCOIN_SIGNED_MSG_PREFIX: &[u8] = b"\x18Bitcoin Signed Message:\n";
 #[cfg(feature = "secp-recovery")]
 mod message_signing {
     use core::fmt;
+    use core::convert::Infallible;
 
     use hashes::sha256d;
     use internals::write_err;
@@ -44,7 +45,9 @@ mod message_signing {
         UnsupportedAddressType(AddressType),
     }
 
-    internals::impl_from_infallible!(MessageSignatureError);
+    impl From<Infallible> for MessageSignatureError {
+        fn from(never: Infallible) -> Self { match never {} }
+    }
 
     impl fmt::Display for MessageSignatureError {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index ca5cbe1157..53a3f95ea5 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -10,6 +10,7 @@ pub mod serialized_signature;
 use core::cmp::{Ordering, Reverse};
 use core::fmt;
 use core::iter::FusedIterator;
+use core::convert::Infallible;
 
 use hashes::{sha256t, HashEngine};
 use internals::{impl_to_hex_from_lower_hex, write_err};
@@ -585,7 +586,9 @@ pub enum IncompleteBuilderError {
     HiddenParts(TaprootBuilder),
 }
 
-internals::impl_from_infallible!(IncompleteBuilderError);
+impl From<Infallible> for IncompleteBuilderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl IncompleteBuilderError {
     /// Converts error into the original incomplete [`TaprootBuilder`] instance.
@@ -631,7 +634,9 @@ pub enum HiddenNodesError {
     HiddenParts(NodeInfo),
 }
 
-internals::impl_from_infallible!(HiddenNodesError);
+impl From<Infallible> for HiddenNodesError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl HiddenNodesError {
     /// Converts error into the original incomplete [`NodeInfo`] instance.
@@ -1341,7 +1346,9 @@ pub enum TaprootBuilderError {
     EmptyTree,
 }
 
-internals::impl_from_infallible!(TaprootBuilderError);
+impl From<Infallible> for TaprootBuilderError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for TaprootBuilderError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1398,7 +1405,9 @@ pub enum TaprootError {
     EmptyTree,
 }
 
-internals::impl_from_infallible!(TaprootError);
+impl From<Infallible> for TaprootError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for TaprootError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1454,7 +1463,9 @@ impl InvalidMerkleBranchSizeError {
     pub fn invalid_merkle_branch_size(&self) -> usize { self.0 }
 }
 
-internals::impl_from_infallible!(InvalidMerkleBranchSizeError);
+impl From<Infallible> for InvalidMerkleBranchSizeError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for InvalidMerkleBranchSizeError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1478,7 +1489,9 @@ impl InvalidMerkleTreeDepthError {
     pub fn invalid_merkle_tree_depth(&self) -> usize { self.0 }
 }
 
-internals::impl_from_infallible!(InvalidMerkleTreeDepthError);
+impl From<Infallible> for InvalidMerkleTreeDepthError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for InvalidMerkleTreeDepthError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1502,7 +1515,9 @@ impl InvalidTaprootLeafVersionError {
     pub fn invalid_leaf_version(&self) -> u8 { self.0 }
 }
 
-internals::impl_from_infallible!(InvalidTaprootLeafVersionError);
+impl From<Infallible> for InvalidTaprootLeafVersionError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for InvalidTaprootLeafVersionError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -1522,7 +1537,9 @@ impl InvalidControlBlockSizeError {
     pub fn invalid_control_block_size(&self) -> usize { self.0 }
 }
 
-internals::impl_from_infallible!(InvalidControlBlockSizeError);
+impl From<Infallible> for InvalidControlBlockSizeError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for InvalidControlBlockSizeError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/internals/src/macros.rs b/internals/src/macros.rs
index ef0addd6fc..69725e232a 100644
--- a/internals/src/macros.rs
+++ b/internals/src/macros.rs
@@ -15,65 +15,6 @@ macro_rules! const_assert {
     }
 }
 
-/// Derives `From<core::convert::Infallible>` for the given type.
-///
-/// Supports types with arbitrary combinations of lifetimes and type parameters.
-///
-/// Note: Paths are not supported (for ex. impl_from_infallible!(Hello<D: std::fmt::Display>).
-///
-/// # Examples
-///
-/// ```rust
-/// # #[allow(unused)]
-/// # fn main() {
-/// # use core::fmt::{Display, Debug};
-/// use bitcoin_internals::impl_from_infallible;
-///
-/// enum AlphaEnum { Item }
-/// impl_from_infallible!(AlphaEnum);
-///
-/// enum BetaEnum<'b> { Item(&'b usize) }
-/// impl_from_infallible!(BetaEnum<'b>);
-///
-/// enum GammaEnum<T> { Item(T) }
-/// impl_from_infallible!(GammaEnum<T>);
-///
-/// enum DeltaEnum<'b, 'a: 'static + 'b, T: 'a, D: Debug + Display + 'a> {
-///     Item((&'b usize, &'a usize, T, D))
-/// }
-/// impl_from_infallible!(DeltaEnum<'b, 'a: 'static + 'b, T: 'a, D: Debug + Display + 'a>);
-///
-/// struct AlphaStruct;
-/// impl_from_infallible!(AlphaStruct);
-///
-/// struct BetaStruct<'b>(&'b usize);
-/// impl_from_infallible!(BetaStruct<'b>);
-///
-/// struct GammaStruct<T>(T);
-/// impl_from_infallible!(GammaStruct<T>);
-///
-/// struct DeltaStruct<'b, 'a: 'static + 'b, T: 'a, D: Debug + Display + 'a> {
-///     hello: &'a T,
-///     what: &'b D,
-/// }
-/// impl_from_infallible!(DeltaStruct<'b, 'a: 'static + 'b, T: 'a, D: Debug + Display + 'a>);
-/// # }
-/// ```
-///
-/// See <https://stackoverflow.com/a/61189128> for more information about this macro.
-#[macro_export]
-macro_rules! impl_from_infallible {
-    ( $name:ident $(< $( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+ >)? ) => {
-        impl $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?
-            From<core::convert::Infallible>
-        for $name
-            $(< $( $lt ),+ >)?
-        {
-            fn from(never: core::convert::Infallible) -> Self { match never {} }
-        }
-    }
-}
-
 /// Adds an implementation of `pub fn to_hex(&self) -> String` if `alloc` feature is enabled.
 ///
 /// The added function allocates a `String` then calls through to [`core::fmt::LowerHex`].
diff --git a/units/src/fee_rate/serde.rs b/units/src/fee_rate/serde.rs
index 281680053f..486b01fe9d 100644
--- a/units/src/fee_rate/serde.rs
+++ b/units/src/fee_rate/serde.rs
@@ -23,6 +23,7 @@
 //! ```
 
 use core::fmt;
+use core::convert::Infallible;
 
 pub mod as_sat_per_kwu {
     //! Serialize and deserialize [`FeeRate`] denominated in satoshis per 1000 weight units.
@@ -243,7 +244,9 @@ pub mod as_sat_per_vb_ceil {
 #[non_exhaustive]
 pub struct OverflowError;
 
-internals::impl_from_infallible!(OverflowError);
+impl From<Infallible> for OverflowError {
+    fn from(never: Infallible) -> Self { match never {} }
+}
 
 impl fmt::Display for OverflowError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

From 4a5b2c60c6dc40905d3081d291536a6cff473813 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 31 Dec 2024 13:30:03 +1100
Subject: [PATCH 190/554] Use ssat variable in tests

As we do in other places use a local variable for the `SignedAmount`
constructor.

Refactor only, no logic change.
---
 units/src/amount/tests.rs | 64 ++++++++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 28 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index f6b8888406..c0766a8638 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -936,6 +936,8 @@ fn serde_as_str_opt() {
 
 #[test]
 fn sum_amounts() {
+    let ssat = SignedAmount::from_sat;
+
     assert_eq!(Amount::ZERO, [].iter().sum::<Amount>());
     assert_eq!(SignedAmount::ZERO, [].iter().sum::<SignedAmount>());
 
@@ -945,16 +947,15 @@ fn sum_amounts() {
     let sum = amounts.into_iter().sum::<Amount>();
     assert_eq!(Amount::from_sat(1400), sum);
 
-    let amounts =
-        [SignedAmount::from_sat(-42), SignedAmount::from_sat(1337), SignedAmount::from_sat(21)];
-    assert_eq!(amounts.iter().sum::<SignedAmount>(), SignedAmount::from_sat(1316));
-
+    let amounts = [ssat(-42), ssat(1337), ssat(21)];
     let sum = amounts.into_iter().sum::<SignedAmount>();
-    assert_eq!(SignedAmount::from_sat(1316), sum);
+    assert_eq!(ssat(1316), sum);
 }
 
 #[test]
 fn checked_sum_amounts() {
+    let ssat = SignedAmount::from_sat;
+
     assert_eq!(Some(Amount::ZERO), [].into_iter().checked_sum());
     assert_eq!(Some(SignedAmount::ZERO), [].into_iter().checked_sum());
 
@@ -966,18 +967,17 @@ fn checked_sum_amounts() {
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 
-    let amounts = [SignedAmount::MIN, SignedAmount::from_sat(-1), SignedAmount::from_sat(21)];
+    let amounts = [SignedAmount::MIN, ssat(-1), ssat(21)];
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 
-    let amounts = [SignedAmount::MAX, SignedAmount::from_sat(1), SignedAmount::from_sat(21)];
+    let amounts = [SignedAmount::MAX, ssat(1), ssat(21)];
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 
-    let amounts =
-        [SignedAmount::from_sat(42), SignedAmount::from_sat(3301), SignedAmount::from_sat(21)];
+    let amounts = [ssat(42), ssat(3301), ssat(21)];
     let sum = amounts.into_iter().checked_sum();
-    assert_eq!(Some(SignedAmount::from_sat(3364)), sum);
+    assert_eq!(Some(ssat(3364)), sum);
 }
 
 #[test]
@@ -1094,9 +1094,11 @@ fn unsigned_sub_assign() {
 #[test]
 #[allow(clippy::op_ref)]
 fn signed_addition() {
-    let one = SignedAmount::from_sat(1);
-    let two = SignedAmount::from_sat(2);
-    let three = SignedAmount::from_sat(3);
+    let ssat = SignedAmount::from_sat;
+
+    let one = ssat(1);
+    let two = ssat(2);
+    let three = ssat(3);
 
     assert!(one + two == three);
     assert!(&one + two == three);
@@ -1107,9 +1109,11 @@ fn signed_addition() {
 #[test]
 #[allow(clippy::op_ref)]
 fn signed_subtract() {
-    let one = SignedAmount::from_sat(1);
-    let two = SignedAmount::from_sat(2);
-    let three = SignedAmount::from_sat(3);
+    let ssat = SignedAmount::from_sat;
+
+    let one = ssat(1);
+    let two = ssat(2);
+    let three = ssat(3);
 
     assert!(three - two == one);
     assert!(&three - two == one);
@@ -1119,22 +1123,26 @@ fn signed_subtract() {
 
 #[test]
 fn signed_add_assign() {
-    let mut f = SignedAmount::from_sat(1);
-    f += SignedAmount::from_sat(2);
-    assert_eq!(f, SignedAmount::from_sat(3));
+    let ssat = SignedAmount::from_sat;
 
-    let mut f = SignedAmount::from_sat(1);
-    f += &SignedAmount::from_sat(2);
-    assert_eq!(f, SignedAmount::from_sat(3));
+    let mut f = ssat(1);
+    f += ssat(2);
+    assert_eq!(f, ssat(3));
+
+    let mut f = ssat(1);
+    f += &ssat(2);
+    assert_eq!(f, ssat(3));
 }
 
 #[test]
 fn signed_sub_assign() {
-    let mut f = SignedAmount::from_sat(3);
-    f -= SignedAmount::from_sat(2);
-    assert_eq!(f, SignedAmount::from_sat(1));
+    let ssat = SignedAmount::from_sat;
+
+    let mut f = ssat(3);
+    f -= ssat(2);
+    assert_eq!(f, ssat(1));
 
-    let mut f = SignedAmount::from_sat(3);
-    f -= &SignedAmount::from_sat(2);
-    assert_eq!(f, SignedAmount::from_sat(1));
+    let mut f = ssat(3);
+    f -= &ssat(2);
+    assert_eq!(f, ssat(1));
 }

From 09df951760e02bdcc488616d3f924046c6d28e85 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 31 Dec 2024 13:31:08 +1100
Subject: [PATCH 191/554] Use sat variable in tests

As we do in other places use a local variable for the `Amount`
constructor.

Refactor only, no logic change.
---
 units/src/amount/tests.rs | 98 +++++++++++++++++++++------------------
 1 file changed, 54 insertions(+), 44 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index c0766a8638..03adce6ace 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -936,16 +936,15 @@ fn serde_as_str_opt() {
 
 #[test]
 fn sum_amounts() {
+    let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
     assert_eq!(Amount::ZERO, [].iter().sum::<Amount>());
     assert_eq!(SignedAmount::ZERO, [].iter().sum::<SignedAmount>());
 
-    let amounts = [Amount::from_sat(42), Amount::from_sat(1337), Amount::from_sat(21)];
-    assert_eq!(amounts.iter().sum::<Amount>(), Amount::from_sat(1400));
-
+    let amounts = [sat(42), sat(1337), sat(21)];
     let sum = amounts.into_iter().sum::<Amount>();
-    assert_eq!(Amount::from_sat(1400), sum);
+    assert_eq!(sat(1400), sum);
 
     let amounts = [ssat(-42), ssat(1337), ssat(21)];
     let sum = amounts.into_iter().sum::<SignedAmount>();
@@ -954,16 +953,17 @@ fn sum_amounts() {
 
 #[test]
 fn checked_sum_amounts() {
+    let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
     assert_eq!(Some(Amount::ZERO), [].into_iter().checked_sum());
     assert_eq!(Some(SignedAmount::ZERO), [].into_iter().checked_sum());
 
-    let amounts = [Amount::from_sat(42), Amount::from_sat(1337), Amount::from_sat(21)];
+    let amounts = [sat(42), sat(1337), sat(21)];
     let sum = amounts.into_iter().checked_sum();
-    assert_eq!(Some(Amount::from_sat(1400)), sum);
+    assert_eq!(Some(sat(1400)), sum);
 
-    let amounts = [Amount::from_sat(u64::MAX), Amount::from_sat(1337), Amount::from_sat(21)];
+    let amounts = [sat(u64::MAX), sat(1337), sat(21)];
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(None, sum);
 
@@ -1020,35 +1020,39 @@ fn disallow_unknown_denomination() {
 #[test]
 #[cfg(feature = "alloc")]
 fn trailing_zeros_for_amount() {
-    assert_eq!(format!("{}", Amount::from_sat(1_000_000)), "0.01 BTC");
+    let sat = Amount::from_sat;
+
+    assert_eq!(format!("{}", sat(1_000_000)), "0.01 BTC");
     assert_eq!(format!("{}", Amount::ONE_SAT), "0.00000001 BTC");
     assert_eq!(format!("{}", Amount::ONE_BTC), "1 BTC");
-    assert_eq!(format!("{}", Amount::from_sat(1)), "0.00000001 BTC");
-    assert_eq!(format!("{}", Amount::from_sat(10)), "0.0000001 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(10)), "0.00 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(100)), "0.00 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(1000)), "0.00 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(10_000)), "0.00 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(100_000)), "0.00 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(1_000_000)), "0.01 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(10_000_000)), "0.10 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(100_000_000)), "1.00 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(500_000)), "0.01 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(9_500_000)), "0.10 BTC");
-    assert_eq!(format!("{:.2}", Amount::from_sat(99_500_000)), "1.00 BTC");
-    assert_eq!(format!("{}", Amount::from_sat(100_000_000)), "1 BTC");
-    assert_eq!(format!("{}", Amount::from_sat(40_000_000_000)), "400 BTC");
-    assert_eq!(format!("{:.10}", Amount::from_sat(100_000_000)), "1.0000000000 BTC");
-    assert_eq!(format!("{}", Amount::from_sat(400_000_000_000_010)), "4000000.0000001 BTC");
-    assert_eq!(format!("{}", Amount::from_sat(400_000_000_000_000)), "4000000 BTC");
+    assert_eq!(format!("{}", sat(1)), "0.00000001 BTC");
+    assert_eq!(format!("{}", sat(10)), "0.0000001 BTC");
+    assert_eq!(format!("{:.2}", sat(10)), "0.00 BTC");
+    assert_eq!(format!("{:.2}", sat(100)), "0.00 BTC");
+    assert_eq!(format!("{:.2}", sat(1000)), "0.00 BTC");
+    assert_eq!(format!("{:.2}", sat(10_000)), "0.00 BTC");
+    assert_eq!(format!("{:.2}", sat(100_000)), "0.00 BTC");
+    assert_eq!(format!("{:.2}", sat(1_000_000)), "0.01 BTC");
+    assert_eq!(format!("{:.2}", sat(10_000_000)), "0.10 BTC");
+    assert_eq!(format!("{:.2}", sat(100_000_000)), "1.00 BTC");
+    assert_eq!(format!("{:.2}", sat(500_000)), "0.01 BTC");
+    assert_eq!(format!("{:.2}", sat(9_500_000)), "0.10 BTC");
+    assert_eq!(format!("{:.2}", sat(99_500_000)), "1.00 BTC");
+    assert_eq!(format!("{}", sat(100_000_000)), "1 BTC");
+    assert_eq!(format!("{}", sat(40_000_000_000)), "400 BTC");
+    assert_eq!(format!("{:.10}", sat(100_000_000)), "1.0000000000 BTC");
+    assert_eq!(format!("{}", sat(400_000_000_000_010)), "4000000.0000001 BTC");
+    assert_eq!(format!("{}", sat(400_000_000_000_000)), "4000000 BTC");
 }
 
 #[test]
 #[allow(clippy::op_ref)]
 fn unsigned_addition() {
-    let one = Amount::from_sat(1);
-    let two = Amount::from_sat(2);
-    let three = Amount::from_sat(3);
+    let sat = Amount::from_sat;
+
+    let one = sat(1);
+    let two = sat(2);
+    let three = sat(3);
 
     assert!(one + two == three);
     assert!(&one + two == three);
@@ -1059,9 +1063,11 @@ fn unsigned_addition() {
 #[test]
 #[allow(clippy::op_ref)]
 fn unsigned_subtract() {
-    let one = Amount::from_sat(1);
-    let two = Amount::from_sat(2);
-    let three = Amount::from_sat(3);
+    let sat = Amount::from_sat;
+
+    let one = sat(1);
+    let two = sat(2);
+    let three = sat(3);
 
     assert!(three - two == one);
     assert!(&three - two == one);
@@ -1071,24 +1077,28 @@ fn unsigned_subtract() {
 
 #[test]
 fn unsigned_add_assign() {
-    let mut f = Amount::from_sat(1);
-    f += Amount::from_sat(2);
-    assert_eq!(f, Amount::from_sat(3));
+    let sat = Amount::from_sat;
 
-    let mut f = Amount::from_sat(1);
-    f += &Amount::from_sat(2);
-    assert_eq!(f, Amount::from_sat(3));
+    let mut f = sat(1);
+    f += sat(2);
+    assert_eq!(f, sat(3));
+
+    let mut f = sat(1);
+    f += &sat(2);
+    assert_eq!(f, sat(3));
 }
 
 #[test]
 fn unsigned_sub_assign() {
-    let mut f = Amount::from_sat(3);
-    f -= Amount::from_sat(2);
-    assert_eq!(f, Amount::from_sat(1));
+    let sat = Amount::from_sat;
+
+    let mut f = sat(3);
+    f -= sat(2);
+    assert_eq!(f, sat(1));
 
-    let mut f = Amount::from_sat(3);
-    f -= &Amount::from_sat(2);
-    assert_eq!(f, Amount::from_sat(1));
+    let mut f = sat(3);
+    f -= &sat(2);
+    assert_eq!(f, sat(1));
 }
 
 #[test]

From a7c44cebf9975c4eeba56a65c0ea65be90e5c7f3 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 31 Dec 2024 13:38:52 +1100
Subject: [PATCH 192/554] Use _unchecked to construct amounts

We have a `_unchecked` constructor now for both `Amount` and
`SignedAmount`. In preparation for enforcing the `MAX_MONEY` invariant
use the `_unchecked` constructor throughout the codebase to construct
amounts from hard coded integer values.
---
 bitcoin/examples/ecdsa-psbt-simple.rs   |  8 +++---
 bitcoin/examples/sign-tx-segwit-v0.rs   |  6 ++---
 bitcoin/examples/sign-tx-taproot.rs     |  6 ++---
 bitcoin/examples/taproot-psbt-simple.rs |  8 +++---
 bitcoin/examples/taproot-psbt.rs        |  2 +-
 bitcoin/src/blockdata/constants.rs      |  2 +-
 bitcoin/src/blockdata/script/tests.rs   | 10 +++----
 bitcoin/src/crypto/sighash.rs           |  6 ++---
 bitcoin/src/psbt/mod.rs                 | 36 ++++++++++++-------------
 bitcoin/tests/serde.rs                  |  4 +--
 units/src/amount/tests.rs               | 18 ++++++-------
 11 files changed, 53 insertions(+), 53 deletions(-)

diff --git a/bitcoin/examples/ecdsa-psbt-simple.rs b/bitcoin/examples/ecdsa-psbt-simple.rs
index 4e2ca10855..45014db096 100644
--- a/bitcoin/examples/ecdsa-psbt-simple.rs
+++ b/bitcoin/examples/ecdsa-psbt-simple.rs
@@ -46,12 +46,12 @@ const BIP84_DERIVATION_PATH: &str = "m/84'/0'/0'";
 const MASTER_FINGERPRINT: &str = "9680603f";
 
 // The dummy UTXO amounts we are spending.
-const DUMMY_UTXO_AMOUNT_INPUT_1: Amount = Amount::from_sat(20_000_000);
-const DUMMY_UTXO_AMOUNT_INPUT_2: Amount = Amount::from_sat(10_000_000);
+const DUMMY_UTXO_AMOUNT_INPUT_1: Amount = Amount::from_sat_unchecked(20_000_000);
+const DUMMY_UTXO_AMOUNT_INPUT_2: Amount = Amount::from_sat_unchecked(10_000_000);
 
 // The amounts we are sending to someone, and receiving back as change.
-const SPEND_AMOUNT: Amount = Amount::from_sat(25_000_000);
-const CHANGE_AMOUNT: Amount = Amount::from_sat(4_990_000); // 10_000 sat fee.
+const SPEND_AMOUNT: Amount = Amount::from_sat_unchecked(25_000_000);
+const CHANGE_AMOUNT: Amount = Amount::from_sat_unchecked(4_990_000); // 10_000 sat fee.
 
 // Derive the external address xpriv.
 fn get_external_address_xpriv<C: Signing>(
diff --git a/bitcoin/examples/sign-tx-segwit-v0.rs b/bitcoin/examples/sign-tx-segwit-v0.rs
index d3ab610301..f7d35c5842 100644
--- a/bitcoin/examples/sign-tx-segwit-v0.rs
+++ b/bitcoin/examples/sign-tx-segwit-v0.rs
@@ -12,9 +12,9 @@ use bitcoin::{
     Txid, WPubkeyHash, Witness,
 };
 
-const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat(20_000_000);
-const SPEND_AMOUNT: Amount = Amount::from_sat(5_000_000);
-const CHANGE_AMOUNT: Amount = Amount::from_sat(14_999_000); // 1000 sat fee.
+const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_unchecked(20_000_000);
+const SPEND_AMOUNT: Amount = Amount::from_sat_unchecked(5_000_000);
+const CHANGE_AMOUNT: Amount = Amount::from_sat_unchecked(14_999_000); // 1000 sat fee.
 
 fn main() {
     let secp = Secp256k1::new();
diff --git a/bitcoin/examples/sign-tx-taproot.rs b/bitcoin/examples/sign-tx-taproot.rs
index b7e22aa4d8..ade7f2dcfb 100644
--- a/bitcoin/examples/sign-tx-taproot.rs
+++ b/bitcoin/examples/sign-tx-taproot.rs
@@ -13,9 +13,9 @@ use bitcoin::{
     Txid, Witness,
 };
 
-const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat(20_000_000);
-const SPEND_AMOUNT: Amount = Amount::from_sat(5_000_000);
-const CHANGE_AMOUNT: Amount = Amount::from_sat(14_999_000); // 1000 sat fee.
+const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_unchecked(20_000_000);
+const SPEND_AMOUNT: Amount = Amount::from_sat_unchecked(5_000_000);
+const CHANGE_AMOUNT: Amount = Amount::from_sat_unchecked(14_999_000); // 1000 sat fee.
 
 fn main() {
     let secp = Secp256k1::new();
diff --git a/bitcoin/examples/taproot-psbt-simple.rs b/bitcoin/examples/taproot-psbt-simple.rs
index 372c1a9693..8671032c10 100644
--- a/bitcoin/examples/taproot-psbt-simple.rs
+++ b/bitcoin/examples/taproot-psbt-simple.rs
@@ -45,12 +45,12 @@ const BIP86_DERIVATION_PATH: &str = "m/86'/0'/0'";
 const MASTER_FINGERPRINT: &str = "9680603f";
 
 // The dummy UTXO amounts we are spending.
-const DUMMY_UTXO_AMOUNT_INPUT_1: Amount = Amount::from_sat(20_000_000);
-const DUMMY_UTXO_AMOUNT_INPUT_2: Amount = Amount::from_sat(10_000_000);
+const DUMMY_UTXO_AMOUNT_INPUT_1: Amount = Amount::from_sat_unchecked(20_000_000);
+const DUMMY_UTXO_AMOUNT_INPUT_2: Amount = Amount::from_sat_unchecked(10_000_000);
 
 // The amounts we are sending to someone, and receiving back as change.
-const SPEND_AMOUNT: Amount = Amount::from_sat(25_000_000);
-const CHANGE_AMOUNT: Amount = Amount::from_sat(4_990_000); // 10_000 sat fee.
+const SPEND_AMOUNT: Amount = Amount::from_sat_unchecked(25_000_000);
+const CHANGE_AMOUNT: Amount = Amount::from_sat_unchecked(4_990_000); // 10_000 sat fee.
 
 // Derive the external address xpriv.
 fn get_external_address_xpriv<C: Signing>(
diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index 4a69d718fd..16b0650991 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -40,7 +40,7 @@ const UTXO_SCRIPT_PUBKEY: &str =
     "5120be27fa8b1f5278faf82cab8da23e8761f8f9bd5d5ebebbb37e0e12a70d92dd16";
 const UTXO_PUBKEY: &str = "a6ac32163539c16b6b5dbbca01b725b8e8acaa5f821ba42c80e7940062140d19";
 const UTXO_MASTER_FINGERPRINT: &str = "e61b318f";
-const ABSOLUTE_FEES_IN_SATS: Amount = Amount::from_sat(1_000);
+const ABSOLUTE_FEES_IN_SATS: Amount = Amount::from_sat_unchecked(1_000);
 
 // UTXO_1 will be used for spending example 1
 const UTXO_1: P2trUtxo = P2trUtxo {
diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 2daa455fe7..91821fe709 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -112,7 +112,7 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
         witness: Witness::default(),
     });
 
-    ret.output.push(TxOut { value: Amount::from_sat(50 * 100_000_000), script_pubkey: out_script });
+    ret.output.push(TxOut { value: Amount::from_sat_unchecked(50 * 100_000_000), script_pubkey: out_script });
 
     // end
     ret
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 38577db866..b14ec86f47 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -676,7 +676,7 @@ fn bitcoinconsensus() {
     let spent_bytes = hex!("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d");
     let spent = Script::from_bytes(&spent_bytes);
     let spending = hex!("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000");
-    spent.verify(0, crate::Amount::from_sat(18393430), &spending).unwrap();
+    spent.verify(0, crate::Amount::from_sat_unchecked(18393430), &spending).unwrap();
 }
 
 #[test]
@@ -685,10 +685,10 @@ fn default_dust_value() {
     // well-known scriptPubKey types.
     let script_p2wpkh = Builder::new().push_int_unchecked(0).push_slice([42; 20]).into_script();
     assert!(script_p2wpkh.is_p2wpkh());
-    assert_eq!(script_p2wpkh.minimal_non_dust(), crate::Amount::from_sat(294));
+    assert_eq!(script_p2wpkh.minimal_non_dust(), crate::Amount::from_sat_unchecked(294));
     assert_eq!(
         script_p2wpkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
-        crate::Amount::from_sat(588)
+        crate::Amount::from_sat_unchecked(588)
     );
 
     let script_p2pkh = Builder::new()
@@ -699,10 +699,10 @@ fn default_dust_value() {
         .push_opcode(OP_CHECKSIG)
         .into_script();
     assert!(script_p2pkh.is_p2pkh());
-    assert_eq!(script_p2pkh.minimal_non_dust(), crate::Amount::from_sat(546));
+    assert_eq!(script_p2pkh.minimal_non_dust(), crate::Amount::from_sat_unchecked(546));
     assert_eq!(
         script_p2pkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
-        crate::Amount::from_sat(1092)
+        crate::Amount::from_sat_unchecked(1092)
     );
 }
 
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 808b64cafb..24803edf85 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -2064,7 +2064,7 @@ mod tests {
         ).unwrap();
 
         let spk = ScriptBuf::from_hex("00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1").unwrap();
-        let value = Amount::from_sat(600_000_000);
+        let value = Amount::from_sat_unchecked(600_000_000);
 
         let mut cache = SighashCache::new(&tx);
         assert_eq!(
@@ -2105,7 +2105,7 @@ mod tests {
 
         let redeem_script =
             ScriptBuf::from_hex("001479091972186c449eb1ded22b78e40d009bdf0089").unwrap();
-        let value = Amount::from_sat(1_000_000_000);
+        let value = Amount::from_sat_unchecked(1_000_000_000);
 
         let mut cache = SighashCache::new(&tx);
         assert_eq!(
@@ -2155,7 +2155,7 @@ mod tests {
         )
         .unwrap();
 
-        let value = Amount::from_sat(987_654_321);
+        let value = Amount::from_sat_unchecked(987_654_321);
         (tx, witness_script, value)
     }
 
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 370bd61bfc..1dcbfb55d9 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -1413,14 +1413,14 @@ mod tests {
                 }],
                 output: vec![
                     TxOut {
-                        value: Amount::from_sat(99_999_699),
+                        value: Amount::from_sat_unchecked(99_999_699),
                         script_pubkey: ScriptBuf::from_hex(
                             "76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac",
                         )
                         .unwrap(),
                     },
                     TxOut {
-                        value: Amount::from_sat(100_000_000),
+                        value: Amount::from_sat_unchecked(100_000_000),
                         script_pubkey: ScriptBuf::from_hex(
                             "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
                         )
@@ -1486,7 +1486,7 @@ mod tests {
                 )]),
             }],
             output: vec![TxOut {
-                value: Amount::from_sat(190_303_501_938),
+                value: Amount::from_sat_unchecked(190_303_501_938),
                 script_pubkey: ScriptBuf::from_hex(
                     "a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587",
                 )
@@ -1537,7 +1537,7 @@ mod tests {
                 Input {
                     non_witness_utxo: Some(tx),
                     witness_utxo: Some(TxOut {
-                        value: Amount::from_sat(190_303_501_938),
+                        value: Amount::from_sat_unchecked(190_303_501_938),
                         script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                     }),
                     sighash_type: Some("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY".parse::<PsbtSighashType>().unwrap()),
@@ -1662,11 +1662,11 @@ mod tests {
                     ],
                     output: vec![
                         TxOut {
-                            value: Amount::from_sat(99_999_699),
+                            value: Amount::from_sat_unchecked(99_999_699),
                             script_pubkey: ScriptBuf::from_hex("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
                         },
                         TxOut {
-                            value: Amount::from_sat(100_000_000),
+                            value: Amount::from_sat_unchecked(100_000_000),
                             script_pubkey: ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
                         },
                     ],
@@ -1709,11 +1709,11 @@ mod tests {
                             ],
                             output: vec![
                                 TxOut {
-                                    value: Amount::from_sat(200_000_000),
+                                    value: Amount::from_sat_unchecked(200_000_000),
                                     script_pubkey: ScriptBuf::from_hex("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
                                 },
                                 TxOut {
-                                    value: Amount::from_sat(190_303_501_938),
+                                    value: Amount::from_sat_unchecked(190_303_501_938),
                                     script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                                 },
                             ],
@@ -1995,11 +1995,11 @@ mod tests {
                 ],
                 output: vec![
                     TxOut {
-                        value: Amount::from_sat(99_999_699),
+                        value: Amount::from_sat_unchecked(99_999_699),
                         script_pubkey: ScriptBuf::from_hex("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
                     },
                     TxOut {
-                        value: Amount::from_sat(100_000_000),
+                        value: Amount::from_sat_unchecked(100_000_000),
                         script_pubkey: ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
                     },
                 ],
@@ -2042,11 +2042,11 @@ mod tests {
                         ],
                         output: vec![
                             TxOut {
-                                value: Amount::from_sat(200_000_000),
+                                value: Amount::from_sat_unchecked(200_000_000),
                                 script_pubkey: ScriptBuf::from_hex("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
                             },
                             TxOut {
-                                value: Amount::from_sat(190_303_501_938),
+                                value: Amount::from_sat_unchecked(190_303_501_938),
                                 script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                             },
                         ],
@@ -2155,9 +2155,9 @@ mod tests {
 
     #[test]
     fn fee() {
-        let output_0_val = Amount::from_sat(99_999_699);
-        let output_1_val = Amount::from_sat(100_000_000);
-        let prev_output_val = Amount::from_sat(200_000_000);
+        let output_0_val = Amount::from_sat_unchecked(99_999_699);
+        let output_1_val = Amount::from_sat_unchecked(100_000_000);
+        let prev_output_val = Amount::from_sat_unchecked(200_000_000);
 
         let t = Psbt {
             unsigned_tx: Transaction {
@@ -2218,7 +2218,7 @@ mod tests {
                                 script_pubkey:  ScriptBuf::new()
                             },
                             TxOut {
-                                value: Amount::from_sat(190_303_501_938),
+                                value: Amount::from_sat_unchecked(190_303_501_938),
                                 script_pubkey:  ScriptBuf::new()
                             },
                         ],
@@ -2280,7 +2280,7 @@ mod tests {
 
         // First input we can spend. See comment above on key_map for why we use defaults here.
         let txout_wpkh = TxOut {
-            value: Amount::from_sat(10),
+            value: Amount::from_sat_unchecked(10),
             script_pubkey: ScriptBuf::new_p2wpkh(pk.wpubkey_hash().unwrap()),
         };
         psbt.inputs[0].witness_utxo = Some(txout_wpkh);
@@ -2292,7 +2292,7 @@ mod tests {
         // Second input is unspendable by us e.g., from another wallet that supports future upgrades.
         let unknown_prog = WitnessProgram::new(WitnessVersion::V4, &[0xaa; 34]).unwrap();
         let txout_unknown_future = TxOut {
-            value: Amount::from_sat(10),
+            value: Amount::from_sat_unchecked(10),
             script_pubkey: ScriptBuf::new_witness_program(&unknown_prog),
         };
         psbt.inputs[1].witness_utxo = Some(txout_unknown_future);
diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
index af6f26ad76..f28c878d5a 100644
--- a/bitcoin/tests/serde.rs
+++ b/bitcoin/tests/serde.rs
@@ -238,7 +238,7 @@ fn serde_regression_psbt() {
             .unwrap()]),
         }],
         output: vec![TxOut {
-            value: Amount::from_sat(190_303_501_938),
+            value: Amount::from_sat_unchecked(190_303_501_938),
             script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587")
                 .unwrap(),
         }],
@@ -285,7 +285,7 @@ fn serde_regression_psbt() {
         inputs: vec![Input {
             non_witness_utxo: Some(tx),
             witness_utxo: Some(TxOut {
-                value: Amount::from_sat(190_303_501_938),
+                value: Amount::from_sat_unchecked(190_303_501_938),
                 script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
             }),
             sighash_type: Some(PsbtSighashType::from("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY".parse::<EcdsaSighashType>().unwrap())),
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 03adce6ace..eccaed53b9 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -759,8 +759,8 @@ fn serde_as_btc() {
     }
 
     let orig = T {
-        amt: Amount::from_sat(20_000_000__000_000_01),
-        samt: SignedAmount::from_sat(-20_000_000__000_000_01),
+        amt: Amount::from_sat_unchecked(20_000_000__000_000_01),
+        samt: SignedAmount::from_sat_unchecked(-20_000_000__000_000_01),
     };
 
     let json = "{\"amt\": 20000000.00000001, \
@@ -795,7 +795,7 @@ fn serde_as_str() {
     }
 
     serde_test::assert_tokens(
-        &T { amt: Amount::from_sat(123_456_789), samt: SignedAmount::from_sat(-123_456_789) },
+        &T { amt: Amount::from_sat_unchecked(123_456_789), samt: SignedAmount::from_sat_unchecked(-123_456_789) },
         &[
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::String("amt"),
@@ -823,8 +823,8 @@ fn serde_as_btc_opt() {
     }
 
     let with = T {
-        amt: Some(Amount::from_sat(2_500_000_00)),
-        samt: Some(SignedAmount::from_sat(-2_500_000_00)),
+        amt: Some(Amount::from_sat_unchecked(2_500_000_00)),
+        samt: Some(SignedAmount::from_sat_unchecked(-2_500_000_00)),
     };
     let without = T { amt: None, samt: None };
 
@@ -865,8 +865,8 @@ fn serde_as_sat_opt() {
     }
 
     let with = T {
-        amt: Some(Amount::from_sat(2_500_000_00)),
-        samt: Some(SignedAmount::from_sat(-2_500_000_00)),
+        amt: Some(Amount::from_sat_unchecked(2_500_000_00)),
+        samt: Some(SignedAmount::from_sat_unchecked(-2_500_000_00)),
     };
     let without = T { amt: None, samt: None };
 
@@ -907,8 +907,8 @@ fn serde_as_str_opt() {
     }
 
     let with = T {
-        amt: Some(Amount::from_sat(123_456_789)),
-        samt: Some(SignedAmount::from_sat(-123_456_789)),
+        amt: Some(Amount::from_sat_unchecked(123_456_789)),
+        samt: Some(SignedAmount::from_sat_unchecked(-123_456_789)),
     };
     let without = T { amt: None, samt: None };
 

From 0e5d6db7df9a1f9b4e9180d49cf1532551570e33 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 30 Dec 2024 11:25:19 +1100
Subject: [PATCH 193/554] units: Don't ignore serde examples

There is no reason to ignore the rustdoc example in
`units::amount::serde`. The `as_btc` function requires the `alloc`
features so use `as_sat` in the example instead.

While we are at it clean up the whole block of rustdocs.
---
 units/src/amount/serde.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index f022ba1594..e7be0fd5d9 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -3,19 +3,20 @@
 // methods are implementation of a standardized serde-specific signature
 #![allow(missing_docs)]
 
-//! This module adds serde serialization and deserialization support for Amounts.
+//! 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:
+//! 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 serialization to use.
 //!
-//! ```rust,ignore
+//! # Examples
+//!
+//! ```
 //! use serde::{Serialize, Deserialize};
 //! use bitcoin_units::Amount;
 //!
 //! #[derive(Serialize, Deserialize)]
 //! pub struct HasAmount {
-//!     #[serde(with = "bitcoin_units::amount::serde::as_btc")]
+//!     #[serde(with = "bitcoin_units::amount::serde::as_sat")]
 //!     pub amount: Amount,
 //! }
 //! ```

From aaa20fc098d480f53328736843643e0583c61d17 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 30 Dec 2024 12:11:18 +1100
Subject: [PATCH 194/554] units: Move code comment to correct imports

This comment is meant to be on top of the `bitcoin_units` imports.
---
 units/tests/api.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/tests/api.rs b/units/tests/api.rs
index 647e29903e..2ae373c2f7 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -21,9 +21,9 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
-// These imports test "typical" usage by user code.
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+// These imports test "typical" usage by user code.
 use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::Height`.
 use bitcoin_units::{
     amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, FeeRate,

From a8fbd5e302fb02b0eaba373c32401204d35e6d98 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 30 Dec 2024 13:39:29 +1100
Subject: [PATCH 195/554] units: Remove api docs

These docs a way too prone to going stale; we only wrote these a week
ago and they are stale already.

Lets just remove them.
---
 units/tests/api.rs | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/units/tests/api.rs b/units/tests/api.rs
index 2ae373c2f7..63bdd7fe07 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -4,18 +4,6 @@
 //!
 //! The point of these tests are to check the API surface as opposed to test the API functionality.
 //!
-//! What this module tests:
-//!
-//! - The location of re-exports for various typical usage styles.
-//! - Regressions in the API surface (things being accidentally moved).
-//! - All public types implement Debug (C-DEBUG).
-//! - For all non-error types:
-//!     - `Debug` representation is never empty (C-DEBUG-NONEMPTY)
-//! - For all error types:
-//!     - Derive standard traits as defined by `rust-bitcoin` policy.
-//!
-//! This file was created by referring to the output of `cargo check-api`.
-//!
 //! ref: <https://rust-lang.github.io/api-guidelines/about.html>
 
 #![allow(dead_code)]

From 01f3eefc12b205a66ce3e2b04c579070d01d9152 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 30 Dec 2024 12:15:14 +1100
Subject: [PATCH 196/554] io: Move bridge type constructors

Put the constructors at the top of the impl block.

Code move only.
---
 io/src/bridge.rs | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/io/src/bridge.rs b/io/src/bridge.rs
index a979f73870..fe37f42923 100644
--- a/io/src/bridge.rs
+++ b/io/src/bridge.rs
@@ -123,18 +123,6 @@ impl<T> ToStd<T> {
     #[inline]
     pub const fn new(inner: T) -> Self { Self(inner) }
 
-    /// Returns the wrapped value.
-    #[inline]
-    pub fn into_inner(self) -> T { self.0 }
-
-    /// Returns a reference to the wrapped value.
-    #[inline]
-    pub fn inner(&self) -> &T { &self.0 }
-
-    /// Returns a mutable reference to the wrapped value.
-    #[inline]
-    pub fn inner_mut(&mut self) -> &mut T { &mut self.0 }
-
     /// Wraps a mutable reference to IO type.
     #[inline]
     pub fn new_mut(inner: &mut T) -> &mut Self {
@@ -149,6 +137,18 @@ impl<T> ToStd<T> {
         // SAFETY: the type is repr(transparent) and the pointer is created from Box
         unsafe { Box::from_raw(Box::into_raw(inner) as *mut Self) }
     }
+
+    /// Returns the wrapped value.
+    #[inline]
+    pub fn into_inner(self) -> T { self.0 }
+
+    /// Returns a reference to the wrapped value.
+    #[inline]
+    pub fn inner(&self) -> &T { &self.0 }
+
+    /// Returns a mutable reference to the wrapped value.
+    #[inline]
+    pub fn inner_mut(&mut self) -> &mut T { &mut self.0 }
 }
 
 impl<T: super::Read> std::io::Read for ToStd<T> {

From 1175faca323cee580b83ca34410c995be9521db7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 30 Dec 2024 12:51:58 +1100
Subject: [PATCH 197/554] io: Introduce api test file

Introduce an `io/tests/api.rs` file to test the API surface of the `io`
crate. In doing so fix C-DEBUG and prove C-DEBUG-NONEMPTY.

C-DEBUG: https://rust-lang.github.io/api-guidelines/debuggability.html#c-debug
---
 io/src/bridge.rs |   2 +
 io/src/lib.rs    |   3 +
 io/tests/api.rs  | 140 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 145 insertions(+)
 create mode 100644 io/tests/api.rs

diff --git a/io/src/bridge.rs b/io/src/bridge.rs
index fe37f42923..471a6aba04 100644
--- a/io/src/bridge.rs
+++ b/io/src/bridge.rs
@@ -5,6 +5,7 @@ use internals::rust_version;
 
 /// A bridging wrapper providing the IO traits for types that already implement `std` IO traits.
 #[repr(transparent)]
+#[derive(Debug)]
 pub struct FromStd<T>(T);
 
 impl<T> FromStd<T> {
@@ -116,6 +117,7 @@ impl<T: std::io::Write> std::io::Write for FromStd<T> {
 
 /// A bridging wrapper providing the std traits for types that already implement our traits.
 #[repr(transparent)]
+#[derive(Debug)]
 pub struct ToStd<T>(T);
 
 impl<T> ToStd<T> {
diff --git a/io/src/lib.rs b/io/src/lib.rs
index 35e12b6311..c8d846dd5a 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -94,6 +94,7 @@ pub trait BufRead: Read {
 /// Reader adapter which limits the bytes read from an underlying reader.
 ///
 /// Created by calling `[Read::take]`.
+#[derive(Debug)]
 pub struct Take<'a, R: Read + ?Sized> {
     reader: &'a mut R,
     remaining: u64,
@@ -191,6 +192,7 @@ impl BufRead for &[u8] {
 }
 
 /// Wraps an in memory reader providing the `position` function.
+#[derive(Debug)]
 pub struct Cursor<T> {
     inner: T,
     pos: u64,
@@ -329,6 +331,7 @@ impl Write for &mut [u8] {
 /// A sink to which all writes succeed. See [`std::io::Sink`] for more info.
 ///
 /// Created using `io::sink()`.
+#[derive(Debug)]
 pub struct Sink;
 
 impl Write for Sink {
diff --git a/io/tests/api.rs b/io/tests/api.rs
new file mode 100644
index 0000000000..426f427ad9
--- /dev/null
+++ b/io/tests/api.rs
@@ -0,0 +1,140 @@
+//! Test the API surface of `io`.
+//!
+//! The point of these tests are to check the API surface as opposed to test the API functionality.
+//!
+//! ref: <https://rust-lang.github.io/api-guidelines/about.html>
+
+#![allow(dead_code)]
+#![allow(unused_imports)]
+
+use core::cell::Cell;
+use core::convert::Infallible;
+
+// These imports test "typical" usage by user code.
+use bitcoin_io::{self as io, BufRead, Cursor, ErrorKind, Read, Sink, Take, Write};
+#[cfg(feature = "std")]
+use bitcoin_io::{FromStd, ToStd};
+
+/// An arbitrary error kind.
+const ERROR_KIND: ErrorKind = ErrorKind::TimedOut;
+
+/// A struct that includes all public non-error enums.
+#[derive(Debug)] // All public types implement Debug (C-DEBUG).
+struct Enums {
+    a: ErrorKind,
+}
+
+impl Enums {
+    /// Creates an arbitrary `Enums` instance.
+    fn new() -> Self { Self { a: ERROR_KIND } }
+}
+
+/// A struct that includes all public non-error structs except `Take`.
+#[derive(Debug)] // All public types implement Debug (C-DEBUG).
+struct Structs {
+    #[cfg(feature = "std")]
+    a: FromStd<u32>,
+    #[cfg(feature = "std")]
+    b: ToStd<Dummy>,
+    c: Cursor<Dummy>,
+    d: Sink,
+}
+
+impl Structs {
+    fn new() -> Self {
+        Self {
+            #[cfg(feature = "std")]
+            a: FromStd::new(0),
+            #[cfg(feature = "std")]
+            b: ToStd::new(DUMMY),
+            c: Cursor::new(DUMMY),
+            d: Sink,
+        }
+    }
+}
+
+#[derive(Debug)] // `Take` implements Debug (C-DEBUG).
+struct Taker<'a> {
+    a: Take<'a, Dummy>,
+}
+
+/// An arbitrary `Dummy` instance.
+static DUMMY: Dummy = Dummy(0);
+
+/// Dummy struct to implement all the traits we provide.
+#[derive(Debug, Copy, Clone)]
+struct Dummy(u64);
+
+impl Read for Dummy {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        if buf.is_empty() {
+            Ok(0)
+        } else {
+            buf[0] = (self.0 & 0xFF) as u8;
+            Ok(1)
+        }
+    }
+}
+
+impl BufRead for Dummy {
+    fn fill_buf(&mut self) -> Result<&[u8], io::Error> { Ok(&[]) }
+    fn consume(&mut self, _: usize) {}
+}
+
+impl Write for Dummy {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> { Ok(buf.len()) }
+    fn write_all(&mut self, _: &[u8]) -> Result<(), io::Error> { Ok(()) }
+    fn flush(&mut self) -> Result<(), io::Error> { Ok(()) }
+}
+
+impl AsRef<[u8]> for Dummy {
+    fn as_ref(&self) -> &[u8] { &[] }
+}
+
+/// A struct that includes all public non-error types.
+#[derive(Debug)] // All public types implement Debug (C-DEBUG).
+struct Types {
+    a: Enums,
+    b: Structs,
+}
+
+impl Types {
+    fn new() -> Self { Self { a: Enums::new(), b: Structs::new() } }
+}
+
+/// A struct that includes all public error types.
+#[derive(Debug)] // `io::Error` only implements `Debug`.
+struct Errors {
+    a: io::Error,
+}
+
+// `Debug` representation is never empty (C-DEBUG-NONEMPTY).
+#[test]
+fn api_all_non_error_types_have_non_empty_debug() {
+    let t = Types::new();
+
+    let debug = format!("{:?}", t.a.a);
+    assert!(!debug.is_empty());
+
+    #[cfg(feature = "std")]
+    {
+        let debug = format!("{:?}", t.b.a);
+        assert!(!debug.is_empty());
+        let debug = format!("{:?}", t.b.b);
+        assert!(!debug.is_empty());
+    }
+    let debug = format!("{:?}", t.b.c);
+    assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.d);
+    assert!(!debug.is_empty());
+}
+
+//  Types are `Send` and `Sync` where possible (C-SEND-SYNC).
+#[test]
+fn all_non_error_tyes_implement_send_sync() {
+    fn assert_send<T: Send>() {}
+    assert_send::<Types>();
+
+    fn assert_sync<T: Sync>() {}
+    assert_sync::<Types>();
+}

From a18d28761b9f6ce3bd06ba72b9afe11773b7443d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 6 Jan 2025 15:37:24 +1100
Subject: [PATCH 198/554] api: Run just check-api

---
 api/io/all-features.txt | 10 ++++++++++
 api/io/alloc-only.txt   |  6 ++++++
 api/io/no-features.txt  |  6 ++++++
 3 files changed, 22 insertions(+)

diff --git a/api/io/all-features.txt b/api/io/all-features.txt
index 055e6305d9..fe3da3040d 100644
--- a/api/io/all-features.txt
+++ b/api/io/all-features.txt
@@ -56,6 +56,7 @@ impl core::convert::From<std::io::error::Error> for bitcoin_io::Error
 impl core::error::Error for bitcoin_io::Error
 impl core::fmt::Debug for bitcoin_io::Error
 impl core::fmt::Debug for bitcoin_io::ErrorKind
+impl core::fmt::Debug for bitcoin_io::Sink
 impl core::fmt::Display for bitcoin_io::Error
 impl core::hash::Hash for bitcoin_io::ErrorKind
 impl core::marker::Copy for bitcoin_io::ErrorKind
@@ -76,6 +77,7 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
 impl std::io::Write for bitcoin_io::Sink
+impl<'a, R: core::fmt::Debug + bitcoin_io::Read + ?core::marker::Sized> core::fmt::Debug for bitcoin_io::Take<'a, R>
 impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
 impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
 impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
@@ -105,6 +107,9 @@ impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for std::io::cursor::Cur
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for std::io::cursor::Cursor<T>
+impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
+impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::FromStd<T>
+impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::ToStd<T>
 impl<T: std::io::BufRead> bitcoin_io::BufRead for bitcoin_io::FromStd<T>
 impl<T: std::io::BufRead> std::io::BufRead for bitcoin_io::FromStd<T>
 impl<T: std::io::Read> bitcoin_io::Read for bitcoin_io::FromStd<T>
@@ -214,6 +219,7 @@ pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
 pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
@@ -242,6 +248,7 @@ pub fn bitcoin_io::FromStd<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::FromStd<T>::fill_buf(&mut self) -> std::io::error::Result<&[u8]>
 pub fn bitcoin_io::FromStd<T>::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::FromStd<T>::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_io::FromStd<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::FromStd<T>::get_mut(&mut self) -> &mut T
 pub fn bitcoin_io::FromStd<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::FromStd<T>::inner(&self) -> &T
@@ -263,6 +270,7 @@ pub fn bitcoin_io::Read::read_to_limit(&mut self, buf: &mut alloc::vec::Vec<u8>,
 pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
 pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Sink::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
 pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
@@ -271,11 +279,13 @@ pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Take<'_, R>::read_to_end(&mut self, buf: &mut alloc::vec::Vec<u8>) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Take<'a, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::ToStd<T>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::ToStd<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::ToStd<T>::fill_buf(&mut self) -> std::io::error::Result<&[u8]>
 pub fn bitcoin_io::ToStd<T>::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::ToStd<T>::flush(&mut self) -> std::io::error::Result<()>
+pub fn bitcoin_io::ToStd<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::ToStd<T>::inner(&self) -> &T
 pub fn bitcoin_io::ToStd<T>::inner_mut(&mut self) -> &mut T
 pub fn bitcoin_io::ToStd<T>::into_inner(self) -> T
diff --git a/api/io/alloc-only.txt b/api/io/alloc-only.txt
index 572cb17e19..7510696882 100644
--- a/api/io/alloc-only.txt
+++ b/api/io/alloc-only.txt
@@ -14,6 +14,7 @@ impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
 impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
 impl core::fmt::Debug for bitcoin_io::Error
 impl core::fmt::Debug for bitcoin_io::ErrorKind
+impl core::fmt::Debug for bitcoin_io::Sink
 impl core::fmt::Display for bitcoin_io::Error
 impl core::hash::Hash for bitcoin_io::ErrorKind
 impl core::marker::Copy for bitcoin_io::ErrorKind
@@ -33,6 +34,7 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ErrorKind
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
+impl<'a, R: core::fmt::Debug + bitcoin_io::Read + ?core::marker::Sized> core::fmt::Debug for bitcoin_io::Take<'a, R>
 impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
 impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
 impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
@@ -48,6 +50,7 @@ impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
+impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
 impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
 impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
 impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
@@ -91,6 +94,7 @@ pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
 pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
@@ -115,12 +119,14 @@ pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Re
 pub fn bitcoin_io::Read::read_to_limit(&mut self, buf: &mut alloc::vec::Vec<u8>, limit: u64) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
 pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Take<'_, R>::read_to_end(&mut self, buf: &mut alloc::vec::Vec<u8>) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Take<'a, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Write::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Write::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Write::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
diff --git a/api/io/no-features.txt b/api/io/no-features.txt
index 93613d4e6d..0874dbcd98 100644
--- a/api/io/no-features.txt
+++ b/api/io/no-features.txt
@@ -13,6 +13,7 @@ impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
 impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
 impl core::fmt::Debug for bitcoin_io::Error
 impl core::fmt::Debug for bitcoin_io::ErrorKind
+impl core::fmt::Debug for bitcoin_io::Sink
 impl core::fmt::Display for bitcoin_io::Error
 impl core::hash::Hash for bitcoin_io::ErrorKind
 impl core::marker::Copy for bitcoin_io::ErrorKind
@@ -32,6 +33,7 @@ impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ErrorKind
 impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
 impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
+impl<'a, R: core::fmt::Debug + bitcoin_io::Read + ?core::marker::Sized> core::fmt::Debug for bitcoin_io::Take<'a, R>
 impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
 impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
 impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
@@ -46,6 +48,7 @@ impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
+impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
 impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
 impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
 impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
@@ -87,6 +90,7 @@ pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
 pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
@@ -108,11 +112,13 @@ pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<u
 pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
 pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
+pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
 pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
+pub fn bitcoin_io::Take<'a, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Write::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Write::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Write::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>

From 29a71de92817bccd49b42b1055cc570832e6b959 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 5 Jan 2025 12:23:38 +1100
Subject: [PATCH 199/554] Bound Address parsing on NetworkValidationUnchecked

Currently it is not possible for downstream to use a generic on the
`Address` type in structs in conjuncture with
derives (`serde::Deserialize` and `Display`) because our impls are only
done for `NetworkUnchecked` (as they should be).

However, as observed by dpc, if we add a secondary marker trait and use
it to bound the impls, implementing the new marker for
`NetworkUnchecked` then downstream can use derives by way of

```
    #[derive(Serialize, Deserialize)]
    struct Foo<V>
        where V: NetworkValidation,
    {
        #[serde(bound(deserialize = "V: NetworkValidationUnchecked"))]
        address: Address<V>,
    }
```

This is cool as hell because the `Address` type is currently a royal PITA.
---
 bitcoin/src/address/mod.rs | 111 +++++++++++++++++++++++++++++++++++--
 1 file changed, 105 insertions(+), 6 deletions(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 8f570979eb..51a02c56ff 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -22,6 +22,22 @@
 //! let address = Address::p2pkh(&public_key, Network::Bitcoin);
 //! }
 //! ```
+//!
+//! ### Using an `Address` as a struct field.
+//!
+//! ```rust
+//! # #[cfg(feature = "serde")] {
+//! # use serde::{self, Deserialize, Serialize};
+//! use bitcoin::address::{Address, NetworkValidation, NetworkValidationUnchecked};
+//! #[derive(Serialize, Deserialize)]
+//! struct Foo<V>
+//!     where V: NetworkValidation,
+//! {
+//!     #[serde(bound(deserialize = "V: NetworkValidationUnchecked"))]
+//!     address: Address<V>,
+//! }
+//! # }
+//! ```
 
 pub mod error;
 pub mod script_pubkey;
@@ -107,6 +123,9 @@ mod sealed {
     pub trait NetworkValidation {}
     impl NetworkValidation for super::NetworkChecked {}
     impl NetworkValidation for super::NetworkUnchecked {}
+
+    pub trait NetworkValidationUnchecked {}
+    impl NetworkValidationUnchecked for super::NetworkUnchecked {}
 }
 
 /// Marker of status of address's network validation. See section [*Parsing addresses*](Address#parsing-addresses)
@@ -116,14 +135,25 @@ pub trait NetworkValidation: sealed::NetworkValidation + Sync + Send + Sized + U
     const IS_CHECKED: bool;
 }
 
+/// Marker trait for `FromStr` and `serde::Deserialize`.
+///
+/// This allows users to use `V: NetworkValidation` in conjunction with derives. Is only ever
+/// implemented for `NetworkUnchecked`.
+pub trait NetworkValidationUnchecked:
+    NetworkValidation + sealed::NetworkValidationUnchecked + Sync + Send + Sized + Unpin
+{
+}
+
 /// 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)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 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)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum NetworkUnchecked {}
 
 impl NetworkValidation for NetworkChecked {
@@ -133,6 +163,8 @@ impl NetworkValidation for NetworkUnchecked {
     const IS_CHECKED: bool = false;
 }
 
+impl NetworkValidationUnchecked for NetworkUnchecked {}
+
 /// The inner representation of an address, without the network validation tag.
 ///
 /// This struct represents the inner representation of an address without the network validation
@@ -361,10 +393,41 @@ impl<N: NetworkValidation> fmt::Display for DisplayUnchecked<'_, N> {
 }
 
 #[cfg(feature = "serde")]
-internals::serde_string_deserialize_impl!(Address<NetworkUnchecked>, "a Bitcoin address");
+impl<'de, U: NetworkValidationUnchecked> serde::Deserialize<'de> for Address<U> {
+    fn deserialize<D>(deserializer: D) -> Result<Address<U>, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+    {
+        use core::fmt::Formatter;
+
+        struct Visitor<U>(PhantomData<U>);
+        impl<U> serde::de::Visitor<'_> for Visitor<U>
+        where
+            U: NetworkValidationUnchecked + NetworkValidation,
+            Address<U>: FromStr,
+        {
+            type Value = Address<U>;
+
+            fn expecting(&self, f: &mut Formatter) -> core::fmt::Result {
+                f.write_str("A Bitcoin address")
+            }
+
+            fn visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                // We know that `U` is only ever `NetworkUnchecked` but the compiler does not.
+                let address = v.parse::<Address<NetworkUnchecked>>().map_err(E::custom)?;
+                Ok(Address(address.0, PhantomData::<U>))
+            }
+        }
+
+        deserializer.deserialize_str(Visitor(PhantomData::<U>))
+    }
+}
 
 #[cfg(feature = "serde")]
-impl<N: NetworkValidation> serde::Serialize for Address<N> {
+impl<V: NetworkValidation> serde::Serialize for Address<V> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -881,14 +944,17 @@ impl<V: NetworkValidation> fmt::Debug for Address<V> {
 ///
 /// - [`UnknownHrpError`] if the address does not begin with one of the above SegWit or
 ///   legacy prefixes.
-impl FromStr for Address<NetworkUnchecked> {
+impl<U: NetworkValidationUnchecked> FromStr for Address<U> {
     type Err = ParseError;
 
-    fn from_str(s: &str) -> Result<Address<NetworkUnchecked>, ParseError> {
+    fn from_str(s: &str) -> Result<Self, ParseError> {
         if ["bc1", "bcrt1", "tb1"].iter().any(|&prefix| s.to_lowercase().starts_with(prefix)) {
-            Ok(Address::from_bech32_str(s)?)
+            let address = Address::from_bech32_str(s)?;
+            // We know that `U` is only ever `NetworkUnchecked` but the compiler does not.
+            Ok(Address(address.0, PhantomData::<U>))
         } else if ["1", "2", "3", "m", "n"].iter().any(|&prefix| s.starts_with(prefix)) {
-            Ok(Address::from_base58_str(s)?)
+            let address = Address::from_base58_str(s)?;
+            Ok(Address(address.0, PhantomData::<U>))
         } else {
             let hrp = match s.rfind('1') {
                 Some(pos) => &s[..pos],
@@ -1427,4 +1493,37 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_address_usage_in_struct() {
+        use serde::{self, Deserialize, Serialize};
+
+        #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+        struct Foo<V>
+        where
+            V: NetworkValidation,
+        {
+            #[serde(bound(deserialize = "V: NetworkValidationUnchecked"))]
+            address: Address<V>,
+        }
+
+        let addr_str = "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k";
+        let unchecked = addr_str.parse::<Address<_>>().unwrap();
+
+        // Serialize with an unchecked address.
+        let foo_unchecked = Foo { address: unchecked.clone() };
+        let ser = serde_json::to_string(&foo_unchecked).expect("failed to serialize");
+        let rinsed: Foo<NetworkUnchecked> =
+            serde_json::from_str(&ser).expect("failed to deserialize");
+        assert_eq!(rinsed, foo_unchecked);
+
+        // Serialize with a checked address.
+        let foo_checked = Foo { address: unchecked.assume_checked() };
+        let ser = serde_json::to_string(&foo_checked).expect("failed to serialize");
+        let rinsed: Foo<NetworkUnchecked> =
+            serde_json::from_str(&ser).expect("failed to deserialize");
+        assert_eq!(&rinsed.address, foo_checked.address.as_unchecked());
+        assert_eq!(rinsed, foo_unchecked);
+    }
 }

From 55a999e0b5c5867ed66ee64d2b516b80e059e402 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 6 Jan 2025 17:56:15 +1100
Subject: [PATCH 200/554] Add serde roundtrip tests to relative locktime types

As we do for absolute locktime types add a couple of `serde` roundtrip
tests to the relative locktime types.
---
 units/src/locktime/relative.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/units/src/locktime/relative.rs b/units/src/locktime/relative.rs
index a217391dab..7a25d49065 100644
--- a/units/src/locktime/relative.rs
+++ b/units/src/locktime/relative.rs
@@ -191,6 +191,9 @@ impl<'a> Arbitrary<'a> for Time {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(feature = "serde")]
+    use internals::serde_round_trip;
+
     use super::*;
 
     const MAXIMUM_ENCODABLE_SECONDS: u32 = u16::MAX as u32 * 512;
@@ -248,4 +251,20 @@ mod tests {
         let result = Time::from_seconds_floor(MAXIMUM_ENCODABLE_SECONDS + 512);
         assert!(result.is_err());
     }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    pub fn encode_decode_height() {
+        serde_round_trip!(Height::ZERO);
+        serde_round_trip!(Height::MIN);
+        serde_round_trip!(Height::MAX);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    pub fn encode_decode_time() {
+        serde_round_trip!(Time::ZERO);
+        serde_round_trip!(Time::MIN);
+        serde_round_trip!(Time::MAX);
+    }
 }

From ffd8702cb312e5722601652d26a2daadeb25f147 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 7 Jan 2025 08:55:26 +1100
Subject: [PATCH 201/554] units: Hide the remaining public macros

We do not want to commit to any public macros in `units`. Recently we (I
at least) learned that adding `doc(hidden)` signals to users that the
macro is unstable and should not be relied upon.

Hide the remaining two macros so we can release 1.0 and not worry about
later breaking them.

With this applied there are no exported macros that are not hidden.
Verify using `git grep -A 1 macro_export`.
---
 units/src/parse.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 4ad750acc1..49f4064b78 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -117,6 +117,7 @@ pub fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, Par
 ///
 /// If parsing the string fails then a `units::parse::ParseIntError` is returned.
 #[macro_export]
+#[doc(hidden)] // This is an 'internal' macro that should not be used outside of the `rust-bitcoin` crate.
 macro_rules! impl_parse_str_from_int_infallible {
     ($to:ident, $inner:ident, $fn:ident) => {
         $crate::impl_tryfrom_str_from_int_infallible!(&str, $to, $inner, $fn);
@@ -174,6 +175,7 @@ macro_rules! impl_tryfrom_str_from_int_infallible {
 ///
 /// All functions use the error returned by `$inner_fn`.
 #[macro_export]
+#[doc(hidden)] // This is an 'internal' macro that should not be used outside of the `rust-bitcoin` crate.
 macro_rules! impl_parse_str {
     ($to:ty, $err:ty, $inner_fn:expr) => {
         $crate::impl_tryfrom_str!(&str, $to, $err, $inner_fn);

From 9396041524e291203d5c86665639872f9a6246b5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 7 Jan 2025 08:58:16 +1100
Subject: [PATCH 202/554] api: Run just check-api

---
 api/units/all-features.txt | 2 --
 api/units/alloc-only.txt   | 2 --
 api/units/no-features.txt  | 2 --
 3 files changed, 6 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 4cfb244a8a..0559a49bc2 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -1220,8 +1220,6 @@ pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
 pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
 pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
 pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub macro bitcoin_units::impl_parse_str!
-pub macro bitcoin_units::impl_parse_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::amount::serde
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 61e5afbfdb..a44702c7a4 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -1064,8 +1064,6 @@ pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
 pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
 pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
 pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub macro bitcoin_units::impl_parse_str!
-pub macro bitcoin_units::impl_parse_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::block
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 367d8501ac..39e957f3e2 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -1018,8 +1018,6 @@ pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
 pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
 pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
 pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub macro bitcoin_units::impl_parse_str!
-pub macro bitcoin_units::impl_parse_str_from_int_infallible!
 pub mod bitcoin_units
 pub mod bitcoin_units::amount
 pub mod bitcoin_units::block

From e09bdb5f98ea516382a04283373ad97a41d57c2b Mon Sep 17 00:00:00 2001
From: Nick Johnson <nick@yonson.dev>
Date: Wed, 18 Dec 2024 16:23:55 -0800
Subject: [PATCH 203/554] Add BIP324 V2 p2p network message support

BIP324 introduced the second version of p2p network messages which
are designed to be used with the new encrypted transport. This patch
adds a V2NetworkMessage type which wraps a NetworkMessage and handles
the V2 encoding and decoding. It is a parallel of the existing
RawNetworkMessage type (which may be better described as
V1NetworkMessage). A priority of this patch was to not re-invent any
wheels and try to use the existing patterns as much as possible.
---
 bitcoin/src/p2p/message.rs | 261 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 258 insertions(+), 3 deletions(-)

diff --git a/bitcoin/src/p2p/message.rs b/bitcoin/src/p2p/message.rs
index f1315c34e0..e293801051 100644
--- a/bitcoin/src/p2p/message.rs
+++ b/bitcoin/src/p2p/message.rs
@@ -148,7 +148,7 @@ impl std::error::Error for CommandStringError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
 }
 
-/// A Network message
+/// A Network message using the v1 p2p protocol.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct RawNetworkMessage {
     magic: Magic,
@@ -157,6 +157,12 @@ pub struct RawNetworkMessage {
     checksum: [u8; 4],
 }
 
+/// A Network message using the v2 p2p protocol defined in BIP324.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct V2NetworkMessage {
+    payload: NetworkMessage,
+}
+
 /// A Network message payload. Proper documentation is available on at
 /// [Bitcoin Wiki: Protocol Specification](https://en.bitcoin.it/wiki/Protocol_specification)
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -332,6 +338,27 @@ impl RawNetworkMessage {
     pub fn command(&self) -> CommandString { self.payload.command() }
 }
 
+impl V2NetworkMessage {
+    /// Constructs a new [V2NetworkMessage].
+    pub fn new(payload: NetworkMessage) -> Self { Self { payload } }
+
+    /// Consumes the [V2NetworkMessage] instance and returns the inner payload.
+    pub fn into_payload(self) -> NetworkMessage { self.payload }
+
+    /// The actual message data
+    pub fn payload(&self) -> &NetworkMessage { &self.payload }
+
+    /// Return the message command as a static string reference.
+    ///
+    /// This returns `"unknown"` for [NetworkMessage::Unknown],
+    /// regardless of the actual command in the unknown message.
+    /// Use the [Self::command] method to get the command for unknown messages.
+    pub fn cmd(&self) -> &'static str { self.payload.cmd() }
+
+    /// Return the CommandString for the message command.
+    pub fn command(&self) -> CommandString { self.payload.command() }
+}
+
 struct HeaderSerializationWrapper<'a>(&'a Vec<block::Header>);
 
 impl Encodable for HeaderSerializationWrapper<'_> {
@@ -404,6 +431,62 @@ impl Encodable for RawNetworkMessage {
     }
 }
 
+impl Encodable for V2NetworkMessage {
+    fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, io::Error> {
+        // A subset of message types are optimized to only use one byte to encode the command.
+        // Non-optimized message types use the zero-byte flag and the following twelve bytes to encode the command.
+        let (command_byte, full_command) = match self.payload {
+            NetworkMessage::Addr(_) => (1u8, None),
+            NetworkMessage::Inv(_) => (14u8, None),
+            NetworkMessage::GetData(_) => (11u8, None),
+            NetworkMessage::NotFound(_) => (17u8, None),
+            NetworkMessage::GetBlocks(_) => (9u8, None),
+            NetworkMessage::GetHeaders(_) => (12u8, None),
+            NetworkMessage::MemPool => (15u8, None),
+            NetworkMessage::Tx(_) => (21u8, None),
+            NetworkMessage::Block(_) => (2u8, None),
+            NetworkMessage::Headers(_) => (13u8, None),
+            NetworkMessage::Ping(_) => (18u8, None),
+            NetworkMessage::Pong(_) => (19u8, None),
+            NetworkMessage::MerkleBlock(_) => (16u8, None),
+            NetworkMessage::FilterLoad(_) => (8u8, None),
+            NetworkMessage::FilterAdd(_) => (6u8, None),
+            NetworkMessage::FilterClear => (7u8, None),
+            NetworkMessage::GetCFilters(_) => (22u8, None),
+            NetworkMessage::CFilter(_) => (23u8, None),
+            NetworkMessage::GetCFHeaders(_) => (24u8, None),
+            NetworkMessage::CFHeaders(_) => (25u8, None),
+            NetworkMessage::GetCFCheckpt(_) => (26u8, None),
+            NetworkMessage::CFCheckpt(_) => (27u8, None),
+            NetworkMessage::SendCmpct(_) => (20u8, None),
+            NetworkMessage::CmpctBlock(_) => (4u8, None),
+            NetworkMessage::GetBlockTxn(_) => (10u8, None),
+            NetworkMessage::BlockTxn(_) => (3u8, None),
+            NetworkMessage::FeeFilter(_) => (5u8, None),
+            NetworkMessage::AddrV2(_) => (28u8, None),
+            NetworkMessage::Version(_)
+            | NetworkMessage::Verack
+            | NetworkMessage::SendHeaders
+            | NetworkMessage::GetAddr
+            | NetworkMessage::WtxidRelay
+            | NetworkMessage::SendAddrV2
+            | NetworkMessage::Alert(_)
+            | NetworkMessage::Reject(_)
+            | NetworkMessage::Unknown { .. } => (0u8, Some(self.payload.command())),
+        };
+
+        let mut len = command_byte.consensus_encode(writer)?;
+        if let Some(cmd) = full_command {
+            len += cmd.consensus_encode(writer)?;
+        }
+
+        // Encode the payload.
+        len += self.payload.consensus_encode(writer)?;
+
+        Ok(len)
+    }
+}
+
 struct HeaderDeserializationWrapper(Vec<block::Header>);
 
 impl Decodable for HeaderDeserializationWrapper {
@@ -537,6 +620,79 @@ impl Decodable for RawNetworkMessage {
     }
 }
 
+impl Decodable for V2NetworkMessage {
+    fn consensus_decode_from_finite_reader<R: BufRead + ?Sized>(
+        r: &mut R,
+    ) -> Result<Self, encode::Error> {
+        let short_id: u8 = Decodable::consensus_decode_from_finite_reader(r)?;
+        let payload = match short_id {
+            0u8 => {
+                // Full command encoding.
+                let cmd = CommandString::consensus_decode_from_finite_reader(r)?;
+                match &cmd.0[..] {
+                    "version" =>
+                        NetworkMessage::Version(Decodable::consensus_decode_from_finite_reader(r)?),
+                    "verack" => NetworkMessage::Verack,
+                    "sendheaders" => NetworkMessage::SendHeaders,
+                    "getaddr" => NetworkMessage::GetAddr,
+                    "wtxidrelay" => NetworkMessage::WtxidRelay,
+                    "sendaddrv2" => NetworkMessage::SendAddrV2,
+                    "alert" =>
+                        NetworkMessage::Alert(Decodable::consensus_decode_from_finite_reader(r)?),
+                    "reject" =>
+                        NetworkMessage::Reject(Decodable::consensus_decode_from_finite_reader(r)?),
+                    _ => NetworkMessage::Unknown {
+                        command: cmd,
+                        payload: Vec::consensus_decode_from_finite_reader(r)?,
+                    },
+                }
+            }
+            1u8 => NetworkMessage::Addr(Decodable::consensus_decode_from_finite_reader(r)?),
+            2u8 => NetworkMessage::Block(Decodable::consensus_decode_from_finite_reader(r)?),
+            3u8 => NetworkMessage::BlockTxn(Decodable::consensus_decode_from_finite_reader(r)?),
+            4u8 => NetworkMessage::CmpctBlock(Decodable::consensus_decode_from_finite_reader(r)?),
+            5u8 => NetworkMessage::FeeFilter(Decodable::consensus_decode_from_finite_reader(r)?),
+            6u8 => NetworkMessage::FilterAdd(Decodable::consensus_decode_from_finite_reader(r)?),
+            7u8 => NetworkMessage::FilterClear,
+            8u8 => NetworkMessage::FilterLoad(Decodable::consensus_decode_from_finite_reader(r)?),
+            9u8 => NetworkMessage::GetBlocks(Decodable::consensus_decode_from_finite_reader(r)?),
+            10u8 => NetworkMessage::GetBlockTxn(Decodable::consensus_decode_from_finite_reader(r)?),
+            11u8 => NetworkMessage::GetData(Decodable::consensus_decode_from_finite_reader(r)?),
+            12u8 => NetworkMessage::GetHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
+            13u8 => NetworkMessage::Headers(
+                HeaderDeserializationWrapper::consensus_decode_from_finite_reader(r)?.0,
+            ),
+            14u8 => NetworkMessage::Inv(Decodable::consensus_decode_from_finite_reader(r)?),
+            15u8 => NetworkMessage::MemPool,
+            16u8 => NetworkMessage::MerkleBlock(Decodable::consensus_decode_from_finite_reader(r)?),
+            17u8 => NetworkMessage::NotFound(Decodable::consensus_decode_from_finite_reader(r)?),
+            18u8 => NetworkMessage::Ping(Decodable::consensus_decode_from_finite_reader(r)?),
+            19u8 => NetworkMessage::Pong(Decodable::consensus_decode_from_finite_reader(r)?),
+            20u8 => NetworkMessage::SendCmpct(Decodable::consensus_decode_from_finite_reader(r)?),
+            21u8 => NetworkMessage::Tx(Decodable::consensus_decode_from_finite_reader(r)?),
+            22u8 => NetworkMessage::GetCFilters(Decodable::consensus_decode_from_finite_reader(r)?),
+            23u8 => NetworkMessage::CFilter(Decodable::consensus_decode_from_finite_reader(r)?),
+            24u8 =>
+                NetworkMessage::GetCFHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
+            25u8 => NetworkMessage::CFHeaders(Decodable::consensus_decode_from_finite_reader(r)?),
+            26u8 =>
+                NetworkMessage::GetCFCheckpt(Decodable::consensus_decode_from_finite_reader(r)?),
+            27u8 => NetworkMessage::CFCheckpt(Decodable::consensus_decode_from_finite_reader(r)?),
+            28u8 => NetworkMessage::AddrV2(Decodable::consensus_decode_from_finite_reader(r)?),
+            _ =>
+                return Err(encode::Error::Parse(encode::ParseError::ParseFailed(
+                    "Unknown short ID",
+                ))),
+        };
+        Ok(V2NetworkMessage { payload })
+    }
+
+    #[inline]
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_MSG_SIZE.to_u64()))
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::net::Ipv4Addr;
@@ -669,9 +825,14 @@ mod test {
             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);
+        for msg in &msgs {
+            // V1 messages.
+            let raw_msg = RawNetworkMessage::new(Magic::from_bytes([57, 0, 0, 0]), msg.clone());
             assert_eq!(deserialize::<RawNetworkMessage>(&serialize(&raw_msg)).unwrap(), raw_msg);
+
+            // V2 messages.
+            let v2_msg = V2NetworkMessage::new(msg.clone());
+            assert_eq!(deserialize::<V2NetworkMessage>(&serialize(&v2_msg)).unwrap(), v2_msg);
         }
     }
 
@@ -709,6 +870,17 @@ mod test {
                         0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
     }
 
+    #[test]
+    fn serialize_v2_verack() {
+        assert_eq!(
+            serialize(&V2NetworkMessage::new(NetworkMessage::Verack)),
+            [
+                0x00, // Full command encoding flag.
+                0x76, 0x65, 0x72, 0x61, 0x63, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]
+        );
+    }
+
     #[test]
     #[rustfmt::skip]
     fn serialize_ping() {
@@ -719,6 +891,17 @@ mod test {
                         0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
     }
 
+    #[test]
+    fn serialize_v2_ping() {
+        assert_eq!(
+            serialize(&V2NetworkMessage::new(NetworkMessage::Ping(100))),
+            [
+                0x12, // Ping command short ID
+                0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]
+        );
+    }
+
     #[test]
     #[rustfmt::skip]
     fn serialize_mempool() {
@@ -728,6 +911,16 @@ mod test {
                         0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
     }
 
+    #[test]
+    fn serialize_v2_mempool() {
+        assert_eq!(
+            serialize(&V2NetworkMessage::new(NetworkMessage::MemPool)),
+            [
+                0x0F, // MemPool command short ID
+            ]
+        );
+    }
+
     #[test]
     #[rustfmt::skip]
     fn serialize_getaddr() {
@@ -737,6 +930,17 @@ mod test {
                         0x00, 0x00, 0x00, 0x00, 0x5d, 0xf6, 0xe0, 0xe2]);
     }
 
+    #[test]
+    fn serialize_v2_getaddr() {
+        assert_eq!(
+            serialize(&V2NetworkMessage::new(NetworkMessage::GetAddr)),
+            [
+                0x00, // Full command encoding flag.
+                0x67, 0x65, 0x74, 0x61, 0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]
+        );
+    }
+
     #[test]
     fn deserialize_getaddr() {
         #[rustfmt::skip]
@@ -752,6 +956,19 @@ mod test {
         assert_eq!(preimage.payload, msg.payload);
     }
 
+    #[test]
+    fn deserialize_v2_getaddr() {
+        let msg = deserialize(&[
+            0x00, // Full command encoding flag
+            0x67, 0x65, 0x74, 0x61, 0x64, 0x64, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00,
+        ]);
+
+        let preimage = V2NetworkMessage::new(NetworkMessage::GetAddr);
+        assert!(msg.is_ok());
+        let msg: V2NetworkMessage = msg.unwrap();
+        assert_eq!(preimage, msg);
+    }
+
     #[test]
     fn deserialize_version() {
         #[rustfmt::skip]
@@ -796,6 +1013,44 @@ mod test {
         }
     }
 
+    #[test]
+    fn deserialize_v2_version() {
+        #[rustfmt::skip]
+        let msg = deserialize::<V2NetworkMessage>(&[
+            0x00, // Full command encoding flag
+            0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, // "version" command
+            0x7f, 0x11, 0x01, 0x00, // version: 70015
+            0x0d, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // services
+            0xf0, 0x0f, 0x4d, 0x5c, 0x00, 0x00, 0x00, 0x00, // timestamp: 1548554224
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // receiver services: NONE
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5b, 0xf0, 0x8c, 0x80, 0xb4, 0xbd, // addr_recv
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // sender services: NONE
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // addr_from
+            0xfa, 0xa9, 0x95, 0x59, 0xcc, 0x68, 0xa1, 0xc1, // nonce
+            0x10, 0x2f, 0x53, 0x61, 0x74, 0x6f, 0x73, 0x68, 0x69, 0x3a, 0x30, 0x2e, 0x31, 0x37, 0x2e, 0x31, 0x2f, // user_agent: "/Satoshi:0.17.1/"
+            0x93, 0x8c, 0x08, 0x00, // start_height: 560275
+            0x01 // relay: true
+        ]).unwrap();
+
+        if let NetworkMessage::Version(version_msg) = msg.payload {
+            assert_eq!(version_msg.version, 70015);
+            assert_eq!(
+                version_msg.services,
+                ServiceFlags::NETWORK
+                    | ServiceFlags::BLOOM
+                    | ServiceFlags::WITNESS
+                    | ServiceFlags::NETWORK_LIMITED
+            );
+            assert_eq!(version_msg.timestamp, 1548554224);
+            assert_eq!(version_msg.nonce, 13952548347456104954);
+            assert_eq!(version_msg.user_agent, "/Satoshi:0.17.1/");
+            assert_eq!(version_msg.start_height, 560275);
+            assert!(version_msg.relay);
+        } else {
+            panic!("wrong message type");
+        }
+    }
+
     #[test]
     fn deserialize_partial_message() {
         #[rustfmt::skip]

From 316d8bcb01504420a14854d2be122d1c8cffb4a9 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 7 Jan 2025 12:37:47 +0000
Subject: [PATCH 204/554] Change all occurrences of "IO" to "I/O"

---
 bitcoin/src/bip158.rs          |  4 ++--
 bitcoin/src/consensus/error.rs |  2 +-
 bitcoin/src/consensus/mod.rs   |  4 ++--
 bitcoin/src/consensus/serde.rs |  4 ++--
 bitcoin/src/crypto/sighash.rs  |  4 ++--
 io/README.md                   |  2 +-
 io/src/bridge.rs               | 14 +++++++-------
 io/src/lib.rs                  |  6 +++---
 8 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/bitcoin/src/bip158.rs b/bitcoin/src/bip158.rs
index 8933767033..419514abf5 100644
--- a/bitcoin/src/bip158.rs
+++ b/bitcoin/src/bip158.rs
@@ -76,7 +76,7 @@ impl_hashencode!(FilterHeader);
 pub enum Error {
     /// Missing UTXO, cannot calculate script filter.
     UtxoMissing(OutPoint),
-    /// IO error reading or writing binary serialization of the filter.
+    /// I/O error reading or writing binary serialization of the filter.
     Io(io::Error),
 }
 
@@ -90,7 +90,7 @@ impl fmt::Display for Error {
 
         match *self {
             UtxoMissing(ref coin) => write!(f, "unresolved UTXO {}", coin),
-            Io(ref e) => write_err!(f, "IO error"; e),
+            Io(ref e) => write_err!(f, "I/O error"; e),
         }
     }
 }
diff --git a/bitcoin/src/consensus/error.rs b/bitcoin/src/consensus/error.rs
index 500e9ecef2..0864d7779f 100644
--- a/bitcoin/src/consensus/error.rs
+++ b/bitcoin/src/consensus/error.rs
@@ -115,7 +115,7 @@ impl fmt::Display for Error {
         use Error::*;
 
         match *self {
-            Io(ref e) => write_err!(f, "IO error"; e),
+            Io(ref e) => write_err!(f, "I/O error"; e),
             Parse(ref e) => write_err!(f, "error parsing encoded object"; e),
         }
     }
diff --git a/bitcoin/src/consensus/mod.rs b/bitcoin/src/consensus/mod.rs
index 708ff6347a..ecf4b6fdb0 100644
--- a/bitcoin/src/consensus/mod.rs
+++ b/bitcoin/src/consensus/mod.rs
@@ -44,8 +44,8 @@ impl<E: fmt::Debug, I: Iterator<Item = Result<u8, E>>> IterReader<E, I> {
 
             (Err(consensus::encode::Error::Io(io_error)), Some(de_error)) if io_error.kind() == io::ErrorKind::Other && io_error.get_ref().is_none() => Err(DecodeError::Other(de_error)),
             (Err(consensus::encode::Error::Parse(parse_error)), None) => Err(DecodeError::Parse(parse_error)),
-            (Err(consensus::encode::Error::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),
+            (Err(consensus::encode::Error::Io(io_error)), de_error) => panic!("unexpected I/O 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` I/O error because of deserialization error {:?} but it returned consensus error {:?} instead", core::any::type_name::<T>(), de_error, consensus_error),
         }
     }
 }
diff --git a/bitcoin/src/consensus/serde.rs b/bitcoin/src/consensus/serde.rs
index 8db3989b21..a182e8640f 100644
--- a/bitcoin/src/consensus/serde.rs
+++ b/bitcoin/src/consensus/serde.rs
@@ -443,12 +443,12 @@ impl<E> With<E> {
             match (result, writer.error) {
                 (Ok(_), None) => writer.serializer.end(),
                 (Ok(_), Some(error)) =>
-                    panic!("{} silently ate an IO error: {:?}", core::any::type_name::<T>(), error),
+                    panic!("{} silently ate an I/O error: {:?}", core::any::type_name::<T>(), error),
                 (Err(io_error), Some(ser_error))
                     if io_error.kind() == io::ErrorKind::Other && io_error.get_ref().is_none() =>
                     Err(ser_error),
                 (Err(io_error), ser_error) => panic!(
-                    "{} returned an unexpected IO error: {:?} serialization error: {:?}",
+                    "{} returned an unexpected I/O error: {:?} serialization error: {:?}",
                     core::any::type_name::<T>(),
                     io_error,
                     ser_error
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 22999fd1a2..2b79411507 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1452,9 +1452,9 @@ impl<E> From<Infallible> for SigningDataError<E> {
 }
 
 impl<E> SigningDataError<E> {
-    /// Returns the sighash variant, panicking if it's IO.
+    /// Returns the sighash variant, panicking if it's I/O.
     ///
-    /// This is used when encoding to hash engine when we know that IO doesn't fail.
+    /// This is used when encoding to hash engine when we know that I/O doesn't fail.
     fn unwrap_sighash(self) -> E {
         match self {
             Self::Sighash(error) => error,
diff --git a/io/README.md b/io/README.md
index f276437bc3..3d5508de34 100644
--- a/io/README.md
+++ b/io/README.md
@@ -1,4 +1,4 @@
-# Rust-Bitcoin IO Library
+# Rust-Bitcoin I/O Library
 
 The `std::io` module is not exposed in `no-std` Rust so building `no-std` applications which require
 reading and writing objects via standard traits is not generally possible. Thus, this library exists
diff --git a/io/src/bridge.rs b/io/src/bridge.rs
index 471a6aba04..4079d57fd4 100644
--- a/io/src/bridge.rs
+++ b/io/src/bridge.rs
@@ -3,24 +3,24 @@ use alloc::boxed::Box;
 
 use internals::rust_version;
 
-/// A bridging wrapper providing the IO traits for types that already implement `std` IO traits.
+/// A bridging wrapper providing the I/O traits for types that already implement `std` I/O traits.
 #[repr(transparent)]
 #[derive(Debug)]
 pub struct FromStd<T>(T);
 
 impl<T> FromStd<T> {
-    /// Wraps an IO type.
+    /// Wraps an I/O type.
     #[inline]
     pub const fn new(inner: T) -> Self { Self(inner) }
 
-    /// Wraps a mutable reference to IO type.
+    /// Wraps a mutable reference to I/O type.
     #[inline]
     pub fn new_mut(inner: &mut T) -> &mut Self {
         // SAFETY: the type is repr(transparent) and the lifetimes match
         unsafe { &mut *(inner as *mut _ as *mut Self) }
     }
 
-    /// Wraps a boxed IO type.
+    /// Wraps a boxed I/O type.
     #[cfg(feature = "alloc")]
     #[inline]
     pub fn new_boxed(inner: Box<T>) -> Box<Self> {
@@ -121,18 +121,18 @@ impl<T: std::io::Write> std::io::Write for FromStd<T> {
 pub struct ToStd<T>(T);
 
 impl<T> ToStd<T> {
-    /// Wraps an IO type.
+    /// Wraps an I/O type.
     #[inline]
     pub const fn new(inner: T) -> Self { Self(inner) }
 
-    /// Wraps a mutable reference to IO type.
+    /// Wraps a mutable reference to I/O type.
     #[inline]
     pub fn new_mut(inner: &mut T) -> &mut Self {
         // SAFETY: the type is repr(transparent) and the lifetimes match
         unsafe { &mut *(inner as *mut _ as *mut Self) }
     }
 
-    /// Wraps a boxed IO type.
+    /// Wraps a boxed I/O type.
     #[cfg(feature = "alloc")]
     #[inline]
     pub fn new_boxed(inner: Box<T>) -> Box<Self> {
diff --git a/io/src/lib.rs b/io/src/lib.rs
index c8d846dd5a..fcaf1aa39b 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -1,4 +1,4 @@
-//! Rust-Bitcoin IO Library
+//! Rust-Bitcoin I/O Library
 //!
 //! The `std::io` module is not exposed in `no-std` Rust so building `no-std` applications which
 //! require reading and writing objects via standard traits is not generally possible. Thus, this
@@ -349,14 +349,14 @@ impl Write for Sink {
 #[inline]
 pub fn sink() -> Sink { Sink }
 
-/// Wraps a `std` IO type to implement the traits from this crate.
+/// Wraps a `std` I/O type to implement the traits from this crate.
 ///
 /// All methods are passed through converting the errors.
 #[cfg(feature = "std")]
 #[inline]
 pub const fn from_std<T>(std_io: T) -> FromStd<T> { FromStd::new(std_io) }
 
-/// Wraps a mutable reference to `std` IO type to implement the traits from this crate.
+/// Wraps a mutable reference to `std` I/O type to implement the traits from this crate.
 ///
 /// All methods are passed through converting the errors.
 #[cfg(feature = "std")]

From cd908fec51b171635c4d5dc5494717ff1d796eeb Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 27 Dec 2024 12:37:43 +1100
Subject: [PATCH 205/554] Use explicit calc getters and setters

We have a bunch of functions and impl blocks scattered around the place
for calculating fee from fee rate and weight.

In preparation for adding a `calc` module use getters and setters in
code that will move to the `calc` module.

(Remember, the `FeeRate` uses an inner sats per kwu value.)

Internal change only.
---
 units/src/amount/unsigned.rs |  4 ++--
 units/src/fee_rate/mod.rs    | 14 ++++++++------
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index f6cb57eb57..96e372302f 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -375,7 +375,7 @@ impl Amount {
     pub const fn checked_div_by_weight_ceil(self, weight: Weight) -> Option<FeeRate> {
         let wu = weight.to_wu();
         // No `?` operator in const context.
-        if let Some(sats) = self.0.checked_mul(1_000) {
+        if let Some(sats) = self.to_sat().checked_mul(1_000) {
             if let Some(wu_minus_one) = wu.checked_sub(1) {
                 if let Some(sats_plus_wu_minus_one) = sats.checked_add(wu_minus_one) {
                     if let Some(fee_rate) = sats_plus_wu_minus_one.checked_div(wu) {
@@ -397,7 +397,7 @@ impl Amount {
     #[must_use]
     pub const fn checked_div_by_weight_floor(self, weight: Weight) -> Option<FeeRate> {
         // No `?` operator in const context.
-        match self.0.checked_mul(1_000) {
+        match self.to_sat().checked_mul(1_000) {
             Some(res) => match res.checked_div(weight.to_wu()) {
                 Some(fee_rate) => Some(FeeRate::from_sat_per_kwu(fee_rate)),
                 None => None,
diff --git a/units/src/fee_rate/mod.rs b/units/src/fee_rate/mod.rs
index 2b5fe82058..938a518ff6 100644
--- a/units/src/fee_rate/mod.rs
+++ b/units/src/fee_rate/mod.rs
@@ -112,7 +112,7 @@ impl FeeRate {
     #[must_use]
     pub const fn checked_mul_by_weight(self, weight: Weight) -> Option<Amount> {
         // No `?` operator in const context.
-        match self.0.checked_mul(weight.to_wu()) {
+        match self.to_sat_per_kwu().checked_mul(weight.to_wu()) {
             Some(mul_res) => match mul_res.checked_add(999) {
                 Some(add_res) => Some(Amount::from_sat(add_res / 1000)),
                 None => None,
@@ -216,7 +216,9 @@ impl ops::Div<Weight> for Amount {
     ///
     /// This is likely the wrong thing for a user dividing an amount by a weight. Consider using
     /// `checked_div_by_weight` instead.
-    fn div(self, rhs: Weight) -> Self::Output { FeeRate(self.to_sat() * 1000 / rhs.to_wu()) }
+    fn div(self, rhs: Weight) -> Self::Output {
+        FeeRate::from_sat_per_kwu(self.to_sat() * 1000 / rhs.to_wu())
+    }
 }
 
 impl core::iter::Sum for FeeRate {
@@ -324,7 +326,7 @@ mod tests {
     #[test]
     fn fee_rate_div_by_weight() {
         let fee_rate = Amount::from_sat(329) / Weight::from_wu(381);
-        assert_eq!(fee_rate, FeeRate(863));
+        assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
     }
 
     #[test]
@@ -402,7 +404,7 @@ mod tests {
 
     #[test]
     fn fee_wu() {
-        let fee_overflow = FeeRate(10).fee_wu(Weight::MAX);
+        let fee_overflow = FeeRate::from_sat_per_kwu(10).fee_wu(Weight::MAX);
         assert!(fee_overflow.is_none());
 
         let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
@@ -412,7 +414,7 @@ mod tests {
 
     #[test]
     fn fee_vb() {
-        let fee_overflow = FeeRate(10).fee_vb(Weight::MAX.to_wu());
+        let fee_overflow = FeeRate::from_sat_per_kwu(10).fee_vb(Weight::MAX.to_wu());
         assert!(fee_overflow.is_none());
 
         let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
@@ -428,7 +430,7 @@ mod tests {
             .expect("expected Amount");
         assert_eq!(Amount::from_sat(100), fee);
 
-        let fee = FeeRate(10).checked_mul_by_weight(Weight::MAX);
+        let fee = FeeRate::from_sat_per_kwu(10).checked_mul_by_weight(Weight::MAX);
         assert!(fee.is_none());
 
         let weight = Weight::from_vb(3).unwrap();

From 9d1cba4994e9ec94850a0e0e49f85fd0c595541e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 27 Dec 2024 12:40:41 +1100
Subject: [PATCH 206/554] units: Introduce fee module

We have a bunch of functions and impl blocks scattered around the place
for calculating fee from fee rate and weight.

In an effort to make the code easier to read/understand and also easier
to audit introduce a private `fee` module and move all the code that is
related to this calculation into it.

This is in internal change only.
---
 units/src/amount/unsigned.rs |  55 ----------
 units/src/fee.rs             | 202 +++++++++++++++++++++++++++++++++++
 units/src/fee_rate/mod.rs    | 127 ----------------------
 units/src/lib.rs             |   1 +
 4 files changed, 203 insertions(+), 182 deletions(-)
 create mode 100644 units/src/fee.rs

diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 96e372302f..9ac7e4497a 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -15,8 +15,6 @@ use super::{
     parse_signed_to_satoshi, split_amount_and_denomination, Denomination, Display, DisplayStyle,
     OutOfRangeError, ParseAmountError, ParseError, SignedAmount,
 };
-#[cfg(feature = "alloc")]
-use crate::{FeeRate, Weight};
 
 /// An amount.
 ///
@@ -353,59 +351,6 @@ impl Amount {
         }
     }
 
-    /// Checked weight ceiling division.
-    ///
-    /// Be aware that integer division loses the remainder if no exact division
-    /// can be made. This method rounds up ensuring the transaction fee-rate is
-    /// sufficient. See also [`Self::checked_div_by_weight_floor`].
-    ///
-    /// Returns [`None`] if overflow occurred.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_units::{Amount, FeeRate, Weight};
-    /// let amount = Amount::from_sat(10);
-    /// let weight = Weight::from_wu(300);
-    /// let fee_rate = amount.checked_div_by_weight_ceil(weight).expect("Division by weight failed");
-    /// assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(34));
-    /// ```
-    #[cfg(feature = "alloc")]
-    #[must_use]
-    pub const fn checked_div_by_weight_ceil(self, weight: Weight) -> Option<FeeRate> {
-        let wu = weight.to_wu();
-        // No `?` operator in const context.
-        if let Some(sats) = self.to_sat().checked_mul(1_000) {
-            if let Some(wu_minus_one) = wu.checked_sub(1) {
-                if let Some(sats_plus_wu_minus_one) = sats.checked_add(wu_minus_one) {
-                    if let Some(fee_rate) = sats_plus_wu_minus_one.checked_div(wu) {
-                        return Some(FeeRate::from_sat_per_kwu(fee_rate));
-                    }
-                }
-            }
-        }
-        None
-    }
-
-    /// Checked weight floor division.
-    ///
-    /// Be aware that integer division loses the remainder if no exact division
-    /// can be made. See also [`Self::checked_div_by_weight_ceil`].
-    ///
-    /// Returns [`None`] if overflow occurred.
-    #[cfg(feature = "alloc")]
-    #[must_use]
-    pub const fn checked_div_by_weight_floor(self, weight: Weight) -> Option<FeeRate> {
-        // No `?` operator in const context.
-        match self.to_sat().checked_mul(1_000) {
-            Some(res) => match res.checked_div(weight.to_wu()) {
-                Some(fee_rate) => Some(FeeRate::from_sat_per_kwu(fee_rate)),
-                None => None,
-            },
-            None => None,
-        }
-    }
-
     /// Checked remainder.
     ///
     /// Returns [`None`] if overflow occurred.
diff --git a/units/src/fee.rs b/units/src/fee.rs
new file mode 100644
index 0000000000..fba121055d
--- /dev/null
+++ b/units/src/fee.rs
@@ -0,0 +1,202 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Calculate transaction fee ([`Amount`]) from a [`FeeRate`] and [`Weight`].
+//!
+//! The total fee for a transaction can be calculated by multiplying the transaction weight by the
+//! fee rate used to send the transaction.
+//!
+//! Either the weight or fee rate can be calculated if one knows the total fee and either of the
+//! other values. Note however that such calculations truncate (as for integer division).
+//!
+//! We provide `fee.checked_div_by_weight_ceil(weight)` to calculate a minimum threshold fee rate
+//! required to pay at least `fee` for transaction with `weight`.
+
+use core::ops;
+
+use crate::{Amount, FeeRate, Weight};
+
+impl Amount {
+    /// Checked weight ceiling division.
+    ///
+    /// Be aware that integer division loses the remainder if no exact division
+    /// can be made. This method rounds up ensuring the transaction fee-rate is
+    /// sufficient. See also [`Self::checked_div_by_weight_floor`].
+    ///
+    /// Returns [`None`] if overflow occurred.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_units::{Amount, FeeRate, Weight};
+    /// let amount = Amount::from_sat(10);
+    /// let weight = Weight::from_wu(300);
+    /// let fee_rate = amount.checked_div_by_weight_ceil(weight).expect("Division by weight failed");
+    /// assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(34));
+    /// ```
+    #[cfg(feature = "alloc")]
+    #[must_use]
+    pub const fn checked_div_by_weight_ceil(self, weight: Weight) -> Option<FeeRate> {
+        let wu = weight.to_wu();
+        // No `?` operator in const context.
+        if let Some(sats) = self.to_sat().checked_mul(1_000) {
+            if let Some(wu_minus_one) = wu.checked_sub(1) {
+                if let Some(sats_plus_wu_minus_one) = sats.checked_add(wu_minus_one) {
+                    if let Some(fee_rate) = sats_plus_wu_minus_one.checked_div(wu) {
+                        return Some(FeeRate::from_sat_per_kwu(fee_rate));
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    /// Checked weight floor division.
+    ///
+    /// Be aware that integer division loses the remainder if no exact division
+    /// can be made. See also [`Self::checked_div_by_weight_ceil`].
+    ///
+    /// Returns [`None`] if overflow occurred.
+    #[cfg(feature = "alloc")]
+    #[must_use]
+    pub const fn checked_div_by_weight_floor(self, weight: Weight) -> Option<FeeRate> {
+        // No `?` operator in const context.
+        match self.to_sat().checked_mul(1_000) {
+            Some(res) => match res.checked_div(weight.to_wu()) {
+                Some(fee_rate) => Some(FeeRate::from_sat_per_kwu(fee_rate)),
+                None => None,
+            },
+            None => None,
+        }
+    }
+}
+
+impl FeeRate {
+    /// Calculates the fee by multiplying this fee rate by weight, in weight units, returning [`None`]
+    /// if an overflow occurred.
+    ///
+    /// This is equivalent to `Self::checked_mul_by_weight()`.
+    #[must_use]
+    pub fn fee_wu(self, weight: Weight) -> Option<Amount> { self.checked_mul_by_weight(weight) }
+
+    /// Calculates the fee by multiplying this fee rate by weight, in virtual bytes, returning [`None`]
+    /// if an overflow occurred.
+    ///
+    /// This is equivalent to converting `vb` to [`Weight`] using [`Weight::from_vb`] and then calling
+    /// `Self::fee_wu(weight)`.
+    #[must_use]
+    pub fn fee_vb(self, vb: u64) -> Option<Amount> {
+        Weight::from_vb(vb).and_then(|w| self.fee_wu(w))
+    }
+
+    /// Checked weight multiplication.
+    ///
+    /// Computes the absolute fee amount for a given [`Weight`] at this fee rate.
+    /// When the resulting fee is a non-integer amount, the amount is rounded up,
+    /// ensuring that the transaction fee is enough instead of falling short if
+    /// rounded down.
+    ///
+    /// [`None`] is returned if an overflow occurred.
+    #[must_use]
+    pub const fn checked_mul_by_weight(self, weight: Weight) -> Option<Amount> {
+        // No `?` operator in const context.
+        match self.to_sat_per_kwu().checked_mul(weight.to_wu()) {
+            Some(mul_res) => match mul_res.checked_add(999) {
+                Some(add_res) => Some(Amount::from_sat(add_res / 1000)),
+                None => None,
+            },
+            None => None,
+        }
+    }
+}
+
+/// Computes the ceiling so that the fee computation is conservative.
+impl ops::Mul<FeeRate> for Weight {
+    type Output = Amount;
+
+    fn mul(self, rhs: FeeRate) -> Self::Output {
+        Amount::from_sat((rhs.to_sat_per_kwu() * self.to_wu() + 999) / 1000)
+    }
+}
+
+impl ops::Mul<Weight> for FeeRate {
+    type Output = Amount;
+
+    fn mul(self, rhs: Weight) -> Self::Output { rhs * self }
+}
+
+impl ops::Div<Weight> for Amount {
+    type Output = FeeRate;
+
+    /// Truncating integer division.
+    ///
+    /// This is likely the wrong thing for a user dividing an amount by a weight. Consider using
+    /// `checked_div_by_weight` instead.
+    fn div(self, rhs: Weight) -> Self::Output {
+        FeeRate::from_sat_per_kwu(self.to_sat() * 1000 / rhs.to_wu())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fee_rate_div_by_weight() {
+        let fee_rate = Amount::from_sat(329) / Weight::from_wu(381);
+        assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
+    }
+
+    #[test]
+    fn fee_wu() {
+        let fee_overflow = FeeRate::from_sat_per_kwu(10).fee_wu(Weight::MAX);
+        assert!(fee_overflow.is_none());
+
+        let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
+        let weight = Weight::from_vb(3).unwrap();
+        assert_eq!(fee_rate.fee_wu(weight).unwrap(), Amount::from_sat(6));
+    }
+
+    #[test]
+    fn fee_vb() {
+        let fee_overflow = FeeRate::from_sat_per_kwu(10).fee_vb(Weight::MAX.to_wu());
+        assert!(fee_overflow.is_none());
+
+        let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
+        assert_eq!(fee_rate.fee_vb(3).unwrap(), Amount::from_sat(6));
+    }
+
+    #[test]
+    fn checked_weight_mul() {
+        let weight = Weight::from_vb(10).unwrap();
+        let fee: Amount = FeeRate::from_sat_per_vb(10)
+            .unwrap()
+            .checked_mul_by_weight(weight)
+            .expect("expected Amount");
+        assert_eq!(Amount::from_sat(100), fee);
+
+        let fee = FeeRate::from_sat_per_kwu(10).checked_mul_by_weight(Weight::MAX);
+        assert!(fee.is_none());
+
+        let weight = Weight::from_vb(3).unwrap();
+        let fee_rate = FeeRate::from_sat_per_vb(3).unwrap();
+        let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
+        assert_eq!(Amount::from_sat(9), fee);
+
+        let weight = Weight::from_wu(381);
+        let fee_rate = FeeRate::from_sat_per_kwu(864);
+        let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
+        // 381 * 0.864 yields 329.18.
+        // The result is then rounded up to 330.
+        assert_eq!(fee, Amount::from_sat(330));
+    }
+
+    #[test]
+    #[allow(clippy::op_ref)]
+    fn multiply() {
+        let two = FeeRate::from_sat_per_vb(2).unwrap();
+        let three = Weight::from_vb(3).unwrap();
+        let six = Amount::from_sat(6);
+
+        assert_eq!(two * three, six);
+    }
+}
diff --git a/units/src/fee_rate/mod.rs b/units/src/fee_rate/mod.rs
index 938a518ff6..c0baeb9df8 100644
--- a/units/src/fee_rate/mod.rs
+++ b/units/src/fee_rate/mod.rs
@@ -10,9 +10,6 @@ use core::{fmt, ops};
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 
-use crate::amount::Amount;
-use crate::weight::Weight;
-
 /// Represents fee rate.
 ///
 /// This is an integer newtype representing fee rate in `sat/kwu`. It provides protection against mixing
@@ -101,26 +98,6 @@ impl FeeRate {
         }
     }
 
-    /// Checked weight multiplication.
-    ///
-    /// Computes the absolute fee amount for a given [`Weight`] at this fee rate.
-    /// When the resulting fee is a non-integer amount, the amount is rounded up,
-    /// ensuring that the transaction fee is enough instead of falling short if
-    /// rounded down.
-    ///
-    /// [`None`] is returned if an overflow occurred.
-    #[must_use]
-    pub const fn checked_mul_by_weight(self, weight: Weight) -> Option<Amount> {
-        // No `?` operator in const context.
-        match self.to_sat_per_kwu().checked_mul(weight.to_wu()) {
-            Some(mul_res) => match mul_res.checked_add(999) {
-                Some(add_res) => Some(Amount::from_sat(add_res / 1000)),
-                None => None,
-            },
-            None => None,
-        }
-    }
-
     /// Checked addition.
     ///
     /// Computes `self + rhs` returning [`None`] if overflow occurred.
@@ -144,23 +121,6 @@ impl FeeRate {
             None => None,
         }
     }
-
-    /// Calculates the fee by multiplying this fee rate by weight, in weight units, returning [`None`]
-    /// if an overflow occurred.
-    ///
-    /// This is equivalent to `Self::checked_mul_by_weight()`.
-    #[must_use]
-    pub fn fee_wu(self, weight: Weight) -> Option<Amount> { self.checked_mul_by_weight(weight) }
-
-    /// Calculates the fee by multiplying this fee rate by weight, in virtual bytes, returning [`None`]
-    /// if an overflow occurred.
-    ///
-    /// This is equivalent to converting `vb` to [`Weight`] using [`Weight::from_vb`] and then calling
-    /// `Self::fee_wu(weight)`.
-    #[must_use]
-    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.
@@ -194,33 +154,6 @@ impl ops::Sub for FeeRate {
 crate::internal_macros::impl_sub_for_references!(FeeRate);
 crate::internal_macros::impl_sub_assign!(FeeRate);
 
-/// Computes the ceiling so that the fee computation is conservative.
-impl ops::Mul<FeeRate> for Weight {
-    type Output = Amount;
-
-    fn mul(self, rhs: FeeRate) -> Self::Output {
-        Amount::from_sat((rhs.to_sat_per_kwu() * self.to_wu() + 999) / 1000)
-    }
-}
-
-impl ops::Mul<Weight> for FeeRate {
-    type Output = Amount;
-
-    fn mul(self, rhs: Weight) -> Self::Output { rhs * self }
-}
-
-impl ops::Div<Weight> for Amount {
-    type Output = FeeRate;
-
-    /// Truncating integer division.
-    ///
-    /// This is likely the wrong thing for a user dividing an amount by a weight. Consider using
-    /// `checked_div_by_weight` instead.
-    fn div(self, rhs: Weight) -> Self::Output {
-        FeeRate::from_sat_per_kwu(self.to_sat() * 1000 / rhs.to_wu())
-    }
-}
-
 impl core::iter::Sum for FeeRate {
     fn sum<I>(iter: I) -> Self
     where
@@ -291,16 +224,6 @@ mod tests {
         assert_eq!(&ten - &seven, three);
     }
 
-    #[test]
-    #[allow(clippy::op_ref)]
-    fn multiply() {
-        let two = FeeRate::from_sat_per_vb(2).unwrap();
-        let three = Weight::from_vb(3).unwrap();
-        let six = Amount::from_sat(6);
-
-        assert_eq!(two * three, six);
-    }
-
     #[test]
     fn add_assign() {
         let mut f = FeeRate(1);
@@ -323,12 +246,6 @@ mod tests {
         assert_eq!(f, FeeRate(1));
     }
 
-    #[test]
-    fn fee_rate_div_by_weight() {
-        let fee_rate = Amount::from_sat(329) / Weight::from_wu(381);
-        assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
-    }
-
     #[test]
     fn checked_add() {
         let f = FeeRate(1).checked_add(2).unwrap();
@@ -402,50 +319,6 @@ mod tests {
         assert!(fee_rate.is_none());
     }
 
-    #[test]
-    fn fee_wu() {
-        let fee_overflow = FeeRate::from_sat_per_kwu(10).fee_wu(Weight::MAX);
-        assert!(fee_overflow.is_none());
-
-        let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
-        let weight = Weight::from_vb(3).unwrap();
-        assert_eq!(fee_rate.fee_wu(weight).unwrap(), Amount::from_sat(6));
-    }
-
-    #[test]
-    fn fee_vb() {
-        let fee_overflow = FeeRate::from_sat_per_kwu(10).fee_vb(Weight::MAX.to_wu());
-        assert!(fee_overflow.is_none());
-
-        let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
-        assert_eq!(fee_rate.fee_vb(3).unwrap(), Amount::from_sat(6));
-    }
-
-    #[test]
-    fn checked_weight_mul() {
-        let weight = Weight::from_vb(10).unwrap();
-        let fee: Amount = FeeRate::from_sat_per_vb(10)
-            .unwrap()
-            .checked_mul_by_weight(weight)
-            .expect("expected Amount");
-        assert_eq!(Amount::from_sat(100), fee);
-
-        let fee = FeeRate::from_sat_per_kwu(10).checked_mul_by_weight(Weight::MAX);
-        assert!(fee.is_none());
-
-        let weight = Weight::from_vb(3).unwrap();
-        let fee_rate = FeeRate::from_sat_per_vb(3).unwrap();
-        let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
-        assert_eq!(Amount::from_sat(9), fee);
-
-        let weight = Weight::from_wu(381);
-        let fee_rate = FeeRate::from_sat_per_kwu(864);
-        let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
-        // 381 * 0.864 yields 329.18.
-        // The result is then rounded up to 330.
-        assert_eq!(fee, Amount::from_sat(330));
-    }
-
     #[test]
     fn checked_div() {
         let fee_rate = FeeRate(10).checked_div(10).expect("expected feerate in sat/kwu");
diff --git a/units/src/lib.rs b/units/src/lib.rs
index e4bd1254be..4d3be98ac2 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -18,6 +18,7 @@ extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std;
 
+mod fee;
 mod internal_macros;
 
 #[doc(hidden)]

From 706a135de6ca2be0231c2f62f4f2b156e08c9a49 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 8 Jan 2025 09:18:00 +1100
Subject: [PATCH 207/554] bitcoin: Add an example of doing I/O to encode/decode

In an effort to improve the documentation on `bitcoin_io` add an example
in `bitcoin` crate that demonstrates a few things:

- Encode/Decode a `rust-bitcoin` type to/from a stdlib type.
- Encode to a custom type by implementing `bitcoin_io` traits.
- Encode to a foreign custom type by using the `bitcoin_io::bridge::FromStd` wrapper.

Later we can link to this example online in the `bitcoin_io` docs.
---
 bitcoin/Cargo.toml     |   4 ++
 bitcoin/examples/io.rs | 131 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 135 insertions(+)
 create mode 100644 bitcoin/examples/io.rs

diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index 34ca0755ee..fd6e61649f 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -94,5 +94,9 @@ required-features = ["rand-std"]
 [[example]]
 name = "sighash"
 
+[[example]]
+name = "io"
+required-features = ["std"]
+
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(fuzzing)', 'cfg(kani)', 'cfg(mutate)'] }
diff --git a/bitcoin/examples/io.rs b/bitcoin/examples/io.rs
new file mode 100644
index 0000000000..812c6b1664
--- /dev/null
+++ b/bitcoin/examples/io.rs
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Demonstrate reading and writing `rust-bitcoin` objects.
+//!
+//! The `std::io` module is not exposed in `no-std` Rust so building `no-std` applications which
+//! require reading and writing objects via standard traits is not generally possible. To support
+//! this we provide the `bitcoin_io` crate which provides `io::Read`, `io::BufRead`, and
+//! `io::Write`. This module demonstrates its usage.
+
+use bitcoin::consensus::{Decodable, Encodable as _};
+use bitcoin::{OutPoint, Txid};
+
+fn main() {
+    // Encode/Decode a `rust-bitcoin` type to/from a stdlib type.
+    encode_decode_from_stdlib_type();
+
+    // Encode to a custom type by implementing `bitcoin_io` traits.
+    encode_to_custom_type();
+
+    // Encode to a foreign custom type by using the `bitcoin_io::bridge::FromStd` wrapper.
+    encode_using_wrapper();
+}
+
+/// Encodes/Decodes a `rust-bitcoin` type to/from a stdlib type.
+///
+/// The consensus encoding and decoding traits are generic over `bitcoin_io::Write` and
+/// `bitcoin_io::Read`. However for various stdlib types we implement our traits so _most_ things
+/// should just work.
+fn encode_decode_from_stdlib_type() {
+    let data = dummy_utxo();
+
+    // A type that implements `std::io::Write`.
+    let mut v = Vec::new();
+
+    // Under the hood we implement our `io` traits for a bunch of stdlib types so this just works.
+    let _bytes_written = data.consensus_encode(&mut v).expect("failed to encode to writer");
+
+    // Slices implement `std::io::Read`.
+    let mut reader = v.as_ref();
+
+    let _: OutPoint =
+        Decodable::consensus_decode(&mut reader).expect("failed to decode from reader");
+}
+
+/// Encodes to a custom type by implementing the `bitcoin_io::Write` trait.
+///
+/// To use the `Encodable` (and `Decodable`) traits you can implement the `bitcoin_io` traits.
+fn encode_to_custom_type() {
+    /// A byte counter - counts how many bytes where written to it.
+    struct WriteCounter {
+        count: usize,
+    }
+
+    /// This `io` is `bitcoin_io` - see `Cargo.toml` usage of `io = { package = "bitcoin-io" }`.
+    impl io::Write for WriteCounter {
+        fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
+            let written = buf.len();
+            self.count += written;
+            Ok(written)
+        }
+        fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error> {
+            self.count += buf.len();
+            Ok(())
+        }
+        fn flush(&mut self) -> Result<(), io::Error> { Ok(()) }
+    }
+
+    let data = dummy_utxo();
+
+    let mut counter = WriteCounter { count: 0 };
+    let bytes_written = data.consensus_encode(&mut counter).expect("failed to encode to writer");
+    assert_eq!(bytes_written, 36); // 32 bytes for txid + 4 bytes for vout.
+}
+
+/// Encodes to a custom type by using the `bitcoin_io::bridge` module.
+///
+/// If you have a type that you don't control that implements `std::io::Write` you can still encode
+/// to it by way of the `io::bridge::FromStd` wrapper.
+fn encode_using_wrapper() {
+    use pretend_this_is_some_other_crate::WriteCounter;
+
+    let data = dummy_utxo();
+
+    // This will not build because `WriteCounter` does not implement `bitcoin_io::Write`.
+    //
+    // let mut counter = WriteCounter::new();
+    // let bytes_written = data.consensus_encode(&mut counter)?;
+
+    let mut counter = io::FromStd::new(WriteCounter::new());
+    let bytes_written = data.consensus_encode(&mut counter).expect("failed to encode to writer");
+    assert_eq!(bytes_written, 36); // 32 bytes for txid + 4 bytes for vout.
+    assert_eq!(bytes_written, counter.get_ref().written());
+
+    // Take back ownership of the `WriteCounter`.
+    let _ = counter.into_inner();
+}
+
+mod pretend_this_is_some_other_crate {
+    /// A byte counter - counts how many bytes where written to it.
+    pub struct WriteCounter {
+        count: usize,
+    }
+
+    impl WriteCounter {
+        /// Constructs a new `WriteCounter`.
+        pub fn new() -> Self { Self { count: 0 } }
+
+        /// Returns the number of bytes written to this counter.
+        pub fn written(&self) -> usize { self.count }
+    }
+
+    impl std::io::Write for WriteCounter {
+        fn write(&mut self, buf: &[u8]) -> Result<usize, std::io::Error> {
+            let written = buf.len();
+            self.count += written;
+            Ok(written)
+        }
+        fn write_all(&mut self, buf: &[u8]) -> Result<(), std::io::Error> {
+            self.count += buf.len();
+            Ok(())
+        }
+        fn flush(&mut self) -> Result<(), std::io::Error> { Ok(()) }
+    }
+}
+
+/// Constructs a dummy UTXO that is just to represent some `rust-bitcoin` type that implements the
+/// [`consensus::Encodable`] and [`consensus::Decodable`] traits.
+fn dummy_utxo() -> OutPoint {
+    let txid = Txid::from_byte_array([0xFF; 32]); // Arbitrary invalid dummy value.
+    OutPoint { txid, vout: 1 }
+}

From 0870cd1660edd21739cc94075e4b3a1c7f1a7d15 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 8 Jan 2025 10:30:03 +1100
Subject: [PATCH 208/554] Remove Copy from PushBytesError

The `PushBytesError` is the only error type in the codebase to derive
`Copy`. Without thinking too hard this is unusual - remove it.

Thinking a bit harder it makes the code less maintainable because
we must commit to implementing `Copy`.
---
 bitcoin/src/blockdata/script/push_bytes.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/blockdata/script/push_bytes.rs b/bitcoin/src/blockdata/script/push_bytes.rs
index 59f6513149..bae7902b3b 100644
--- a/bitcoin/src/blockdata/script/push_bytes.rs
+++ b/bitcoin/src/blockdata/script/push_bytes.rs
@@ -413,7 +413,7 @@ mod error {
 
     /// Error returned on attempt to create too large `PushBytes`.
     #[allow(unused)]
-    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
     pub struct PushBytesError {
         never: core::convert::Infallible,
     }
@@ -435,7 +435,7 @@ mod error {
     use core::fmt;
 
     /// Error returned on attempt to create too large `PushBytes`.
-    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    #[derive(Debug, Clone, PartialEq, Eq)]
     pub struct PushBytesError {
         /// How long the input was.
         pub(super) len: usize,

From 2f91092d773e1618314b62c9e3eae17c08e1f5ad Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 8 Jan 2025 10:34:47 +1100
Subject: [PATCH 209/554] Derive Clone on consensus errors

All error types in the repo use either [0]:

- `#[derive(Debug, Clone, PartialEq, Eq)]``
- `#[derive(Debug)]`

However the `consensus` error types do not have `Clone` derived.

Derive `Clone` on `consensus::ParseError` and `consensus::Error`.

[0] Excluding `PushBytesError`, fixed in #3879
---
 bitcoin/src/consensus/error.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/consensus/error.rs b/bitcoin/src/consensus/error.rs
index 500e9ecef2..d10f033e39 100644
--- a/bitcoin/src/consensus/error.rs
+++ b/bitcoin/src/consensus/error.rs
@@ -13,7 +13,7 @@ use internals::write_err;
 use super::IterReader;
 
 /// Error deserializing from a slice.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum DeserializeError {
     /// Error parsing encoded object.
@@ -149,7 +149,7 @@ impl From<ParseError> for Error {
 }
 
 /// Encoding is invalid.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum ParseError {
     /// Missing data (early end of file or slice too short).

From 96f427a8b84129179e86f3914be8e4712a89f660 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 8 Jan 2025 14:08:41 +1100
Subject: [PATCH 210/554] units: Refactor Send/Sync api test

The `api` test for types implementing `Send` and `Sync` is part of both
C-SEND-SYNC and also C-GOOD-ERR (for error types).

Refactor the Send/Sync tests in both `units` and `io` and improve
comments.
---
 io/tests/api.rs    |  6 +++---
 units/tests/api.rs | 14 +++++++-------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/io/tests/api.rs b/io/tests/api.rs
index 426f427ad9..608969c027 100644
--- a/io/tests/api.rs
+++ b/io/tests/api.rs
@@ -129,12 +129,12 @@ fn api_all_non_error_types_have_non_empty_debug() {
     assert!(!debug.is_empty());
 }
 
-//  Types are `Send` and `Sync` where possible (C-SEND-SYNC).
 #[test]
 fn all_non_error_tyes_implement_send_sync() {
     fn assert_send<T: Send>() {}
-    assert_send::<Types>();
-
     fn assert_sync<T: Sync>() {}
+
+    //  Types are `Send` and `Sync` where possible (C-SEND-SYNC).
+    assert_send::<Types>();
     assert_sync::<Types>();
 }
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 63bdd7fe07..0fec691bdc 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -221,16 +221,16 @@ fn api_all_non_error_types_have_non_empty_debug() {
 }
 
 #[test]
-fn send() {
+fn all_types_implement_send_sync() {
     fn assert_send<T: Send>() {}
-    assert_send::<Types>();
-    assert_send::<Errors>();
-}
-
-#[test]
-fn sync() {
     fn assert_sync<T: Sync>() {}
+
+    //  Types are `Send` and `Sync` where possible (C-SEND-SYNC).
+    assert_send::<Types>();
     assert_sync::<Types>();
+
+    // Error types should implement the Send and Sync traits (C-GOOD-ERR).
+    assert_send::<Errors>();
     assert_sync::<Errors>();
 }
 

From e315aaf1c65225b89435d0a60907a3233caa5db1 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 8 Jan 2025 14:42:50 +1100
Subject: [PATCH 211/554] io: Allow setting position bigger than inner buffer

Currently if one calls `set_position` on a cursor setting the position
greater than the total length of the inner buffer future calls to `Read`
will panic. Bad `Cursor` - no biscuit.

Mirror the stdlib `Cursor` and allow setting the position to any value.
Make reads past the end of the buffer return `Ok(0)`.
---
 io/src/lib.rs | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/io/src/lib.rs b/io/src/lib.rs
index c8d846dd5a..8dd775b190 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -212,7 +212,7 @@ impl<T: AsRef<[u8]>> Cursor<T> {
     /// This method allows seeking within the wrapped memory by setting the position.
     ///
     /// Note that setting a position that is larger than the buffer length will cause reads to
-    /// return no bytes (EOF).
+    /// succeed by reading zero bytes.
     #[inline]
     pub fn set_position(&mut self, position: u64) { self.pos = position; }
 
@@ -247,6 +247,10 @@ impl<T: AsRef<[u8]>> Read for Cursor<T> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         let inner: &[u8] = self.inner.as_ref();
         let start_pos = self.pos.try_into().unwrap_or(inner.len());
+        if start_pos >= self.inner.as_ref().len() {
+            return Ok(0);
+        }
+
         let read = core::cmp::min(inner.len().saturating_sub(start_pos), buf.len());
         buf[..read].copy_from_slice(&inner[start_pos..start_pos + read]);
         self.pos = self.pos.saturating_add(read.try_into().unwrap_or(u64::MAX /* unreachable */));
@@ -415,4 +419,30 @@ mod tests {
         assert_eq!(read, 2);
         assert_eq!(&buf, "16".as_bytes())
     }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn set_position_past_end_read_returns_eof() {
+        const BUF_LEN: usize = 64; // Just a small buffer.
+        let mut buf = [0_u8; BUF_LEN]; // We never actually write to this buffer.
+
+        let v = [1_u8; BUF_LEN];
+
+        // Sanity check the stdlib Cursor's behaviour.
+        let mut c = std::io::Cursor::new(v);
+        for pos in [BUF_LEN, BUF_LEN + 1, BUF_LEN * 2] {
+            c.set_position(pos as u64);
+            let read = c.read(&mut buf).unwrap();
+            assert_eq!(read, 0);
+            assert_eq!(buf[0], 0x00); // Double check that buffer state is sane.
+        }
+
+        let mut c = Cursor::new(v);
+        for pos in [BUF_LEN, BUF_LEN + 1, BUF_LEN * 2] {
+            c.set_position(pos as u64);
+            let read = c.read(&mut buf).unwrap();
+            assert_eq!(read, 0);
+            assert_eq!(buf[0], 0x00); // Double check that buffer state is sane.
+        }
+    }
 }

From 7a3df57659d02ab610e328072435836386ed1c97 Mon Sep 17 00:00:00 2001
From: yhzlsm <yhzlsm@gmail.com>
Date: Wed, 8 Jan 2025 21:05:17 -0300
Subject: [PATCH 212/554] Reorder assertions in units::amount::tests to follow
 got, want order

Reorder assertions in `units::amount::tests` to follow got, want order

Makes debugging easier, as there's no need to check the test to verify the order.
---
 units/src/amount/tests.rs | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index eccaed53b9..ecd813ffd1 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -939,16 +939,16 @@ fn sum_amounts() {
     let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
-    assert_eq!(Amount::ZERO, [].iter().sum::<Amount>());
-    assert_eq!(SignedAmount::ZERO, [].iter().sum::<SignedAmount>());
+    assert_eq!([].iter().sum::<Amount>(), Amount::ZERO);
+    assert_eq!([].iter().sum::<SignedAmount>(), SignedAmount::ZERO);
 
     let amounts = [sat(42), sat(1337), sat(21)];
     let sum = amounts.into_iter().sum::<Amount>();
-    assert_eq!(sat(1400), sum);
+    assert_eq!(sum, sat(1400));
 
     let amounts = [ssat(-42), ssat(1337), ssat(21)];
     let sum = amounts.into_iter().sum::<SignedAmount>();
-    assert_eq!(ssat(1316), sum);
+    assert_eq!(sum, ssat(1316));
 }
 
 #[test]
@@ -956,28 +956,28 @@ fn checked_sum_amounts() {
     let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
-    assert_eq!(Some(Amount::ZERO), [].into_iter().checked_sum());
-    assert_eq!(Some(SignedAmount::ZERO), [].into_iter().checked_sum());
+    assert_eq!([].into_iter().checked_sum(), Some(Amount::ZERO));
+    assert_eq!([].into_iter().checked_sum(), Some(SignedAmount::ZERO));
 
     let amounts = [sat(42), sat(1337), sat(21)];
     let sum = amounts.into_iter().checked_sum();
-    assert_eq!(Some(sat(1400)), sum);
+    assert_eq!(sum, Some(sat(1400)));
 
     let amounts = [sat(u64::MAX), sat(1337), sat(21)];
     let sum = amounts.into_iter().checked_sum();
-    assert_eq!(None, sum);
+    assert_eq!(sum, None);
 
     let amounts = [SignedAmount::MIN, ssat(-1), ssat(21)];
     let sum = amounts.into_iter().checked_sum();
-    assert_eq!(None, sum);
+    assert_eq!(sum, None);
 
     let amounts = [SignedAmount::MAX, ssat(1), ssat(21)];
     let sum = amounts.into_iter().checked_sum();
-    assert_eq!(None, sum);
+    assert_eq!(sum, None);
 
     let amounts = [ssat(42), ssat(3301), ssat(21)];
     let sum = amounts.into_iter().checked_sum();
-    assert_eq!(Some(ssat(3364)), sum);
+    assert_eq!(sum, Some(ssat(3364)));
 }
 
 #[test]

From 6cf90132bce0d54a0d78e0b27939b20599264770 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 6 Jan 2025 16:11:16 +1100
Subject: [PATCH 213/554] io: Add traits

So that our `io` crate is not surprising it seems we should generally,
unless there is a good reason not to, follow `std::io`.

Copy the derived trait implementations from `std::io` for `Cursor`,
`Sink`, and `Take`.

Done while investigating C-COMMON-TRAITS
---
 io/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/io/src/lib.rs b/io/src/lib.rs
index c8d846dd5a..5f747b2892 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -192,7 +192,7 @@ impl BufRead for &[u8] {
 }
 
 /// Wraps an in memory reader providing the `position` function.
-#[derive(Debug)]
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct Cursor<T> {
     inner: T,
     pos: u64,
@@ -331,7 +331,7 @@ impl Write for &mut [u8] {
 /// A sink to which all writes succeed. See [`std::io::Sink`] for more info.
 ///
 /// Created using `io::sink()`.
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug, Default)]
 pub struct Sink;
 
 impl Write for Sink {

From 426f585a479ca20b7c3390c589b836f8726b9b03 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 9 Jan 2025 15:42:25 +1100
Subject: [PATCH 214/554] api: Run just check-api

---
 api/io/all-features.txt | 13 +++++++++++++
 api/io/alloc-only.txt   | 13 +++++++++++++
 api/io/no-features.txt  | 13 +++++++++++++
 3 files changed, 39 insertions(+)

diff --git a/api/io/all-features.txt b/api/io/all-features.txt
index fe3da3040d..17d4ca33d7 100644
--- a/api/io/all-features.txt
+++ b/api/io/all-features.txt
@@ -47,12 +47,14 @@ impl bitcoin_io::Write for std::net::tcp::TcpStream
 impl bitcoin_io::Write for std::os::unix::net::stream::UnixStream
 impl bitcoin_io::Write for std::process::ChildStdin
 impl core::clone::Clone for bitcoin_io::ErrorKind
+impl core::clone::Clone for bitcoin_io::Sink
 impl core::cmp::Eq for bitcoin_io::ErrorKind
 impl core::cmp::PartialEq for bitcoin_io::ErrorKind
 impl core::convert::From<bitcoin_io::Error> for std::io::error::Error
 impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
 impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
 impl core::convert::From<std::io::error::Error> for bitcoin_io::Error
+impl core::default::Default for bitcoin_io::Sink
 impl core::error::Error for bitcoin_io::Error
 impl core::fmt::Debug for bitcoin_io::Error
 impl core::fmt::Debug for bitcoin_io::ErrorKind
@@ -60,6 +62,7 @@ impl core::fmt::Debug for bitcoin_io::Sink
 impl core::fmt::Display for bitcoin_io::Error
 impl core::hash::Hash for bitcoin_io::ErrorKind
 impl core::marker::Copy for bitcoin_io::ErrorKind
+impl core::marker::Copy for bitcoin_io::Sink
 impl core::marker::Freeze for bitcoin_io::Error
 impl core::marker::Freeze for bitcoin_io::ErrorKind
 impl core::marker::Freeze for bitcoin_io::Sink
@@ -102,11 +105,15 @@ impl<T: bitcoin_io::Read> std::io::Read for bitcoin_io::ToStd<T>
 impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
 impl<T: bitcoin_io::Write> bitcoin_io::Write for bitcoin_io::ToStd<T>
 impl<T: bitcoin_io::Write> std::io::Write for bitcoin_io::ToStd<T>
+impl<T: core::clone::Clone> core::clone::Clone for bitcoin_io::Cursor<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_io::Cursor<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for std::io::cursor::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for std::io::cursor::Cursor<T>
+impl<T: core::default::Default> core::default::Default for bitcoin_io::Cursor<T>
 impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
 impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::FromStd<T>
 impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::ToStd<T>
@@ -124,6 +131,7 @@ impl<T> core::marker::Freeze for bitcoin_io::ToStd<T> where T: core::marker::Fre
 impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
 impl<T> core::marker::Send for bitcoin_io::FromStd<T> where T: core::marker::Send
 impl<T> core::marker::Send for bitcoin_io::ToStd<T> where T: core::marker::Send
+impl<T> core::marker::StructuralPartialEq for bitcoin_io::Cursor<T>
 impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
 impl<T> core::marker::Sync for bitcoin_io::FromStd<T> where T: core::marker::Sync
 impl<T> core::marker::Sync for bitcoin_io::ToStd<T> where T: core::marker::Sync
@@ -217,7 +225,10 @@ pub fn alloc::vec::Vec<u8>::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn alloc::vec::Vec<u8>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::clone(&self) -> bitcoin_io::Cursor<T>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Cursor<T>::default() -> bitcoin_io::Cursor<T>
+pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
@@ -268,6 +279,8 @@ pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<u
 pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Read::read_to_limit(&mut self, buf: &mut alloc::vec::Vec<u8>, limit: u64) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
+pub fn bitcoin_io::Sink::clone(&self) -> bitcoin_io::Sink
+pub fn bitcoin_io::Sink::default() -> bitcoin_io::Sink
 pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Sink::flush(&mut self) -> std::io::error::Result<()>
 pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
diff --git a/api/io/alloc-only.txt b/api/io/alloc-only.txt
index 7510696882..acd87863d4 100644
--- a/api/io/alloc-only.txt
+++ b/api/io/alloc-only.txt
@@ -8,16 +8,19 @@ impl bitcoin_io::Write for &mut [u8]
 impl bitcoin_io::Write for alloc::vec::Vec<u8>
 impl bitcoin_io::Write for bitcoin_io::Sink
 impl core::clone::Clone for bitcoin_io::ErrorKind
+impl core::clone::Clone for bitcoin_io::Sink
 impl core::cmp::Eq for bitcoin_io::ErrorKind
 impl core::cmp::PartialEq for bitcoin_io::ErrorKind
 impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
 impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
+impl core::default::Default for bitcoin_io::Sink
 impl core::fmt::Debug for bitcoin_io::Error
 impl core::fmt::Debug for bitcoin_io::ErrorKind
 impl core::fmt::Debug for bitcoin_io::Sink
 impl core::fmt::Display for bitcoin_io::Error
 impl core::hash::Hash for bitcoin_io::ErrorKind
 impl core::marker::Copy for bitcoin_io::ErrorKind
+impl core::marker::Copy for bitcoin_io::Sink
 impl core::marker::Freeze for bitcoin_io::Error
 impl core::marker::Freeze for bitcoin_io::ErrorKind
 impl core::marker::Freeze for bitcoin_io::Sink
@@ -47,12 +50,17 @@ impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Take<'_, R>
 impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for &mut T
 impl<T: bitcoin_io::Read> bitcoin_io::Read for &mut T
 impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
+impl<T: core::clone::Clone> core::clone::Clone for bitcoin_io::Cursor<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_io::Cursor<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
+impl<T: core::default::Default> core::default::Default for bitcoin_io::Cursor<T>
 impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
 impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
 impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
+impl<T> core::marker::StructuralPartialEq for bitcoin_io::Cursor<T>
 impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
 impl<T> core::marker::Unpin for bitcoin_io::Cursor<T> where T: core::marker::Unpin
 impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::RefUnwindSafe
@@ -92,7 +100,10 @@ pub fn alloc::vec::Vec<u8>::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn alloc::vec::Vec<u8>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::clone(&self) -> bitcoin_io::Cursor<T>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Cursor<T>::default() -> bitcoin_io::Cursor<T>
+pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
@@ -118,6 +129,8 @@ pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<u
 pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Read::read_to_limit(&mut self, buf: &mut alloc::vec::Vec<u8>, limit: u64) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
+pub fn bitcoin_io::Sink::clone(&self) -> bitcoin_io::Sink
+pub fn bitcoin_io::Sink::default() -> bitcoin_io::Sink
 pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
diff --git a/api/io/no-features.txt b/api/io/no-features.txt
index 0874dbcd98..15660438bd 100644
--- a/api/io/no-features.txt
+++ b/api/io/no-features.txt
@@ -7,16 +7,19 @@ impl bitcoin_io::Read for &[u8]
 impl bitcoin_io::Write for &mut [u8]
 impl bitcoin_io::Write for bitcoin_io::Sink
 impl core::clone::Clone for bitcoin_io::ErrorKind
+impl core::clone::Clone for bitcoin_io::Sink
 impl core::cmp::Eq for bitcoin_io::ErrorKind
 impl core::cmp::PartialEq for bitcoin_io::ErrorKind
 impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
 impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
+impl core::default::Default for bitcoin_io::Sink
 impl core::fmt::Debug for bitcoin_io::Error
 impl core::fmt::Debug for bitcoin_io::ErrorKind
 impl core::fmt::Debug for bitcoin_io::Sink
 impl core::fmt::Display for bitcoin_io::Error
 impl core::hash::Hash for bitcoin_io::ErrorKind
 impl core::marker::Copy for bitcoin_io::ErrorKind
+impl core::marker::Copy for bitcoin_io::Sink
 impl core::marker::Freeze for bitcoin_io::Error
 impl core::marker::Freeze for bitcoin_io::ErrorKind
 impl core::marker::Freeze for bitcoin_io::Sink
@@ -45,12 +48,17 @@ impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Read for bitcoin_io
 impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for &mut T
 impl<T: bitcoin_io::Read> bitcoin_io::Read for &mut T
 impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
+impl<T: core::clone::Clone> core::clone::Clone for bitcoin_io::Cursor<T>
+impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_io::Cursor<T>
+impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
 impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
+impl<T: core::default::Default> core::default::Default for bitcoin_io::Cursor<T>
 impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
 impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
 impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
+impl<T> core::marker::StructuralPartialEq for bitcoin_io::Cursor<T>
 impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
 impl<T> core::marker::Unpin for bitcoin_io::Cursor<T> where T: core::marker::Unpin
 impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::RefUnwindSafe
@@ -88,7 +96,10 @@ pub fn &mut [u8]::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn &mut [u8]::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
 pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
+pub fn bitcoin_io::Cursor<T>::clone(&self) -> bitcoin_io::Cursor<T>
 pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
+pub fn bitcoin_io::Cursor<T>::default() -> bitcoin_io::Cursor<T>
+pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
@@ -111,6 +122,8 @@ pub fn bitcoin_io::ErrorKind::hash<__H: core::hash::Hasher>(&self, state: &mut _
 pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
+pub fn bitcoin_io::Sink::clone(&self) -> bitcoin_io::Sink
+pub fn bitcoin_io::Sink::default() -> bitcoin_io::Sink
 pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>

From e8b157317eff0559b9c4bc0bfdc6c176dfb6f14b Mon Sep 17 00:00:00 2001
From: Update Stable Rustc Bot <bot@example.com>
Date: Fri, 10 Jan 2025 00:57:18 +0000
Subject: [PATCH 215/554] Automated update to Github CI to rustc stable-1.84.0

---
 .github/workflows/stable-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stable-version b/.github/workflows/stable-version
index 6b4de0a42b..bd0f9e6c28 100644
--- a/.github/workflows/stable-version
+++ b/.github/workflows/stable-version
@@ -1 +1 @@
-1.83.0
+1.84.0

From 1e0c065740266a8ad207a95f4d964394ba3f07d7 Mon Sep 17 00:00:00 2001
From: Jose Storopoli <jose@storopoli.com>
Date: Fri, 10 Jan 2025 11:11:43 -0300
Subject: [PATCH 216/554] typo: Address::is_valid_for_network

I believe this is a typo.
---
 bitcoin/src/address/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 51a02c56ff..45b547c742 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -768,7 +768,7 @@ impl Address<NetworkUnchecked> {
     }
 
     /// 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
+    /// regtest and signet addresses 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.

From b844637935f7725e80a4e32d5ea8c9ff3c2be3f1 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 7 Jan 2025 17:16:24 +1100
Subject: [PATCH 217/554] io: Remove rustdoc for private module

This doc adds little value and has typos in it - just remove it.
---
 io/src/macros.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/io/src/macros.rs b/io/src/macros.rs
index 5fae2a7508..a0ed865765 100644
--- a/io/src/macros.rs
+++ b/io/src/macros.rs
@@ -1,5 +1,3 @@
-//! Public macros for porvide.d for users to be able implement our `io::Write` trait.
-
 #[macro_export]
 /// Because we cannot provide a blanket implementation of [`std::io::Write`] for all implementers
 /// of this crate's `io::Write` trait, we provide this macro instead.

From 07d8703a00b5e3721f1dcdb141cf6bc606351df5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 7 Jan 2025 09:21:57 +1100
Subject: [PATCH 218/554] io: Add SPDX identifier

The `io` crate is licensed in the manifest using the CC0-1.0 license
same as the rest of the codebase but none of the individual files have a
license blurb.

Add a CC0-1.0 license blurb by way of an SPDX-License-Identifier tag.
---
 io/src/bridge.rs | 2 ++
 io/src/error.rs  | 2 ++
 io/src/lib.rs    | 2 ++
 io/src/macros.rs | 2 ++
 4 files changed, 8 insertions(+)

diff --git a/io/src/bridge.rs b/io/src/bridge.rs
index 4079d57fd4..fc49a07719 100644
--- a/io/src/bridge.rs
+++ b/io/src/bridge.rs
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: CC0-1.0
+
 #[cfg(feature = "alloc")]
 use alloc::boxed::Box;
 
diff --git a/io/src/error.rs b/io/src/error.rs
index 172dd3d6a9..6ae9719bdf 100644
--- a/io/src/error.rs
+++ b/io/src/error.rs
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: CC0-1.0
+
 #[cfg(all(not(feature = "std"), feature = "alloc"))]
 use alloc::boxed::Box;
 use core::fmt;
diff --git a/io/src/lib.rs b/io/src/lib.rs
index ffb2af0de6..f501ad46ed 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: CC0-1.0
+
 //! Rust-Bitcoin I/O Library
 //!
 //! The `std::io` module is not exposed in `no-std` Rust so building `no-std` applications which
diff --git a/io/src/macros.rs b/io/src/macros.rs
index a0ed865765..4904a826d8 100644
--- a/io/src/macros.rs
+++ b/io/src/macros.rs
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: CC0-1.0
+
 #[macro_export]
 /// Because we cannot provide a blanket implementation of [`std::io::Write`] for all implementers
 /// of this crate's `io::Write` trait, we provide this macro instead.

From b109177e116d83872e38321675525567e7d22b6f Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 7 Jan 2025 10:35:24 +1100
Subject: [PATCH 219/554] io: Improve rustdocs

In preparation for releasing `io v1.0` make a sweep of the rustdocs and
improve them for all modules except `macros`.

With this applied I believe we can tick off:

- C-FAILURE
- C-LINK
- C-HIDDEN
---
 io/src/lib.rs | 44 ++++++++++++++++++++++++++++++++++++--------
 1 file changed, 36 insertions(+), 8 deletions(-)

diff --git a/io/src/lib.rs b/io/src/lib.rs
index f501ad46ed..1605300eae 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -2,9 +2,9 @@
 
 //! Rust-Bitcoin I/O Library
 //!
-//! The `std::io` module is not exposed in `no-std` Rust so building `no-std` applications which
+//! The [`std::io`] module is not exposed in `no-std` Rust so building `no-std` applications which
 //! require reading and writing objects via standard traits is not generally possible. Thus, this
-//! library exists to export a minmal version of `std::io`'s traits which we use in `rust-bitcoin`
+//! library exists to export a minimal version of `std::io`'s traits which we use in `rust-bitcoin`
 //! so that we can support `no-std` applications.
 //!
 //! These traits are not one-for-one drop-ins, but are as close as possible while still implementing
@@ -43,12 +43,22 @@ pub use self::error::{Error, ErrorKind};
 /// Result type returned by functions in this crate.
 pub type Result<T> = core::result::Result<T, Error>;
 
-/// A generic trait describing an input stream. See [`std::io::Read`] for more info.
+/// A generic trait describing an input stream.
+///
+/// See [`std::io::Read`] for more information.
 pub trait Read {
     /// Reads bytes from source into `buf`.
+    ///
+    /// # Returns
+    ///
+    /// The number of bytes read if successful or an [`Error`] if reading fails.
     fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
 
     /// Reads bytes from source until `buf` is full.
+    ///
+    /// # Errors
+    ///
+    /// If the exact number of bytes required to fill `buf` cannot be read.
     #[inline]
     fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<()> {
         while !buf.is_empty() {
@@ -71,7 +81,11 @@ pub trait Read {
     /// `limit` is used to prevent a denial of service attack vector since an unbounded reader will
     /// exhaust all memory.
     ///
-    /// Similar to `std::io::Read::read_to_end` but with the DOS protection.
+    /// Similar to [`std::io::Read::read_to_end`] but with the DOS protection.
+    ///
+    /// # Returns
+    ///
+    /// The number of bytes read if successful or an [`Error`] if reading fails.
     #[doc(alias = "read_to_end")]
     #[cfg(feature = "alloc")]
     #[inline]
@@ -83,6 +97,10 @@ pub trait Read {
 /// A trait describing an input stream that uses an internal buffer when reading.
 pub trait BufRead: Read {
     /// Returns data read from this reader, filling the internal buffer if needed.
+    ///
+    /// # Errors
+    ///
+    /// May error if reading fails.
     fn fill_buf(&mut self) -> Result<&[u8]>;
 
     /// Marks the buffered data up to amount as consumed.
@@ -104,6 +122,12 @@ pub struct Take<'a, R: Read + ?Sized> {
 
 impl<R: Read + ?Sized> Take<'_, R> {
     /// Reads all bytes until EOF from the underlying reader into `buf`.
+    ///
+    /// Allocates space in `buf` as needed.
+    ///
+    /// # Returns
+    ///
+    /// The number of bytes read if successful or an [`Error`] if reading fails.
     #[cfg(feature = "alloc")]
     #[inline]
     pub fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {
@@ -274,7 +298,9 @@ impl<T: AsRef<[u8]>> BufRead for Cursor<T> {
     }
 }
 
-/// A generic trait describing an output stream. See [`std::io::Write`] for more info.
+/// A generic trait describing an output stream.
+///
+/// See [`std::io::Write`] for more information.
 pub trait Write {
     /// Writes `buf` into this writer, returning how many bytes were written.
     fn write(&mut self, buf: &[u8]) -> Result<usize>;
@@ -334,9 +360,9 @@ impl Write for &mut [u8] {
     fn flush(&mut self) -> Result<()> { Ok(()) }
 }
 
-/// A sink to which all writes succeed. See [`std::io::Sink`] for more info.
+/// A sink to which all writes succeed.
 ///
-/// Created using `io::sink()`.
+/// Created using [`sink()`]. See [`std::io::Sink`] for more information.
 #[derive(Clone, Copy, Debug, Default)]
 pub struct Sink;
 
@@ -351,7 +377,9 @@ impl Write for Sink {
     fn flush(&mut self) -> Result<()> { Ok(()) }
 }
 
-/// Returns a sink to which all writes succeed. See [`std::io::sink`] for more info.
+/// Returns a sink to which all writes succeed.
+///
+/// See [`std::io::sink`] for more information.
 #[inline]
 pub fn sink() -> Sink { Sink }
 

From 9c81d5e74767b10c5a49bbdf9e3c38becbbd89b7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 7 Jan 2025 10:46:09 +1100
Subject: [PATCH 220/554] io: Move macro_export below docs

The `io::macros` crate uses a kind of nifty trick of putting
`macro_export` _above_ the docs. But we do not do this anywhere else in
the code base so its a bit surprising. We should be uniform.

Simply because its an easier change move the `macro_export` attribute to
be under the docs.

Internal change only.
---
 io/src/macros.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/io/src/macros.rs b/io/src/macros.rs
index 4904a826d8..26e9d1a2dc 100644
--- a/io/src/macros.rs
+++ b/io/src/macros.rs
@@ -1,6 +1,5 @@
 // SPDX-License-Identifier: CC0-1.0
 
-#[macro_export]
 /// Because we cannot provide a blanket implementation of [`std::io::Write`] for all implementers
 /// of this crate's `io::Write` trait, we provide this macro instead.
 ///
@@ -9,6 +8,7 @@
 /// that feature. In any case, this crate's `io::Write` feature will be implemented for the given
 /// type, even if indirectly.
 #[cfg(not(feature = "std"))]
+#[macro_export]
 macro_rules! impl_write {
     ($ty: ty, $write_fn: expr, $flush_fn: expr $(, $bounded_ty: ident : $bounds: path),*) => {
         impl<$($bounded_ty: $bounds),*> $crate::Write for $ty {
@@ -24,7 +24,6 @@ macro_rules! impl_write {
     }
 }
 
-#[macro_export]
 /// Because we cannot provide a blanket implementation of [`std::io::Write`] for all implementers
 /// of this crate's `io::Write` trait, we provide this macro instead.
 ///
@@ -33,6 +32,7 @@ macro_rules! impl_write {
 /// that feature. In any case, this crate's `io::Write` feature will be implemented for the given
 /// type, even if indirectly.
 #[cfg(feature = "std")]
+#[macro_export]
 macro_rules! impl_write {
     ($ty: ty, $write_fn: expr, $flush_fn: expr $(, $bounded_ty: ident : $bounds: path),*) => {
         impl<$($bounded_ty: $bounds),*> std::io::Write for $ty {

From 71fab82a1b32e6077adb896be9d8ac12d5513e0a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 7 Jan 2025 10:54:26 +1100
Subject: [PATCH 221/554] io: Improve docs on macro

Note that the docsrs build enables all features so the `impl_write`
macro gets a `std` feature flag even though it is available without the
`std` feature enabled. I can't think of a solution to that slight
annoyance ATM.

The current docs on `impl_write` seem to be stale. The macro just does a
simple call through implementation of `crate::Write` and the same for
`std::io::Write` if `std` is enabled.

Improve the rusdocs by doing:

- Remove module level docs because this is a private module and they
  only add minimal value.
- Put the docs on the `std` macro only (docs build uses --all-features)
- Explain just what the macro does and include an `# Arguments` section.
---
 io/src/macros.rs | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/io/src/macros.rs b/io/src/macros.rs
index 26e9d1a2dc..55df18aa73 100644
--- a/io/src/macros.rs
+++ b/io/src/macros.rs
@@ -1,12 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
-/// Because we cannot provide a blanket implementation of [`std::io::Write`] for all implementers
-/// of this crate's `io::Write` trait, we provide this macro instead.
-///
-/// This macro will implement `Write` given a `write` and `flush` fn, either by implementing the
-/// crate's native `io::Write` trait directly, or a more generic trait from `std` for users using
-/// that feature. In any case, this crate's `io::Write` feature will be implemented for the given
-/// type, even if indirectly.
+/// Implements [`crate::Write`] for `$ty`.
+// See below for docs (docs.rs build enables all features).
 #[cfg(not(feature = "std"))]
 #[macro_export]
 macro_rules! impl_write {
@@ -24,13 +19,16 @@ macro_rules! impl_write {
     }
 }
 
-/// Because we cannot provide a blanket implementation of [`std::io::Write`] for all implementers
-/// of this crate's `io::Write` trait, we provide this macro instead.
+/// Implements [`crate::Write`] for `$ty`.
+///
+/// Also implements [`std::io::Write`] for `$ty` if `bitcoin_io` has the `std` feature enabled.
+///
+/// # Arguments
 ///
-/// This macro will implement `Write` given a `write` and `flush` fn, either by implementing the
-/// crate's native `io::Write` trait directly, or a more generic trait from `std` for users using
-/// that feature. In any case, this crate's `io::Write` feature will be implemented for the given
-/// type, even if indirectly.
+/// * `$ty` - the type used to implement the two traits.
+/// * `write_fn` - the function called by the `Write::write` trait method.
+/// * `flush_fn` - the function called by the `Write::flush` trait method.
+/// * `$bounded_ty: $bounds` - optional trait bounds if required.
 #[cfg(feature = "std")]
 #[macro_export]
 macro_rules! impl_write {

From a431a13c2408baea97d578bde3530e76e8d65c6a Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 11 Jan 2025 01:41:39 +0000
Subject: [PATCH 222/554] Automated update to Github CI to rustc
 nightly-2025-01-10

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 5de8e30254..ecd2b22dcc 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2024-12-26
+nightly-2025-01-10

From 8bdd67a368fd1613c7babeed85fecbf20ba820ad Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 12 Jan 2025 01:23:13 +0000
Subject: [PATCH 223/554] 2025-01-12 automated rustfmt nightly

---
 base58/src/error.rs                           |  2 +-
 bitcoin/src/address/error.rs                  |  2 +-
 bitcoin/src/bip152.rs                         |  2 +-
 bitcoin/src/bip158.rs                         |  2 +-
 bitcoin/src/bip32.rs                          |  2 +-
 bitcoin/src/blockdata/block.rs                |  2 +-
 bitcoin/src/blockdata/constants.rs            |  5 ++-
 bitcoin/src/blockdata/script/mod.rs           |  2 +-
 .../src/blockdata/script/witness_program.rs   |  2 +-
 .../src/blockdata/script/witness_version.rs   |  2 +-
 bitcoin/src/consensus/error.rs                |  2 +-
 bitcoin/src/consensus_validation.rs           |  2 +-
 bitcoin/src/crypto/ecdsa.rs                   |  2 +-
 bitcoin/src/crypto/key.rs                     |  2 +-
 bitcoin/src/crypto/sighash.rs                 |  2 +-
 bitcoin/src/crypto/taproot.rs                 |  2 +-
 bitcoin/src/merkle_tree/block.rs              |  2 +-
 bitcoin/src/psbt/error.rs                     |  2 +-
 bitcoin/src/psbt/mod.rs                       |  4 +--
 bitcoin/src/sign_message.rs                   |  2 +-
 bitcoin/src/taproot/mod.rs                    |  2 +-
 chacha20_poly1305/src/poly1305.rs             | 12 +++----
 units/src/amount/tests.rs                     | 35 +++++++++++++++----
 units/src/block.rs                            | 15 ++++++--
 units/src/fee_rate/serde.rs                   |  2 +-
 units/src/parse.rs                            |  2 --
 26 files changed, 72 insertions(+), 41 deletions(-)

diff --git a/base58/src/error.rs b/base58/src/error.rs
index c86e6daccc..67409d2865 100644
--- a/base58/src/error.rs
+++ b/base58/src/error.rs
@@ -2,8 +2,8 @@
 
 //! Error code for the `base58` crate.
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use internals::write_err;
 
diff --git a/bitcoin/src/address/error.rs b/bitcoin/src/address/error.rs
index 65eb34f4d2..eaa8205525 100644
--- a/bitcoin/src/address/error.rs
+++ b/bitcoin/src/address/error.rs
@@ -1,7 +1,7 @@
 //! Error code for the address module.
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use internals::write_err;
 
diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs
index d2cdcaf8ec..f57fe3e1ce 100644
--- a/bitcoin/src/bip152.rs
+++ b/bitcoin/src/bip152.rs
@@ -4,8 +4,8 @@
 //!
 //! Implementation of compact blocks data structure and algorithms.
 
-use core::{convert, fmt, mem};
 use core::convert::Infallible;
+use core::{convert, fmt, mem};
 #[cfg(feature = "std")]
 use std::error;
 
diff --git a/bitcoin/src/bip158.rs b/bitcoin/src/bip158.rs
index 419514abf5..a0d57c1a87 100644
--- a/bitcoin/src/bip158.rs
+++ b/bitcoin/src/bip158.rs
@@ -38,8 +38,8 @@
 //!  ```
 
 use core::cmp::{self, Ordering};
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use hashes::{sha256d, siphash24, HashEngine as _};
 use internals::{write_err, ToU64 as _};
diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index b029004358..832b497ad6 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -5,10 +5,10 @@
 //! Implementation of BIP32 hierarchical deterministic wallets, as defined
 //! at <https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki>.
 
+use core::convert::Infallible;
 use core::ops::Index;
 use core::str::FromStr;
 use core::{fmt, slice};
-use core::convert::Infallible;
 
 use hashes::{hash160, hash_newtype, sha512, GeneralHash, HashEngine, Hmac, HmacEngine};
 use internals::write_err;
diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs
index 72149a44d4..43ac31ad73 100644
--- a/bitcoin/src/blockdata/block.rs
+++ b/bitcoin/src/blockdata/block.rs
@@ -7,8 +7,8 @@
 //! module describes structures and functions needed to describe
 //! these blocks and the blockchain.
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use hashes::{sha256d, HashEngine};
 use internals::{compact_size, ToU64};
diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 91821fe709..dd45b1c883 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -112,7 +112,10 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
         witness: Witness::default(),
     });
 
-    ret.output.push(TxOut { value: Amount::from_sat_unchecked(50 * 100_000_000), script_pubkey: out_script });
+    ret.output.push(TxOut {
+        value: Amount::from_sat_unchecked(50 * 100_000_000),
+        script_pubkey: out_script,
+    });
 
     // end
     ret
diff --git a/bitcoin/src/blockdata/script/mod.rs b/bitcoin/src/blockdata/script/mod.rs
index ac2a018427..b77acb2c77 100644
--- a/bitcoin/src/blockdata/script/mod.rs
+++ b/bitcoin/src/blockdata/script/mod.rs
@@ -57,8 +57,8 @@ mod tests;
 pub mod witness_program;
 pub mod witness_version;
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use io::{BufRead, Write};
 use primitives::opcodes::all::*;
diff --git a/bitcoin/src/blockdata/script/witness_program.rs b/bitcoin/src/blockdata/script/witness_program.rs
index 9f1448da3d..4c60228dc9 100644
--- a/bitcoin/src/blockdata/script/witness_program.rs
+++ b/bitcoin/src/blockdata/script/witness_program.rs
@@ -7,8 +7,8 @@
 //!
 //! [BIP141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use internals::array_vec::ArrayVec;
 use secp256k1::{Secp256k1, Verification};
diff --git a/bitcoin/src/blockdata/script/witness_version.rs b/bitcoin/src/blockdata/script/witness_version.rs
index 98b6edc16c..fa4f06d48c 100644
--- a/bitcoin/src/blockdata/script/witness_version.rs
+++ b/bitcoin/src/blockdata/script/witness_version.rs
@@ -7,9 +7,9 @@
 //!
 //! [BIP141]: <https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki>
 
+use core::convert::Infallible;
 use core::fmt;
 use core::str::FromStr;
-use core::convert::Infallible;
 
 use internals::write_err;
 use units::parse::{self, ParseIntError};
diff --git a/bitcoin/src/consensus/error.rs b/bitcoin/src/consensus/error.rs
index d3cbaa8462..be0bccc9de 100644
--- a/bitcoin/src/consensus/error.rs
+++ b/bitcoin/src/consensus/error.rs
@@ -2,8 +2,8 @@
 
 //! Consensus encoding errors.
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use hex::error::{InvalidCharError, OddLengthStringError};
 use hex::DisplayHex as _;
diff --git a/bitcoin/src/consensus_validation.rs b/bitcoin/src/consensus_validation.rs
index d3d67f0ea3..b461374d15 100644
--- a/bitcoin/src/consensus_validation.rs
+++ b/bitcoin/src/consensus_validation.rs
@@ -4,8 +4,8 @@
 //!
 //! Relies on the `bitcoinconsensus` crate that uses Bitcoin Core libconsensus to perform validation.
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use internals::write_err;
 
diff --git a/bitcoin/src/crypto/ecdsa.rs b/bitcoin/src/crypto/ecdsa.rs
index 90e6d105e1..58c0b028b4 100644
--- a/bitcoin/src/crypto/ecdsa.rs
+++ b/bitcoin/src/crypto/ecdsa.rs
@@ -4,9 +4,9 @@
 //!
 //! This module provides ECDSA signatures used by Bitcoin that can be roundtrip (de)serialized.
 
+use core::convert::Infallible;
 use core::str::FromStr;
 use core::{fmt, iter};
-use core::convert::Infallible;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index e51350afab..c3f3affe8c 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -5,10 +5,10 @@
 //! This module provides keys used in Bitcoin that can be roundtrip
 //! (de)serialized.
 
+use core::convert::Infallible;
 use core::fmt::{self, Write as _};
 use core::ops;
 use core::str::FromStr;
-use core::convert::Infallible;
 
 use hashes::hash160;
 use hex::{FromHex, HexToArrayError};
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 6c7a0664d3..83a82433b4 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -11,8 +11,8 @@
 //! handle its complexity efficiently. Computing these hashes is as simple as creating
 //! [`SighashCache`] and calling its methods.
 
-use core::{fmt, str};
 use core::convert::Infallible;
+use core::{fmt, str};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
diff --git a/bitcoin/src/crypto/taproot.rs b/bitcoin/src/crypto/taproot.rs
index fed166e303..a0c73309ea 100644
--- a/bitcoin/src/crypto/taproot.rs
+++ b/bitcoin/src/crypto/taproot.rs
@@ -4,8 +4,8 @@
 //!
 //! This module provides Taproot keys used in Bitcoin (including reexporting secp256k1 keys).
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
diff --git a/bitcoin/src/merkle_tree/block.rs b/bitcoin/src/merkle_tree/block.rs
index 73a0adb675..e39fab19af 100644
--- a/bitcoin/src/merkle_tree/block.rs
+++ b/bitcoin/src/merkle_tree/block.rs
@@ -9,8 +9,8 @@
 //!
 //! Support proofs that transaction(s) belong to a block.
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use internals::ToU64 as _;
 use io::{BufRead, Write};
diff --git a/bitcoin/src/psbt/error.rs b/bitcoin/src/psbt/error.rs
index 35f38146fd..dcf244ad38 100644
--- a/bitcoin/src/psbt/error.rs
+++ b/bitcoin/src/psbt/error.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 use internals::write_err;
 
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 2e7b45efcb..184e785ae4 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -13,8 +13,8 @@ mod map;
 pub mod raw;
 pub mod serialize;
 
-use core::{cmp, fmt};
 use core::convert::Infallible;
+use core::{cmp, fmt};
 #[cfg(feature = "std")]
 use std::collections::{HashMap, HashSet};
 
@@ -1154,9 +1154,9 @@ impl std::error::Error for IndexOutOfBoundsError {
 
 #[cfg(feature = "base64")]
 mod display_from_str {
+    use core::convert::Infallible;
     use core::fmt;
     use core::str::FromStr;
-    use core::convert::Infallible;
 
     use base64::display::Base64Display;
     use base64::prelude::{Engine as _, BASE64_STANDARD};
diff --git a/bitcoin/src/sign_message.rs b/bitcoin/src/sign_message.rs
index 979a174c97..045544d5e3 100644
--- a/bitcoin/src/sign_message.rs
+++ b/bitcoin/src/sign_message.rs
@@ -21,8 +21,8 @@ pub const BITCOIN_SIGNED_MSG_PREFIX: &[u8] = b"\x18Bitcoin Signed Message:\n";
 
 #[cfg(feature = "secp-recovery")]
 mod message_signing {
-    use core::fmt;
     use core::convert::Infallible;
+    use core::fmt;
 
     use hashes::sha256d;
     use internals::write_err;
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 53a3f95ea5..50ea6c257a 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -8,9 +8,9 @@ pub mod merkle_branch;
 pub mod serialized_signature;
 
 use core::cmp::{Ordering, Reverse};
+use core::convert::Infallible;
 use core::fmt;
 use core::iter::FusedIterator;
-use core::convert::Infallible;
 
 use hashes::{sha256t, HashEngine};
 use internals::{impl_to_hex_from_lower_hex, write_err};
diff --git a/chacha20_poly1305/src/poly1305.rs b/chacha20_poly1305/src/poly1305.rs
index 0b277b01f1..4aef1343ca 100644
--- a/chacha20_poly1305/src/poly1305.rs
+++ b/chacha20_poly1305/src/poly1305.rs
@@ -197,12 +197,12 @@ fn prepare_padded_message_slice(msg: &[u8], is_last: bool) -> [u32; 5] {
     let m0 = u32::from_le_bytes(fmt_msg[0..4].try_into().expect("Valid subset of 32.")) & BITMASK;
     let m1 =
         (u32::from_le_bytes(fmt_msg[3..7].try_into().expect("Valid subset of 32.")) >> 2) & BITMASK;
-    let m2 =
-        (u32::from_le_bytes(fmt_msg[6..10].try_into().expect("Valid subset of 32.")) >> 4) & BITMASK;
-    let m3 =
-        (u32::from_le_bytes(fmt_msg[9..13].try_into().expect("Valid subset of 32.")) >> 6) & BITMASK;
-    let m4 =
-        (u32::from_le_bytes(fmt_msg[12..16].try_into().expect("Valid subset of 32.")) >> 8) | hi_bit;
+    let m2 = (u32::from_le_bytes(fmt_msg[6..10].try_into().expect("Valid subset of 32.")) >> 4)
+        & BITMASK;
+    let m3 = (u32::from_le_bytes(fmt_msg[9..13].try_into().expect("Valid subset of 32.")) >> 6)
+        & BITMASK;
+    let m4 = (u32::from_le_bytes(fmt_msg[12..16].try_into().expect("Valid subset of 32.")) >> 8)
+        | hi_bit;
     [m0, m1, m2, m3, m4]
 }
 
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index ecd813ffd1..d6becf50fb 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -19,7 +19,10 @@ use crate::{FeeRate, Weight};
 #[test]
 fn sanity_check() {
     assert_eq!(SignedAmount::from_sat(-100).abs(), SignedAmount::from_sat(100));
-    assert_eq!(SignedAmount::from_sat(i64::MIN + 1).checked_abs().unwrap(), SignedAmount::from_sat(i64::MAX));
+    assert_eq!(
+        SignedAmount::from_sat(i64::MIN + 1).checked_abs().unwrap(),
+        SignedAmount::from_sat(i64::MAX)
+    );
     assert_eq!(SignedAmount::from_sat(-100).signum(), -1);
     assert_eq!(SignedAmount::from_sat(0).signum(), 0);
     assert_eq!(SignedAmount::from_sat(100).signum(), 1);
@@ -30,8 +33,14 @@ fn sanity_check() {
 
     #[cfg(feature = "alloc")]
     {
-        assert_eq!(Amount::from_float_in(0_f64, Denomination::Bitcoin).unwrap(), Amount::from_sat(0));
-        assert_eq!(Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(), Amount::from_sat(200_000_000));
+        assert_eq!(
+            Amount::from_float_in(0_f64, Denomination::Bitcoin).unwrap(),
+            Amount::from_sat(0)
+        );
+        assert_eq!(
+            Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(),
+            Amount::from_sat(200_000_000)
+        );
         assert!(Amount::from_float_in(-100_f64, Denomination::Bitcoin).is_err());
     }
 }
@@ -170,15 +179,24 @@ fn checked_arithmetic() {
 #[test]
 #[allow(deprecated_in_future)]
 fn unchecked_arithmetic() {
-    assert_eq!(SignedAmount::from_sat(10).unchecked_add(SignedAmount::from_sat(20)), SignedAmount::from_sat(30));
-    assert_eq!(SignedAmount::from_sat(50).unchecked_sub(SignedAmount::from_sat(10)), SignedAmount::from_sat(40));
+    assert_eq!(
+        SignedAmount::from_sat(10).unchecked_add(SignedAmount::from_sat(20)),
+        SignedAmount::from_sat(30)
+    );
+    assert_eq!(
+        SignedAmount::from_sat(50).unchecked_sub(SignedAmount::from_sat(10)),
+        SignedAmount::from_sat(40)
+    );
     assert_eq!(Amount::from_sat(5).unchecked_add(Amount::from_sat(7)), Amount::from_sat(12));
     assert_eq!(Amount::from_sat(10).unchecked_sub(Amount::from_sat(7)), Amount::from_sat(3));
 }
 
 #[test]
 fn positive_sub() {
-    assert_eq!(SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(7)).unwrap(), SignedAmount::from_sat(3));
+    assert_eq!(
+        SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(7)).unwrap(),
+        SignedAmount::from_sat(3)
+    );
     assert!(SignedAmount::from_sat(-10).positive_sub(SignedAmount::from_sat(7)).is_none());
     assert!(SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(-7)).is_none());
     assert!(SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(11)).is_none());
@@ -795,7 +813,10 @@ fn serde_as_str() {
     }
 
     serde_test::assert_tokens(
-        &T { amt: Amount::from_sat_unchecked(123_456_789), samt: SignedAmount::from_sat_unchecked(-123_456_789) },
+        &T {
+            amt: Amount::from_sat_unchecked(123_456_789),
+            samt: SignedAmount::from_sat_unchecked(-123_456_789),
+        },
         &[
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::String("amt"),
diff --git a/units/src/block.rs b/units/src/block.rs
index 8eaca0da48..49bd88ac9d 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -289,7 +289,8 @@ mod tests {
         let interval_from_height: BlockInterval = relative::Height::from(10u16).into();
         assert_eq!(interval_from_height.to_u32(), 10u32);
 
-        let invalid_height_greater = relative::Height::try_from(BlockInterval(u32::from(u16::MAX) + 1));
+        let invalid_height_greater =
+            relative::Height::try_from(BlockInterval(u32::from(u16::MAX) + 1));
         assert!(invalid_height_greater.is_err());
 
         let valid_height = relative::Height::try_from(BlockInterval(u32::from(u16::MAX)));
@@ -314,8 +315,16 @@ mod tests {
         // interval - interval = interval
         assert!(BlockInterval(10) - BlockInterval(7) == BlockInterval(3));
 
-        assert!([BlockInterval(1), BlockInterval(2), BlockInterval(3)].iter().sum::<BlockInterval>() == BlockInterval(6));
-        assert!([BlockInterval(4), BlockInterval(5), BlockInterval(6)].into_iter().sum::<BlockInterval>() == BlockInterval(15));
+        assert!(
+            [BlockInterval(1), BlockInterval(2), BlockInterval(3)].iter().sum::<BlockInterval>()
+                == BlockInterval(6)
+        );
+        assert!(
+            [BlockInterval(4), BlockInterval(5), BlockInterval(6)]
+                .into_iter()
+                .sum::<BlockInterval>()
+                == BlockInterval(15)
+        );
 
         // interval += interval
         let mut int = BlockInterval(1);
diff --git a/units/src/fee_rate/serde.rs b/units/src/fee_rate/serde.rs
index 486b01fe9d..cd914c322b 100644
--- a/units/src/fee_rate/serde.rs
+++ b/units/src/fee_rate/serde.rs
@@ -22,8 +22,8 @@
 //! }
 //! ```
 
-use core::fmt;
 use core::convert::Infallible;
+use core::fmt;
 
 pub mod as_sat_per_kwu {
     //! Serialize and deserialize [`FeeRate`] denominated in satoshis per 1000 weight units.
diff --git a/units/src/parse.rs b/units/src/parse.rs
index 49f4064b78..08f0cf464a 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -567,7 +567,6 @@ mod tests {
         let want = 171; // 0xab
         assert_eq!(hex_u32_prefixed("0xab").unwrap(), want);
         assert!(hex_u32_unprefixed("0xab").is_err());
-
     }
 
     #[test]
@@ -596,7 +595,6 @@ mod tests {
         let want = 3_735_928_559;
         assert_eq!(hex_u128_prefixed("0xdeadbeef").unwrap(), want);
         assert!(hex_u128_unprefixed("0xdeadbeef").is_err());
-
     }
 
     #[test]

From ac59b25f2cfe8d65435ea9e6f4265e52ac06e92e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 8 Jan 2025 15:13:32 +1100
Subject: [PATCH 224/554] io: Add unit tests for Take

Add two unit tests:

- Check we can read into an empty buffer as validation of args as
  part of C-VALIDATE
- Do basic read using `Take::read_to_end` since it is currently
  untested.
---
 io/src/lib.rs | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/io/src/lib.rs b/io/src/lib.rs
index ffb2af0de6..08a6c089dd 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -445,4 +445,35 @@ mod tests {
             assert_eq!(buf[0], 0x00); // Double check that buffer state is sane.
         }
     }
+
+    #[test]
+    fn read_into_zero_length_buffer() {
+        use crate::Read as _;
+
+        const BUF_LEN: usize = 64;
+        let data = [1_u8; BUF_LEN];
+        let mut buf = [0_u8; BUF_LEN];
+
+        let mut slice = data.as_ref();
+        let mut take = Read::take(&mut slice, 32);
+
+        let read = take.read(&mut buf[0..0]).unwrap();
+        assert_eq!(read, 0);
+        assert_eq!(buf[0], 0x00); // Check the buffer didn't get touched.
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn take_and_read_to_end() {
+        const BUF_LEN: usize = 64;
+        let data = [1_u8; BUF_LEN];
+
+        let mut slice = data.as_ref();
+        let mut take = Read::take(&mut slice, 32);
+
+        let mut v = Vec::new();
+        let read = take.read_to_end(&mut v).unwrap();
+        assert_eq!(read, 32);
+        assert_eq!(data[0..32], v[0..32]);
+    }
 }

From 668056fb36c87bb2eeeacc8fa6c44ed942c558b3 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 14 Jan 2025 09:48:48 +1100
Subject: [PATCH 225/554] Use Amount in examples

Use the `Amount` type as parameter in examples code instead of a `u64`.

Done as part of preparation for enforcing MAX_MONEY.
---
 bitcoin/examples/sighash.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index 370dd89dd5..079d4d0f2f 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -19,8 +19,8 @@ use hex_lit::hex;
 ///
 /// * `raw_tx` - spending tx hex
 /// * `inp_idx` - spending tx input index
-/// * `value` - ref tx output value in sats
-fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, value: u64) {
+/// * `amount` - ref tx output value in sats
+fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
     let tx: Transaction = consensus::deserialize(raw_tx).unwrap();
     let inp = &tx.input[inp_idx];
     let witness = &inp.witness;
@@ -43,7 +43,7 @@ fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, value: u64) {
 
     let mut cache = sighash::SighashCache::new(&tx);
     let sighash = cache
-        .p2wpkh_signature_hash(inp_idx, &spk, Amount::from_sat(value), sig.sighash_type)
+        .p2wpkh_signature_hash(inp_idx, &spk, amount, sig.sighash_type)
         .expect("failed to compute sighash");
     println!("SegWit p2wpkh sighash: {:x}", sighash);
     let msg = secp256k1::Message::from(sighash);
@@ -104,8 +104,8 @@ fn compute_sighash_legacy(raw_tx: &[u8], inp_idx: usize, script_pubkey_bytes_opt
 ///
 /// * `raw_tx` - spending tx hex
 /// * `inp_idx` - spending tx input index
-/// * `value` - ref tx output value in sats
-fn compute_sighash_p2wsh(raw_tx: &[u8], inp_idx: usize, value: u64) {
+/// * `amount` - ref tx output value in sats
+fn compute_sighash_p2wsh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
     let tx: Transaction = consensus::deserialize(raw_tx).unwrap();
     let inp = &tx.input[inp_idx];
     let witness = &inp.witness;
@@ -128,7 +128,7 @@ fn compute_sighash_p2wsh(raw_tx: &[u8], inp_idx: usize, value: u64) {
             .p2wsh_signature_hash(
                 inp_idx,
                 witness_script,
-                Amount::from_sat(value),
+                amount,
                 sig.sighash_type,
             )
             .expect("failed to compute sighash");
@@ -153,7 +153,7 @@ fn sighash_p2wpkh() {
     let inp_idx = 0;
     //output value from the referenced vout:0 from the referenced tx:
     //bitcoin-cli getrawtransaction 752d675b9cc0bd14e0bd23969effee0005ad6d7e550dcc832f0216c7ffd4e15c  3
-    let ref_out_value = 200000000;
+    let ref_out_value = Amount::from_sat(200000000);
 
     println!("\nsighash_p2wpkh:");
     compute_sighash_p2wpkh(&raw_tx, inp_idx, ref_out_value);
@@ -183,7 +183,7 @@ fn sighash_p2wsh_multisig_2x2() {
     //For the witness transaction sighash computation, we need its referenced output's value from the original transaction:
     //bitcoin-cli getrawtransaction 2845399a8cd7a52733f9f9d0e0b8b6c5d1c88aea4cee09f8d8fa762912b49e1b  3
     //we need vout 0 value in sats:
-    let ref_out_value = 968240;
+    let ref_out_value = Amount::from_sat(968240);
 
     println!("\nsighash_p2wsh_multisig_2x2:");
     compute_sighash_p2wsh(&raw_tx, 0, ref_out_value);

From 39523ea1f528231c33faa5ba1aa8900ee30349dc Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 3 Jan 2025 09:06:43 +1100
Subject: [PATCH 226/554] units: Remove InputString from the public API

Currently `InputString` is in the public API of `units` because of the
trait bound on `parse::int()`. We can just do the monomorphisisation
manually to remove it.

This patch renames `int` to have three different names, one for `&str`
one for `String`, and one for `Box<str>`.
---
 .../src/blockdata/script/witness_version.rs   |  2 +-
 bitcoin/src/blockdata/transaction.rs          |  2 +-
 bitcoin/src/lib.rs                            |  4 +-
 primitives/src/transaction.rs                 |  2 +-
 units/src/parse.rs                            | 78 ++++++++++++-------
 5 files changed, 57 insertions(+), 31 deletions(-)

diff --git a/bitcoin/src/blockdata/script/witness_version.rs b/bitcoin/src/blockdata/script/witness_version.rs
index fa4f06d48c..3c8f408dbc 100644
--- a/bitcoin/src/blockdata/script/witness_version.rs
+++ b/bitcoin/src/blockdata/script/witness_version.rs
@@ -82,7 +82,7 @@ impl FromStr for WitnessVersion {
     type Err = FromStrError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let version: u8 = parse::int(s)?;
+        let version: u8 = parse::int_from_str(s)?;
         Ok(WitnessVersion::try_from(version)?)
     }
 }
diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 5dea49ba93..8a497ffd2d 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -1214,7 +1214,7 @@ mod tests {
         assert_eq!(
             "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:lol"
                 .parse::<OutPoint>(),
-            Err(ParseOutPointError::Vout(parse::int::<u32, _>("lol").unwrap_err()))
+            Err(ParseOutPointError::Vout(parse::int_from_str::<u32>("lol").unwrap_err()))
         );
 
         assert_eq!(
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index 21c11b472c..da1a714aca 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -239,8 +239,8 @@ pub mod parse {
     #[doc(inline)]
     pub use units::parse::{
         hex_check_unprefixed, hex_remove_prefix, hex_u128, hex_u128_unchecked, hex_u128_unprefixed,
-        hex_u32, hex_u32_unchecked, hex_u32_unprefixed, int, ParseIntError, PrefixedHexError,
-        UnprefixedHexError,
+        hex_u32, hex_u32_unchecked, hex_u32_unprefixed, int_from_box, int_from_str,
+        int_from_string, ParseIntError, PrefixedHexError, UnprefixedHexError,
     };
 }
 
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 4424103f44..bb4005798d 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -424,7 +424,7 @@ fn parse_vout(s: &str) -> Result<u32, ParseOutPointError> {
             return Err(ParseOutPointError::VoutNotCanonical);
         }
     }
-    parse::int(s).map_err(ParseOutPointError::Vout)
+    parse::int_from_str(s).map_err(ParseOutPointError::Vout)
 }
 
 /// An error in parsing an [`OutPoint`].
diff --git a/units/src/parse.rs b/units/src/parse.rs
index 08f0cf464a..130a294620 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -76,9 +76,28 @@ mod sealed {
 
 /// 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 fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, ParseIntError> {
+/// On error this function allocates to copy the input string into the error return. If the caller
+/// has a `String` or `Box<str>` which is not used later it's better to call
+/// [`parse::int_from_string`] or [`parse::int_from_box`] respectively.
+///
+/// [`parse::int_from_string`]: crate::parse::int_from_string
+/// [`parse::int_from_box`]: crate::parse::int_from_box
+pub fn int_from_str<T: Integer>(s: &str) -> Result<T, ParseIntError> { int(s) }
+
+/// Parses the input string as an integer returning an error carrying rich context.
+///
+/// On error the input string is moved into the error return without allocating.
+#[cfg(feature = "alloc")]
+pub fn int_from_string<T: Integer>(s: alloc::string::String) -> Result<T, ParseIntError> { int(s) }
+
+/// Parses the input string as an integer returning an error carrying rich context.
+///
+/// On error the input string is converted into the error return without allocating.
+#[cfg(feature = "alloc")]
+pub fn int_from_box<T: Integer>(s: alloc::boxed::Box<str>) -> Result<T, ParseIntError> { int(s) }
+
+// This must be private because we do not want `InputString` to appear in the public API.
+fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, ParseIntError> {
     s.as_ref().parse().map_err(|error| {
         ParseIntError {
             input: s.into(),
@@ -120,37 +139,44 @@ pub fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, Par
 #[doc(hidden)] // This is an 'internal' macro that should not be used outside of the `rust-bitcoin` crate.
 macro_rules! impl_parse_str_from_int_infallible {
     ($to:ident, $inner:ident, $fn:ident) => {
-        $crate::impl_tryfrom_str_from_int_infallible!(&str, $to, $inner, $fn);
-        #[cfg(feature = "alloc")]
-        $crate::impl_tryfrom_str_from_int_infallible!(alloc::string::String, $to, $inner, $fn; alloc::boxed::Box<str>, $to, $inner, $fn);
-
         impl $crate::_export::_core::str::FromStr for $to {
             type Err = $crate::parse::ParseIntError;
 
             fn from_str(s: &str) -> $crate::_export::_core::result::Result<Self, Self::Err> {
-                $crate::parse::int::<$inner, &str>(s).map($to::$fn)
+                $crate::_export::_core::convert::TryFrom::try_from(s)
             }
         }
 
-    }
-}
+        impl $crate::_export::_core::convert::TryFrom<&str> for $to {
+            type Error = $crate::parse::ParseIntError;
 
-/// Implements `TryFrom<$from> for $to` using `parse::int`, mapping the output using infallible
-/// conversion function `fn`.
-#[macro_export]
-#[doc(hidden)] // Helper macro called by `impl_parse_str_from_int_infallible`.
-macro_rules! impl_tryfrom_str_from_int_infallible {
-    ($($from:ty, $to:ident, $inner:ident, $fn:ident);*) => {
-        $(
-        impl $crate::_export::_core::convert::TryFrom<$from> for $to {
+            fn try_from(s: &str) -> $crate::_export::_core::result::Result<Self, Self::Error> {
+                $crate::parse::int_from_str::<$inner>(s).map($to::$fn)
+            }
+        }
+
+        #[cfg(feature = "alloc")]
+        impl $crate::_export::_core::convert::TryFrom<alloc::string::String> for $to {
             type Error = $crate::parse::ParseIntError;
 
-            fn try_from(s: $from) -> $crate::_export::_core::result::Result<Self, Self::Error> {
-                $crate::parse::int::<$inner, $from>(s).map($to::$fn)
+            fn try_from(
+                s: alloc::string::String,
+            ) -> $crate::_export::_core::result::Result<Self, Self::Error> {
+                $crate::parse::int_from_string::<$inner>(s).map($to::$fn)
             }
         }
-        )*
-    }
+
+        #[cfg(feature = "alloc")]
+        impl $crate::_export::_core::convert::TryFrom<alloc::boxed::Box<str>> for $to {
+            type Error = $crate::parse::ParseIntError;
+
+            fn try_from(
+                s: alloc::boxed::Box<str>,
+            ) -> $crate::_export::_core::result::Result<Self, Self::Error> {
+                $crate::parse::int_from_box::<$inner>(s).map($to::$fn)
+            }
+        }
+    };
 }
 
 /// Implements standard parsing traits for `$type` by calling through to `$inner_fn`.
@@ -497,9 +523,9 @@ mod tests {
 
     #[test]
     fn parse_int() {
-        assert!(int::<u8, _>("1").is_ok());
-        let _ = int::<i8, _>("not a number").map_err(|e| assert!(e.is_signed));
-        let _ = int::<u8, _>("not a number").map_err(|e| assert!(!e.is_signed));
+        assert!(int_from_str::<u8>("1").is_ok());
+        let _ = int_from_str::<i8>("not a number").map_err(|e| assert!(e.is_signed));
+        let _ = int_from_str::<u8>("not a number").map_err(|e| assert!(!e.is_signed));
     }
 
     #[test]
@@ -520,7 +546,7 @@ mod tests {
             fn from(_: i8) -> Self { TestTypeLargerThanU128(0, 0) }
         }
 
-        let result = panic::catch_unwind(|| int::<TestTypeLargerThanU128, _>("not a number"));
+        let result = panic::catch_unwind(|| int_from_str::<TestTypeLargerThanU128>("not a number"));
         assert!(result.is_err());
     }
 

From 56286265a55368572c61b03bcb81fe04fb7921c0 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 14 Jan 2025 08:59:11 +1100
Subject: [PATCH 227/554] api: Run just check-api

---
 api/units/all-features.txt | 4 +++-
 api/units/alloc-only.txt   | 4 +++-
 api/units/no-features.txt  | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 0559a49bc2..5698c7c896 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -1183,7 +1183,9 @@ pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitco
 pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
 pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::int_from_box<T: bitcoin_units::parse::Integer>(s: alloc::boxed::Box<str>) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::int_from_str<T: bitcoin_units::parse::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::int_from_string<T: bitcoin_units::parse::Integer>(s: alloc::string::String) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index a44702c7a4..6274ad864d 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -1030,7 +1030,9 @@ pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitco
 pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
 pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::int_from_box<T: bitcoin_units::parse::Integer>(s: alloc::boxed::Box<str>) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::int_from_str<T: bitcoin_units::parse::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::int_from_string<T: bitcoin_units::parse::Integer>(s: alloc::string::String) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 39e957f3e2..5c448c09e0 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -986,7 +986,7 @@ pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitco
 pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
 pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::int<T: bitcoin_units::parse::Integer, S: core::convert::AsRef<str> + core::convert::Into<bitcoin_internals::error::input_string::InputString>>(s: S) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
+pub fn bitcoin_units::parse::int_from_str<T: bitcoin_units::parse::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
 pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)

From 29f1a4613a090cd23baded1ef577aa4e3da8d33f Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 15 Jan 2025 15:38:41 +0000
Subject: [PATCH 228/554] Enable `ref_option` lint and allow individually

Enable the lint and allow the ref_option lint in the cases where the
lint wants us to change the API to use `Option<&T>` instead of
`&Option<T>`
---
 units/Cargo.toml            | 2 +-
 units/src/amount/serde.rs   | 3 +++
 units/src/fee_rate/serde.rs | 3 +++
 3 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/units/Cargo.toml b/units/Cargo.toml
index d0368dace9..fd49837da3 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -129,7 +129,7 @@ redundant_closure_for_method_calls = "warn"
 redundant_else = "warn"
 ref_as_ptr = "warn"
 ref_binding_to_reference = "warn"
-ref_option = "allow" # TODO: Still neds considering.
+ref_option = "warn"
 ref_option_ref = "warn"
 return_self_not_must_use = "warn"
 same_functions_in_if_condition = "warn"
diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index e7be0fd5d9..36c56ec35a 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -207,6 +207,7 @@ pub mod as_sat {
         use super::private;
         use crate::amount::serde::SerdeAmountForOpt;
 
+        #[allow(clippy::ref_option)] // API forced by serde.
         pub fn serialize<A: SerdeAmountForOpt, S: Serializer>(
             a: &Option<A>,
             s: S,
@@ -277,6 +278,7 @@ pub mod as_btc {
         use super::private;
         use crate::amount::serde::SerdeAmountForOpt;
 
+        #[allow(clippy::ref_option)] // API forced by serde.
         pub fn serialize<A: SerdeAmountForOpt, S: Serializer>(
             a: &Option<A>,
             s: S,
@@ -347,6 +349,7 @@ pub mod as_str {
         use super::private;
         use crate::amount::serde::SerdeAmountForOpt;
 
+        #[allow(clippy::ref_option)] // API forced by serde.
         pub fn serialize<A: SerdeAmountForOpt, S: Serializer>(
             a: &Option<A>,
             s: S,
diff --git a/units/src/fee_rate/serde.rs b/units/src/fee_rate/serde.rs
index cd914c322b..b5b6168165 100644
--- a/units/src/fee_rate/serde.rs
+++ b/units/src/fee_rate/serde.rs
@@ -53,6 +53,7 @@ pub mod as_sat_per_kwu {
 
         use crate::FeeRate;
 
+        #[allow(clippy::ref_option)] // API forced by serde.
         pub fn serialize<S: Serializer>(f: &Option<FeeRate>, s: S) -> Result<S::Ok, S::Error> {
             match *f {
                 Some(f) => s.serialize_some(&f.to_sat_per_kwu()),
@@ -124,6 +125,7 @@ pub mod as_sat_per_vb_floor {
         use crate::fee_rate::serde::OverflowError;
         use crate::fee_rate::FeeRate;
 
+        #[allow(clippy::ref_option)] // API forced by serde.
         pub fn serialize<S: Serializer>(f: &Option<FeeRate>, s: S) -> Result<S::Ok, S::Error> {
             match *f {
                 Some(f) => s.serialize_some(&f.to_sat_per_vb_floor()),
@@ -199,6 +201,7 @@ pub mod as_sat_per_vb_ceil {
         use crate::fee_rate::serde::OverflowError;
         use crate::fee_rate::FeeRate;
 
+        #[allow(clippy::ref_option)] // API forced by serde.
         pub fn serialize<S: Serializer>(f: &Option<FeeRate>, s: S) -> Result<S::Ok, S::Error> {
             match *f {
                 Some(f) => s.serialize_some(&f.to_sat_per_vb_ceil()),

From b11ace359a52d9137b8fe5919d9825d61e3e9fad Mon Sep 17 00:00:00 2001
From: Innocent Onyemaenu <rockcoolsaint@gmail.com>
Date: Wed, 15 Jan 2025 21:00:42 +0100
Subject: [PATCH 229/554] Fix up ParsePublickeyError

In #3847 we added an `InvalidCharError` into one of the variants of
`ParsePublicKeyError` but we forgot to update the trait
implementations.

Fix the `error::Error` and `Display` implementations for
`ParsePublicKeyError`. While we are at it match on `*self` as is
typical in this codebase.

 With this applied #3835 is fully resolved.

 Close: #3835
---
 bitcoin/src/crypto/key.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index c3f3affe8c..9e9f1aa8c7 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -1034,9 +1034,9 @@ impl From<Infallible> for ParsePublicKeyError {
 impl fmt::Display for ParsePublicKeyError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use ParsePublicKeyError::*;
-        match self {
-            Encoding(e) => write_err!(f, "string error"; e),
-            InvalidChar(char) => write!(f, "hex error {}", char),
+        match *self {
+            Encoding(ref e) => write_err!(f, "string error"; e),
+            InvalidChar(ref e) => write_err!(f, "hex decoding"; e),
             InvalidHexLength(got) =>
                 write!(f, "pubkey string should be 66 or 130 digits long, got: {}", got),
         }
@@ -1048,9 +1048,10 @@ impl std::error::Error for ParsePublicKeyError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         use ParsePublicKeyError::*;
 
-        match self {
-            Encoding(e) => Some(e),
-            InvalidChar(_) | InvalidHexLength(_) => None,
+        match *self {
+            Encoding(ref e) => Some(e),
+            InvalidChar(ref e) => Some(e),
+            InvalidHexLength(_) => None,
         }
     }
 }

From f9be30ddbe5c0837ab3e408dfadabc6c6cd2068e Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 13 Jan 2025 19:16:32 +0000
Subject: [PATCH 230/554] units: Fix `missing_errors_doc` clippy lint

Change the lint to `warn` in `units/Cargo.toml`.
Allow `missing_errors_doc` in `amount/serde.rs` and `fee_rate/serde.rs`.
Add missing `# Errors` sections to rustdocs where the lint gives a
warning.
---
 units/Cargo.toml               |  2 +-
 units/src/amount/serde.rs      |  1 +
 units/src/fee_rate/serde.rs    |  1 +
 units/src/locktime/absolute.rs |  8 ++++++++
 units/src/parse.rs             | 11 +++++++++--
 5 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/units/Cargo.toml b/units/Cargo.toml
index d0368dace9..c0c33af40f 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -105,7 +105,7 @@ match_wild_err_arm = "warn"
 match_wildcard_for_single_variants = "warn"
 maybe_infinite_iter = "warn"
 mismatching_type_param_order = "warn"
-missing_errors_doc = "allow" # TODO: Still needs considering.
+missing_errors_doc = "warn"
 missing_fields_in_debug = "warn"
 missing_panics_doc = "allow" # TODO: Still needs considering.
 must_use_candidate = "allow" # Useful for audit but many false positives.
diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index e7be0fd5d9..dc6a08e850 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -2,6 +2,7 @@
 
 // methods are implementation of a standardized serde-specific signature
 #![allow(missing_docs)]
+#![allow(clippy::missing_errors_doc)]
 
 //! This module adds serde serialization and deserialization support for amounts.
 //!
diff --git a/units/src/fee_rate/serde.rs b/units/src/fee_rate/serde.rs
index cd914c322b..4ebd56e9b8 100644
--- a/units/src/fee_rate/serde.rs
+++ b/units/src/fee_rate/serde.rs
@@ -3,6 +3,7 @@
 // Module implements standardized serde-specific trait methods.
 #![allow(missing_docs)]
 #![allow(clippy::trivially_copy_pass_by_ref)]
+#![allow(clippy::missing_errors_doc)]
 
 //! This module adds serde serialization and deserialization support for amounts.
 //!
diff --git a/units/src/locktime/absolute.rs b/units/src/locktime/absolute.rs
index b7ee722e6a..fbc842fb7a 100644
--- a/units/src/locktime/absolute.rs
+++ b/units/src/locktime/absolute.rs
@@ -41,6 +41,10 @@ impl Height {
     /// Constructs a new [`Height`] from a hex string.
     ///
     /// The input string may or may not contain a typical hex prefix e.g., `0x`.
+    ///
+    /// # Errors
+    ///
+    /// If the input string is not a valid hex representation of a block height.
     pub fn from_hex(s: &str) -> Result<Self, ParseHeightError> {
         parse_hex(s, Self::from_consensus)
     }
@@ -139,6 +143,10 @@ impl Time {
     /// Constructs a new [`Time`] from a hex string.
     ///
     /// The input string may or may not contain a typical hex prefix e.g., `0x`.
+    ///
+    /// # Errors
+    ///
+    /// If the input string is not a valid hex representation of a block time.
     pub fn from_hex(s: &str) -> Result<Self, ParseTimeError> { parse_hex(s, Self::from_consensus) }
 
     /// Constructs a new block time.
diff --git a/units/src/parse.rs b/units/src/parse.rs
index 130a294620..6127a8f9e8 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -76,22 +76,29 @@ mod sealed {
 
 /// Parses the input string as an integer returning an error carrying rich context.
 ///
-/// On error this function allocates to copy the input string into the error return. If the caller
-/// has a `String` or `Box<str>` which is not used later it's better to call
+/// If the caller has a `String` or `Box<str>` which is not used later it's better to call
 /// [`parse::int_from_string`] or [`parse::int_from_box`] respectively.
 ///
 /// [`parse::int_from_string`]: crate::parse::int_from_string
 /// [`parse::int_from_box`]: crate::parse::int_from_box
+///
+/// # Errors
+///
+/// On error this function allocates to copy the input string into the error return.
 pub fn int_from_str<T: Integer>(s: &str) -> Result<T, ParseIntError> { int(s) }
 
 /// Parses the input string as an integer returning an error carrying rich context.
 ///
+/// # Errors
+///
 /// On error the input string is moved into the error return without allocating.
 #[cfg(feature = "alloc")]
 pub fn int_from_string<T: Integer>(s: alloc::string::String) -> Result<T, ParseIntError> { int(s) }
 
 /// Parses the input string as an integer returning an error carrying rich context.
 ///
+/// # Errors
+///
 /// On error the input string is converted into the error return without allocating.
 #[cfg(feature = "alloc")]
 pub fn int_from_box<T: Integer>(s: alloc::boxed::Box<str>) -> Result<T, ParseIntError> { int(s) }

From e316e6e7195993b7dd0e005d2f22f29dfea023c5 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 14 Jan 2025 12:22:52 +0000
Subject: [PATCH 231/554] Fix `missing_panics_doc` clippy lint in units

Change the lint to `warn` and allow for the functions that can't panic.
---
 units/Cargo.toml             | 2 +-
 units/src/amount/signed.rs   | 1 +
 units/src/amount/unsigned.rs | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/units/Cargo.toml b/units/Cargo.toml
index d0368dace9..5c76f052eb 100644
--- a/units/Cargo.toml
+++ b/units/Cargo.toml
@@ -107,7 +107,7 @@ maybe_infinite_iter = "warn"
 mismatching_type_param_order = "warn"
 missing_errors_doc = "allow" # TODO: Still needs considering.
 missing_fields_in_debug = "warn"
-missing_panics_doc = "allow" # TODO: Still needs considering.
+missing_panics_doc = "warn"
 must_use_candidate = "allow" # Useful for audit but many false positives.
 mut_mut = "warn"
 naive_bytecount = "warn"
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 4580af033a..ada79d1709 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -193,6 +193,7 @@ impl SignedAmount {
     /// assert_eq!(amount.to_float_in(Denomination::Bitcoin), 0.001)
     /// ```
     #[cfg(feature = "alloc")]
+    #[allow(clippy::missing_panics_doc)]
     pub fn to_float_in(self, denom: Denomination) -> f64 {
         self.to_string_in(denom).parse::<f64>().unwrap()
     }
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 9ac7e4497a..443b1fcd83 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -199,6 +199,7 @@ impl Amount {
     /// assert_eq!(amount.to_float_in(Denomination::Bitcoin), 0.001)
     /// ```
     #[cfg(feature = "alloc")]
+    #[allow(clippy::missing_panics_doc)]
     pub fn to_float_in(self, denom: Denomination) -> f64 {
         self.to_string_in(denom).parse::<f64>().unwrap()
     }

From 34f846c0740c042093c93de0940839dbe78bceca Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 16 Jan 2025 10:39:18 +1100
Subject: [PATCH 232/554] Use ssat variable for constructor

As we do in other places in the `amount::tests` module; use a local
`ssat` variable bound to the `SignedAmount::from_sat` constructor.

Internal change, no logic changes.
---
 units/src/amount/tests.rs | 46 ++++++++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 20 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index d6becf50fb..1f148874d5 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -18,18 +18,20 @@ use crate::{FeeRate, Weight};
 
 #[test]
 fn sanity_check() {
-    assert_eq!(SignedAmount::from_sat(-100).abs(), SignedAmount::from_sat(100));
+    let ssat = SignedAmount::from_sat;
+
+    assert_eq!(ssat(-100).abs(), ssat(100));
     assert_eq!(
-        SignedAmount::from_sat(i64::MIN + 1).checked_abs().unwrap(),
-        SignedAmount::from_sat(i64::MAX)
+        ssat(i64::MIN + 1).checked_abs().unwrap(),
+        ssat(i64::MAX)
     );
-    assert_eq!(SignedAmount::from_sat(-100).signum(), -1);
-    assert_eq!(SignedAmount::from_sat(0).signum(), 0);
-    assert_eq!(SignedAmount::from_sat(100).signum(), 1);
-    assert_eq!(SignedAmount::from(Amount::from_sat(100)), SignedAmount::from_sat(100));
-    assert!(SignedAmount::from_sat(i64::MIN).checked_abs().is_none());
-    assert!(!SignedAmount::from_sat(-100).is_positive());
-    assert!(SignedAmount::from_sat(100).is_positive());
+    assert_eq!(ssat(-100).signum(), -1);
+    assert_eq!(ssat(0).signum(), 0);
+    assert_eq!(ssat(100).signum(), 1);
+    assert_eq!(SignedAmount::from(Amount::from_sat(100)), ssat(100));
+    assert!(ssat(i64::MIN).checked_abs().is_none());
+    assert!(!ssat(-100).is_positive());
+    assert!(ssat(100).is_positive());
 
     #[cfg(feature = "alloc")]
     {
@@ -143,7 +145,7 @@ fn mul_div() {
     b %= 3;
     assert_eq!(b, ssat(1));
     b *= 3;
-    assert_eq!(b, SignedAmount::from_sat(3));
+    assert_eq!(b, ssat(3));
 }
 
 #[test]
@@ -179,13 +181,15 @@ fn checked_arithmetic() {
 #[test]
 #[allow(deprecated_in_future)]
 fn unchecked_arithmetic() {
+    let ssat = SignedAmount::from_sat;
+
     assert_eq!(
-        SignedAmount::from_sat(10).unchecked_add(SignedAmount::from_sat(20)),
-        SignedAmount::from_sat(30)
+        ssat(10).unchecked_add(ssat(20)),
+        ssat(30)
     );
     assert_eq!(
-        SignedAmount::from_sat(50).unchecked_sub(SignedAmount::from_sat(10)),
-        SignedAmount::from_sat(40)
+        ssat(50).unchecked_sub(ssat(10)),
+        ssat(40)
     );
     assert_eq!(Amount::from_sat(5).unchecked_add(Amount::from_sat(7)), Amount::from_sat(12));
     assert_eq!(Amount::from_sat(10).unchecked_sub(Amount::from_sat(7)), Amount::from_sat(3));
@@ -193,13 +197,15 @@ fn unchecked_arithmetic() {
 
 #[test]
 fn positive_sub() {
+    let ssat = SignedAmount::from_sat;
+
     assert_eq!(
-        SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(7)).unwrap(),
-        SignedAmount::from_sat(3)
+        ssat(10).positive_sub(ssat(7)).unwrap(),
+        ssat(3)
     );
-    assert!(SignedAmount::from_sat(-10).positive_sub(SignedAmount::from_sat(7)).is_none());
-    assert!(SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(-7)).is_none());
-    assert!(SignedAmount::from_sat(10).positive_sub(SignedAmount::from_sat(11)).is_none());
+    assert!(ssat(-10).positive_sub(ssat(7)).is_none());
+    assert!(ssat(10).positive_sub(ssat(-7)).is_none());
+    assert!(ssat(10).positive_sub(ssat(11)).is_none());
 }
 
 #[cfg(feature = "alloc")]

From f01bb30121ef5a59af069a55db727ee5a9ba71bb Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 16 Jan 2025 10:42:41 +1100
Subject: [PATCH 233/554] Use sat variable for constructor

As we do in other places in the `amount::tests` module; use a local
`sat` variable bound to the `Amount::from_sat` constructor.

Internal change, no logic changes.
---
 units/src/amount/tests.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 1f148874d5..42a9e3d3ca 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -18,6 +18,7 @@ use crate::{FeeRate, Weight};
 
 #[test]
 fn sanity_check() {
+    let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
     assert_eq!(ssat(-100).abs(), ssat(100));
@@ -28,7 +29,7 @@ fn sanity_check() {
     assert_eq!(ssat(-100).signum(), -1);
     assert_eq!(ssat(0).signum(), 0);
     assert_eq!(ssat(100).signum(), 1);
-    assert_eq!(SignedAmount::from(Amount::from_sat(100)), ssat(100));
+    assert_eq!(SignedAmount::from(sat(100)), ssat(100));
     assert!(ssat(i64::MIN).checked_abs().is_none());
     assert!(!ssat(-100).is_positive());
     assert!(ssat(100).is_positive());
@@ -37,11 +38,11 @@ fn sanity_check() {
     {
         assert_eq!(
             Amount::from_float_in(0_f64, Denomination::Bitcoin).unwrap(),
-            Amount::from_sat(0)
+            sat(0)
         );
         assert_eq!(
             Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(),
-            Amount::from_sat(200_000_000)
+            sat(200_000_000)
         );
         assert!(Amount::from_float_in(-100_f64, Denomination::Bitcoin).is_err());
     }
@@ -137,7 +138,7 @@ fn mul_div() {
     a %= 3;
     assert_eq!(a, sat(1));
     a *= 3;
-    assert_eq!(a, Amount::from_sat(3));
+    assert_eq!(a, sat(3));
 
     let mut b = ssat(30);
     b /= 3;
@@ -181,6 +182,7 @@ fn checked_arithmetic() {
 #[test]
 #[allow(deprecated_in_future)]
 fn unchecked_arithmetic() {
+    let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
     assert_eq!(
@@ -191,8 +193,8 @@ fn unchecked_arithmetic() {
         ssat(50).unchecked_sub(ssat(10)),
         ssat(40)
     );
-    assert_eq!(Amount::from_sat(5).unchecked_add(Amount::from_sat(7)), Amount::from_sat(12));
-    assert_eq!(Amount::from_sat(10).unchecked_sub(Amount::from_sat(7)), Amount::from_sat(3));
+    assert_eq!(sat(5).unchecked_add(sat(7)), sat(12));
+    assert_eq!(sat(10).unchecked_sub(sat(7)), sat(3));
 }
 
 #[test]

From 3542803c4eafa23adfaa6b3327e753c1297d1b2c Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 16 Jan 2025 13:35:25 +1100
Subject: [PATCH 234/554] Make Cursor methods const

Mirror the `std::io::Cursor` type by making the same methods `const`.
---
 io/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/io/src/lib.rs b/io/src/lib.rs
index 08a6c089dd..c0bda4c974 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -201,11 +201,11 @@ pub struct Cursor<T> {
 impl<T: AsRef<[u8]>> Cursor<T> {
     /// Constructs a new `Cursor` by wrapping `inner`.
     #[inline]
-    pub fn new(inner: T) -> Self { Cursor { inner, pos: 0 } }
+    pub const fn new(inner: T) -> Self { Cursor { inner, pos: 0 } }
 
     /// Returns the position read up to thus far.
     #[inline]
-    pub fn position(&self) -> u64 { self.pos }
+    pub const fn position(&self) -> u64 { self.pos }
 
     /// Sets the internal position.
     ///
@@ -226,7 +226,7 @@ impl<T: AsRef<[u8]>> Cursor<T> {
     ///
     /// This is the whole wrapped buffer, including the bytes already read.
     #[inline]
-    pub fn get_ref(&self) -> &T { &self.inner }
+    pub const fn get_ref(&self) -> &T { &self.inner }
 
     /// Returns a mutable reference to the inner buffer.
     ///

From 9ef8e294ac81c79f413fbe47372a3f94c926ef12 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 16 Jan 2025 13:35:25 +1100
Subject: [PATCH 235/554] api: Run just check-api

---
 api/io/all-features.txt | 6 +++---
 api/io/alloc-only.txt   | 6 +++---
 api/io/no-features.txt  | 6 +++---
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/api/io/all-features.txt b/api/io/all-features.txt
index 17d4ca33d7..8f3698e432 100644
--- a/api/io/all-features.txt
+++ b/api/io/all-features.txt
@@ -164,6 +164,9 @@ pub bitcoin_io::ErrorKind::TimedOut
 pub bitcoin_io::ErrorKind::UnexpectedEof
 pub bitcoin_io::ErrorKind::WouldBlock
 pub bitcoin_io::ErrorKind::WriteZero
+pub const fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
+pub const fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
+pub const fn bitcoin_io::Cursor<T>::position(&self) -> u64
 pub const fn bitcoin_io::FromStd<T>::new(inner: T) -> Self
 pub const fn bitcoin_io::ToStd<T>::new(inner: T) -> Self
 pub const fn bitcoin_io::from_std<T>(std_io: T) -> bitcoin_io::FromStd<T>
@@ -232,11 +235,8 @@ pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
-pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
-pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
-pub fn bitcoin_io::Cursor<T>::position(&self) -> u64
 pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
 pub fn bitcoin_io::Error::cause(&self) -> core::option::Option<&dyn core::error::Error>
diff --git a/api/io/alloc-only.txt b/api/io/alloc-only.txt
index acd87863d4..e0d9a76e55 100644
--- a/api/io/alloc-only.txt
+++ b/api/io/alloc-only.txt
@@ -83,6 +83,9 @@ pub bitcoin_io::ErrorKind::TimedOut
 pub bitcoin_io::ErrorKind::UnexpectedEof
 pub bitcoin_io::ErrorKind::WouldBlock
 pub bitcoin_io::ErrorKind::WriteZero
+pub const fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
+pub const fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
+pub const fn bitcoin_io::Cursor<T>::position(&self) -> u64
 pub enum bitcoin_io::ErrorKind
 pub fn &[u8]::consume(&mut self, amount: usize)
 pub fn &[u8]::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
@@ -107,11 +110,8 @@ pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
-pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
-pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
-pub fn bitcoin_io::Cursor<T>::position(&self) -> u64
 pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
 pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
diff --git a/api/io/no-features.txt b/api/io/no-features.txt
index 15660438bd..3874ee8f7e 100644
--- a/api/io/no-features.txt
+++ b/api/io/no-features.txt
@@ -81,6 +81,9 @@ pub bitcoin_io::ErrorKind::TimedOut
 pub bitcoin_io::ErrorKind::UnexpectedEof
 pub bitcoin_io::ErrorKind::WouldBlock
 pub bitcoin_io::ErrorKind::WriteZero
+pub const fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
+pub const fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
+pub const fn bitcoin_io::Cursor<T>::position(&self) -> u64
 pub enum bitcoin_io::ErrorKind
 pub fn &[u8]::consume(&mut self, amount: usize)
 pub fn &[u8]::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
@@ -103,11 +106,8 @@ pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
 pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
 pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
-pub fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
-pub fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
-pub fn bitcoin_io::Cursor<T>::position(&self) -> u64
 pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
 pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result

From 5eb5941215f7aeff2de513d098de267d3968e367 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 17 Jan 2025 10:08:09 +1100
Subject: [PATCH 236/554] Add FIFTY_BTC const to the amount types

The mining reward for the first epoc is 50 bitcoin. For mainnet this is
old news but for regtest it is still relevant.

Add and use a new const `FIFTY_BTC` to the `Amount` type. To keep the
amount types uniform also add it to the `SignedAmount`.
---
 bitcoin/examples/taproot-psbt.rs   | 6 +++---
 bitcoin/src/blockdata/constants.rs | 2 +-
 units/src/amount/signed.rs         | 2 ++
 units/src/amount/unsigned.rs       | 2 ++
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index 16b0650991..d75b4e14f5 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -49,7 +49,7 @@ const UTXO_1: P2trUtxo = P2trUtxo {
     script_pubkey: UTXO_SCRIPT_PUBKEY,
     pubkey: UTXO_PUBKEY,
     master_fingerprint: UTXO_MASTER_FINGERPRINT,
-    amount_in_sats: Amount::from_int_btc_const(50),
+    amount_in_sats: Amount::FIFTY_BTC,
     derivation_path: BIP86_DERIVATION_PATH,
 };
 
@@ -60,7 +60,7 @@ const UTXO_2: P2trUtxo = P2trUtxo {
     script_pubkey: UTXO_SCRIPT_PUBKEY,
     pubkey: UTXO_PUBKEY,
     master_fingerprint: UTXO_MASTER_FINGERPRINT,
-    amount_in_sats: Amount::from_int_btc_const(50),
+    amount_in_sats: Amount::FIFTY_BTC,
     derivation_path: BIP86_DERIVATION_PATH,
 };
 
@@ -71,7 +71,7 @@ const UTXO_3: P2trUtxo = P2trUtxo {
     script_pubkey: UTXO_SCRIPT_PUBKEY,
     pubkey: UTXO_PUBKEY,
     master_fingerprint: UTXO_MASTER_FINGERPRINT,
-    amount_in_sats: Amount::from_int_btc_const(50),
+    amount_in_sats: Amount::FIFTY_BTC,
     derivation_path: BIP86_DERIVATION_PATH,
 };
 
diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index dd45b1c883..e1f15030ce 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -113,7 +113,7 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
     });
 
     ret.output.push(TxOut {
-        value: Amount::from_sat_unchecked(50 * 100_000_000),
+        value: Amount::FIFTY_BTC,
         script_pubkey: out_script,
     });
 
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index ada79d1709..82a07fa051 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -55,6 +55,8 @@ impl SignedAmount {
     pub const ONE_SAT: Self = SignedAmount(1);
     /// Exactly one bitcoin.
     pub const ONE_BTC: Self = SignedAmount(100_000_000);
+    /// Exactly fifty bitcoin.
+    pub const FIFTY_BTC: Self = Self::from_sat_unchecked(50 * 100_000_000);
     /// The maximum value allowed as an amount. Useful for sanity checking.
     pub const MAX_MONEY: Self = SignedAmount(21_000_000 * 100_000_000);
     /// The minimum value of an amount.
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 443b1fcd83..d3c4949213 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -58,6 +58,8 @@ impl Amount {
     pub const ONE_SAT: Self = Amount(1);
     /// Exactly one bitcoin.
     pub const ONE_BTC: Self = Self::from_int_btc_const(1);
+    /// Exactly fifty bitcoin.
+    pub const FIFTY_BTC: Self = Self::from_sat_unchecked(50 * 100_000_000);
     /// The maximum value allowed as an amount. Useful for sanity checking.
     pub const MAX_MONEY: Self = Self::from_int_btc_const(21_000_000);
     /// The minimum value of an amount.

From e0028239cf207660deb2873a92bacfa1315af634 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 17 Jan 2025 10:21:55 +1100
Subject: [PATCH 237/554] api: Run just check-api

---
 api/units/all-features.txt | 2 ++
 api/units/alloc-only.txt   | 2 ++
 api/units/no-features.txt  | 2 ++
 3 files changed, 6 insertions(+)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 5698c7c896..0f5a1c0f2f 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -673,6 +673,7 @@ pub bitcoin_units::amount::Denomination::MilliBitcoin
 pub bitcoin_units::amount::Denomination::Satoshi
 pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
 pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
+pub const bitcoin_units::Amount::FIFTY_BTC: Self
 pub const bitcoin_units::Amount::MAX: Self
 pub const bitcoin_units::Amount::MAX_MONEY: Self
 pub const bitcoin_units::Amount::MIN: Self
@@ -680,6 +681,7 @@ pub const bitcoin_units::Amount::ONE_BTC: Self
 pub const bitcoin_units::Amount::ONE_SAT: Self
 pub const bitcoin_units::Amount::SIZE: usize
 pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
 pub const bitcoin_units::SignedAmount::MAX: Self
 pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
 pub const bitcoin_units::SignedAmount::MIN: Self
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 6274ad864d..4993726217 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -611,6 +611,7 @@ pub bitcoin_units::amount::Denomination::MilliBitcoin
 pub bitcoin_units::amount::Denomination::Satoshi
 pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
 pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
+pub const bitcoin_units::Amount::FIFTY_BTC: Self
 pub const bitcoin_units::Amount::MAX: Self
 pub const bitcoin_units::Amount::MAX_MONEY: Self
 pub const bitcoin_units::Amount::MIN: Self
@@ -618,6 +619,7 @@ pub const bitcoin_units::Amount::ONE_BTC: Self
 pub const bitcoin_units::Amount::ONE_SAT: Self
 pub const bitcoin_units::Amount::SIZE: usize
 pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
 pub const bitcoin_units::SignedAmount::MAX: Self
 pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
 pub const bitcoin_units::SignedAmount::MIN: Self
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 5c448c09e0..4532ae555a 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -595,6 +595,7 @@ pub bitcoin_units::amount::Denomination::MilliBitcoin
 pub bitcoin_units::amount::Denomination::Satoshi
 pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
 pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
+pub const bitcoin_units::Amount::FIFTY_BTC: Self
 pub const bitcoin_units::Amount::MAX: Self
 pub const bitcoin_units::Amount::MAX_MONEY: Self
 pub const bitcoin_units::Amount::MIN: Self
@@ -602,6 +603,7 @@ pub const bitcoin_units::Amount::ONE_BTC: Self
 pub const bitcoin_units::Amount::ONE_SAT: Self
 pub const bitcoin_units::Amount::SIZE: usize
 pub const bitcoin_units::Amount::ZERO: Self
+pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
 pub const bitcoin_units::SignedAmount::MAX: Self
 pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
 pub const bitcoin_units::SignedAmount::MIN: Self

From 1e503a8d3be3994f5e88b505a7e6d702c78230da Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 17 Jan 2025 13:28:21 +1100
Subject: [PATCH 238/554] Remove deprecated std::error::Error trait method
 impls

The `description` method was deprecated in Rust `v1.42`. The `cause`
method was deprecated in Rust `v1.33`. Our MSRV is now Rust `v1.63`.

We do not need to implement the deprecated functions any longer.

Fix: #3869
---
 io/src/error.rs | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/io/src/error.rs b/io/src/error.rs
index 172dd3d6a9..6ef943e42f 100644
--- a/io/src/error.rs
+++ b/io/src/error.rs
@@ -76,19 +76,6 @@ impl std::error::Error for Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         self.error.as_ref().and_then(|e| e.as_ref().source())
     }
-
-    #[allow(deprecated)]
-    fn description(&self) -> &str {
-        match self.error.as_ref() {
-            Some(e) => e.description(),
-            None => self.kind.description(),
-        }
-    }
-
-    #[allow(deprecated)]
-    fn cause(&self) -> Option<&dyn std::error::Error> {
-        self.error.as_ref().and_then(|e| e.as_ref().cause())
-    }
 }
 
 #[cfg(feature = "std")]

From 0719997feef4ef8b2686e570d4083f88be9c5bb0 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 17 Jan 2025 13:31:55 +1100
Subject: [PATCH 239/554] api: Run just check-api

---
 api/io/all-features.txt | 2 --
 1 file changed, 2 deletions(-)

diff --git a/api/io/all-features.txt b/api/io/all-features.txt
index 8f3698e432..1a6cb4f7ac 100644
--- a/api/io/all-features.txt
+++ b/api/io/all-features.txt
@@ -239,8 +239,6 @@ pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
 pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
 pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
 pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
-pub fn bitcoin_io::Error::cause(&self) -> core::option::Option<&dyn core::error::Error>
-pub fn bitcoin_io::Error::description(&self) -> &str
 pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_io::Error::fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
 pub fn bitcoin_io::Error::from(kind: bitcoin_io::ErrorKind) -> bitcoin_io::Error

From 34bde3671212f17082db9ef862e26825602fc6a6 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Sat, 18 Jan 2025 18:17:56 +0530
Subject: [PATCH 240/554] docs: fix fee rate serde module documentation

---
 units/src/fee_rate/serde.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/units/src/fee_rate/serde.rs b/units/src/fee_rate/serde.rs
index 017f6a0d03..496fee54dd 100644
--- a/units/src/fee_rate/serde.rs
+++ b/units/src/fee_rate/serde.rs
@@ -5,10 +5,10 @@
 #![allow(clippy::trivially_copy_pass_by_ref)]
 #![allow(clippy::missing_errors_doc)]
 
-//! This module adds serde serialization and deserialization support for amounts.
+//! This module adds serde serialization and deserialization support for fee rates.
 //!
-//! 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.
+//! Since there is not a default way to serialize and deserialize fee rates, multiple
+//! ways are supported and it's up to the user to decide which serialization to use.
 //!
 //! The provided modules can be used as follows:
 //!

From fec6a7669e4bb8b3d61c2e09013e67d311b7549a Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 19 Jan 2025 01:19:33 +0000
Subject: [PATCH 241/554] 2025-01-19 automated rustfmt nightly

---
 bitcoin/examples/sighash.rs | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index 079d4d0f2f..15439b46cd 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -125,12 +125,7 @@ fn compute_sighash_p2wsh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
         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,
-                sig.sighash_type,
-            )
+            .p2wsh_signature_hash(inp_idx, witness_script, amount, sig.sighash_type)
             .expect("failed to compute sighash");
         println!("SegWit p2wsh sighash: {:x} ({})", sighash, sig.sighash_type);
     }

From 289a5214265a1f0d7b320b0121775f868a386c57 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 20 Jan 2025 09:36:23 +1100
Subject: [PATCH 242/554] units: Test for dyn compatibility

Phew! dyn compatibility is a non-trivial concept. There are four public
traits in `units`, only one is dyn compatible.

This patch is done in order to check off C-OBJECT from the Rust API
guidelines checklist.

Add a test to check the public traits in `units` for dyn compatibility.

While we are at it add a code comment on `Integer` stating why its not
dyn-compatible.

ref: https://rust-lang.github.io/api-guidelines/flexibility.html#c-object
---
 units/src/parse.rs |  1 +
 units/tests/api.rs | 12 ++++++++++++
 2 files changed, 13 insertions(+)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 6127a8f9e8..b3a6598e2c 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -53,6 +53,7 @@ impl AsRef<core::num::ParseIntError> for ParseIntError {
 
 /// Not strictly necessary but serves as a lint - avoids weird behavior if someone accidentally
 /// passes non-integer to the `parse()` function.
+// This trait is not dyn-compatible because `FromStr` is not dyn-compatible.
 pub trait Integer:
     FromStr<Err = core::num::ParseIntError> + TryFrom<i8> + Sized + sealed::Sealed
 {
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 0fec691bdc..00ad9b0841 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -247,6 +247,18 @@ fn regression_default() {
     assert_eq!(got, want);
 }
 
+#[test]
+fn dyn_compatible() {
+    // If this builds then traits are dyn compatible.
+    struct Traits {
+        a: Box<dyn amount::CheckedSum<Amount>>,
+        // These traits are explicitly not dyn compatible.
+        // b: Box<dyn amount::serde::SerdeAmount>,
+        // c: Box<dyn amount::serde::SerdeAmountForOpt>,
+        // d: Box<dyn parse::Integer>,
+    }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Types {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {

From d97cbc6d27e7c38b2c59841cd3d1d3fb0bbac69d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 20 Jan 2025 13:22:06 +1100
Subject: [PATCH 243/554] units: Correct docs on private Sealed trait

Trivial fix to the rustdocs on private trait (required to keep linter
quiet).
---
 units/src/parse.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 6127a8f9e8..3161869535 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -70,7 +70,7 @@ macro_rules! impl_integer {
 impl_integer!(u8, i8, u16, i16, u32, i32, u64, i64, u128, i128);
 
 mod sealed {
-    /// Seals the extension traits.
+    /// Seals the `Integer` trait.
     pub trait Sealed {}
 }
 

From f1e2564821686f620fe1c99f0ba7e4e0ab551576 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 20 Jan 2025 13:34:09 +1100
Subject: [PATCH 244/554] Improve docs on parse::int_from_string

I only just worked on this function a week ago and already I couldn't
see from reading the code why it exists. Add a paragraph to the rustdocs
to save the next guy the trouble of working it out.
---
 units/src/parse.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 3161869535..01adc3a018 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -76,6 +76,11 @@ mod sealed {
 
 /// Parses the input string as an integer returning an error carrying rich context.
 ///
+/// Apart from the rich error context this function exists so that we can handle builds with and
+/// without an allocator. If an allocator is available (`alloc` feature enabled) then this function
+/// allocates to copy the input string into the error return. If `alloc` is not enabled the input
+/// string is lost.
+///
 /// If the caller has a `String` or `Box<str>` which is not used later it's better to call
 /// [`parse::int_from_string`] or [`parse::int_from_box`] respectively.
 ///

From 7ca5c5ccae1efe5862f21bfc670257837a202517 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 20 Jan 2025 13:44:25 +1100
Subject: [PATCH 245/554] Fix rustdoc title on hex_u128_*

The `hex_u32` versions of these functions have better docs, copy them to
the `hex_u128` versions.
---
 units/src/parse.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 01adc3a018..c210a6c474 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -335,7 +335,7 @@ pub fn hex_u128(s: &str) -> Result<u128, ParseIntError> {
     Ok(hex_u128_unchecked(unchecked)?)
 }
 
-/// Parses a `u128` from a hex string.
+/// Parses a `u128` from a prefixed hex string.
 ///
 /// # Errors
 ///
@@ -346,7 +346,7 @@ pub fn hex_u128_prefixed(s: &str) -> Result<u128, PrefixedHexError> {
     Ok(hex_u128_unchecked(checked)?)
 }
 
-/// Parses a `u128` from a hex string.
+/// Parses a `u128` from an unprefixed hex string.
 ///
 /// # Errors
 ///

From 7c7fc36784603480df1975f4a77ec583b74efa5c Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 20 Jan 2025 16:06:48 +1100
Subject: [PATCH 246/554] Improve docs on Denomination

Document what each denomination means.
---
 units/src/amount/mod.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 2c7f59f2b6..8e3a92515e 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -68,17 +68,17 @@ pub use self::{
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 #[non_exhaustive]
 pub enum Denomination {
-    /// BTC
+    /// BTC (1 BTC = 100,000,000 satoshi).
     Bitcoin,
-    /// cBTC
+    /// cBTC (1 cBTC = 1,000,000 satoshi).
     CentiBitcoin,
-    /// mBTC
+    /// mBTC (1 mBTC = 100,000 satoshi).
     MilliBitcoin,
-    /// uBTC
+    /// uBTC (1 uBTC = 100 satoshi).
     MicroBitcoin,
-    /// bits
+    /// bits (bits = uBTC).
     Bit,
-    /// satoshi
+    /// satoshi (1 BTC = 100,000,000 satoshi).
     Satoshi,
 }
 

From 81d4c2e067ec7ed1d39372783261704cb1e802d8 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 20 Jan 2025 17:22:08 +1100
Subject: [PATCH 247/554] Remove unnecessary doc(hidden)

This trait is private and is meant just for sealing. It already will not
show up in public docs and cannot be used by downstream users.

Resolve: #3912
---
 hashes/src/lib.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 920ce99731..9f0067aafd 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -303,7 +303,6 @@ impl<const N: usize> IsByteArray for [u8; N] {
 }
 
 mod sealed {
-    #[doc(hidden)]
     pub trait IsByteArray {}
 
     impl<const N: usize> IsByteArray for [u8; N] {}

From 55470f73571ce0e0279f5697a252695e8c8df9b5 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 20 Jan 2025 16:06:29 +0000
Subject: [PATCH 248/554] Change `create` to `construct` in rustdocs

---
 units/src/parse.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 6127a8f9e8..aa5a7bf3ef 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -121,7 +121,7 @@ fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, ParseIn
 /// Implements standard parsing traits for `$type` by calling `parse::int`.
 ///
 /// Once the string is converted to an integer the infallible conversion function `fn` is used to
-/// create the type `to`.
+/// construct the type `to`.
 ///
 /// Implements:
 ///

From 7277092af44f44f59bdb6326561b0b47416cc085 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 20 Jan 2025 15:28:06 +1100
Subject: [PATCH 249/554] Remove mutagen

Back in 2022 we elected to use `mutagen` for mutation testing. Since
then `cargo mutants` has progressed to a point where we would now like
to use it instead.

Remove all the `mutagen` stuff and update the lock files.

Close: #2829
---
 Cargo-minimal.lock                  | 47 ----------------------
 Cargo-recent.lock                   | 62 +----------------------------
 bitcoin/Cargo.toml                  |  3 --
 bitcoin/src/pow.rs                  | 23 -----------
 primitives/Cargo.toml               |  3 --
 primitives/src/locktime/absolute.rs |  4 --
 primitives/src/locktime/relative.rs |  7 ----
 7 files changed, 2 insertions(+), 147 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index de123e13f9..5e47891e01 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -2,12 +2,6 @@
 # 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 = "arbitrary"
 version = "1.4.1"
@@ -68,7 +62,6 @@ dependencies = [
  "bitcoinconsensus",
  "hex-conservative 0.3.0",
  "hex_lit",
- "mutagen",
  "ordered",
  "secp256k1",
  "serde",
@@ -118,7 +111,6 @@ dependencies = [
  "bitcoin-units",
  "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
- "mutagen",
  "ordered",
  "serde",
  "serde_json",
@@ -242,12 +234,6 @@ 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"
@@ -269,39 +255,6 @@ 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 = "ordered"
 version = "0.4.0"
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index b9ed4db003..47641c992a 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -2,12 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "anyhow"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6"
-
 [[package]]
 name = "arbitrary"
 version = "1.4.1"
@@ -67,7 +61,6 @@ dependencies = [
  "bitcoinconsensus",
  "hex-conservative 0.3.0",
  "hex_lit",
- "mutagen",
  "ordered",
  "secp256k1",
  "serde",
@@ -117,7 +110,6 @@ dependencies = [
  "bitcoin-units",
  "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
- "mutagen",
  "ordered",
  "serde",
  "serde_json",
@@ -244,12 +236,6 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
-[[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.5.0"
@@ -277,39 +263,6 @@ 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 1.0.109",
-]
-
-[[package]]
-name = "mutagen-transform"
-version = "0.2.0"
-source = "git+https://github.com/llogiq/mutagen#a6377c4c3f360afeb7a287c1c17e4b69456d5f53"
-dependencies = [
- "mutagen-core",
- "proc-macro2",
-]
-
 [[package]]
 name = "ordered"
 version = "0.4.0"
@@ -432,7 +385,7 @@ checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.79",
+ "syn",
 ]
 
 [[package]]
@@ -462,17 +415,6 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
-[[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 = "syn"
 version = "2.0.79"
@@ -514,5 +456,5 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.79",
+ "syn",
 ]
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index fd6e61649f..cf0575029d 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -49,9 +49,6 @@ serde_test = "1.0.19"
 bincode = "1.3.1"
 hex_lit = "0.1.1"
 
-[target.'cfg(mutate)'.dev-dependencies]
-mutagen = { git = "https://github.com/llogiq/mutagen" }
-
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index 63a5c854ac..e25319273d 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -10,8 +10,6 @@ use core::{cmp, fmt};
 
 use internals::impl_to_hex_from_lower_hex;
 use io::{BufRead, Write};
-#[cfg(all(test, mutate))]
-use mutagen::mutate;
 use units::parse::{self, ParseIntError, PrefixedHexError, UnprefixedHexError};
 
 use crate::block::{BlockHash, Header};
@@ -218,7 +216,6 @@ impl Target {
     ///
     /// Proof-of-work validity for a block requires the hash of the block to be less than or equal
     /// to the target.
-    #[cfg_attr(all(test, mutate), mutate)]
     pub fn is_met_by(&self, hash: BlockHash) -> bool {
         let hash = U256::from_le_bytes(hash.to_byte_array());
         hash <= self.0
@@ -255,7 +252,6 @@ impl Target {
     ///
     /// [max]: Target::max
     /// [target]: crate::block::HeaderExt::target
-    #[cfg_attr(all(test, mutate), mutate)]
     pub fn difficulty(&self, params: impl AsRef<Params>) -> u128 {
         // Panic here may be eaiser to debug than during the actual division.
         assert_ne!(self.0, U256::ZERO, "divide by zero");
@@ -274,7 +270,6 @@ impl Target {
     /// Panics if `self` is zero (divide by zero).
     ///
     /// [`difficulty`]: Target::difficulty
-    #[cfg_attr(all(test, mutate), mutate)]
     pub fn difficulty_float(&self, params: impl AsRef<Params>) -> f64 {
         // We want to explicitly panic to be uniform with `difficulty()`
         // (float division by zero does not panic).
@@ -499,7 +494,6 @@ impl U256 {
     }
 
     /// Constructs a new `U256` from a big-endian array of `u8`s.
-    #[cfg_attr(all(test, mutate), mutate)]
     fn from_be_bytes(a: [u8; 32]) -> U256 {
         let (high, low) = split_in_half(a);
         let big = u128::from_be_bytes(high);
@@ -508,7 +502,6 @@ impl U256 {
     }
 
     /// Constructs a new `U256` from a little-endian array of `u8`s.
-    #[cfg_attr(all(test, mutate), mutate)]
     fn from_le_bytes(a: [u8; 32]) -> U256 {
         let (high, low) = split_in_half(a);
         let little = u128::from_le_bytes(high);
@@ -517,7 +510,6 @@ impl U256 {
     }
 
     /// Converts `U256` to a big-endian array of `u8`s.
-    #[cfg_attr(all(test, mutate), mutate)]
     fn to_be_bytes(self) -> [u8; 32] {
         let mut out = [0; 32];
         out[..16].copy_from_slice(&self.0.to_be_bytes());
@@ -526,7 +518,6 @@ impl U256 {
     }
 
     /// Converts `U256` to a little-endian array of `u8`s.
-    #[cfg_attr(all(test, mutate), mutate)]
     fn to_le_bytes(self) -> [u8; 32] {
         let mut out = [0; 32];
         out[..16].copy_from_slice(&self.1.to_le_bytes());
@@ -558,13 +549,10 @@ impl U256 {
         ret.wrapping_inc()
     }
 
-    #[cfg_attr(all(test, mutate), mutate)]
     fn is_zero(&self) -> bool { self.0 == 0 && self.1 == 0 }
 
-    #[cfg_attr(all(test, mutate), mutate)]
     fn is_one(&self) -> bool { self.0 == 0 && self.1 == 1 }
 
-    #[cfg_attr(all(test, mutate), mutate)]
     fn is_max(&self) -> bool { self.0 == u128::MAX && self.1 == u128::MAX }
 
     /// Returns the low 32 bits.
@@ -587,7 +575,6 @@ impl U256 {
     }
 
     /// Returns the least number of bits needed to represent the number.
-    #[cfg_attr(all(test, mutate), mutate)]
     fn bits(&self) -> u32 {
         if self.0 > 0 {
             256 - self.0.leading_zeros()
@@ -602,9 +589,6 @@ impl U256 {
     ///
     /// The multiplication result along with a boolean indicating whether an arithmetic overflow
     /// occurred. If an overflow occurred then the wrapped value is returned.
-    // mutagen false pos mul_u64: replace `|` with `^` (XOR is same as OR when combined with <<)
-    // mutagen false pos mul_u64: replace `|` with `^`
-    #[cfg_attr(all(test, mutate), mutate)]
     fn mul_u64(self, rhs: u64) -> (U256, bool) {
         let mut carry: u128 = 0;
         let mut split_le =
@@ -632,7 +616,6 @@ impl U256 {
     /// # Panics
     ///
     /// If `rhs` is zero.
-    #[cfg_attr(all(test, mutate), mutate)]
     fn div_rem(self, rhs: Self) -> (Self, Self) {
         let mut sub_copy = self;
         let mut shift_copy = rhs;
@@ -672,7 +655,6 @@ impl U256 {
     /// Returns a tuple of the addition along with a boolean indicating whether an arithmetic
     /// overflow would occur. If an overflow would have occurred then the wrapped value is returned.
     #[must_use = "this returns the result of the operation, without modifying the original"]
-    #[cfg_attr(all(test, mutate), mutate)]
     fn overflowing_add(self, rhs: Self) -> (Self, bool) {
         let mut ret = U256::ZERO;
         let mut ret_overflow = false;
@@ -697,7 +679,6 @@ impl U256 {
     /// Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic
     /// overflow would occur. If an overflow would have occurred then the wrapped value is returned.
     #[must_use = "this returns the result of the operation, without modifying the original"]
-    #[cfg_attr(all(test, mutate), mutate)]
     fn overflowing_sub(self, rhs: Self) -> (Self, bool) {
         let ret = self.wrapping_add(!rhs).wrapping_add(Self::ONE);
         let overflow = rhs > self;
@@ -710,7 +691,6 @@ impl U256 {
     /// indicating whether an arithmetic overflow would occur. If an
     /// overflow would have occurred then the wrapped value is returned.
     #[must_use = "this returns the result of the operation, without modifying the original"]
-    #[cfg_attr(all(test, mutate), mutate)]
     fn overflowing_mul(self, rhs: Self) -> (Self, bool) {
         let mut ret = U256::ZERO;
         let mut ret_overflow = false;
@@ -758,7 +738,6 @@ impl U256 {
 
     /// Returns `self` incremented by 1 wrapping around at the boundary of the type.
     #[must_use = "this returns the result of the increment, without modifying the original"]
-    #[cfg_attr(all(test, mutate), mutate)]
     fn wrapping_inc(&self) -> U256 {
         let mut ret = U256::ZERO;
 
@@ -778,7 +757,6 @@ impl U256 {
     /// restricted to the range of the type, rather than the bits shifted out of the LHS being
     /// returned to the other end. We do not currently support `rotate_left`.
     #[must_use = "this returns the result of the operation, without modifying the original"]
-    #[cfg_attr(all(test, mutate), mutate)]
     fn wrapping_shl(self, rhs: u32) -> Self {
         let shift = rhs & 0x000000ff;
 
@@ -805,7 +783,6 @@ impl U256 {
     /// restricted to the range of the type, rather than the bits shifted out of the LHS being
     /// returned to the other end. We do not currently support `rotate_right`.
     #[must_use = "this returns the result of the operation, without modifying the original"]
-    #[cfg_attr(all(test, mutate), mutate)]
     fn wrapping_shr(self, rhs: u32) -> Self {
         let shift = rhs & 0x000000ff;
 
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 199a9d808a..a44c42c6e5 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -36,9 +36,6 @@ serde = { version = "1.0.103", default-features = false, features = ["derive", "
 serde_json = "1.0.0"
 bincode = "1.3.1"
 
-[target.'cfg(mutate)'.dev-dependencies]
-mutagen = { git = "https://github.com/llogiq/mutagen" }
-
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index e54dae56d6..02196da7a6 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -10,8 +10,6 @@ use core::fmt;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
-#[cfg(all(test, mutate))]
-use mutagen::mutate;
 use units::parse::{self, PrefixedHexError, UnprefixedHexError};
 
 #[cfg(all(doc, feature = "alloc"))]
@@ -214,7 +212,6 @@ impl LockTime {
     /// }
     /// ````
     #[inline]
-    #[cfg_attr(all(test, mutate), mutate)]
     pub fn is_satisfied_by(&self, height: Height, time: Time) -> bool {
         use LockTime::*;
 
@@ -244,7 +241,6 @@ impl LockTime {
     /// 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::*;
 
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 98b4efe1c2..7e8d968e81 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -9,9 +9,6 @@
 use core::cmp::Ordering;
 use core::{cmp, convert, fmt};
 
-#[cfg(all(test, mutate))]
-use mutagen::mutate;
-
 use crate::Sequence;
 #[cfg(all(doc, feature = "alloc"))]
 use crate::{relative, TxIn};
@@ -177,7 +174,6 @@ impl LockTime {
     /// 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
@@ -216,7 +212,6 @@ impl LockTime {
     /// assert!(satisfied);
     /// ```
     #[inline]
-    #[cfg_attr(all(test, mutate), mutate)]
     pub fn is_implied_by(&self, other: LockTime) -> bool {
         use LockTime::*;
 
@@ -258,7 +253,6 @@ impl LockTime {
     /// assert!(lock.is_satisfied_by_height(Height::from(required_height + 1)).expect("a height"));
     /// ```
     #[inline]
-    #[cfg_attr(all(test, mutate), mutate)]
     pub fn is_satisfied_by_height(&self, height: Height) -> Result<bool, IncompatibleHeightError> {
         use LockTime::*;
 
@@ -285,7 +279,6 @@ impl LockTime {
     /// 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, time: Time) -> Result<bool, IncompatibleTimeError> {
         use LockTime::*;
 

From 31dda6d53d4d014e88ca599ecee7a5fbdb88b9c1 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 17 Jan 2025 14:22:31 +1100
Subject: [PATCH 250/554] Make io::Error Sync

Currently we use a marker that contains an `UnsafeCell` but `UnsafeCell`
is not `Sync` so this makes `io::Error` not `Sync`. We can instead wrap
the `UnsafeCell` and implement `Sync` for it.

Fix: #3883
---
 io/src/error.rs | 17 +++++++++++++----
 io/tests/api.rs |  4 ++++
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/io/src/error.rs b/io/src/error.rs
index 6ef943e42f..ae5b5e44a9 100644
--- a/io/src/error.rs
+++ b/io/src/error.rs
@@ -6,10 +6,12 @@ use core::fmt;
 #[derive(Debug)]
 pub struct Error {
     kind: ErrorKind,
-    /// Indicates that the `struct` can pretend to own a mutable static reference
-    /// and an [`UnsafeCell`](core::cell::UnsafeCell), which are not unwind safe.
-    /// This is so that it does not introduce non-additive cargo features.
-    _not_unwind_safe: core::marker::PhantomData<(&'static mut (), core::cell::UnsafeCell<()>)>,
+    /// We want this type to be `?UnwindSafe` and `?RefUnwindSafe` - the same as `std::io::Error`.
+    ///
+    /// In `std` builds the existence of `dyn std::error:Error` prevents `UnwindSafe` and
+    /// `RefUnwindSafe` from being automatically implemented. But in `no-std` builds without the
+    /// marker nothing prevents it.
+    _not_unwind_safe: core::marker::PhantomData<NotUnwindSafe>,
 
     #[cfg(feature = "std")]
     error: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
@@ -100,6 +102,13 @@ impl From<Error> for std::io::Error {
     }
 }
 
+/// Useful for preventing `UnwindSafe` and `RefUnwindSafe` from being automatically implemented.
+struct NotUnwindSafe {
+    _not_unwind_safe: core::marker::PhantomData<(&'static mut (), core::cell::UnsafeCell<()>)>,
+}
+
+unsafe impl Sync for NotUnwindSafe {}
+
 macro_rules! define_errorkind {
     ($($(#[$($attr:tt)*])* $kind:ident),*) => {
         #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
diff --git a/io/tests/api.rs b/io/tests/api.rs
index 608969c027..efc64f2e69 100644
--- a/io/tests/api.rs
+++ b/io/tests/api.rs
@@ -137,4 +137,8 @@ fn all_non_error_tyes_implement_send_sync() {
     //  Types are `Send` and `Sync` where possible (C-SEND-SYNC).
     assert_send::<Types>();
     assert_sync::<Types>();
+
+    // Error types are meaningful and well-behaved (C-GOOD-ERR)
+    assert_send::<Errors>();
+    assert_sync::<Errors>();
 }

From 11a9dced766c56d6258af6f43d8691aaf7b2110f Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 17 Jan 2025 14:25:08 +1100
Subject: [PATCH 251/554] api: Run just check-api

---
 api/io/all-features.txt | 2 +-
 api/io/alloc-only.txt   | 2 +-
 api/io/no-features.txt  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/api/io/all-features.txt b/api/io/all-features.txt
index 1a6cb4f7ac..46b6a29355 100644
--- a/api/io/all-features.txt
+++ b/api/io/all-features.txt
@@ -1,6 +1,5 @@
 #[repr(transparent)] pub struct bitcoin_io::FromStd<T>(_)
 #[repr(transparent)] pub struct bitcoin_io::ToStd<T>(_)
-impl !core::marker::Sync for bitcoin_io::Error
 impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
 impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
 impl bitcoin_io::BufRead for &[u8]
@@ -70,6 +69,7 @@ impl core::marker::Send for bitcoin_io::Error
 impl core::marker::Send for bitcoin_io::ErrorKind
 impl core::marker::Send for bitcoin_io::Sink
 impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::Error
 impl core::marker::Sync for bitcoin_io::ErrorKind
 impl core::marker::Sync for bitcoin_io::Sink
 impl core::marker::Unpin for bitcoin_io::Error
diff --git a/api/io/alloc-only.txt b/api/io/alloc-only.txt
index e0d9a76e55..5cb6127948 100644
--- a/api/io/alloc-only.txt
+++ b/api/io/alloc-only.txt
@@ -1,4 +1,3 @@
-impl !core::marker::Sync for bitcoin_io::Error
 impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
 impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
 impl bitcoin_io::BufRead for &[u8]
@@ -28,6 +27,7 @@ impl core::marker::Send for bitcoin_io::Error
 impl core::marker::Send for bitcoin_io::ErrorKind
 impl core::marker::Send for bitcoin_io::Sink
 impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::Error
 impl core::marker::Sync for bitcoin_io::ErrorKind
 impl core::marker::Sync for bitcoin_io::Sink
 impl core::marker::Unpin for bitcoin_io::Error
diff --git a/api/io/no-features.txt b/api/io/no-features.txt
index 3874ee8f7e..493aab9300 100644
--- a/api/io/no-features.txt
+++ b/api/io/no-features.txt
@@ -1,4 +1,3 @@
-impl !core::marker::Sync for bitcoin_io::Error
 impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
 impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
 impl bitcoin_io::BufRead for &[u8]
@@ -27,6 +26,7 @@ impl core::marker::Send for bitcoin_io::Error
 impl core::marker::Send for bitcoin_io::ErrorKind
 impl core::marker::Send for bitcoin_io::Sink
 impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
+impl core::marker::Sync for bitcoin_io::Error
 impl core::marker::Sync for bitcoin_io::ErrorKind
 impl core::marker::Sync for bitcoin_io::Sink
 impl core::marker::Unpin for bitcoin_io::Error

From bcc38c40e08faa74e47814c148c75505facbff37 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Sat, 11 Jan 2025 22:01:46 +0530
Subject: [PATCH 252/554] Add Amount division by FeeRate

Implement `checked_div_by_fee_rate_floor` and `checked_div_by_fee_rate_ceil` methods to compute the maximum and minimum transaction weights.
These methods provide precise weight calculations using both floor and ceiling divisions.

- Introduce `checked_div_by_fee_rate_floor` for floor-based weight division.
- Add `checked_div_by_fee_rate_ceil` for ceiling-based weight division.
- Update `ops::Div` implementation for `Amount` to use floor division by default.
- Include unit tests to validate both floor and ceiling division methods.
---
 units/src/amount/tests.rs | 42 ++++++++++++++++++++
 units/src/fee.rs          | 84 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 126 insertions(+)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index ecd813ffd1..b8374456be 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -220,6 +220,48 @@ fn amount_checked_div_by_weight_floor() {
     assert!(fee_rate.is_none());
 }
 
+#[cfg(feature = "alloc")]
+#[test]
+fn amount_checked_div_by_fee_rate() {
+    let amount = Amount::from_sat(1000);
+    let fee_rate = FeeRate::from_sat_per_kwu(2);
+
+    // Test floor division
+    let weight = amount.checked_div_by_fee_rate_floor(fee_rate).unwrap();
+    // 1000 sats / (2 sats/kwu) = 500,000 wu
+    assert_eq!(weight, Weight::from_wu(500_000));
+
+    // Test ceiling division
+    let weight = amount.checked_div_by_fee_rate_ceil(fee_rate).unwrap();
+    assert_eq!(weight, Weight::from_wu(500_000)); // Same result for exact division
+
+    // Test truncation behavior
+    let amount = Amount::from_sat(1000);
+    let fee_rate = FeeRate::from_sat_per_kwu(3);
+    let floor_weight = amount.checked_div_by_fee_rate_floor(fee_rate).unwrap();
+    let ceil_weight = amount.checked_div_by_fee_rate_ceil(fee_rate).unwrap();
+    assert_eq!(floor_weight, Weight::from_wu(333_333));
+    assert_eq!(ceil_weight, Weight::from_wu(333_334));
+
+    // Test division by zero
+    let zero_fee_rate = FeeRate::from_sat_per_kwu(0);
+    assert!(amount.checked_div_by_fee_rate_floor(zero_fee_rate).is_none());
+    assert!(amount.checked_div_by_fee_rate_ceil(zero_fee_rate).is_none());
+
+    // Test with maximum amount
+    let max_amount = Amount::MAX;
+    let small_fee_rate = FeeRate::from_sat_per_kwu(1);
+    let weight = max_amount.checked_div_by_fee_rate_floor(small_fee_rate).unwrap();
+    // 21_000_000_0000_0000 sats / (1 sat/kwu) = 2_100_000_000_000_000_000 wu
+    assert_eq!(weight, Weight::from_wu(2_100_000_000_000_000_000));
+
+    // Test overflow case
+    let tiny_fee_rate = FeeRate::from_sat_per_kwu(1);
+    let large_amount = Amount::from_sat(u64::MAX);
+    assert!(large_amount.checked_div_by_fee_rate_floor(tiny_fee_rate).is_none());
+    assert!(large_amount.checked_div_by_fee_rate_ceil(tiny_fee_rate).is_none());
+}
+
 #[cfg(feature = "alloc")]
 #[test]
 fn floating_point() {
diff --git a/units/src/fee.rs b/units/src/fee.rs
index fba121055d..a1475f9bd3 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -68,6 +68,48 @@ impl Amount {
             None => None,
         }
     }
+
+    /// Checked fee rate floor division.
+    ///
+    /// Computes the maximum weight that would result in a fee less than or equal to this amount
+    /// at the given `fee_rate`. Uses floor division to ensure the resulting weight doesn't cause
+    /// the fee to exceed the amount.
+    ///
+    /// Returns [`None`] if overflow occurred or if `fee_rate` is zero.
+    #[must_use]
+    pub const fn checked_div_by_fee_rate_floor(self, fee_rate: FeeRate) -> Option<Weight> {
+        match self.to_sat().checked_mul(1000) {
+            Some(amount_msats) => match amount_msats.checked_div(fee_rate.to_sat_per_kwu()) {
+                Some(wu) => Some(Weight::from_wu(wu)),
+                None => None,
+            },
+            None => None,
+        }
+    }
+
+    /// Checked fee rate ceiling division.
+    ///
+    /// Computes the minimum weight that would result in a fee greater than or equal to this amount
+    /// at the given `fee_rate`. Uses ceiling division to ensure the resulting weight is sufficient.
+    ///
+    /// Returns [`None`] if overflow occurred or if `fee_rate` is zero.
+    #[must_use]
+    pub const fn checked_div_by_fee_rate_ceil(self, fee_rate: FeeRate) -> Option<Weight> {
+        let rate = fee_rate.to_sat_per_kwu();
+        match self.to_sat().checked_mul(1000) {
+            Some(amount_msats) => match rate.checked_sub(1) {
+                Some(rate_minus_one) => match amount_msats.checked_add(rate_minus_one) {
+                    Some(rounded_msats) => match rounded_msats.checked_div(rate) {
+                        Some(wu) => Some(Weight::from_wu(wu)),
+                        None => None,
+                    },
+                    None => None,
+                },
+                None => None,
+            },
+            None => None,
+        }
+    }
 }
 
 impl FeeRate {
@@ -136,6 +178,21 @@ impl ops::Div<Weight> for Amount {
     }
 }
 
+impl ops::Div<FeeRate> for Amount {
+    type Output = Weight;
+
+    /// Truncating integer division.
+    ///
+    /// # Panics
+    ///
+    /// This operation will panic if `fee_rate` is zero or the division results in overflow.
+    ///
+    /// Note: This uses floor division. For ceiling division use [`Amount::checked_div_by_fee_rate_ceil`].
+    fn div(self, rhs: FeeRate) -> Self::Output {
+        self.checked_div_by_fee_rate_floor(rhs).unwrap()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -199,4 +256,31 @@ mod tests {
 
         assert_eq!(two * three, six);
     }
+
+    #[test]
+    fn amount_div_by_fee_rate() {
+        // Test exact division
+        let amount = Amount::from_sat(1000);
+        let fee_rate = FeeRate::from_sat_per_kwu(2);
+        let weight = amount / fee_rate;
+        assert_eq!(weight, Weight::from_wu(500_000));
+
+        // Test truncation behavior
+        let amount = Amount::from_sat(1000);
+        let fee_rate = FeeRate::from_sat_per_kwu(3);
+        let weight = amount / fee_rate;
+        // 1000 * 1000 = 1,000,000 msats
+        // 1,000,000 / 3 = 333,333.33... wu
+        // Should truncate down to 333,333 wu
+        assert_eq!(weight, Weight::from_wu(333_333));
+
+        // Verify that ceiling division gives different result
+        let ceil_weight = amount.checked_div_by_fee_rate_ceil(fee_rate).unwrap();
+        assert_eq!(ceil_weight, Weight::from_wu(333_334));
+
+        // Test that division by zero returns None
+        let zero_rate = FeeRate::from_sat_per_kwu(0);
+        assert!(amount.checked_div_by_fee_rate_floor(zero_rate).is_none());
+        assert!(amount.checked_div_by_fee_rate_ceil(zero_rate).is_none());
+    }
 }

From 7482fcd934c09e3cd6cd25fd4328960b02f8e976 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Sat, 18 Jan 2025 16:27:19 +0530
Subject: [PATCH 253/554] Run just check-api

---
 api/units/all-features.txt | 5 +++++
 api/units/alloc-only.txt   | 5 +++++
 api/units/no-features.txt  | 5 +++++
 3 files changed, 15 insertions(+)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 0559a49bc2..27831e2021 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -505,6 +505,7 @@ impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units
 impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::ops::arith::Div for bitcoin_units::weight::Weight
+impl core::ops::arith::Div<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::Amount
 impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
 impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
 impl core::ops::arith::Div<u64> for bitcoin_units::Amount
@@ -720,6 +721,8 @@ pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
 pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
 pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
+pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_floor(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
 pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
 pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
 pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
@@ -814,6 +817,7 @@ pub fn bitcoin_units::Amount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D,
 pub fn bitcoin_units::Amount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
@@ -1285,6 +1289,7 @@ pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::Amount::Output = bitcoin_units::weight::Weight
 pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index a44702c7a4..8b5ae4bede 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -470,6 +470,7 @@ impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units
 impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::ops::arith::Div for bitcoin_units::weight::Weight
+impl core::ops::arith::Div<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::Amount
 impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
 impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
 impl core::ops::arith::Div<u64> for bitcoin_units::Amount
@@ -658,6 +659,8 @@ pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
 pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
 pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
+pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_floor(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
 pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
 pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
 pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
@@ -748,6 +751,7 @@ pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core:
 pub fn bitcoin_units::Amount::default() -> Self
 pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
@@ -1113,6 +1117,7 @@ pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::Amount::Output = bitcoin_units::weight::Weight
 pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 39e957f3e2..a23e0e4d20 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -454,6 +454,7 @@ impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units
 impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
 impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
 impl core::ops::arith::Div for bitcoin_units::weight::Weight
+impl core::ops::arith::Div<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::Amount
 impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
 impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
 impl core::ops::arith::Div<u64> for bitcoin_units::Amount
@@ -642,6 +643,8 @@ pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
 pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
 pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
+pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
+pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_floor(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
 pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
@@ -730,6 +733,7 @@ pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core:
 pub fn bitcoin_units::Amount::default() -> Self
 pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
+pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
 pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
 pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
 pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
@@ -1067,6 +1071,7 @@ pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
 pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
 pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
+pub type bitcoin_units::Amount::Output = bitcoin_units::weight::Weight
 pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
 pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError

From 462c7a11309fb4828d69ca8df045155413497244 Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Sun, 22 Dec 2024 15:48:30 -0600
Subject: [PATCH 254/554] Add weekly cargo-mutants workflow

---
 .cargo/mutants.toml                           | 27 ++++++++++++
 .../workflows/cron-weekly-cargo-mutants.yml   | 41 +++++++++++++++++++
 .gitignore                                    |  1 +
 3 files changed, 69 insertions(+)
 create mode 100644 .cargo/mutants.toml
 create mode 100644 .github/workflows/cron-weekly-cargo-mutants.yml

diff --git a/.cargo/mutants.toml b/.cargo/mutants.toml
new file mode 100644
index 0000000000..b6ed18c553
--- /dev/null
+++ b/.cargo/mutants.toml
@@ -0,0 +1,27 @@
+additional_cargo_args = ["--all-features"]
+examine_globs = ["units/src/**/*.rs"]
+exclude_globs = [
+    "units/src/amount/verification.rs" # kani tests
+]
+exclude_re = [
+    "impl Debug",
+    "impl Arbitrary",
+    "impl Display",
+    ".*Error",
+    # --------------------------------------------Crate-specific exclusions--------------------------------------------
+    # Units
+    # src/amount/mod.rs
+    "parse_signed_to_satoshi", # Can't kill all mutants since there is no denomination smaller than Satoshi
+    "fmt_satoshi_in", # Related to formatting/display
+    "dec_width", # Replacing num /= 10 with num %=10 in a loop causes a timeout due to infinite loop
+    # src/fee_rate/serde.rs
+    "as_sat_per_kwu::opt::deserialize::<impl Visitor for VisitOpt>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
+    "as_sat_per_vb_floor::opt::deserialize::<impl Visitor for VisitOpt>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
+    "as_sat_per_vb_ceil::opt::deserialize::<impl Visitor for VisitOpt>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
+    # src/amount/serde.rs
+    "as_sat::opt::deserialize::<impl Visitor for VisitOptAmt<X>>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
+    "as_btc::opt::deserialize::<impl Visitor for VisitOptAmt<X>>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
+    "as_str::opt::deserialize::<impl Visitor for VisitOptAmt<X>>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
+    # src/locktime/relative.rs
+    "Time::to_consensus_u32" # It will replace | with ^, which will return the same value since the XOR is always taken against the u16 and an all-zero bitmask
+]
diff --git a/.github/workflows/cron-weekly-cargo-mutants.yml b/.github/workflows/cron-weekly-cargo-mutants.yml
new file mode 100644
index 0000000000..30896e4027
--- /dev/null
+++ b/.github/workflows/cron-weekly-cargo-mutants.yml
@@ -0,0 +1,41 @@
+name: Weekly cargo-mutants
+on:
+  schedule:
+    - cron: "0 0 * * 0" # runs weekly on Sunday at 00:00
+  workflow_dispatch: # allows manual triggering
+jobs:
+  cargo-mutants:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-mutants
+      - run: cargo mutants --in-place --no-shuffle
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: mutants.out
+          path: mutants.out
+      - name: Check for new mutants
+        if: always()
+        run: |
+          if [ -s mutants.out/missed.txt ]; then
+            echo "New missed mutants found"
+            gh issue create \
+            --title "New Mutants Found" \
+            --body "$(cat <<EOF
+          Displaying up to the first 10 mutants:
+
+          $(head -n 10 mutants.out/missed.txt)
+
+          For the complete list, please check the [mutants.out artifact](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}).
+          EOF
+          )"
+            echo "create_issue=true" >> $GITHUB_ENV
+          else
+            echo "No new mutants found"
+            echo "create_issue=false" >> $GITHUB_ENV
+          fi
+    env:
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.gitignore b/.gitignore
index 6055dd8637..48c9cedca4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,6 +14,7 @@ hashes/target
 
 # Test artifacts
 bitcoin/dep_test
+mutants.out*
 
 # Fuzz artifacts
 hfuzz_target

From 871fa08f6162727dcd51afa4ed02d8e2ead94246 Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Wed, 15 Jan 2025 23:04:33 -0600
Subject: [PATCH 255/554] Fix typo in serde docs

---
 units/src/fee_rate/serde.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/src/fee_rate/serde.rs b/units/src/fee_rate/serde.rs
index 496fee54dd..1b1ad33648 100644
--- a/units/src/fee_rate/serde.rs
+++ b/units/src/fee_rate/serde.rs
@@ -171,7 +171,7 @@ pub mod as_sat_per_vb_ceil {
     //! Serialize and deserialize [`FeeRate`] denominated in satoshis per virtual byte.
     //!
     //! When serializing use ceil division to convert per kwu to per virtual byte.
-    //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_vb")]`.
+    //! Use with `#[serde(with = "fee_rate::serde::as_sat_per_vb_ceil")]`.
 
     use serde::{Deserialize, Deserializer, Serialize, Serializer};
 

From bfba2a85ddaad6b366a7502cbda1ff2462dfd4c7 Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Wed, 15 Jan 2025 23:21:14 -0600
Subject: [PATCH 256/554] Kill remaining mutants

---
 units/src/amount/tests.rs      | 2 ++
 units/src/fee_rate/mod.rs      | 3 ---
 units/src/locktime/relative.rs | 2 --
 3 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 42a9e3d3ca..df1785e548 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -972,10 +972,12 @@ fn sum_amounts() {
     assert_eq!([].iter().sum::<SignedAmount>(), SignedAmount::ZERO);
 
     let amounts = [sat(42), sat(1337), sat(21)];
+    assert_eq!(amounts.iter().sum::<Amount>(), sat(1400));
     let sum = amounts.into_iter().sum::<Amount>();
     assert_eq!(sum, sat(1400));
 
     let amounts = [ssat(-42), ssat(1337), ssat(21)];
+    assert_eq!(amounts.iter().sum::<SignedAmount>(), ssat(1316));
     let sum = amounts.into_iter().sum::<SignedAmount>();
     assert_eq!(sum, ssat(1316));
 }
diff --git a/units/src/fee_rate/mod.rs b/units/src/fee_rate/mod.rs
index c0baeb9df8..f9dca7b870 100644
--- a/units/src/fee_rate/mod.rs
+++ b/units/src/fee_rate/mod.rs
@@ -69,9 +69,6 @@ impl FeeRate {
     pub const fn to_sat_per_vb_floor(self) -> u64 { self.0 / (1000 / 4) }
 
     /// Converts to sat/vB rounding up.
-    /// TODO: cargo-mutants will try to replace - with /, which results in 1000 / 4 / 1 which is also 250.
-    /// Since we're addressing the mutants before introducing the cargo-mutants workflow, come back later
-    /// and skip this function in the mutants.toml config file
     pub const fn to_sat_per_vb_ceil(self) -> u64 { (self.0 + (1000 / 4 - 1)) / (1000 / 4) }
 
     /// Checked multiplication.
diff --git a/units/src/locktime/relative.rs b/units/src/locktime/relative.rs
index 7a25d49065..7f8b4413a2 100644
--- a/units/src/locktime/relative.rs
+++ b/units/src/locktime/relative.rs
@@ -116,8 +116,6 @@ impl Time {
 
     /// Returns the `u32` value used to encode this locktime in an nSequence field or
     /// argument to `OP_CHECKSEQUENCEVERIFY`.
-    /// TODO: Skip this in cargo-mutants. It will replace | with ^, which will return the same
-    /// value since the XOR is always taken against the u16 and an all-zero bitmask
     #[inline]
     pub const fn to_consensus_u32(self) -> u32 {
         (1u32 << 22) | self.0 as u32 // cast safety: u32 is wider than u16 on all architectures

From 20d3f16a540e629ee3829c8a3d90269156918a13 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 20 Jan 2025 16:43:48 +0000
Subject: [PATCH 257/554] Fix clippy lint in new rustc nightly

New nightly lint warning "called `Iterator::last` on a
`DoubleEndedIterator`; this will needlessly iterate the entire iterator"

Code that gives the warning is correct, allow the lint to remove the
warning.

Update rustc nightly to 2025-01-16
---
 bitcoin/src/taproot/merkle_branch.rs | 1 +
 nightly-version                      | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/bitcoin/src/taproot/merkle_branch.rs b/bitcoin/src/taproot/merkle_branch.rs
index c629eacb69..10b2d0718c 100644
--- a/bitcoin/src/taproot/merkle_branch.rs
+++ b/bitcoin/src/taproot/merkle_branch.rs
@@ -252,6 +252,7 @@ impl Iterator for IntoIter {
     fn nth(&mut self, n: usize) -> Option<Self::Item> { self.0.nth(n) }
 
     #[inline]
+    #[allow(clippy::double_ended_iterator_last)] // False positive.  Using `.last()` on a `vec::IntoIter` is correct.
     fn last(self) -> Option<Self::Item> { self.0.last() }
 
     #[inline]
diff --git a/nightly-version b/nightly-version
index ecd2b22dcc..4b004c97ef 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-01-10
+nightly-2025-01-16

From 6d0c6c61ef759ac4bfc3b16d32e93f1b483b9365 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 20 Jan 2025 16:44:43 +0000
Subject: [PATCH 258/554] Run just check-api

---
 api/hashes/all-features.txt     |  2 +-
 api/hashes/alloc-only.txt       |  2 +-
 api/hashes/no-features.txt      |  2 +-
 api/io/alloc-only.txt           |  2 +-
 api/primitives/all-features.txt |  4 +--
 api/primitives/alloc-only.txt   |  4 +--
 api/units/all-features.txt      | 64 ++++++++++++++++-----------------
 api/units/alloc-only.txt        |  4 +--
 api/units/no-features.txt       |  4 +--
 9 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/api/hashes/all-features.txt b/api/hashes/all-features.txt
index 1f85ee2724..6a776f228d 100644
--- a/api/hashes/all-features.txt
+++ b/api/hashes/all-features.txt
@@ -1048,7 +1048,7 @@ pub struct bitcoin_hashes::siphash24::State
 pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
 pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
 pub trait bitcoin_hashes::HashEngine: core::clone::Clone
-pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + sealed::IsByteArray
+pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + bitcoin_hashes::sealed::IsByteArray
 pub trait bitcoin_hashes::sha256t::Tag
 pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
 pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
diff --git a/api/hashes/alloc-only.txt b/api/hashes/alloc-only.txt
index 93d5bf78e1..35bf80f4de 100644
--- a/api/hashes/alloc-only.txt
+++ b/api/hashes/alloc-only.txt
@@ -900,7 +900,7 @@ pub struct bitcoin_hashes::siphash24::State
 pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
 pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
 pub trait bitcoin_hashes::HashEngine: core::clone::Clone
-pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + sealed::IsByteArray
+pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + bitcoin_hashes::sealed::IsByteArray
 pub trait bitcoin_hashes::sha256t::Tag
 pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
 pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
diff --git a/api/hashes/no-features.txt b/api/hashes/no-features.txt
index e1ce225513..cd19b4663e 100644
--- a/api/hashes/no-features.txt
+++ b/api/hashes/no-features.txt
@@ -847,7 +847,7 @@ pub struct bitcoin_hashes::siphash24::State
 pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
 pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
 pub trait bitcoin_hashes::HashEngine: core::clone::Clone
-pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + sealed::IsByteArray
+pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + bitcoin_hashes::sealed::IsByteArray
 pub trait bitcoin_hashes::sha256t::Tag
 pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
 pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
diff --git a/api/io/alloc-only.txt b/api/io/alloc-only.txt
index 5cb6127948..93035f5443 100644
--- a/api/io/alloc-only.txt
+++ b/api/io/alloc-only.txt
@@ -119,7 +119,7 @@ pub fn bitcoin_io::Error::fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core
 pub fn bitcoin_io::Error::from(kind: bitcoin_io::ErrorKind) -> bitcoin_io::Error
 pub fn bitcoin_io::Error::get_ref(&self) -> core::option::Option<&(dyn core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static)>
 pub fn bitcoin_io::Error::kind(&self) -> bitcoin_io::ErrorKind
-pub fn bitcoin_io::Error::new<E: sealed::IntoBoxDynDebug>(kind: bitcoin_io::ErrorKind, error: E) -> bitcoin_io::Error
+pub fn bitcoin_io::Error::new<E: bitcoin_io::error::sealed::IntoBoxDynDebug>(kind: bitcoin_io::ErrorKind, error: E) -> bitcoin_io::Error
 pub fn bitcoin_io::ErrorKind::clone(&self) -> bitcoin_io::ErrorKind
 pub fn bitcoin_io::ErrorKind::eq(&self, other: &bitcoin_io::ErrorKind) -> bool
 pub fn bitcoin_io::ErrorKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
diff --git a/api/primitives/all-features.txt b/api/primitives/all-features.txt
index 7412ae3dcb..b2cfbe1e01 100644
--- a/api/primitives/all-features.txt
+++ b/api/primitives/all-features.txt
@@ -1975,8 +1975,8 @@ pub struct bitcoin_primitives::transaction::Version(pub i32)
 pub struct bitcoin_primitives::transaction::Wtxid(_)
 pub struct bitcoin_primitives::witness::Iter<'a>
 pub struct bitcoin_primitives::witness::Witness
-pub trait bitcoin_primitives::BlockValidation: sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
-pub trait bitcoin_primitives::block::Validation: sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::BlockValidation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::block::Validation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
 pub type &'a bitcoin_primitives::witness::Witness::IntoIter = bitcoin_primitives::witness::Iter<'a>
 pub type &'a bitcoin_primitives::witness::Witness::Item = &'a [u8]
 pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
diff --git a/api/primitives/alloc-only.txt b/api/primitives/alloc-only.txt
index 3e0f4d2b6c..1ccd74b296 100644
--- a/api/primitives/alloc-only.txt
+++ b/api/primitives/alloc-only.txt
@@ -1832,8 +1832,8 @@ pub struct bitcoin_primitives::transaction::Version(pub i32)
 pub struct bitcoin_primitives::transaction::Wtxid(_)
 pub struct bitcoin_primitives::witness::Iter<'a>
 pub struct bitcoin_primitives::witness::Witness
-pub trait bitcoin_primitives::BlockValidation: sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
-pub trait bitcoin_primitives::block::Validation: sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::BlockValidation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
+pub trait bitcoin_primitives::block::Validation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
 pub type &'a bitcoin_primitives::witness::Witness::IntoIter = bitcoin_primitives::witness::Iter<'a>
 pub type &'a bitcoin_primitives::witness::Witness::Item = &'a [u8]
 pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 0f5a1c0f2f..5dd5209117 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -811,9 +811,9 @@ pub fn bitcoin_units::Amount::arbitrary(u: &mut arbitrary::unstructured::Unstruc
 pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
 pub fn bitcoin_units::Amount::default() -> Self
-pub fn bitcoin_units::Amount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::Amount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::Amount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::Amount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::Amount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::Amount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
@@ -833,12 +833,12 @@ pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
 pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
 pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
-pub fn bitcoin_units::Amount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_str<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::Amount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
 pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
@@ -851,7 +851,7 @@ pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::Amount::type_prefix(_: private::Token) -> &'static str
+pub fn bitcoin_units::Amount::type_prefix(_: bitcoin_units::amount::serde::private::Token) -> &'static str
 pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
 pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
@@ -863,9 +863,9 @@ pub fn bitcoin_units::SignedAmount::arbitrary(u: &mut arbitrary::unstructured::U
 pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
 pub fn bitcoin_units::SignedAmount::default() -> Self
-pub fn bitcoin_units::SignedAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::SignedAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::SignedAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::SignedAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::SignedAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::SignedAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
 pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
@@ -889,12 +889,12 @@ pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::Si
 pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
 pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
 pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
-pub fn bitcoin_units::SignedAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::SignedAmount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_units::SignedAmount::signum(self) -> i64
 pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
 pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
@@ -907,7 +907,7 @@ pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amou
 pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
 pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::type_prefix(_: private::Token) -> &'static str
+pub fn bitcoin_units::SignedAmount::type_prefix(_: bitcoin_units::amount::serde::private::Token) -> &'static str
 pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
 pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
@@ -977,16 +977,16 @@ pub fn bitcoin_units::amount::UnknownDenominationError::clone(&self) -> bitcoin_
 pub fn bitcoin_units::amount::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::UnknownDenominationError) -> bool
 pub fn bitcoin_units::amount::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_units::amount::UnknownDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::serde::SerdeAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::type_prefix(_: private::Token) -> &'static str
+pub fn bitcoin_units::amount::serde::SerdeAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
+pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::type_prefix(_: bitcoin_units::amount::serde::private::Token) -> &'static str
 pub fn bitcoin_units::amount::serde::as_btc::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::as_btc::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_units::amount::serde::as_btc::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
@@ -1277,10 +1277,10 @@ pub struct bitcoin_units::locktime::relative::TimeOverflowError
 pub struct bitcoin_units::parse::PrefixedHexError(_)
 pub struct bitcoin_units::parse::UnprefixedHexError(_)
 pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
+pub trait bitcoin_units::amount::CheckedSum<R>: bitcoin_units::amount::sealed::Sealed<R>
 pub trait bitcoin_units::amount::serde::SerdeAmount: core::marker::Copy + core::marker::Sized
 pub trait bitcoin_units::amount::serde::SerdeAmountForOpt: core::marker::Copy + core::marker::Sized + bitcoin_units::amount::serde::SerdeAmount
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse::sealed::Sealed
 pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 4993726217..5caee2ba6a 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -1107,8 +1107,8 @@ pub struct bitcoin_units::locktime::relative::TimeOverflowError
 pub struct bitcoin_units::parse::PrefixedHexError(_)
 pub struct bitcoin_units::parse::UnprefixedHexError(_)
 pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
+pub trait bitcoin_units::amount::CheckedSum<R>: bitcoin_units::amount::sealed::Sealed<R>
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse::sealed::Sealed
 pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 4532ae555a..82a703c74e 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -1059,8 +1059,8 @@ pub struct bitcoin_units::locktime::relative::TimeOverflowError
 pub struct bitcoin_units::parse::PrefixedHexError(_)
 pub struct bitcoin_units::parse::UnprefixedHexError(_)
 pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: sealed::Sealed<R>
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + sealed::Sealed
+pub trait bitcoin_units::amount::CheckedSum<R>: bitcoin_units::amount::sealed::Sealed<R>
+pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse::sealed::Sealed
 pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
 pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
 pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate

From 2ca24f00f2161d6d618df2ee55d29c44ccce9359 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 22 Jan 2025 13:12:40 +0000
Subject: [PATCH 259/554] =?UTF-8?q?Add=20`=C2=B5BTC`=20as=20a=20recognized?=
 =?UTF-8?q?=20`str`=20form=20of=20`uBTC`?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`µ` is the correct letter for the SI unit micro but is not on most
standard keyboards.  `u` was used instead because it looks similar.

Add `µBTC` to the list of recognized strings for MicroBitcoin and to the
rustdocs.
---
 units/src/amount/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 8e3a92515e..732f1cc10d 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -42,7 +42,7 @@ pub use self::{
 ///
 /// # Accepted Denominations
 ///
-/// All upper or lower case, excluding SI prefix (c, m, u) which must be lower case.
+/// All upper or lower case, excluding SI prefixes c, m and u (or µ) which must be lower case.
 /// - Singular: BTC, cBTC, mBTC, uBTC
 /// - Plural or singular: sat, satoshi, bit
 ///
@@ -119,7 +119,7 @@ impl Denomination {
             "BTC" | "btc" => Some(Denomination::Bitcoin),
             "cBTC" | "cbtc" => Some(Denomination::CentiBitcoin),
             "mBTC" | "mbtc" => Some(Denomination::MilliBitcoin),
-            "uBTC" | "ubtc" => Some(Denomination::MicroBitcoin),
+            "uBTC" | "ubtc" | "µBTC" | "µbtc" => Some(Denomination::MicroBitcoin),
             "bit" | "bits" | "BIT" | "BITS" => Some(Denomination::Bit),
             "SATOSHI" | "satoshi" | "SATOSHIS" | "satoshis" | "SAT" | "sat" | "SATS" | "sats" =>
                 Some(Denomination::Satoshi),

From afba28e188c6c44e0ddd3169843be7bbc06b2f7e Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 22 Jan 2025 13:26:03 +0000
Subject: [PATCH 260/554] =?UTF-8?q?Change=20`uBTC`=20to=20`=C2=B5BTC`=20in?=
 =?UTF-8?q?=20rustdocs?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Clippy thinks `µBTC` in the docs needs backticks. Allow it without
backticks.
---
 units/src/amount/mod.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 732f1cc10d..1980a8c54f 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -67,6 +67,7 @@ pub use self::{
 /// ```
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 #[non_exhaustive]
+#[allow(clippy::doc_markdown)]
 pub enum Denomination {
     /// BTC (1 BTC = 100,000,000 satoshi).
     Bitcoin,
@@ -74,9 +75,9 @@ pub enum Denomination {
     CentiBitcoin,
     /// mBTC (1 mBTC = 100,000 satoshi).
     MilliBitcoin,
-    /// uBTC (1 uBTC = 100 satoshi).
+    /// µBTC (1 µBTC = 100 satoshi).
     MicroBitcoin,
-    /// bits (bits = uBTC).
+    /// bits (bits = µBTC).
     Bit,
     /// satoshi (1 BTC = 100,000,000 satoshi).
     Satoshi,

From 4dcdf73cfa896b2c095cda9064c6e0a0e9aeec2b Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 22 Jan 2025 13:26:36 +0000
Subject: [PATCH 261/554] =?UTF-8?q?Add=20`=C2=B5BTC`=20and=20`=C2=B5btc`?=
 =?UTF-8?q?=20to=20tests?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 units/src/amount/tests.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 42a9e3d3ca..192b1552be 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1013,8 +1013,9 @@ fn checked_sum_amounts() {
 fn denomination_string_acceptable_forms() {
     // Exhaustive list of valid forms.
     let valid = [
-        "BTC", "btc", "cBTC", "cbtc", "mBTC", "mbtc", "uBTC", "ubtc", "bit", "bits", "BIT", "BITS",
-        "SATOSHI", "satoshi", "SATOSHIS", "satoshis", "SAT", "sat", "SATS", "sats",
+        "BTC", "btc", "cBTC", "cbtc", "mBTC", "mbtc", "uBTC", "ubtc", "µBTC", "µbtc", "bit",
+        "bits", "BIT", "BITS", "SATOSHI", "satoshi", "SATOSHIS", "satoshis", "SAT", "sat", "SATS",
+        "sats",
     ];
     for denom in valid {
         assert!(denom.parse::<Denomination>().is_ok());

From 420e8c043e34817fa51939c0484ed77cb972ad46 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 23 Jan 2025 12:14:16 +0000
Subject: [PATCH 262/554] Fix mutants in units

Cargo mutant found missed mutants in the bitcoin consts in both signed
and unsigned amounts.

Add a test to check their values.
---
 units/src/amount/tests.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 94b9a54624..1404ae1083 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1230,3 +1230,12 @@ fn signed_sub_assign() {
     f -= &ssat(2);
     assert_eq!(f, ssat(1));
 }
+
+#[test]
+fn check_const() {
+    assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);
+    assert_eq!(Amount::ONE_BTC.to_sat(), 100_000_000);
+    assert_eq!(SignedAmount::FIFTY_BTC.to_sat(), SignedAmount::ONE_BTC.to_sat() * 50);
+    assert_eq!(Amount::FIFTY_BTC.to_sat(), Amount::ONE_BTC.to_sat() * 50);
+    assert_eq!(Amount::MAX_MONEY.to_sat() as i64, SignedAmount::MAX_MONEY.to_sat());
+}

From 2c73546454cf39cc4759a99ef6f1caf63b8da584 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 23 Jan 2025 18:35:21 +0000
Subject: [PATCH 263/554] Improve absolute::LockTime tests

Cargo mutants found some untested mutants.

Add test cases and refactor to improve readability.
---
 primitives/src/locktime/absolute.rs | 34 +++++++++++++++++++----------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 02196da7a6..679d3218b4 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -447,40 +447,50 @@ mod tests {
 
     #[test]
     fn parses_correctly_to_height_or_time() {
-        let lock = LockTime::from_consensus(750_000);
+        let lock_height = LockTime::from_consensus(750_000);
 
-        assert!(lock.is_block_height());
-        assert!(!lock.is_block_time());
+        assert!(lock_height.is_block_height());
+        assert!(!lock_height.is_block_time());
 
         let t: u32 = 1653195600; // May 22nd, 5am UTC.
-        let lock = LockTime::from_consensus(t);
+        let lock_time = LockTime::from_consensus(t);
+
+        assert!(!lock_time.is_block_height());
+        assert!(lock_time.is_block_time());
 
-        assert!(!lock.is_block_height());
-        assert!(lock.is_block_time());
+        // Test is_same_unit() logic
+        assert!(lock_height.is_same_unit(LockTime::from_consensus(800_000)));
+        assert!(!lock_height.is_same_unit(lock_time));
+        assert!(lock_time.is_same_unit(LockTime::from_consensus(1653282000)));
+        assert!(!lock_time.is_same_unit(lock_height));
     }
 
     #[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 height_above = Height::from_consensus(800_000).expect("failed to parse height");
+        let height_below = Height::from_consensus(700_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))
+        assert!(lock.is_satisfied_by(height_above, time));
+        assert!(!lock.is_satisfied_by(height_below, time));
     }
 
     #[test]
     fn satisfied_by_time() {
-        let lock = LockTime::from_consensus(1053195600);
+        let lock_time = LockTime::from_consensus(1653195600); // May 22nd 2022, 5am UTC.
 
-        let t: u32 = 1653195600; // May 22nd, 5am UTC.
-        let time = Time::from_consensus(t).expect("invalid time value");
+        let day_after = Time::from_consensus(1653282000).expect("May 23rd 2022, 5am UTC");
+        let day_before = Time::from_consensus(1653109200).expect("May 21th 2022, 5am UTC");
 
         let height = Height::from_consensus(800_000).expect("failed to parse height");
 
-        assert!(lock.is_satisfied_by(height, time))
+        assert!(lock_time.is_satisfied_by(height, day_after));
+        assert!(!lock_time.is_satisfied_by(height, day_before));
+
     }
 
     #[test]

From 40dc8969322f18bd2f4cb8d9a49eee0b4ed927cc Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 23 Jan 2025 18:49:04 +0000
Subject: [PATCH 264/554] Improve relative::LockTime tests

Cargo mutants found some untested mutants.

Add test cases to kill the mutants.
---
 primitives/src/locktime/relative.rs | 43 +++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 7e8d968e81..8b4a21915a 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -425,6 +425,31 @@ impl std::error::Error for IncompatibleTimeError {}
 mod tests {
     use super::*;
 
+    #[test]
+    fn parses_correctly_to_height_or_time() {
+        let height1 = Height::from(10);
+        let height2 = Height::from(11);
+        let time1 = Time::from_512_second_intervals(70);
+        let time2 = Time::from_512_second_intervals(71);
+
+        let lock_height1 = LockTime::from(height1);
+        let lock_height2 = LockTime::from(height2);
+        let lock_time1 = LockTime::from(time1);
+        let lock_time2 = LockTime::from(time2);
+
+        assert!(lock_height1.is_block_height());
+        assert!(!lock_height1.is_block_time());
+
+        assert!(!lock_time1.is_block_height());
+        assert!(lock_time1.is_block_time());
+
+        // Test is_same_unit() logic
+        assert!(lock_height1.is_same_unit(lock_height2));
+        assert!(!lock_height1.is_same_unit(lock_time1));
+        assert!(lock_time1.is_same_unit(lock_time2));
+        assert!(!lock_time1.is_same_unit(lock_height1));
+    }
+
     #[test]
     fn satisfied_by_height() {
         let height = Height::from(10);
@@ -469,6 +494,24 @@ mod tests {
         assert!(lock.is_implied_by(LockTime::from(Time::from_512_second_intervals(71))));
     }
 
+    #[test]
+    fn sequence_correctly_implies() {
+        let height = Height::from(10);
+        let time = Time::from_512_second_intervals(70);
+
+        let lock_height = LockTime::from(height);
+        let lock_time = LockTime::from(time);
+
+        let seq_height = Sequence::from(lock_height);
+        let seq_time = Sequence::from(lock_time);
+
+        assert!(lock_height.is_implied_by_sequence(seq_height));
+        assert!(!lock_height.is_implied_by_sequence(seq_time));
+
+        assert!(lock_time.is_implied_by_sequence(seq_time));
+        assert!(!lock_time.is_implied_by_sequence(seq_height));
+    }
+
     #[test]
     fn incorrect_units_do_not_imply() {
         let time = Time::from_512_second_intervals(70);

From 8e16a4825277934491d81cb1356940bdcc0534a4 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 20 Jan 2025 08:37:36 +1100
Subject: [PATCH 265/554] Run the formatter

Manually run `just fmt` - no other changes.
---
 bitcoin/src/blockdata/constants.rs |  5 +----
 units/src/amount/tests.rs          | 30 ++++++------------------------
 units/src/fee.rs                   |  4 +---
 3 files changed, 8 insertions(+), 31 deletions(-)

diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index e1f15030ce..ad8e96fdf2 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -112,10 +112,7 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
         witness: Witness::default(),
     });
 
-    ret.output.push(TxOut {
-        value: Amount::FIFTY_BTC,
-        script_pubkey: out_script,
-    });
+    ret.output.push(TxOut { value: Amount::FIFTY_BTC, script_pubkey: out_script });
 
     // end
     ret
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 94b9a54624..a37971563e 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -22,10 +22,7 @@ fn sanity_check() {
     let ssat = SignedAmount::from_sat;
 
     assert_eq!(ssat(-100).abs(), ssat(100));
-    assert_eq!(
-        ssat(i64::MIN + 1).checked_abs().unwrap(),
-        ssat(i64::MAX)
-    );
+    assert_eq!(ssat(i64::MIN + 1).checked_abs().unwrap(), ssat(i64::MAX));
     assert_eq!(ssat(-100).signum(), -1);
     assert_eq!(ssat(0).signum(), 0);
     assert_eq!(ssat(100).signum(), 1);
@@ -36,14 +33,8 @@ fn sanity_check() {
 
     #[cfg(feature = "alloc")]
     {
-        assert_eq!(
-            Amount::from_float_in(0_f64, Denomination::Bitcoin).unwrap(),
-            sat(0)
-        );
-        assert_eq!(
-            Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(),
-            sat(200_000_000)
-        );
+        assert_eq!(Amount::from_float_in(0_f64, Denomination::Bitcoin).unwrap(), sat(0));
+        assert_eq!(Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(), sat(200_000_000));
         assert!(Amount::from_float_in(-100_f64, Denomination::Bitcoin).is_err());
     }
 }
@@ -185,14 +176,8 @@ fn unchecked_arithmetic() {
     let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
-    assert_eq!(
-        ssat(10).unchecked_add(ssat(20)),
-        ssat(30)
-    );
-    assert_eq!(
-        ssat(50).unchecked_sub(ssat(10)),
-        ssat(40)
-    );
+    assert_eq!(ssat(10).unchecked_add(ssat(20)), ssat(30));
+    assert_eq!(ssat(50).unchecked_sub(ssat(10)), ssat(40));
     assert_eq!(sat(5).unchecked_add(sat(7)), sat(12));
     assert_eq!(sat(10).unchecked_sub(sat(7)), sat(3));
 }
@@ -201,10 +186,7 @@ fn unchecked_arithmetic() {
 fn positive_sub() {
     let ssat = SignedAmount::from_sat;
 
-    assert_eq!(
-        ssat(10).positive_sub(ssat(7)).unwrap(),
-        ssat(3)
-    );
+    assert_eq!(ssat(10).positive_sub(ssat(7)).unwrap(), ssat(3));
     assert!(ssat(-10).positive_sub(ssat(7)).is_none());
     assert!(ssat(10).positive_sub(ssat(-7)).is_none());
     assert!(ssat(10).positive_sub(ssat(11)).is_none());
diff --git a/units/src/fee.rs b/units/src/fee.rs
index a1475f9bd3..1f0a535b48 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -188,9 +188,7 @@ impl ops::Div<FeeRate> for Amount {
     /// This operation will panic if `fee_rate` is zero or the division results in overflow.
     ///
     /// Note: This uses floor division. For ceiling division use [`Amount::checked_div_by_fee_rate_ceil`].
-    fn div(self, rhs: FeeRate) -> Self::Output {
-        self.checked_div_by_fee_rate_floor(rhs).unwrap()
-    }
+    fn div(self, rhs: FeeRate) -> Self::Output { self.checked_div_by_fee_rate_floor(rhs).unwrap() }
 }
 
 #[cfg(test)]

From 154a4420fce5466273b492977d179b8f77b48a97 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 17 Jan 2025 10:24:45 +1100
Subject: [PATCH 266/554] Stop using FQP on Amount type

Using `crate::Amount` adds no additional information - stop doing that.

Internal change only.
---
 bitcoin/src/blockdata/script/borrowed.rs | 12 ++++++------
 bitcoin/src/blockdata/script/tests.rs    | 12 ++++++------
 bitcoin/src/consensus_validation.rs      |  4 ++--
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs
index b3a65ff964..14c32e3149 100644
--- a/bitcoin/src/blockdata/script/borrowed.rs
+++ b/bitcoin/src/blockdata/script/borrowed.rs
@@ -15,7 +15,7 @@ use crate::opcodes::{self, Opcode};
 use crate::policy::{DUST_RELAY_TX_FEE, MAX_OP_RETURN_RELAY};
 use crate::prelude::{sink, DisplayHex, String, ToString};
 use crate::taproot::{LeafVersion, TapLeafHash, TapLeafHashExt as _};
-use crate::FeeRate;
+use crate::{Amount, FeeRate};
 
 #[rustfmt::skip]            // Keep public re-exports separate.
 #[doc(inline)]
@@ -261,7 +261,7 @@ crate::internal_macros::define_extension_trait! {
         /// Returns the minimum value an output with this script should have in order to be
         /// broadcastable on today’s Bitcoin network.
         #[deprecated(since = "0.32.0", note = "use `minimal_non_dust` etc. instead")]
-        fn dust_value(&self) -> crate::Amount { self.minimal_non_dust() }
+        fn dust_value(&self) -> Amount { self.minimal_non_dust() }
 
         /// Returns the minimum value an output with this script should have in order to be
         /// broadcastable on today's Bitcoin network.
@@ -272,7 +272,7 @@ crate::internal_macros::define_extension_trait! {
         /// To use a custom value, use [`minimal_non_dust_custom`].
         ///
         /// [`minimal_non_dust_custom`]: Script::minimal_non_dust_custom
-        fn minimal_non_dust(&self) -> crate::Amount {
+        fn minimal_non_dust(&self) -> Amount {
             self.minimal_non_dust_internal(DUST_RELAY_TX_FEE.into())
         }
 
@@ -287,7 +287,7 @@ crate::internal_macros::define_extension_trait! {
         /// To use the default Bitcoin Core value, use [`minimal_non_dust`].
         ///
         /// [`minimal_non_dust`]: Script::minimal_non_dust
-        fn minimal_non_dust_custom(&self, dust_relay_fee: FeeRate) -> crate::Amount {
+        fn minimal_non_dust_custom(&self, dust_relay_fee: FeeRate) -> Amount {
             self.minimal_non_dust_internal(dust_relay_fee.to_sat_per_kwu() * 4)
         }
 
@@ -394,7 +394,7 @@ mod sealed {
 
 crate::internal_macros::define_extension_trait! {
     pub(crate) trait ScriptExtPriv impl for Script {
-        fn minimal_non_dust_internal(&self, dust_relay_fee: u64) -> crate::Amount {
+        fn minimal_non_dust_internal(&self, dust_relay_fee: u64) -> Amount {
             // This must never be lower than Bitcoin Core's GetDustThreshold() (as of v0.21) as it may
             // otherwise allow users to create transactions which likely can never be broadcast/confirmed.
             let sats = dust_relay_fee
@@ -414,7 +414,7 @@ crate::internal_macros::define_extension_trait! {
                         // Note: We ensure the division happens at the end, since Core performs the division at the end.
                         //       This will make sure none of the implicit floor operations mess with the value.
 
-            crate::Amount::from_sat(sats)
+            Amount::from_sat(sats)
         }
 
         fn count_sigops_internal(&self, accurate: bool) -> usize {
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index b14ec86f47..4085085d2f 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -9,7 +9,7 @@ use crate::address::script_pubkey::{
 };
 use crate::consensus::encode::{deserialize, serialize};
 use crate::crypto::key::{PublicKey, XOnlyPublicKey};
-use crate::FeeRate;
+use crate::{Amount, FeeRate};
 
 #[test]
 #[rustfmt::skip]
@@ -676,7 +676,7 @@ fn bitcoinconsensus() {
     let spent_bytes = hex!("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d");
     let spent = Script::from_bytes(&spent_bytes);
     let spending = hex!("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000");
-    spent.verify(0, crate::Amount::from_sat_unchecked(18393430), &spending).unwrap();
+    spent.verify(0, Amount::from_sat_unchecked(18393430), &spending).unwrap();
 }
 
 #[test]
@@ -685,10 +685,10 @@ fn default_dust_value() {
     // well-known scriptPubKey types.
     let script_p2wpkh = Builder::new().push_int_unchecked(0).push_slice([42; 20]).into_script();
     assert!(script_p2wpkh.is_p2wpkh());
-    assert_eq!(script_p2wpkh.minimal_non_dust(), crate::Amount::from_sat_unchecked(294));
+    assert_eq!(script_p2wpkh.minimal_non_dust(), Amount::from_sat_unchecked(294));
     assert_eq!(
         script_p2wpkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
-        crate::Amount::from_sat_unchecked(588)
+        Amount::from_sat_unchecked(588)
     );
 
     let script_p2pkh = Builder::new()
@@ -699,10 +699,10 @@ fn default_dust_value() {
         .push_opcode(OP_CHECKSIG)
         .into_script();
     assert!(script_p2pkh.is_p2pkh());
-    assert_eq!(script_p2pkh.minimal_non_dust(), crate::Amount::from_sat_unchecked(546));
+    assert_eq!(script_p2pkh.minimal_non_dust(), Amount::from_sat_unchecked(546));
     assert_eq!(
         script_p2pkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
-        crate::Amount::from_sat_unchecked(1092)
+        Amount::from_sat_unchecked(1092)
     );
 }
 
diff --git a/bitcoin/src/consensus_validation.rs b/bitcoin/src/consensus_validation.rs
index b461374d15..e80994f905 100644
--- a/bitcoin/src/consensus_validation.rs
+++ b/bitcoin/src/consensus_validation.rs
@@ -134,7 +134,7 @@ define_extension_trait! {
         fn verify(
             &self,
             index: usize,
-            amount: crate::Amount,
+            amount: Amount,
             spending_tx: &[u8],
         ) -> Result<(), BitcoinconsensusError> {
             verify_script(self, index, amount, spending_tx)
@@ -153,7 +153,7 @@ define_extension_trait! {
         fn verify_with_flags(
             &self,
             index: usize,
-            amount: crate::Amount,
+            amount: Amount,
             spending_tx: &[u8],
             flags: impl Into<u32>,
         ) -> Result<(), BitcoinconsensusError> {

From dbec9807f9adb6a3c0356cd4bc1ad25ec0d9857a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 17 Jan 2025 10:30:02 +1100
Subject: [PATCH 267/554] Shorten identifiers by removing _in_sats

Using `_in_sats` is not meaningful because an `Amount` is an amount,
period.

Remove `_in_sats` and `_IN_SATS` from identifiers.

Internal change only.
---
 bitcoin/examples/taproot-psbt.rs | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index d75b4e14f5..1d712ed1b1 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -40,7 +40,7 @@ const UTXO_SCRIPT_PUBKEY: &str =
     "5120be27fa8b1f5278faf82cab8da23e8761f8f9bd5d5ebebbb37e0e12a70d92dd16";
 const UTXO_PUBKEY: &str = "a6ac32163539c16b6b5dbbca01b725b8e8acaa5f821ba42c80e7940062140d19";
 const UTXO_MASTER_FINGERPRINT: &str = "e61b318f";
-const ABSOLUTE_FEES_IN_SATS: Amount = Amount::from_sat_unchecked(1_000);
+const ABSOLUTE_FEES: Amount = Amount::from_sat_unchecked(1_000);
 
 // UTXO_1 will be used for spending example 1
 const UTXO_1: P2trUtxo = P2trUtxo {
@@ -49,7 +49,7 @@ const UTXO_1: P2trUtxo = P2trUtxo {
     script_pubkey: UTXO_SCRIPT_PUBKEY,
     pubkey: UTXO_PUBKEY,
     master_fingerprint: UTXO_MASTER_FINGERPRINT,
-    amount_in_sats: Amount::FIFTY_BTC,
+    amount: Amount::FIFTY_BTC,
     derivation_path: BIP86_DERIVATION_PATH,
 };
 
@@ -60,7 +60,7 @@ const UTXO_2: P2trUtxo = P2trUtxo {
     script_pubkey: UTXO_SCRIPT_PUBKEY,
     pubkey: UTXO_PUBKEY,
     master_fingerprint: UTXO_MASTER_FINGERPRINT,
-    amount_in_sats: Amount::FIFTY_BTC,
+    amount: Amount::FIFTY_BTC,
     derivation_path: BIP86_DERIVATION_PATH,
 };
 
@@ -71,7 +71,7 @@ const UTXO_3: P2trUtxo = P2trUtxo {
     script_pubkey: UTXO_SCRIPT_PUBKEY,
     pubkey: UTXO_PUBKEY,
     master_fingerprint: UTXO_MASTER_FINGERPRINT,
-    amount_in_sats: Amount::FIFTY_BTC,
+    amount: Amount::FIFTY_BTC,
     derivation_path: BIP86_DERIVATION_PATH,
 };
 
@@ -106,11 +106,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let change_address = "bcrt1pz449kexzydh2kaypatup5ultru3ej284t6eguhnkn6wkhswt0l7q3a7j76"
         .parse::<Address<_>>()?
         .require_network(Network::Regtest)?;
-    let amount_to_send_in_sats = Amount::ONE_BTC;
+    let amount_to_send = Amount::ONE_BTC;
     let change_amount = UTXO_1
-        .amount_in_sats
-        .checked_sub(amount_to_send_in_sats)
-        .and_then(|x| x.checked_sub(ABSOLUTE_FEES_IN_SATS))
+        .amount
+        .checked_sub(amount_to_send)
+        .and_then(|x| x.checked_sub(ABSOLUTE_FEES))
         .ok_or("fees more than input amount!")?;
 
     let tx_hex_string = encode::serialize_hex(&generate_bip86_key_spend_tx(
@@ -120,7 +120,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         // Set these fields with valid data for the UTXO from step 5 above
         UTXO_1,
         vec![
-            TxOut { value: amount_to_send_in_sats, script_pubkey: to_address.script_pubkey() },
+            TxOut { value: amount_to_send, script_pubkey: to_address.script_pubkey() },
             TxOut { value: change_amount, script_pubkey: change_address.script_pubkey() },
         ],
     )?);
@@ -215,7 +215,7 @@ struct P2trUtxo<'a> {
     script_pubkey: &'a str,
     pubkey: &'a str,
     master_fingerprint: &'a str,
-    amount_in_sats: Amount,
+    amount: Amount,
     derivation_path: &'a str,
 }
 
@@ -226,7 +226,7 @@ fn generate_bip86_key_spend_tx(
     input_utxo: P2trUtxo,
     outputs: Vec<TxOut>,
 ) -> Result<Transaction, Box<dyn std::error::Error>> {
-    let from_amount = input_utxo.amount_in_sats;
+    let from_amount = input_utxo.amount;
     let input_pubkey = input_utxo.pubkey.parse::<XOnlyPublicKey>()?;
 
     // CREATOR + UPDATER
@@ -274,7 +274,7 @@ fn generate_bip86_key_spend_tx(
     let mut input_txouts = Vec::<TxOut>::new();
     for input in [&input_utxo].iter() {
         input_txouts.push(TxOut {
-            value: input.amount_in_sats,
+            value: input.amount,
             script_pubkey: ScriptBuf::from_hex(input.script_pubkey)?,
         });
     }
@@ -412,7 +412,7 @@ impl BenefactorWallet {
             taproot_spend_info.internal_key(),
             taproot_spend_info.merkle_root(),
         );
-        let value = input_utxo.amount_in_sats - ABSOLUTE_FEES_IN_SATS;
+        let value = input_utxo.amount - ABSOLUTE_FEES;
 
         // Spend a normal BIP86-like output as an input in our inheritance funding transaction
         let tx = generate_bip86_key_spend_tx(
@@ -476,7 +476,7 @@ impl BenefactorWallet {
             let mut psbt = self.next_psbt.clone().expect("should have next_psbt");
             let input = &mut psbt.inputs[0];
             let input_value = input.witness_utxo.as_ref().unwrap().value;
-            let output_value = input_value - ABSOLUTE_FEES_IN_SATS;
+            let output_value = input_value - ABSOLUTE_FEES;
 
             // We use some other derivation path in this example for our inheritance protocol. The important thing is to ensure
             // that we use an unhardened path so we can make use of xpubs.
@@ -649,7 +649,7 @@ impl BeneficiaryWallet {
         psbt.unsigned_tx.lock_time = lock_time;
         psbt.unsigned_tx.output = vec![TxOut {
             script_pubkey: to_address.script_pubkey(),
-            value: input_value - ABSOLUTE_FEES_IN_SATS,
+            value: input_value - ABSOLUTE_FEES,
         }];
         psbt.outputs = vec![Output::default()];
         let unsigned_tx = psbt.unsigned_tx.clone();

From f3e853e07a207bef1e63e4a5752c4af1bfc722b6 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 23 Jan 2025 14:43:11 +1100
Subject: [PATCH 268/554] units: Do trivial refactor of amount::tests

We are trying to make changes to `units::amount` but the diff is too
big - do the remove-whitespace change on its own.

Whitespace only.
---
 units/src/amount/tests.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index a37971563e..82a966912e 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -576,9 +576,7 @@ fn unsigned_signed_conversion() {
     let max_sats: u64 = Amount::MAX.to_sat();
 
     assert_eq!(ua(max_sats).to_signed(), sa(max_sats as i64));
-
     assert_eq!(sa(max_sats as i64).to_unsigned(), Ok(ua(max_sats)));
-
     assert_eq!(sa(max_sats as i64).to_unsigned().unwrap().to_signed(), sa(max_sats as i64));
 }
 

From c6f056672b20aa8970a544e5e7750d8e1c3a0fef Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 24 Jan 2025 08:56:58 +1100
Subject: [PATCH 269/554] Change local var sa to ssat

Match other identifiers in the `amount` test module. Only done for the
signed amount to make review brain dead easy.
---
 units/src/amount/tests.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 82a966912e..034a80ee51 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -571,13 +571,13 @@ check_format_non_negative_show_denom! {
 
 #[test]
 fn unsigned_signed_conversion() {
-    let sa = SignedAmount::from_sat;
+    let ssat = SignedAmount::from_sat;
     let ua = Amount::from_sat;
     let max_sats: u64 = Amount::MAX.to_sat();
 
-    assert_eq!(ua(max_sats).to_signed(), sa(max_sats as i64));
-    assert_eq!(sa(max_sats as i64).to_unsigned(), Ok(ua(max_sats)));
-    assert_eq!(sa(max_sats as i64).to_unsigned().unwrap().to_signed(), sa(max_sats as i64));
+    assert_eq!(ua(max_sats).to_signed(), ssat(max_sats as i64));
+    assert_eq!(ssat(max_sats as i64).to_unsigned(), Ok(ua(max_sats)));
+    assert_eq!(ssat(max_sats as i64).to_unsigned().unwrap().to_signed(), ssat(max_sats as i64));
 }
 
 #[test]

From 8fdec67f7dbf0d6a1766247168db8b53b8fb672c Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 24 Jan 2025 08:58:54 +1100
Subject: [PATCH 270/554] Change local var ua to sat

As we did for the signed amount; match other identifiers in the `amount`
test module.
---
 units/src/amount/tests.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 034a80ee51..27d5607fe9 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -572,11 +572,11 @@ check_format_non_negative_show_denom! {
 #[test]
 fn unsigned_signed_conversion() {
     let ssat = SignedAmount::from_sat;
-    let ua = Amount::from_sat;
+    let sat = Amount::from_sat;
     let max_sats: u64 = Amount::MAX.to_sat();
 
-    assert_eq!(ua(max_sats).to_signed(), ssat(max_sats as i64));
-    assert_eq!(ssat(max_sats as i64).to_unsigned(), Ok(ua(max_sats)));
+    assert_eq!(sat(max_sats).to_signed(), ssat(max_sats as i64));
+    assert_eq!(ssat(max_sats as i64).to_unsigned(), Ok(sat(max_sats)));
     assert_eq!(ssat(max_sats as i64).to_unsigned().unwrap().to_signed(), ssat(max_sats as i64));
 }
 

From 00b71a670fcedeca255e69fe5e3d08e5a9d1b72e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 24 Jan 2025 09:05:00 +1100
Subject: [PATCH 271/554] Use from_sat_unchecked for hardcoded ints

We have an `_unchecked` amount constructor that makes no assumptions
about the argument. We would like to start enforcing MAX_MONEY but the
diff to introduce this is massive. In an effort to make it smaller we
can do all the hardcoded ints first. We did this already but a bunch
more snuck in or were missed.

In any amount constructor that passes in a hardcoded const as a decimal
integer (i.e., not hex) use the `_unchecked` version.

Done in preparation for enforcing MAX_MONEY.
---
 bitcoin/examples/sighash.rs |  4 ++--
 units/src/amount/tests.rs   |  6 +++---
 units/src/fee.rs            | 18 +++++++++---------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index 15439b46cd..4f1f4d441a 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -148,7 +148,7 @@ fn sighash_p2wpkh() {
     let inp_idx = 0;
     //output value from the referenced vout:0 from the referenced tx:
     //bitcoin-cli getrawtransaction 752d675b9cc0bd14e0bd23969effee0005ad6d7e550dcc832f0216c7ffd4e15c  3
-    let ref_out_value = Amount::from_sat(200000000);
+    let ref_out_value = Amount::from_sat_unchecked(200000000);
 
     println!("\nsighash_p2wpkh:");
     compute_sighash_p2wpkh(&raw_tx, inp_idx, ref_out_value);
@@ -178,7 +178,7 @@ fn sighash_p2wsh_multisig_2x2() {
     //For the witness transaction sighash computation, we need its referenced output's value from the original transaction:
     //bitcoin-cli getrawtransaction 2845399a8cd7a52733f9f9d0e0b8b6c5d1c88aea4cee09f8d8fa762912b49e1b  3
     //we need vout 0 value in sats:
-    let ref_out_value = Amount::from_sat(968240);
+    let ref_out_value = Amount::from_sat_unchecked(968240);
 
     println!("\nsighash_p2wsh_multisig_2x2:");
     compute_sighash_p2wsh(&raw_tx, 0, ref_out_value);
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 27d5607fe9..33eeb5f8de 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -142,7 +142,7 @@ fn mul_div() {
 
 #[test]
 fn neg() {
-    let amount = -SignedAmount::from_sat(2);
+    let amount = -SignedAmount::from_sat_unchecked(2);
     assert_eq!(amount.to_sat(), -2);
 }
 
@@ -231,7 +231,7 @@ fn amount_checked_div_by_weight_floor() {
 #[cfg(feature = "alloc")]
 #[test]
 fn amount_checked_div_by_fee_rate() {
-    let amount = Amount::from_sat(1000);
+    let amount = Amount::from_sat_unchecked(1000);
     let fee_rate = FeeRate::from_sat_per_kwu(2);
 
     // Test floor division
@@ -244,7 +244,7 @@ fn amount_checked_div_by_fee_rate() {
     assert_eq!(weight, Weight::from_wu(500_000)); // Same result for exact division
 
     // Test truncation behavior
-    let amount = Amount::from_sat(1000);
+    let amount = Amount::from_sat_unchecked(1000);
     let fee_rate = FeeRate::from_sat_per_kwu(3);
     let floor_weight = amount.checked_div_by_fee_rate_floor(fee_rate).unwrap();
     let ceil_weight = amount.checked_div_by_fee_rate_ceil(fee_rate).unwrap();
diff --git a/units/src/fee.rs b/units/src/fee.rs
index 1f0a535b48..8333992798 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -197,7 +197,7 @@ mod tests {
 
     #[test]
     fn fee_rate_div_by_weight() {
-        let fee_rate = Amount::from_sat(329) / Weight::from_wu(381);
+        let fee_rate = Amount::from_sat_unchecked(329) / Weight::from_wu(381);
         assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
     }
 
@@ -208,7 +208,7 @@ mod tests {
 
         let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
         let weight = Weight::from_vb(3).unwrap();
-        assert_eq!(fee_rate.fee_wu(weight).unwrap(), Amount::from_sat(6));
+        assert_eq!(fee_rate.fee_wu(weight).unwrap(), Amount::from_sat_unchecked(6));
     }
 
     #[test]
@@ -217,7 +217,7 @@ mod tests {
         assert!(fee_overflow.is_none());
 
         let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
-        assert_eq!(fee_rate.fee_vb(3).unwrap(), Amount::from_sat(6));
+        assert_eq!(fee_rate.fee_vb(3).unwrap(), Amount::from_sat_unchecked(6));
     }
 
     #[test]
@@ -227,7 +227,7 @@ mod tests {
             .unwrap()
             .checked_mul_by_weight(weight)
             .expect("expected Amount");
-        assert_eq!(Amount::from_sat(100), fee);
+        assert_eq!(Amount::from_sat_unchecked(100), fee);
 
         let fee = FeeRate::from_sat_per_kwu(10).checked_mul_by_weight(Weight::MAX);
         assert!(fee.is_none());
@@ -235,14 +235,14 @@ mod tests {
         let weight = Weight::from_vb(3).unwrap();
         let fee_rate = FeeRate::from_sat_per_vb(3).unwrap();
         let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
-        assert_eq!(Amount::from_sat(9), fee);
+        assert_eq!(Amount::from_sat_unchecked(9), fee);
 
         let weight = Weight::from_wu(381);
         let fee_rate = FeeRate::from_sat_per_kwu(864);
         let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
         // 381 * 0.864 yields 329.18.
         // The result is then rounded up to 330.
-        assert_eq!(fee, Amount::from_sat(330));
+        assert_eq!(fee, Amount::from_sat_unchecked(330));
     }
 
     #[test]
@@ -250,7 +250,7 @@ mod tests {
     fn multiply() {
         let two = FeeRate::from_sat_per_vb(2).unwrap();
         let three = Weight::from_vb(3).unwrap();
-        let six = Amount::from_sat(6);
+        let six = Amount::from_sat_unchecked(6);
 
         assert_eq!(two * three, six);
     }
@@ -258,13 +258,13 @@ mod tests {
     #[test]
     fn amount_div_by_fee_rate() {
         // Test exact division
-        let amount = Amount::from_sat(1000);
+        let amount = Amount::from_sat_unchecked(1000);
         let fee_rate = FeeRate::from_sat_per_kwu(2);
         let weight = amount / fee_rate;
         assert_eq!(weight, Weight::from_wu(500_000));
 
         // Test truncation behavior
-        let amount = Amount::from_sat(1000);
+        let amount = Amount::from_sat_unchecked(1000);
         let fee_rate = FeeRate::from_sat_per_kwu(3);
         let weight = amount / fee_rate;
         // 1000 * 1000 = 1,000,000 msats

From 5f75bfaa63309c7526136d430ca8092197ab7c8e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 24 Jan 2025 09:26:46 +1100
Subject: [PATCH 272/554] Improve examples on Denomination

Reduce the noise in the examples.
---
 units/src/amount/mod.rs | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 1980a8c54f..b290c625fd 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -58,12 +58,20 @@ pub use self::{
 /// ```
 /// # use bitcoin_units::Amount;
 ///
-/// assert_eq!("1 BTC".parse::<Amount>().unwrap(), Amount::from_sat(100_000_000));
-/// assert_eq!("1 cBTC".parse::<Amount>().unwrap(), Amount::from_sat(1_000_000));
-/// assert_eq!("1 mBTC".parse::<Amount>().unwrap(), Amount::from_sat(100_000));
-/// assert_eq!("1 uBTC".parse::<Amount>().unwrap(), Amount::from_sat(100));
-/// assert_eq!("1 bit".parse::<Amount>().unwrap(), Amount::from_sat(100));
-/// assert_eq!("1 sat".parse::<Amount>().unwrap(), Amount::from_sat(1));
+/// let equal = [
+///     ("1 BTC", 100_000_000),
+///     ("1 cBTC", 1_000_000),
+///     ("1 mBTC", 100_000),
+///     ("1 uBTC", 100),
+///     ("1 bit", 100),
+///     ("1 sat", 1),
+/// ];
+/// for (string, sats) in equal {
+///     assert_eq!(
+///         string.parse::<Amount>().expect("valid bitcoin amount string"),
+///         Amount::from_sat(sats),
+///     )
+/// }
 /// ```
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 #[non_exhaustive]

From 08bb57e4995602fef5c5b771c98a76b98a7bb652 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 24 Jan 2025 09:17:24 +1100
Subject: [PATCH 273/554] Use MAX_MONEY in serde regression test

We plan on enforcing MAX_MONEY in the amount types. In preparation use
MAX_MONEY in the serde regression test instead of the arbitrary, and too
large DEADBEEFCAFEBABE value.
---
 bitcoin/tests/data/serde/txout_bincode | Bin 19 -> 19 bytes
 bitcoin/tests/serde.rs                 |   6 ++----
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/bitcoin/tests/data/serde/txout_bincode b/bitcoin/tests/data/serde/txout_bincode
index 2c3d2077743b014009c2f5b98d33fb263287c688..1bbd8c3317b4fed1310bbed89e13e21e313435ee 100644
GIT binary patch
literal 19
UcmZQ@V2}Dx%Fe*d00oRp03V<N6aWAK

literal 19
VcmdnD>))yO`_|rLW`F`lCIDo527dqm

diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
index f28c878d5a..807f838a6e 100644
--- a/bitcoin/tests/serde.rs
+++ b/bitcoin/tests/serde.rs
@@ -109,10 +109,8 @@ fn serde_regression_txin() {
 
 #[test]
 fn serde_regression_txout() {
-    let txout = TxOut {
-        value: Amount::from_sat(0xDEADBEEFCAFEBABE),
-        script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]),
-    };
+    let txout =
+        TxOut { value: Amount::MAX_MONEY, 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)

From 34e3049ae0ebe15f24be771f0ece3c72ee46ce5c Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 24 Jan 2025 11:36:32 +1100
Subject: [PATCH 274/554] Use sats instead of satoshi

No one says that, just use `sats`.

Internal change only.
---
 units/src/amount/unsigned.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index d3c4949213..0cc4a43560 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -152,19 +152,19 @@ impl Amount {
     ///
     /// If the amount is too big, too precise or negative.
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<Amount, ParseAmountError> {
-        let (negative, satoshi) =
+        let (negative, sats) =
             parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(false))?;
         if negative {
             return Err(ParseAmountError(ParseAmountErrorInner::OutOfRange(
                 OutOfRangeError::negative(),
             )));
         }
-        if satoshi > Self::MAX.0 {
+        if sats > Self::MAX.0 {
             return Err(ParseAmountError(ParseAmountErrorInner::OutOfRange(
                 OutOfRangeError::too_big(false),
             )));
         }
-        Ok(Amount::from_sat(satoshi))
+        Ok(Amount::from_sat(sats))
     }
 
     /// Parses amounts with denomination suffix as produced by [`Self::to_string_with_denomination`]

From 13a3f490b80e4c8f8e1753111a914315eefd73e6 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 24 Jan 2025 11:54:24 +1100
Subject: [PATCH 275/554] Use Self instead of amount type

I claim that if the two amount modules are coded as similarly as
possible it will be easier to ensure that we have the API's uniform and
bug free. To make auditing the modules easier and less error prone use
`Self` instead of the explicit type. This makes it easier to see
differences in the modules and to ensure the differences are correct and
required.

Internal change, no logic changes whatsoever.
---
 units/src/amount/signed.rs   | 24 ++++++++++++------------
 units/src/amount/unsigned.rs | 24 ++++++++++++------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 82a07fa051..aece125bd0 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -109,7 +109,7 @@ impl SignedAmount {
     /// ```
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<SignedAmount, ParseAmountError> {
-        SignedAmount::from_float_in(btc, Denomination::Bitcoin)
+        Self::from_float_in(btc, Denomination::Bitcoin)
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`].
@@ -120,7 +120,7 @@ impl SignedAmount {
     /// per bitcoin overflows an `i64` type.
     pub fn from_int_btc<T: Into<i64>>(whole_bitcoin: T) -> Result<SignedAmount, OutOfRangeError> {
         match whole_bitcoin.into().checked_mul(100_000_000) {
-            Some(amount) => Ok(SignedAmount::from_sat(amount)),
+            Some(amount) => Ok(Self::from_sat(amount)),
             None => Err(OutOfRangeError { is_signed: true, is_greater_than_max: true }),
         }
     }
@@ -180,7 +180,7 @@ impl SignedAmount {
     /// ```
     pub fn from_str_with_denomination(s: &str) -> Result<SignedAmount, ParseError> {
         let (amt, denom) = split_amount_and_denomination(s)?;
-        SignedAmount::from_str_in(amt, denom).map_err(Into::into)
+        Self::from_str_in(amt, denom).map_err(Into::into)
     }
 
     /// Expresses this [`SignedAmount`] as a floating-point value in the given [`Denomination`].
@@ -228,7 +228,7 @@ impl SignedAmount {
     ) -> 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)
+        Self::from_str_in(&value.to_string(), denom)
     }
 
     /// Constructs a new object that implements [`fmt::Display`] in the given [`Denomination`].
@@ -548,14 +548,14 @@ impl FromStr for SignedAmount {
     ///
     /// If the returned value would be zero or negative zero, then no denomination is required.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let result = SignedAmount::from_str_with_denomination(s);
+        let result = Self::from_str_with_denomination(s);
 
         match result {
             Err(ParseError(ParseErrorInner::MissingDenomination(_))) => {
-                let d = SignedAmount::from_str_in(s, Denomination::Satoshi);
+                let d = Self::from_str_in(s, Denomination::Satoshi);
 
-                if d == Ok(SignedAmount::ZERO) {
-                    Ok(SignedAmount::ZERO)
+                if d == Ok(Self::ZERO) {
+                    Ok(Self::ZERO)
                 } else {
                     result
                 }
@@ -568,14 +568,14 @@ impl FromStr for SignedAmount {
 impl From<Amount> for SignedAmount {
     fn from(value: Amount) -> Self {
         let v = value.to_sat() as i64; // Cast ok, signed amount and amount share positive range.
-        SignedAmount::from_sat_unchecked(v)
+        Self::from_sat_unchecked(v)
     }
 }
 
 impl core::iter::Sum for SignedAmount {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
         let sats: i64 = iter.map(|amt| amt.0).sum();
-        SignedAmount::from_sat(sats)
+        Self::from_sat(sats)
     }
 }
 
@@ -585,7 +585,7 @@ impl<'a> core::iter::Sum<&'a SignedAmount> for SignedAmount {
         I: Iterator<Item = &'a SignedAmount>,
     {
         let sats: i64 = iter.map(|amt| amt.0).sum();
-        SignedAmount::from_sat(sats)
+        Self::from_sat(sats)
     }
 }
 
@@ -593,6 +593,6 @@ impl<'a> core::iter::Sum<&'a SignedAmount> for SignedAmount {
 impl<'a> Arbitrary<'a> for SignedAmount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let s = i64::arbitrary(u)?;
-        Ok(SignedAmount(s))
+        Ok(Self(s))
     }
 }
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 0cc4a43560..e80f5c6b72 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -112,7 +112,7 @@ impl Amount {
     /// ```
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<Amount, ParseAmountError> {
-        Amount::from_float_in(btc, Denomination::Bitcoin)
+        Self::from_float_in(btc, Denomination::Bitcoin)
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`].
@@ -123,7 +123,7 @@ impl Amount {
     /// per bitcoin overflows a `u64` type.
     pub fn from_int_btc<T: Into<u64>>(whole_bitcoin: T) -> Result<Amount, OutOfRangeError> {
         match whole_bitcoin.into().checked_mul(100_000_000) {
-            Some(amount) => Ok(Amount::from_sat(amount)),
+            Some(amount) => Ok(Self::from_sat(amount)),
             None => Err(OutOfRangeError { is_signed: false, is_greater_than_max: true }),
         }
     }
@@ -164,7 +164,7 @@ impl Amount {
                 OutOfRangeError::too_big(false),
             )));
         }
-        Ok(Amount::from_sat(sats))
+        Ok(Self::from_sat(sats))
     }
 
     /// Parses amounts with denomination suffix as produced by [`Self::to_string_with_denomination`]
@@ -186,7 +186,7 @@ impl Amount {
     /// ```
     pub fn from_str_with_denomination(s: &str) -> Result<Amount, ParseError> {
         let (amt, denom) = split_amount_and_denomination(s)?;
-        Amount::from_str_in(amt, denom).map_err(Into::into)
+        Self::from_str_in(amt, denom).map_err(Into::into)
     }
 
     /// Expresses this [`Amount`] as a floating-point value in the given [`Denomination`].
@@ -234,7 +234,7 @@ impl Amount {
         }
         // 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)
+        Self::from_str_in(&value.to_string(), denom)
     }
 
     /// Constructs a new object that implements [`fmt::Display`] in the given [`Denomination`].
@@ -483,14 +483,14 @@ impl FromStr for Amount {
     ///
     /// If the returned value would be zero or negative zero, then no denomination is required.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let result = Amount::from_str_with_denomination(s);
+        let result = Self::from_str_with_denomination(s);
 
         match result {
             Err(ParseError(ParseErrorInner::MissingDenomination(_))) => {
-                let d = Amount::from_str_in(s, Denomination::Satoshi);
+                let d = Self::from_str_in(s, Denomination::Satoshi);
 
-                if d == Ok(Amount::ZERO) {
-                    Ok(Amount::ZERO)
+                if d == Ok(Self::ZERO) {
+                    Ok(Self::ZERO)
                 } else {
                     result
                 }
@@ -509,7 +509,7 @@ impl TryFrom<SignedAmount> for Amount {
 impl core::iter::Sum for Amount {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
         let sats: u64 = iter.map(|amt| amt.0).sum();
-        Amount::from_sat(sats)
+        Self::from_sat(sats)
     }
 }
 
@@ -519,7 +519,7 @@ impl<'a> core::iter::Sum<&'a Amount> for Amount {
         I: Iterator<Item = &'a Amount>,
     {
         let sats: u64 = iter.map(|amt| amt.0).sum();
-        Amount::from_sat(sats)
+        Self::from_sat(sats)
     }
 }
 
@@ -527,6 +527,6 @@ impl<'a> core::iter::Sum<&'a Amount> for Amount {
 impl<'a> Arbitrary<'a> for Amount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let a = u64::arbitrary(u)?;
-        Ok(Amount(a))
+        Ok(Self(a))
     }
 }

From 4dad4730a81f9f08a565f196e5699f054e28f977 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 25 Jan 2025 06:51:26 +1100
Subject: [PATCH 276/554] Add unreleased changelog entry

We want to be sure to mention the new MAX_MONEY invariant and the fact
that we silently broke serde while doing it.
---
 bitcoin/CHANGELOG.md | 6 ++++++
 units/CHANGELOG.md   | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/bitcoin/CHANGELOG.md b/bitcoin/CHANGELOG.md
index 203e3967bc..3684890090 100644
--- a/bitcoin/CHANGELOG.md
+++ b/bitcoin/CHANGELOG.md
@@ -1,3 +1,9 @@
+# Unreleased
+
+- TODO: Make a comment about `Amount::MAX_MONEY` (perhaps here in `bitcoin` release notes as well as in `amount`)
+
+- Use MAX_MONEY in serde regression test [#3950](https://github.com/rust-bitcoin/rust-bitcoin/pull/3950)
+
 # 0.33.0-alpha.0 - 2024-11-18
 
 This series of alpha releases is meant for two things:
diff --git a/units/CHANGELOG.md b/units/CHANGELOG.md
index dbb1bab813..c2f6a470f9 100644
--- a/units/CHANGELOG.md
+++ b/units/CHANGELOG.md
@@ -1,3 +1,9 @@
+# Unreleased
+
+- TODO: Make a comment about `Amount::MAX_MONEY` including breaking serde
+
+- Use MAX_MONEY in serde regression test [#3950](https://github.com/rust-bitcoin/rust-bitcoin/pull/3950)
+
 # 0.2.0 - 2024-09-18
 
 * Bump MSRV to 1.63.0 [#3100](https://github.com/rust-bitcoin/rust-bitcoin/pull/3100)

From 75303b331eb0dfb159882b71d9dfa4c4235dcbbf Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 25 Jan 2025 01:34:42 +0000
Subject: [PATCH 277/554] Automated update to Github CI to rustc
 nightly-2025-01-24

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 4b004c97ef..b085f16de2 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-01-16
+nightly-2025-01-24

From a3d2b2a93ac8daecb9dc6670c2dcccd24d428b28 Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 26 Jan 2025 01:16:37 +0000
Subject: [PATCH 278/554] 2025-01-26 automated rustfmt nightly

---
 bitcoin/src/blockdata/constants.rs  |  5 +----
 primitives/src/locktime/absolute.rs |  1 -
 units/src/amount/tests.rs           | 30 ++++++-----------------------
 units/src/fee.rs                    |  4 +---
 4 files changed, 8 insertions(+), 32 deletions(-)

diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index e1f15030ce..ad8e96fdf2 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -112,10 +112,7 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
         witness: Witness::default(),
     });
 
-    ret.output.push(TxOut {
-        value: Amount::FIFTY_BTC,
-        script_pubkey: out_script,
-    });
+    ret.output.push(TxOut { value: Amount::FIFTY_BTC, script_pubkey: out_script });
 
     // end
     ret
diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 679d3218b4..8a3fc0a1e0 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -490,7 +490,6 @@ mod tests {
 
         assert!(lock_time.is_satisfied_by(height, day_after));
         assert!(!lock_time.is_satisfied_by(height, day_before));
-
     }
 
     #[test]
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 1404ae1083..031526ad4d 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -22,10 +22,7 @@ fn sanity_check() {
     let ssat = SignedAmount::from_sat;
 
     assert_eq!(ssat(-100).abs(), ssat(100));
-    assert_eq!(
-        ssat(i64::MIN + 1).checked_abs().unwrap(),
-        ssat(i64::MAX)
-    );
+    assert_eq!(ssat(i64::MIN + 1).checked_abs().unwrap(), ssat(i64::MAX));
     assert_eq!(ssat(-100).signum(), -1);
     assert_eq!(ssat(0).signum(), 0);
     assert_eq!(ssat(100).signum(), 1);
@@ -36,14 +33,8 @@ fn sanity_check() {
 
     #[cfg(feature = "alloc")]
     {
-        assert_eq!(
-            Amount::from_float_in(0_f64, Denomination::Bitcoin).unwrap(),
-            sat(0)
-        );
-        assert_eq!(
-            Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(),
-            sat(200_000_000)
-        );
+        assert_eq!(Amount::from_float_in(0_f64, Denomination::Bitcoin).unwrap(), sat(0));
+        assert_eq!(Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(), sat(200_000_000));
         assert!(Amount::from_float_in(-100_f64, Denomination::Bitcoin).is_err());
     }
 }
@@ -185,14 +176,8 @@ fn unchecked_arithmetic() {
     let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
-    assert_eq!(
-        ssat(10).unchecked_add(ssat(20)),
-        ssat(30)
-    );
-    assert_eq!(
-        ssat(50).unchecked_sub(ssat(10)),
-        ssat(40)
-    );
+    assert_eq!(ssat(10).unchecked_add(ssat(20)), ssat(30));
+    assert_eq!(ssat(50).unchecked_sub(ssat(10)), ssat(40));
     assert_eq!(sat(5).unchecked_add(sat(7)), sat(12));
     assert_eq!(sat(10).unchecked_sub(sat(7)), sat(3));
 }
@@ -201,10 +186,7 @@ fn unchecked_arithmetic() {
 fn positive_sub() {
     let ssat = SignedAmount::from_sat;
 
-    assert_eq!(
-        ssat(10).positive_sub(ssat(7)).unwrap(),
-        ssat(3)
-    );
+    assert_eq!(ssat(10).positive_sub(ssat(7)).unwrap(), ssat(3));
     assert!(ssat(-10).positive_sub(ssat(7)).is_none());
     assert!(ssat(10).positive_sub(ssat(-7)).is_none());
     assert!(ssat(10).positive_sub(ssat(11)).is_none());
diff --git a/units/src/fee.rs b/units/src/fee.rs
index a1475f9bd3..1f0a535b48 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -188,9 +188,7 @@ impl ops::Div<FeeRate> for Amount {
     /// This operation will panic if `fee_rate` is zero or the division results in overflow.
     ///
     /// Note: This uses floor division. For ceiling division use [`Amount::checked_div_by_fee_rate_ceil`].
-    fn div(self, rhs: FeeRate) -> Self::Output {
-        self.checked_div_by_fee_rate_floor(rhs).unwrap()
-    }
+    fn div(self, rhs: FeeRate) -> Self::Output { self.checked_div_by_fee_rate_floor(rhs).unwrap() }
 }
 
 #[cfg(test)]

From 33a7a35bbb6d486d8133ea41183b2f35a07b9f4c Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 24 Jan 2025 15:38:18 +0000
Subject: [PATCH 279/554] Make naming consistent in tests

Rename all occurrences of LockTime to specify if it is by height or
time.
---
 primitives/src/locktime/absolute.rs | 83 +++++++++++++++--------------
 primitives/src/locktime/relative.rs | 76 +++++++++++++-------------
 2 files changed, 80 insertions(+), 79 deletions(-)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 8a3fc0a1e0..7790e7aabe 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -406,36 +406,36 @@ mod tests {
 
     #[test]
     fn display_and_alternate() {
-        let n = LockTime::from_consensus(741521);
-        let s = format!("{}", n);
+        let lock_by_height = LockTime::from_consensus(741521);
+        let s = format!("{}", lock_by_height);
         assert_eq!(&s, "741521");
 
-        let got = format!("{:#}", n);
+        let got = format!("{:#}", lock_by_height);
         assert_eq!(got, "block-height 741521");
     }
 
     #[test]
     fn lock_time_from_hex_lower() {
-        let lock = LockTime::from_hex("0x6289c350").unwrap();
-        assert_eq!(lock, LockTime::from_consensus(0x6289C350));
+        let lock_by_time = LockTime::from_hex("0x6289c350").unwrap();
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289C350));
     }
 
     #[test]
     fn lock_time_from_hex_upper() {
-        let lock = LockTime::from_hex("0X6289C350").unwrap();
-        assert_eq!(lock, LockTime::from_consensus(0x6289C350));
+        let lock_by_time = LockTime::from_hex("0X6289C350").unwrap();
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289C350));
     }
 
     #[test]
     fn lock_time_from_unprefixed_hex_lower() {
-        let lock = LockTime::from_unprefixed_hex("6289c350").unwrap();
-        assert_eq!(lock, LockTime::from_consensus(0x6289C350));
+        let lock_by_time = LockTime::from_unprefixed_hex("6289c350").unwrap();
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289C350));
     }
 
     #[test]
     fn lock_time_from_unprefixed_hex_upper() {
-        let lock = LockTime::from_unprefixed_hex("6289C350").unwrap();
-        assert_eq!(lock, LockTime::from_consensus(0x6289C350));
+        let lock_by_time = LockTime::from_unprefixed_hex("6289C350").unwrap();
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289C350));
     }
 
     #[test]
@@ -447,27 +447,27 @@ mod tests {
 
     #[test]
     fn parses_correctly_to_height_or_time() {
-        let lock_height = LockTime::from_consensus(750_000);
+        let lock_by_height = LockTime::from_consensus(750_000);
 
-        assert!(lock_height.is_block_height());
-        assert!(!lock_height.is_block_time());
+        assert!(lock_by_height.is_block_height());
+        assert!(!lock_by_height.is_block_time());
 
         let t: u32 = 1653195600; // May 22nd, 5am UTC.
-        let lock_time = LockTime::from_consensus(t);
+        let lock_by_time = LockTime::from_consensus(t);
 
-        assert!(!lock_time.is_block_height());
-        assert!(lock_time.is_block_time());
+        assert!(!lock_by_time.is_block_height());
+        assert!(lock_by_time.is_block_time());
 
         // Test is_same_unit() logic
-        assert!(lock_height.is_same_unit(LockTime::from_consensus(800_000)));
-        assert!(!lock_height.is_same_unit(lock_time));
-        assert!(lock_time.is_same_unit(LockTime::from_consensus(1653282000)));
-        assert!(!lock_time.is_same_unit(lock_height));
+        assert!(lock_by_height.is_same_unit(LockTime::from_consensus(800_000)));
+        assert!(!lock_by_height.is_same_unit(lock_by_time));
+        assert!(lock_by_time.is_same_unit(LockTime::from_consensus(1653282000)));
+        assert!(!lock_by_time.is_same_unit(lock_by_height));
     }
 
     #[test]
     fn satisfied_by_height() {
-        let lock = LockTime::from_consensus(750_000);
+        let lock_by_height = LockTime::from_consensus(750_000);
 
         let height_above = Height::from_consensus(800_000).expect("failed to parse height");
         let height_below = Height::from_consensus(700_000).expect("failed to parse height");
@@ -475,68 +475,69 @@ mod tests {
         let t: u32 = 1653195600; // May 22nd, 5am UTC.
         let time = Time::from_consensus(t).expect("invalid time value");
 
-        assert!(lock.is_satisfied_by(height_above, time));
-        assert!(!lock.is_satisfied_by(height_below, time));
+        assert!(lock_by_height.is_satisfied_by(height_above, time));
+        assert!(!lock_by_height.is_satisfied_by(height_below, time));
     }
 
     #[test]
     fn satisfied_by_time() {
-        let lock_time = LockTime::from_consensus(1653195600); // May 22nd 2022, 5am UTC.
+        let lock_by_time = LockTime::from_consensus(1653195600); // May 22nd 2022, 5am UTC.
 
         let day_after = Time::from_consensus(1653282000).expect("May 23rd 2022, 5am UTC");
         let day_before = Time::from_consensus(1653109200).expect("May 21th 2022, 5am UTC");
 
         let height = Height::from_consensus(800_000).expect("failed to parse height");
 
-        assert!(lock_time.is_satisfied_by(height, day_after));
-        assert!(!lock_time.is_satisfied_by(height, day_before));
+        assert!(lock_by_time.is_satisfied_by(height, day_after));
+        assert!(!lock_by_time.is_satisfied_by(height, day_before));
+
     }
 
     #[test]
     fn satisfied_by_same_height() {
         let h = 750_000;
-        let lock = LockTime::from_consensus(h);
+        let lock_by_height = 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))
+        assert!(lock_by_height.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 lock_by_time = 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))
+        assert!(lock_by_time.is_satisfied_by(height, time))
     }
 
     #[test]
     fn height_correctly_implies() {
-        let lock = LockTime::from_consensus(750_005);
+        let lock_by_height = 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)));
+        assert!(!lock_by_height.is_implied_by(LockTime::from_consensus(750_004)));
+        assert!(lock_by_height.is_implied_by(LockTime::from_consensus(750_005)));
+        assert!(lock_by_height.is_implied_by(LockTime::from_consensus(750_006)));
     }
 
     #[test]
     fn time_correctly_implies() {
         let t: u32 = 1700000005;
-        let lock = LockTime::from_consensus(t);
+        let lock_by_time = 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)));
+        assert!(!lock_by_time.is_implied_by(LockTime::from_consensus(1700000004)));
+        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1700000005)));
+        assert!(lock_by_time.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)));
+        let lock_by_height = LockTime::from_consensus(750_005);
+        assert!(!lock_by_height.is_implied_by(LockTime::from_consensus(1700000004)));
     }
 }
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 8b4a21915a..2c3fb0ad68 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -432,22 +432,22 @@ mod tests {
         let time1 = Time::from_512_second_intervals(70);
         let time2 = Time::from_512_second_intervals(71);
 
-        let lock_height1 = LockTime::from(height1);
-        let lock_height2 = LockTime::from(height2);
-        let lock_time1 = LockTime::from(time1);
-        let lock_time2 = LockTime::from(time2);
+        let lock_by_height1 = LockTime::from(height1);
+        let lock_by_height2 = LockTime::from(height2);
+        let lock_by_time1 = LockTime::from(time1);
+        let lock_by_time2 = LockTime::from(time2);
 
-        assert!(lock_height1.is_block_height());
-        assert!(!lock_height1.is_block_time());
+        assert!(lock_by_height1.is_block_height());
+        assert!(!lock_by_height1.is_block_time());
 
-        assert!(!lock_time1.is_block_height());
-        assert!(lock_time1.is_block_time());
+        assert!(!lock_by_time1.is_block_height());
+        assert!(lock_by_time1.is_block_time());
 
         // Test is_same_unit() logic
-        assert!(lock_height1.is_same_unit(lock_height2));
-        assert!(!lock_height1.is_same_unit(lock_time1));
-        assert!(lock_time1.is_same_unit(lock_time2));
-        assert!(!lock_time1.is_same_unit(lock_height1));
+        assert!(lock_by_height1.is_same_unit(lock_by_height2));
+        assert!(!lock_by_height1.is_same_unit(lock_by_time1));
+        assert!(lock_by_time1.is_same_unit(lock_by_time2));
+        assert!(!lock_by_time1.is_same_unit(lock_by_height1));
     }
 
     #[test]
@@ -455,11 +455,11 @@ mod tests {
         let height = Height::from(10);
         let time = Time::from_512_second_intervals(70);
 
-        let lock = LockTime::from(height);
+        let lock_by_height = 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));
+        assert!(!lock_by_height.is_satisfied_by(Height::from(9), time));
+        assert!(lock_by_height.is_satisfied_by(Height::from(10), time));
+        assert!(lock_by_height.is_satisfied_by(Height::from(11), time));
     }
 
     #[test]
@@ -467,31 +467,31 @@ mod tests {
         let height = Height::from(10);
         let time = Time::from_512_second_intervals(70);
 
-        let lock = LockTime::from(time);
+        let lock_by_time = 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)));
+        assert!(!lock_by_time.is_satisfied_by(height, Time::from_512_second_intervals(69)));
+        assert!(lock_by_time.is_satisfied_by(height, Time::from_512_second_intervals(70)));
+        assert!(lock_by_time.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);
+        let lock_by_height = 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))));
+        assert!(!lock_by_height.is_implied_by(LockTime::from(Height::from(9))));
+        assert!(lock_by_height.is_implied_by(LockTime::from(Height::from(10))));
+        assert!(lock_by_height.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);
+        let lock_by_time = 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))));
+        assert!(!lock_by_time.is_implied_by(LockTime::from(Time::from_512_second_intervals(69))));
+        assert!(lock_by_time.is_implied_by(LockTime::from(Time::from_512_second_intervals(70))));
+        assert!(lock_by_time.is_implied_by(LockTime::from(Time::from_512_second_intervals(71))));
     }
 
     #[test]
@@ -499,17 +499,17 @@ mod tests {
         let height = Height::from(10);
         let time = Time::from_512_second_intervals(70);
 
-        let lock_height = LockTime::from(height);
-        let lock_time = LockTime::from(time);
+        let lock_by_height = LockTime::from(height);
+        let lock_by_time = LockTime::from(time);
 
-        let seq_height = Sequence::from(lock_height);
-        let seq_time = Sequence::from(lock_time);
+        let seq_height = Sequence::from(lock_by_height);
+        let seq_time = Sequence::from(lock_by_time);
 
-        assert!(lock_height.is_implied_by_sequence(seq_height));
-        assert!(!lock_height.is_implied_by_sequence(seq_time));
+        assert!(lock_by_height.is_implied_by_sequence(seq_height));
+        assert!(!lock_by_height.is_implied_by_sequence(seq_time));
 
-        assert!(lock_time.is_implied_by_sequence(seq_time));
-        assert!(!lock_time.is_implied_by_sequence(seq_height));
+        assert!(lock_by_time.is_implied_by_sequence(seq_time));
+        assert!(!lock_by_time.is_implied_by_sequence(seq_height));
     }
 
     #[test]
@@ -517,8 +517,8 @@ mod tests {
         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)));
+        let lock_by_time = LockTime::from(time);
+        assert!(!lock_by_time.is_implied_by(LockTime::from(height)));
     }
 
     #[test]

From 922392268fce57ce40b57564379a3804cf395c2e Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 24 Jan 2025 15:46:00 +0000
Subject: [PATCH 280/554] Combine satisfied by into singe tests

Include the satisfied by same time/height into the previous test that
checks above and below.
---
 primitives/src/locktime/absolute.rs | 27 ++++-----------------------
 1 file changed, 4 insertions(+), 23 deletions(-)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 7790e7aabe..4dae676e7c 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -469,12 +469,14 @@ mod tests {
     fn satisfied_by_height() {
         let lock_by_height = LockTime::from_consensus(750_000);
 
+        let height_same = Height::from_consensus(750_000).expect("failed to parse height");
         let height_above = Height::from_consensus(800_000).expect("failed to parse height");
         let height_below = Height::from_consensus(700_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_by_height.is_satisfied_by(height_same, time));
         assert!(lock_by_height.is_satisfied_by(height_above, time));
         assert!(!lock_by_height.is_satisfied_by(height_below, time));
     }
@@ -483,39 +485,18 @@ mod tests {
     fn satisfied_by_time() {
         let lock_by_time = LockTime::from_consensus(1653195600); // May 22nd 2022, 5am UTC.
 
+        let time = Time::from_consensus(1653195600).expect("May 22nd 2022, 5am UTC");
         let day_after = Time::from_consensus(1653282000).expect("May 23rd 2022, 5am UTC");
         let day_before = Time::from_consensus(1653109200).expect("May 21th 2022, 5am UTC");
 
         let height = Height::from_consensus(800_000).expect("failed to parse height");
 
+        assert!(lock_by_time.is_satisfied_by(height, time));
         assert!(lock_by_time.is_satisfied_by(height, day_after));
         assert!(!lock_by_time.is_satisfied_by(height, day_before));
 
     }
 
-    #[test]
-    fn satisfied_by_same_height() {
-        let h = 750_000;
-        let lock_by_height = 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_by_height.is_satisfied_by(height, time))
-    }
-
-    #[test]
-    fn satisfied_by_same_time() {
-        let t: u32 = 1653195600; // May 22nd, 5am UTC.
-        let lock_by_time = 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_by_time.is_satisfied_by(height, time))
-    }
-
     #[test]
     fn height_correctly_implies() {
         let lock_by_height = LockTime::from_consensus(750_005);

From bc8a378187b9fade96223c8ae9578b78f941f449 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 24 Jan 2025 15:49:57 +0000
Subject: [PATCH 281/554] Rename `day_` variables to `time_`

To be consistent with similar lock height test function rename
`day_after/before` to `time_after/before` and change the same `time` to
`time_same`.
---
 primitives/src/locktime/absolute.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 4dae676e7c..b48d8f9bd5 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -485,15 +485,15 @@ mod tests {
     fn satisfied_by_time() {
         let lock_by_time = LockTime::from_consensus(1653195600); // May 22nd 2022, 5am UTC.
 
-        let time = Time::from_consensus(1653195600).expect("May 22nd 2022, 5am UTC");
-        let day_after = Time::from_consensus(1653282000).expect("May 23rd 2022, 5am UTC");
-        let day_before = Time::from_consensus(1653109200).expect("May 21th 2022, 5am UTC");
+        let time_same = Time::from_consensus(1653195600).expect("May 22nd 2022, 5am UTC");
+        let time_after = Time::from_consensus(1653282000).expect("May 23rd 2022, 5am UTC");
+        let time_before = Time::from_consensus(1653109200).expect("May 21th 2022, 5am UTC");
 
         let height = Height::from_consensus(800_000).expect("failed to parse height");
 
-        assert!(lock_by_time.is_satisfied_by(height, time));
-        assert!(lock_by_time.is_satisfied_by(height, day_after));
-        assert!(!lock_by_time.is_satisfied_by(height, day_before));
+        assert!(lock_by_time.is_satisfied_by(height, time_same));
+        assert!(lock_by_time.is_satisfied_by(height, time_after));
+        assert!(!lock_by_time.is_satisfied_by(height, time_before));
 
     }
 

From fe09896c7d87a0ae6a1b6d6c2525bd5fdff4f3ea Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 24 Jan 2025 13:10:26 +0000
Subject: [PATCH 282/554] Update `README.md`

`.github/workflows/README.md` is stale

Add the new `API`
check and reorder jobs to match `rust.yaml`.
---
 .github/workflows/README.md | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/README.md b/.github/workflows/README.md
index 54da70c567..5dd3aeb894 100644
--- a/.github/workflows/README.md
+++ b/.github/workflows/README.md
@@ -22,13 +22,14 @@ Run from rust.yml unless stated otherwise. Unfortunately we are now exceeding th
 8.  `Docs`
 9.  `Docsrs`
 10. `Bench`
-11. `ASAN`
-12. `WASM`
-13. `Arch32bit`
-14. `Cross`
-15. `Embedded`
+11. `Arch32bit`
+12. `Cross`
+13. `Embedded`
+14. `ASAN`
+15. `WASM`
 16. `Kani`
-17. `Coveralls` - run by `coveralls.yml`
-18. `release` - run by `release.yml`
-19. `labeler` - run by `manage-pr.yml`
-20. `Shellcheck` - run by `shellcheck.yml`
+17. `API`
+18. `Coveralls` - run by `coveralls.yml`
+19. `release` - run by `release.yml`
+20. `labeler` - run by `manage-pr.yml`
+21. `Shellcheck` - run by `shellcheck.yml`

From cb5ffde9eed5ebf55cfbeb03d693a2e01c148afa Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 27 Jan 2025 20:13:29 +0000
Subject: [PATCH 283/554] Change `#[must_use]` to be the same as stdlib

---
 primitives/src/witness.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index 4d0bb9bc5e..abec3e1fb2 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -103,7 +103,7 @@ impl Witness {
     pub fn is_empty(&self) -> bool { self.witness_elements == 0 }
 
     /// Returns a struct implementing [`Iterator`].
-    #[must_use = "returned iterator should be used"]
+    #[must_use = "iterators are lazy and do nothing unless consumed"]
     pub fn iter(&self) -> Iter {
         Iter { inner: self.content.as_slice(), indices_start: self.indices_start, current_index: 0 }
     }

From 566a6e5da6651715f13bafb48e554b10ef0578fe Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 28 Jan 2025 20:09:20 +0000
Subject: [PATCH 284/554] Add `Script` tests

Add tests to `borrowed` to kill the mutants found by `cargo mutants`.
Tests for `to_bytes` were not added since it is deprecated.
---
 primitives/src/script/borrowed.rs | 59 +++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index e8ea04bcd1..af5c48ebc8 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -152,3 +152,62 @@ delegate_index!(
     RangeToInclusive<usize>,
     (Bound<usize>, Bound<usize>)
 );
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn script_from_bytes() {
+        let script = Script::from_bytes(&[1, 2, 3]);
+        assert_eq!(script.as_bytes(), [1, 2, 3]);
+    }
+
+    #[test]
+    fn script_from_bytes_mut() {
+        let bytes = &mut [1, 2, 3];
+        let script = Script::from_bytes_mut(bytes);
+        script.as_mut_bytes()[0] = 4;
+        assert_eq!(script.as_mut_bytes(), [4, 2, 3]);
+    }
+
+    #[test]
+    fn script_to_vec() {
+        let script = Script::from_bytes(&[1, 2, 3]);
+        assert_eq!(script.to_vec(), vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn script_len() {
+        let script = Script::from_bytes(&[1, 2, 3]);
+        assert_eq!(script.len(), 3);
+    }
+
+    #[test]
+    fn script_is_empty() {
+        let script = Script::new();
+        assert!(script.is_empty());
+
+        let script = Script::from_bytes(&[1, 2, 3]);
+        assert!(!script.is_empty());
+    }
+
+    #[test]
+    fn script_to_owned() {
+        let script = Script::from_bytes(&[1, 2, 3]);
+        let script_buf = script.to_owned();
+        assert_eq!(script_buf.as_bytes(), [1, 2, 3]);
+    }
+
+    #[test]
+    fn test_index() {
+        let script = Script::from_bytes(&[1, 2, 3, 4, 5]);
+
+        assert_eq!(script[1..3].as_bytes(), &[2, 3]);
+        assert_eq!(script[2..].as_bytes(), &[3, 4, 5]);
+        assert_eq!(script[..3].as_bytes(), &[1, 2, 3]);
+        assert_eq!(script[..].as_bytes(), &[1, 2, 3, 4, 5]);
+        assert_eq!(script[1..=3].as_bytes(), &[2, 3, 4]);
+        assert_eq!(script[..=2].as_bytes(), &[1, 2, 3]);
+    }
+}

From 6cde537d9ba9bd56495ca47afb3f9a560e9b4358 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 28 Jan 2025 20:10:40 +0000
Subject: [PATCH 285/554] Add `ScriptBuf` tests

Add tests to `owned` to kill the mutants found by `cargo mutants`.
---
 primitives/src/script/owned.rs | 66 ++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 8b640b1068..45a8aa6874 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -94,3 +94,69 @@ impl<'a> Arbitrary<'a> for ScriptBuf {
         Ok(ScriptBuf(v))
     }
 }
+
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn script_buf_from_bytes() {
+        let bytes = vec![1, 2, 3];
+        let script = ScriptBuf::from_bytes(bytes.clone());
+        assert_eq!(script.0, bytes);
+    }
+
+    #[test]
+    fn script_buf_as_script() {
+        let bytes = vec![1, 2, 3];
+        let script = ScriptBuf::from_bytes(bytes.clone());
+        let script_ref = script.as_script();
+        assert_eq!(script_ref.as_bytes(), bytes);
+    }
+
+    #[test]
+    fn script_buf_as_mut_script() {
+        let bytes = vec![1, 2, 3];
+        let mut script = ScriptBuf::from_bytes(bytes.clone());
+        let script_mut_ref = script.as_mut_script();
+        script_mut_ref.as_mut_bytes()[0] = 4;
+        assert_eq!(script.0, vec![4, 2, 3]);
+    }
+
+    #[test]
+    fn script_buf_into_bytes() {
+        let bytes = vec![1, 2, 3];
+        let script = ScriptBuf::from_bytes(bytes.clone());
+        let result = script.into_bytes();
+        assert_eq!(result, bytes);
+    }
+
+    #[test]
+    fn script_buf_into_boxed_script() {
+        let bytes = vec![1, 2, 3];
+        let script = ScriptBuf::from_bytes(bytes.clone());
+        let boxed_script = script.into_boxed_script();
+        assert_eq!(boxed_script.as_bytes(), bytes);
+    }
+
+    #[test]
+    fn script_buf_capacity() {
+        let script = ScriptBuf::with_capacity(10);
+        assert!(script.0.capacity() >= 10);
+    }
+
+    #[test]
+    fn script_buf_reserve() {
+        let mut script = ScriptBuf::new();
+        script.reserve(10);
+        assert!(script.0.capacity() >= 10);
+    }
+
+    #[test]
+    fn script_buf_reserve_exact() {
+        let mut script = ScriptBuf::new();
+        script.reserve_exact(10);
+        assert!(script.0.capacity() >= 10);
+    }
+}

From 9b81a8a2ed1c4f138c592468979e927aa1178830 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 27 Jan 2025 10:36:39 +1100
Subject: [PATCH 286/554] hashes: Remove sha256t::Hash Default impl

The other hash types do not implement `Default` but the tagged one does
still - bad bitcoin devs, no biscuit.
---
 hashes/src/sha256t.rs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/hashes/src/sha256t.rs b/hashes/src/sha256t.rs
index cb3f4aaaac..6c62846c87 100644
--- a/hashes/src/sha256t.rs
+++ b/hashes/src/sha256t.rs
@@ -119,9 +119,6 @@ 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))

From 513402518016bde0d55ec66f8be573bd3e6209ee Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 29 Jan 2025 12:28:24 +1100
Subject: [PATCH 287/554] api: Run just check-api

---
 api/hashes/all-features.txt | 2 --
 api/hashes/alloc-only.txt   | 2 --
 api/hashes/no-features.txt  | 2 --
 3 files changed, 6 deletions(-)

diff --git a/api/hashes/all-features.txt b/api/hashes/all-features.txt
index 6a776f228d..afc1cf84f6 100644
--- a/api/hashes/all-features.txt
+++ b/api/hashes/all-features.txt
@@ -475,7 +475,6 @@ impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::s
 impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::default::Default for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Display for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::LowerHex for bitcoin_hashes::sha256t::Hash<T>
@@ -845,7 +844,6 @@ pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
 pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
 pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
 pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256t::Hash<T>::default() -> Self
 pub fn bitcoin_hashes::sha256t::Hash<T>::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, <D as serde::de::Deserializer>::Error>
 pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
 pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
diff --git a/api/hashes/alloc-only.txt b/api/hashes/alloc-only.txt
index 35bf80f4de..36736de917 100644
--- a/api/hashes/alloc-only.txt
+++ b/api/hashes/alloc-only.txt
@@ -431,7 +431,6 @@ impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::s
 impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::default::Default for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Display for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::LowerHex for bitcoin_hashes::sha256t::Hash<T>
@@ -734,7 +733,6 @@ pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
 pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
 pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
 pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256t::Hash<T>::default() -> Self
 pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
 pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
 pub fn bitcoin_hashes::sha256t::Hash<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
diff --git a/api/hashes/no-features.txt b/api/hashes/no-features.txt
index cd19b4663e..c725663858 100644
--- a/api/hashes/no-features.txt
+++ b/api/hashes/no-features.txt
@@ -395,7 +395,6 @@ impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::s
 impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::default::Default for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::hash::Hash for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> core::marker::Copy for bitcoin_hashes::sha256t::Hash<T>
@@ -687,7 +686,6 @@ pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
 pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
 pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
 pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256t::Hash<T>::default() -> Self
 pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
 pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
 pub fn bitcoin_hashes::sha256t::Hash<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result

From 25a67425739d1d29ccc75ba8ba6f631f111448d8 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 28 Jan 2025 15:19:13 +0000
Subject: [PATCH 288/554] Add examples to `relative::LockTime`

---
 primitives/src/locktime/relative.rs | 44 +++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 2c3fb0ad68..f37e49354f 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -32,6 +32,23 @@ pub use units::locktime::relative::{Height, Time, TimeOverflowError};
 ///
 /// * [BIP 68 Relative lock-time using consensus-enforced sequence numbers](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki)
 /// * [BIP 112 CHECKSEQUENCEVERIFY](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki)
+///
+/// # Examples
+///
+/// ```
+/// use bitcoin_primitives::relative::{LockTime, Height, Time};
+/// let lock_by_height = LockTime::from_height(144); // 144 blocks, approx 24h.
+/// assert!(lock_by_height.is_block_height());
+///
+/// let lock_by_time = LockTime::from_512_second_intervals(168); // 168 time intervals, approx 24h.
+/// assert!(lock_by_time.is_block_time());
+///
+/// // Check if a lock time is satisfied by a given height or time.
+/// let height = Height::from(150);
+/// let time = Time::from_512_second_intervals(200);
+/// assert!(lock_by_height.is_satisfied_by(height, time));
+/// assert!(lock_by_time.is_satisfied_by(height, time));
+/// ```
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum LockTime {
@@ -89,6 +106,18 @@ impl LockTime {
     ///
     /// This method will **not** round-trip with [`Self::to_sequence`]. See the
     /// docs for [`Self::from_consensus`] for more information.
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use bitcoin_primitives::{Sequence, relative::LockTime};
+    ///
+    /// // Interpret a sequence number from a Bitcoin transaction input as a relative lock time
+    /// let sequence_number = Sequence::from_consensus(144); // 144 blocks, approx 24h.
+    /// let lock_time = LockTime::from_sequence(sequence_number)?;
+    /// assert!(lock_time.is_block_height());
+    ///
+    /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
+    /// ```
     #[inline]
     pub fn from_sequence(n: Sequence) -> Result<Self, DisabledLockTimeError> {
         Self::from_consensus(n.to_consensus_u32())
@@ -227,6 +256,21 @@ impl LockTime {
     /// When deciding whether an instance of `<n> CHECKSEQUENCEVERIFY` will pass, this
     /// method can be used by parsing `n` as a [`LockTime`] and calling this method
     /// with the sequence number of the input which spends the script.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_primitives::{Sequence, relative::LockTime};
+    ///
+    /// let sequence = Sequence::from_consensus(1 << 22 | 168); // Bit 22 is 1 with time approx 24h.
+    /// let lock_time = LockTime::from_sequence(sequence)?;
+    /// let input_sequence = Sequence::from_consensus(1 << 22 | 336); // Approx 48h.
+    /// assert!(lock_time.is_block_time());
+    ///
+    /// assert!(lock_time.is_implied_by_sequence(input_sequence));
+    ///
+    /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
+    /// ```
     #[inline]
     pub fn is_implied_by_sequence(&self, other: Sequence) -> bool {
         if let Ok(other) = LockTime::from_sequence(other) {

From 2d73746ad1cd4536b84d174b6410c75ab187bdcf Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 28 Jan 2025 15:44:45 +0000
Subject: [PATCH 289/554] Improve `from_consensus` example

The existing example at first look seemed to contradict the doc above
that the function would not round trip.

Update the example to show the useage for both a time and height based
lock time.

Replace unwrap() with ?
---
 primitives/src/locktime/relative.rs | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index f37e49354f..85aeeaeaa9 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -77,10 +77,19 @@ impl LockTime {
     /// ```rust
     /// # use bitcoin_primitives::relative::LockTime;
     ///
-    /// // `from_consensus` roundtrips with `to_consensus_u32` for small values.
-    /// let n_lock_time: u32 = 7000;
-    /// let lock_time = LockTime::from_consensus(n_lock_time).unwrap();
-    /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
+    /// // Values with bit 22 set to 0 will be interpreted as height-based lock times.
+    /// let height: u32 = 144; // 144 blocks, approx 24h.
+    /// let lock_time = LockTime::from_consensus(height)?;
+    /// assert!(lock_time.is_block_height());
+    /// assert_eq!(lock_time.to_consensus_u32(), height);
+    ///
+    /// // Values with bit 22 set to 1 will be interpreted as time-based lock times.
+    /// let time: u32 = 168 | (1 << 22) ; // Bit 22 is 1 with time approx 24h.
+    /// let lock_time = LockTime::from_consensus(time)?;
+    /// assert!(lock_time.is_block_time());
+    /// assert_eq!(lock_time.to_consensus_u32(), time);
+    ///
+    /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
     /// ```
     pub fn from_consensus(n: u32) -> Result<Self, DisabledLockTimeError> {
         let sequence = crate::Sequence::from_consensus(n);

From c16eab772375a0b8f82789a3453f7e983523fd50 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 28 Jan 2025 15:24:15 +0000
Subject: [PATCH 290/554] Add examples to `absolute::LockTime`

---
 primitives/src/locktime/absolute.rs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index b48d8f9bd5..5bb295c8f1 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -91,12 +91,34 @@ impl LockTime {
     pub const SIZE: usize = 4; // Serialized length of a u32.
 
     /// Constructs a new `LockTime` from a prefixed hex string.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_primitives::absolute::LockTime;
+    /// let hex_str = "0x61cf9980"; // Unix timestamp for January 1, 2022
+    /// let lock_time = LockTime::from_hex(hex_str)?;
+    /// assert_eq!(lock_time.to_consensus_u32(), 0x61cf9980);
+    ///
+    /// # Ok::<_, units::parse::PrefixedHexError>(())
+    /// ```
     pub fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
         let lock_time = parse::hex_u32_prefixed(s)?;
         Ok(Self::from_consensus(lock_time))
     }
 
     /// Constructs a new `LockTime` from an unprefixed hex string.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use bitcoin_primitives::absolute::LockTime;
+    /// let hex_str = "61cf9980"; // Unix timestamp for January 1, 2022
+    /// let lock_time = LockTime::from_unprefixed_hex(hex_str)?;
+    /// assert_eq!(lock_time.to_consensus_u32(), 0x61cf9980);
+    ///
+    /// # Ok::<_, units::parse::UnprefixedHexError>(())
+    /// ```
     pub fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
         let lock_time = parse::hex_u32_unprefixed(s)?;
         Ok(Self::from_consensus(lock_time))

From 313406d6abd9bb3b66cd7defd4bfece8ffd7c6f0 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Wed, 29 Jan 2025 22:24:51 +0100
Subject: [PATCH 291/554] Optimize `encode_signing_data_to_inner`

The `encode_signing_data_to_inner` function previously constructed a
transaction internally, requiring a bunch of allocations, which it'd
then consensus-serialize into a writer (hasher). It also used a dummy
`TxOut::NULL` value which we want to get rid of.

To get rid of both allocations and the NULL value we serialize the
transaction on-the-fly. Because the encoding doesn't involve witnesses
it's not too complicated and the consensus encoding will never change so
there are no desync bugs possible. We may later change this to an
abstract transaction though.
---
 bitcoin/src/crypto/sighash.rs | 91 +++++++++++++++++------------------
 1 file changed, 44 insertions(+), 47 deletions(-)

diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 83a82433b4..a984156049 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -22,11 +22,11 @@ use io::Write;
 
 use crate::address::script_pubkey::ScriptExt as _;
 use crate::consensus::{encode, Encodable};
-use crate::prelude::{Borrow, BorrowMut, String, ToOwned, Vec};
+use crate::prelude::{Borrow, BorrowMut, String, ToOwned};
 use crate::taproot::{LeafVersion, TapLeafHash, TapLeafTag, TAPROOT_ANNEX_PREFIX};
 use crate::transaction::TransactionExt as _;
 use crate::witness::Witness;
-use crate::{transaction, Amount, Script, ScriptBuf, Sequence, Transaction, TxIn, TxOut};
+use crate::{transaction, Amount, Script, Sequence, Transaction, TxOut};
 
 /// Used for signature hash for invalid use of SIGHASH_SINGLE.
 #[rustfmt::skip]
@@ -959,63 +959,59 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             script_pubkey: &Script,
             sighash_type: u32,
         ) -> Result<(), io::Error> {
+            use crate::consensus::encode::WriteExt;
+
             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![],
-            };
+            self_.version.consensus_encode(writer)?;
             // 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(),
-                }];
+                writer.emit_compact_size(1u8)?;
+                self_.input[input_index].previous_output.consensus_encode(writer)?;
+                script_pubkey.consensus_encode(writer)?;
+                self_.input[input_index].sequence.consensus_encode(writer)?;
             } else {
-                tx.input = Vec::with_capacity(self_.input.len());
+                writer.emit_compact_size(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(),
-                    });
+                    input.previous_output.consensus_encode(writer)?;
+                    if n == input_index {
+                        script_pubkey.consensus_encode(writer)?;
+                    } else {
+                        Script::new().consensus_encode(writer)?;
+                    }
+                    if n != input_index
+                        && (sighash == EcdsaSighashType::Single
+                            || sighash == EcdsaSighashType::None)
+                    {
+                        Sequence::ZERO.consensus_encode(writer)?;
+                    } else {
+                        input.sequence.consensus_encode(writer)?;
+                    }
                 }
             }
             // ..then all outputs
-            tx.output = match sighash {
-                EcdsaSighashType::All => self_.output.clone(),
+            match sighash {
+                EcdsaSighashType::All => {
+                    self_.output.consensus_encode(writer)?;
+                },
                 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![],
+                    // sign all outputs up to and including this one, but erase
+                    // all of them except for this one
+                    let count = input_index.min(self_.output.len() - 1);
+                    writer.emit_compact_size(count + 1)?;
+                    for _ in 0..count {
+                        // consensus encoding of the "NULL txout" - max amount, empty script_pubkey
+                        writer.write_all(&[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00])?;
+                    }
+                    self_.output[count].consensus_encode(writer)?;
+                },
+                EcdsaSighashType::None => {
+                    writer.emit_compact_size(0u8)?;
+                },
                 _ => unreachable!(),
             };
-            // hash the result
-            tx.consensus_encode(writer)?;
+            self_.lock_time.consensus_encode(writer)?;
             sighash_type.to_le_bytes().consensus_encode(writer)?;
             Ok(())
         }
@@ -1529,7 +1525,8 @@ mod tests {
     use super::*;
     use crate::consensus::deserialize;
     use crate::locktime::absolute;
-    use crate::script::ScriptBufExt as _;
+    use crate::script::{ScriptBuf, ScriptBufExt as _};
+    use crate::TxIn;
 
     extern crate serde_json;
 

From a9ffb1571c157fc1f91d549b65a75a98103a5538 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Wed, 29 Jan 2025 22:30:13 +0100
Subject: [PATCH 292/554] Stop using `TxOut::NULL` in tests

We want to get rid of this constant, so we replace it in tests with 0
amount, empty script. Notably, the tests were already using it as a
dummy value - the exact amount was irrelevant, so this change doesn't
break anything.
---
 bitcoin/src/crypto/sighash.rs | 8 +++++---
 bitcoin/src/psbt/mod.rs       | 2 +-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index a984156049..0671e3654d 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1530,6 +1530,8 @@ mod tests {
 
     extern crate serde_json;
 
+    const DUMMY_TXOUT: TxOut = TxOut { value: Amount::MIN, script_pubkey: ScriptBuf::new() };
+
     #[test]
     fn sighash_single_bug() {
         const SIGHASH_SINGLE: u32 = 3;
@@ -1539,7 +1541,7 @@ mod tests {
             version: transaction::Version::ONE,
             lock_time: absolute::LockTime::ZERO,
             input: vec![TxIn::EMPTY_COINBASE, TxIn::EMPTY_COINBASE],
-            output: vec![TxOut::NULL],
+            output: vec![DUMMY_TXOUT],
         };
         let script = ScriptBuf::new();
         let cache = SighashCache::new(&tx);
@@ -1740,13 +1742,13 @@ mod tests {
             c.taproot_signature_hash(0, &empty_prevouts, None, None, TapSighashType::All),
             Err(TaprootError::PrevoutsSize(PrevoutsSizeError))
         );
-        let two = [TxOut::NULL, TxOut::NULL];
+        let two = [DUMMY_TXOUT, DUMMY_TXOUT];
         let too_many_prevouts = Prevouts::All(&two);
         assert_eq!(
             c.taproot_signature_hash(0, &too_many_prevouts, None, None, TapSighashType::All),
             Err(TaprootError::PrevoutsSize(PrevoutsSizeError))
         );
-        let tx_out = TxOut::NULL;
+        let tx_out = DUMMY_TXOUT;
         let prevout = Prevouts::One(1, &tx_out);
         assert_eq!(
             c.taproot_signature_hash(0, &prevout, None, None, TapSighashType::All),
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 184e785ae4..96e36786a9 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -2279,7 +2279,7 @@ mod tests {
             version: transaction::Version::TWO,
             lock_time: absolute::LockTime::ZERO,
             input: vec![TxIn::EMPTY_COINBASE, TxIn::EMPTY_COINBASE],
-            output: vec![TxOut::NULL],
+            output: vec![TxOut { value: Amount::from_sat(0), script_pubkey: ScriptBuf::new() }],
         };
         let mut psbt = Psbt::from_unsigned_tx(unsigned_tx).unwrap();
 

From dd2df2bf101f4857a4aa563cd4fc05ccc1f52388 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Wed, 29 Jan 2025 22:33:47 +0100
Subject: [PATCH 293/554] Delete `TxOut::NULL`

We've stopped using `TxOut::NULL` in the code and we want to restrict
`Amount` to 21M BTC, so we are now deleting this constant without
deprecation. Deprecation can be backported if needed.
---
 primitives/src/transaction.rs | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index bb4005798d..e91540e557 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -350,13 +350,6 @@ pub struct TxOut {
     pub script_pubkey: ScriptBuf,
 }
 
-#[cfg(feature = "alloc")]
-impl TxOut {
-    /// This is used as a "null txout" in consensus signing code.
-    pub const NULL: Self =
-        TxOut { value: Amount::from_sat(0xffffffffffffffff), script_pubkey: ScriptBuf::new() };
-}
-
 /// A reference to a transaction output.
 ///
 /// ### Bitcoin Core References

From b98c489066e8916a383099e5037e5a24832548ba Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 30 Jan 2025 10:42:10 +1100
Subject: [PATCH 294/554] hashes: Move from_engine functions

In order to use the `general_hash_type` macro the must exist a
standalone `from_engine` function. Currently this function is in
different places in different modules. In an effort to make the `hashes`
code easier to reason about put the functions right below the macro.

Code move only, no other changes.
---
 hashes/src/hash160.rs | 18 +++++++++---------
 hashes/src/sha256d.rs | 18 +++++++++---------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/hashes/src/hash160.rs b/hashes/src/hash160.rs
index 2e90ca3914..b984960c9b 100644
--- a/hashes/src/hash160.rs
+++ b/hashes/src/hash160.rs
@@ -15,6 +15,15 @@ crate::internal_macros::general_hash_type! {
     "Output of the Bitcoin HASH160 hash function. (RIPEMD160(SHA256))"
 }
 
+fn from_engine(e: HashEngine) -> Hash {
+    let sha2 = sha256::Hash::from_engine(e.0);
+    let rmd = ripemd160::Hash::hash(sha2.as_byte_array());
+
+    let mut ret = [0; 20];
+    ret.copy_from_slice(rmd.as_byte_array());
+    Hash(ret)
+}
+
 /// Engine to compute HASH160 hash function.
 #[derive(Clone)]
 pub struct HashEngine(sha256::HashEngine);
@@ -34,15 +43,6 @@ impl crate::HashEngine for HashEngine {
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
 }
 
-fn from_engine(e: HashEngine) -> Hash {
-    let sha2 = sha256::Hash::from_engine(e.0);
-    let rmd = ripemd160::Hash::hash(sha2.as_byte_array());
-
-    let mut ret = [0; 20];
-    ret.copy_from_slice(rmd.as_byte_array());
-    Hash(ret)
-}
-
 #[cfg(test)]
 mod tests {
     #[test]
diff --git a/hashes/src/sha256d.rs b/hashes/src/sha256d.rs
index 332d6bc118..165bee52e6 100644
--- a/hashes/src/sha256d.rs
+++ b/hashes/src/sha256d.rs
@@ -10,6 +10,15 @@ crate::internal_macros::general_hash_type! {
     "Output of the SHA256d hash function."
 }
 
+fn from_engine(e: HashEngine) -> Hash {
+    let sha2 = sha256::Hash::from_engine(e.0);
+    let sha2d = sha256::Hash::hash(sha2.as_byte_array());
+
+    let mut ret = [0; 32];
+    ret.copy_from_slice(sha2d.as_byte_array());
+    Hash(ret)
+}
+
 /// Engine to compute SHA256d hash function.
 #[derive(Clone)]
 pub struct HashEngine(sha256::HashEngine);
@@ -29,15 +38,6 @@ impl crate::HashEngine for HashEngine {
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
 }
 
-fn from_engine(e: HashEngine) -> Hash {
-    let sha2 = sha256::Hash::from_engine(e.0);
-    let sha2d = sha256::Hash::hash(sha2.as_byte_array());
-
-    let mut ret = [0; 32];
-    ret.copy_from_slice(sha2d.as_byte_array());
-    Hash(ret)
-}
-
 #[cfg(test)]
 mod tests {
     #[allow(unused_imports)] // whether this is used depends on features

From 5fd80581eb9167195bbb4552fbd2210c40b22b7b Mon Sep 17 00:00:00 2001
From: Peter Todd <pete@petertodd.org>
Date: Thu, 30 Jan 2025 02:37:59 +0000
Subject: [PATCH 295/554] Fix spelling of `invalid_legcay_address_length`

Incorrect spelling kept as a deprecated, hidden, function.
---
 bitcoin/src/address/error.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/bitcoin/src/address/error.rs b/bitcoin/src/address/error.rs
index 65eb34f4d2..05022aa666 100644
--- a/bitcoin/src/address/error.rs
+++ b/bitcoin/src/address/error.rs
@@ -334,7 +334,11 @@ pub struct LegacyAddressTooLongError {
 
 impl LegacyAddressTooLongError {
     /// Returns the invalid legacy address length.
-    pub fn invalid_legcay_address_length(&self) -> usize { self.length }
+    pub fn invalid_legacy_address_length(&self) -> usize { self.length }
+
+    #[doc(hidden)]
+    #[deprecated = "Use invalid_legacy_address_length() instead"]
+    pub fn invalid_legcay_address_length(&self) -> usize { self.invalid_legacy_address_length() }
 }
 
 impl fmt::Display for LegacyAddressTooLongError {

From 53bcdefba5f60878cc7049d6e157e21e985bb72c Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 30 Jan 2025 09:06:36 +1100
Subject: [PATCH 296/554] api: Run just check-api

---
 api/primitives/all-features.txt | 2 --
 api/primitives/alloc-only.txt   | 2 --
 2 files changed, 4 deletions(-)

diff --git a/api/primitives/all-features.txt b/api/primitives/all-features.txt
index b2cfbe1e01..9564cd7cef 100644
--- a/api/primitives/all-features.txt
+++ b/api/primitives/all-features.txt
@@ -46,7 +46,6 @@ impl bitcoin_primitives::taproot::TapTweakHash
 impl bitcoin_primitives::transaction::OutPoint
 impl bitcoin_primitives::transaction::Transaction
 impl bitcoin_primitives::transaction::TxIn
-impl bitcoin_primitives::transaction::TxOut
 impl bitcoin_primitives::transaction::Txid
 impl bitcoin_primitives::transaction::Version
 impl bitcoin_primitives::transaction::Wtxid
@@ -1258,7 +1257,6 @@ pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
 pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
 pub const bitcoin_primitives::transaction::Transaction::MAX_STANDARD_WEIGHT: bitcoin_units::weight::Weight
 pub const bitcoin_primitives::transaction::TxIn::EMPTY_COINBASE: bitcoin_primitives::transaction::TxIn
-pub const bitcoin_primitives::transaction::TxOut::NULL: Self
 pub const bitcoin_primitives::transaction::Txid::COINBASE_PREVOUT: Self
 pub const bitcoin_primitives::transaction::Txid::DISPLAY_BACKWARD: bool
 pub const bitcoin_primitives::transaction::Version::ONE: Self
diff --git a/api/primitives/alloc-only.txt b/api/primitives/alloc-only.txt
index 1ccd74b296..6154e801c0 100644
--- a/api/primitives/alloc-only.txt
+++ b/api/primitives/alloc-only.txt
@@ -46,7 +46,6 @@ impl bitcoin_primitives::taproot::TapTweakHash
 impl bitcoin_primitives::transaction::OutPoint
 impl bitcoin_primitives::transaction::Transaction
 impl bitcoin_primitives::transaction::TxIn
-impl bitcoin_primitives::transaction::TxOut
 impl bitcoin_primitives::transaction::Txid
 impl bitcoin_primitives::transaction::Version
 impl bitcoin_primitives::transaction::Wtxid
@@ -1184,7 +1183,6 @@ pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
 pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
 pub const bitcoin_primitives::transaction::Transaction::MAX_STANDARD_WEIGHT: bitcoin_units::weight::Weight
 pub const bitcoin_primitives::transaction::TxIn::EMPTY_COINBASE: bitcoin_primitives::transaction::TxIn
-pub const bitcoin_primitives::transaction::TxOut::NULL: Self
 pub const bitcoin_primitives::transaction::Txid::COINBASE_PREVOUT: Self
 pub const bitcoin_primitives::transaction::Txid::DISPLAY_BACKWARD: bool
 pub const bitcoin_primitives::transaction::Version::ONE: Self

From 12a1c3c4b7bc097553fbfb05a0e92320ae42975c Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 30 Jan 2025 21:46:11 +0000
Subject: [PATCH 297/554] Add `script` tests

Add tests to kill all the mutants found by `cargo mutants` in `scripts`,
except for those related to `serde`.
---
 primitives/src/script/mod.rs | 167 +++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)

diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index 8c240ddc32..dda2240225 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -569,3 +569,170 @@ impl<'de> serde::Deserialize<'de> for ScriptBuf {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn scriptbuf_from_vec_u8() {
+        let vec = vec![0x51, 0x52, 0x53];
+        let script_buf: ScriptBuf = vec.clone().into();
+        let result: Vec<u8> = script_buf.into();
+        assert_eq!(result, vec);
+    }
+
+    #[test]
+    fn scriptbuf_as_ref() {
+        let script_buf = ScriptBuf::from(vec![0x51, 0x52, 0x53]);
+        let script_ref: &[u8] = script_buf.as_ref();
+        assert_eq!(script_ref, &[0x51, 0x52, 0x53]);
+    }
+
+    #[test]
+    fn scriptbuf_as_mut() {
+        let mut script_buf = ScriptBuf::from(vec![0x51, 0x52, 0x53]);
+        let script_mut: &mut [u8] = script_buf.as_mut();
+        script_mut[0] = 0x50;
+        assert_eq!(script_mut, [0x50, 0x52, 0x53]);
+    }
+
+    #[test]
+    fn script_as_ref() {
+        let script = Script::from_bytes(&[0x51, 0x52, 0x53]);
+        let script_ref: &[u8] = script.as_ref();
+        assert_eq!(script_ref, &[0x51, 0x52, 0x53]);
+    }
+
+    #[test]
+    fn script_as_mut() {
+        let bytes = &mut [0x51, 0x52, 0x53];
+        let script = Script::from_bytes_mut(bytes);
+        let script_mut: &mut [u8] = script.as_mut();
+        script_mut[0] = 0x50;
+        assert_eq!(script_mut, [0x50, 0x52, 0x53]);
+    }
+
+    #[test]
+    fn partial_ord() {
+        let script_small = Script::from_bytes(&[0x51, 0x52, 0x53]);
+        let script_big = Script::from_bytes(&[0x54, 0x55, 0x56]);
+        let script_buf_small = ScriptBuf::from(vec![0x51, 0x52, 0x53]);
+        let script_buf_big = ScriptBuf::from(vec![0x54, 0x55, 0x56]);
+
+        assert!(script_small == &script_buf_small);
+        assert!(script_buf_small == *script_small);
+        assert!(script_small != &script_buf_big);
+        assert!(script_buf_small != *script_big);
+
+        assert!(script_small < &script_buf_big);
+        assert!(script_buf_small < *script_big);
+        assert!(script_big > &script_buf_small);
+        assert!(script_buf_big > *script_small);
+    }
+
+    #[test]
+    fn script_hash_from_script() {
+        let script = Script::from_bytes(&[0x51; 520]);
+        assert!(ScriptHash::from_script(script).is_ok());
+
+        let script = Script::from_bytes(&[0x51; 521]);
+        assert!(ScriptHash::from_script(script).is_err());
+    }
+
+    #[test]
+    fn script_hash_from_script_unchecked() {
+        let script = Script::from_bytes(&[0x51; 521]);
+        let hash = ScriptHash::from_script_unchecked(script);
+        assert_eq!(hash, ScriptHash(hash160::Hash::hash(script.as_bytes())));
+    }
+
+    #[test]
+    fn wscript_hash_from_script() {
+        let script = Script::from_bytes(&[0x51; 10_000]);
+        assert!(WScriptHash::from_script(script).is_ok());
+
+        let script = Script::from_bytes(&[0x51; 10_001]);
+        assert!(WScriptHash::from_script(script).is_err());
+    }
+
+    #[test]
+    fn wscript_hash_from_script_unchecked() {
+        let script = Script::from_bytes(&[0x51; 10_001]);
+        let hash = WScriptHash::from_script_unchecked(script);
+        assert_eq!(hash, WScriptHash(sha256::Hash::hash(script.as_bytes())));
+    }
+
+    #[test]
+    fn try_from_scriptbuf_for_scripthash() {
+        let script = ScriptBuf::from(vec![0x51; 520]);
+        assert!(ScriptHash::try_from(script).is_ok());
+
+        let script = ScriptBuf::from(vec![0x51; 521]);
+        assert!(ScriptHash::try_from(script).is_err());
+    }
+
+    #[test]
+    fn try_from_scriptbuf_for_wscript_hash() {
+        let script = ScriptBuf::from(vec![0x51; 10_000]);
+        assert!(WScriptHash::try_from(script).is_ok());
+
+        let script = ScriptBuf::from(vec![0x51; 10_001]);
+        assert!(WScriptHash::try_from(script).is_err());
+    }
+
+    #[test]
+    fn script_display() {
+        let script = Script::from_bytes(&[0xa1, 0xb2, 0xc3]);
+        assert_eq!(format!("{}", script), "OP_LESSTHANOREQUAL OP_CSV OP_RETURN_195");
+        assert_eq!(format!("{:x}", script), "a1b2c3");
+        assert_eq!(format!("{:X}", script), "A1B2C3");
+    }
+
+    #[test]
+    fn scriptbuf_display() {
+        let script_buf = ScriptBuf::from(vec![0xa1, 0xb2, 0xc3]);
+        assert_eq!(format!("{}", script_buf), "OP_LESSTHANOREQUAL OP_CSV OP_RETURN_195");
+        assert_eq!(format!("{:x}", script_buf), "a1b2c3");
+        assert_eq!(format!("{:X}", script_buf), "A1B2C3");
+    }
+
+    #[test]
+    fn cow_script_to_scriptbuf() {
+        let script = Script::from_bytes(&[0x51, 0x52, 0x53]);
+        let cow_borrowed: Cow<Script> = Cow::Borrowed(script);
+        let script_buf: ScriptBuf = cow_borrowed.into();
+        assert_eq!(script_buf.as_bytes(), &[0x51, 0x52, 0x53]);
+    }
+
+    #[test]
+    fn cow_scriptbuf_to_script() {
+        let script_buf = ScriptBuf::from(vec![0x51, 0x52, 0x53]);
+        let cow_owned: Cow<Script> = Cow::Owned(script_buf.clone());
+        let script: &Script = cow_owned.borrow();
+        assert_eq!(script.as_bytes(), &[0x51, 0x52, 0x53]);
+    }
+
+    #[test]
+    fn cow_scriptbuf_to_box_script() {
+        let script_buf = ScriptBuf::from(vec![0x51, 0x52, 0x53]);
+        let cow_owned: Cow<Script> = Cow::Owned(script_buf.clone());
+        let boxed_script: Box<Script> = cow_owned.into();
+        let script_buf2 = boxed_script.into_script_buf();
+        assert_eq!(script_buf2, script_buf);
+    }
+
+    #[test]
+    fn cow_script_to_box_script() {
+        let script = Script::from_bytes(&[0x51, 0x52, 0x53]);
+        let cow_borrowed: Cow<Script> = Cow::Borrowed(script);
+        let boxed_script: Box<Script> = cow_borrowed.into();
+        assert_eq!(boxed_script.as_bytes(), &[0x51, 0x52, 0x53]);
+
+        let cow_owned: Cow<Script> = Cow::from(script.to_owned());
+        assert_eq!(cow_owned.as_ref().as_bytes(), &[0x51, 0x52, 0x53]);
+
+        let cow_from_script: Cow<Script> = Cow::from(script);
+        assert_eq!(cow_from_script.as_ref().as_bytes(), &[0x51, 0x52, 0x53]);
+    }
+}

From c352d376ed4de2958c55dae960c6efd40b263c6d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 30 Jan 2025 10:47:18 +1100
Subject: [PATCH 298/554] Do not implement Default for HmacEngine

The `HmacEngine` should be created using a key. Currently we are
providing a `Default` impl that uses `&[]` as the key. This is, I
believe, a hangover from when we had a `Default` trait bound somewhere
else. It is incorrect and an API footgun - remove it.
---
 hashes/src/hmac.rs         | 13 +++----------
 hashes/tests/regression.rs | 16 ----------------
 2 files changed, 3 insertions(+), 26 deletions(-)

diff --git a/hashes/src/hmac.rs b/hashes/src/hmac.rs
index 283bdc7d0b..c3dca2d851 100644
--- a/hashes/src/hmac.rs
+++ b/hashes/src/hmac.rs
@@ -31,13 +31,6 @@ pub struct HmacEngine<T: GeneralHash> {
     oengine: T::Engine,
 }
 
-impl<T: GeneralHash> Default for HmacEngine<T>
-where
-    <T as GeneralHash>::Engine: Default,
-{
-    fn default() -> Self { HmacEngine::new(&[]) }
-}
-
 impl<T: GeneralHash> HmacEngine<T> {
     /// Constructs a new keyed HMAC from `key`.
     ///
@@ -328,7 +321,7 @@ mod benches {
 
     #[bench]
     pub fn hmac_sha256_10(bh: &mut Bencher) {
-        let mut engine = Hmac::<sha256::Hash>::engine();
+        let mut engine = HmacEngine::<sha256::Hashe>::new(&[]);
         let bytes = [1u8; 10];
         bh.iter(|| {
             engine.input(&bytes);
@@ -338,7 +331,7 @@ mod benches {
 
     #[bench]
     pub fn hmac_sha256_1k(bh: &mut Bencher) {
-        let mut engine = Hmac::<sha256::Hash>::engine();
+        let mut engine = HmacEngine::<sha256::Hashe>::new(&[]);
         let bytes = [1u8; 1024];
         bh.iter(|| {
             engine.input(&bytes);
@@ -348,7 +341,7 @@ mod benches {
 
     #[bench]
     pub fn hmac_sha256_64k(bh: &mut Bencher) {
-        let mut engine = Hmac::<sha256::Hash>::engine();
+        let mut engine = HmacEngine::<sha256::Hashe>::new(&[]);
         let bytes = [1u8; 65536];
         bh.iter(|| {
             engine.input(&bytes);
diff --git a/hashes/tests/regression.rs b/hashes/tests/regression.rs
index d40998e361..0b68567945 100644
--- a/hashes/tests/regression.rs
+++ b/hashes/tests/regression.rs
@@ -56,22 +56,6 @@ fn regression_sha256t() {
     assert_eq!(got, want);
 }
 
-#[test]
-fn regression_hmac_sha256_with_default_key() {
-    let hash = Hmac::<sha256::Hash>::hash(DATA.as_bytes());
-    let got = format!("{}", hash);
-    let want = "58cc7ed8567bd86eba61f7ed2d5a4edab1774dc10488e57de2eb007a2d9ae82d";
-    assert_eq!(got, want);
-}
-
-#[test]
-fn regression_hmac_sha512_with_default_key() {
-    let hash = Hmac::<sha512::Hash>::hash(DATA.as_bytes());
-    let got = format!("{}", hash);
-    let want = "5f5db2f3e1178bf19af5db38a0ed04dc5bc52d641648542886eea9b6bbec0db658ed7a5799ca18f5bc1949f39d24151a32990ee85974e40bb8a35e2288f494ce";
-    assert_eq!(got, want);
-}
-
 #[test]
 fn regression_hmac_sha256_with_key() {
     let mut engine = HmacEngine::<sha256::Hash>::new(HMAC_KEY);

From 134c1467489189ab821a5255ce7f122993028687 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Thu, 30 Jan 2025 03:36:10 +0300
Subject: [PATCH 299/554] Add Weight::checked_mul_by_fee_rate method

Mirror FeeRate::checked_mul_by_weight functionality by adding a symmetrical method to Weight.
This allows users to calculate fees starting from either Weight or FeeRate with consistent behavior.
---
 units/src/fee.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/units/src/fee.rs b/units/src/fee.rs
index 8333992798..f53a15c89f 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -191,6 +191,21 @@ impl ops::Div<FeeRate> for Amount {
     fn div(self, rhs: FeeRate) -> Self::Output { self.checked_div_by_fee_rate_floor(rhs).unwrap() }
 }
 
+impl Weight {
+    /// Checked fee rate multiplication.
+    ///
+    /// Computes the absolute fee amount for a given [`FeeRate`] at this weight.
+    /// When the resulting fee is a non-integer amount, the amount is rounded up,
+    /// ensuring that the transaction fee is enough instead of falling short if
+    /// rounded down.
+    ///
+    /// [`None`] is returned if an overflow occurred.
+    #[must_use]
+    pub const fn checked_mul_by_fee_rate(self, fee_rate: FeeRate) -> Option<Amount> {
+        fee_rate.checked_mul_by_weight(self)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

From e91cb3ff7078277f5b173773263863fcaef47ae3 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Fri, 31 Jan 2025 01:12:57 +0300
Subject: [PATCH 300/554] Run just check-api

---
 api/units/all-features.txt | 1 +
 api/units/alloc-only.txt   | 1 +
 api/units/no-features.txt  | 1 +
 3 files changed, 3 insertions(+)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index c08ae272b6..5d5fdeab7a 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -776,6 +776,7 @@ pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_mul_by_fee_rate(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 171de5f039..8aaeaeb7d3 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -714,6 +714,7 @@ pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_mul_by_fee_rate(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 5526bb2395..19a5305016 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -696,6 +696,7 @@ pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
 pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
+pub const fn bitcoin_units::weight::Weight::checked_mul_by_fee_rate(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::Amount>
 pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
 pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
 pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>

From 1eb8f1f9e044b4bb613f49d3e1b0073c8d11bb8e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 31 Jan 2025 11:15:42 +1100
Subject: [PATCH 301/554] Add a Hmac::engine function

The `HmacEngine` cannot be constructed by way of the `GeneralHash` trait
method because it requires a key. However we can still add an inherent
function to the type to construct an engine.

Add the engine constructor and use it in bench code.
---
 hashes/src/hmac.rs | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/hashes/src/hmac.rs b/hashes/src/hmac.rs
index c3dca2d851..a661f64e32 100644
--- a/hashes/src/hmac.rs
+++ b/hashes/src/hmac.rs
@@ -19,6 +19,16 @@ use crate::{FromSliceError, GeneralHash, Hash, HashEngine};
 #[repr(transparent)]
 pub struct Hmac<T: GeneralHash>(T);
 
+impl<T: GeneralHash> Hmac<T> {
+    /// Constructs a new keyed HMAC engine from `key`.
+    pub fn engine(key: &[u8]) -> HmacEngine<T>
+    where
+        <T as GeneralHash>::Engine: Default,
+    {
+        HmacEngine::new(key)
+    }
+}
+
 impl<T: GeneralHash + 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)?)) }
@@ -32,7 +42,7 @@ pub struct HmacEngine<T: GeneralHash> {
 }
 
 impl<T: GeneralHash> HmacEngine<T> {
-    /// Constructs a new keyed HMAC from `key`.
+    /// Constructs a new keyed HMAC engine from `key`.
     ///
     /// We only support underlying hashes whose block sizes are ≤ 128 bytes.
     ///
@@ -321,7 +331,7 @@ mod benches {
 
     #[bench]
     pub fn hmac_sha256_10(bh: &mut Bencher) {
-        let mut engine = HmacEngine::<sha256::Hashe>::new(&[]);
+        let mut engine = Hmac::<sha256::Hash>::engine(&[]);
         let bytes = [1u8; 10];
         bh.iter(|| {
             engine.input(&bytes);
@@ -331,7 +341,7 @@ mod benches {
 
     #[bench]
     pub fn hmac_sha256_1k(bh: &mut Bencher) {
-        let mut engine = HmacEngine::<sha256::Hashe>::new(&[]);
+        let mut engine = Hmac::<sha256::Hash>::engine(&[]);
         let bytes = [1u8; 1024];
         bh.iter(|| {
             engine.input(&bytes);
@@ -341,7 +351,7 @@ mod benches {
 
     #[bench]
     pub fn hmac_sha256_64k(bh: &mut Bencher) {
-        let mut engine = HmacEngine::<sha256::Hashe>::new(&[]);
+        let mut engine = Hmac::<sha256::Hash>::engine(&[]);
         let bytes = [1u8; 65536];
         bh.iter(|| {
             engine.input(&bytes);

From 18619a6d0b0bca7b7e3603e260b254b4aae6cebf Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 31 Jan 2025 11:17:01 +1100
Subject: [PATCH 302/554] api: Run just check-api

---
 api/hashes/all-features.txt | 4 ++--
 api/hashes/alloc-only.txt   | 4 ++--
 api/hashes/no-features.txt  | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/api/hashes/all-features.txt b/api/hashes/all-features.txt
index 6a776f228d..b860a654de 100644
--- a/api/hashes/all-features.txt
+++ b/api/hashes/all-features.txt
@@ -458,10 +458,10 @@ impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_has
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_io::Write for bitcoin_hashes::hmac::HmacEngine<T>
 impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> core::default::Default for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
 impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::GeneralHash> std::io::Write for bitcoin_hashes::hmac::HmacEngine<T>
 impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
@@ -669,6 +669,7 @@ pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
 pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
 pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
 pub fn bitcoin_hashes::hmac::Hmac<T>::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::hmac::Hmac<T>::engine(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
 pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
 pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
@@ -680,7 +681,6 @@ pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes:
 pub fn bitcoin_hashes::hmac::Hmac<T>::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
 pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::default() -> Self
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::flush(&mut self) -> bitcoin_io::Result<()>
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::flush(&mut self) -> std::io::error::Result<()>
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
diff --git a/api/hashes/alloc-only.txt b/api/hashes/alloc-only.txt
index 35bf80f4de..2000ca4f60 100644
--- a/api/hashes/alloc-only.txt
+++ b/api/hashes/alloc-only.txt
@@ -416,9 +416,9 @@ impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_has
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
 impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> core::default::Default for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
 impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::Hash for bitcoin_hashes::sha256t::Hash<T>
@@ -598,6 +598,7 @@ pub fn bitcoin_hashes::hmac::Hmac<T>::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
 pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
 pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
+pub fn bitcoin_hashes::hmac::Hmac<T>::engine(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
 pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
 pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
@@ -608,7 +609,6 @@ pub fn bitcoin_hashes::hmac::Hmac<T>::hash<__H: core::hash::Hasher>(&self, state
 pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::default() -> Self
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::input(&mut self, buf: &[u8])
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::n_bytes_hashed(&self) -> u64
diff --git a/api/hashes/no-features.txt b/api/hashes/no-features.txt
index cd19b4663e..8ac99fc5df 100644
--- a/api/hashes/no-features.txt
+++ b/api/hashes/no-features.txt
@@ -380,9 +380,9 @@ impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_has
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
+impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
 impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> core::default::Default for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
 impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
 impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
 impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::Hash for bitcoin_hashes::sha256t::Hash<T>
@@ -555,6 +555,7 @@ pub fn bitcoin_hashes::hmac::Hmac<T>::as_byte_array(&self) -> &Self::Bytes
 pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
 pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
 pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
+pub fn bitcoin_hashes::hmac::Hmac<T>::engine(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
 pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
 pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
@@ -565,7 +566,6 @@ pub fn bitcoin_hashes::hmac::Hmac<T>::hash<__H: core::hash::Hasher>(&self, state
 pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::option::Option<core::cmp::Ordering>
 pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::default() -> Self
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::input(&mut self, buf: &[u8])
 pub fn bitcoin_hashes::hmac::HmacEngine<T>::n_bytes_hashed(&self) -> u64

From 390cc39d0711e60155e97e72268299343f4cb6c6 Mon Sep 17 00:00:00 2001
From: Update Stable Rustc Bot <bot@example.com>
Date: Fri, 31 Jan 2025 00:54:42 +0000
Subject: [PATCH 303/554] Automated update to Github CI to rustc stable-1.84.1

---
 .github/workflows/stable-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stable-version b/.github/workflows/stable-version
index bd0f9e6c28..1a17bdc171 100644
--- a/.github/workflows/stable-version
+++ b/.github/workflows/stable-version
@@ -1 +1 @@
-1.84.0
+1.84.1

From 76bc22b496e73b4cf9eb1e5c0559eb8c7b7361c8 Mon Sep 17 00:00:00 2001
From: Update cargo-semver-checks Bot <bot@example.com>
Date: Sat, 1 Feb 2025 01:07:54 +0000
Subject: [PATCH 304/554] Automated update to Github CI to cargo-semver-checks
 version-0.39.0

---
 .github/workflows/cargo-semver-checks-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/cargo-semver-checks-version b/.github/workflows/cargo-semver-checks-version
index ca75280b09..4ef2eb086f 100644
--- a/.github/workflows/cargo-semver-checks-version
+++ b/.github/workflows/cargo-semver-checks-version
@@ -1 +1 @@
-0.38.0
+0.39.0

From 282bc14d6e38ec78b0df01b1169b7ed42a2265cf Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 2 Feb 2025 01:18:01 +0000
Subject: [PATCH 305/554] 2025-02-02 automated rustfmt nightly

---
 bitcoin/src/crypto/sighash.rs       | 9 +++++----
 primitives/src/locktime/absolute.rs | 1 -
 primitives/src/script/owned.rs      | 1 -
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 0671e3654d..5498211a04 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -994,7 +994,7 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
             match sighash {
                 EcdsaSighashType::All => {
                     self_.output.consensus_encode(writer)?;
-                },
+                }
                 EcdsaSighashType::Single => {
                     // sign all outputs up to and including this one, but erase
                     // all of them except for this one
@@ -1002,13 +1002,14 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
                     writer.emit_compact_size(count + 1)?;
                     for _ in 0..count {
                         // consensus encoding of the "NULL txout" - max amount, empty script_pubkey
-                        writer.write_all(&[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00])?;
+                        writer
+                            .write_all(&[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00])?;
                     }
                     self_.output[count].consensus_encode(writer)?;
-                },
+                }
                 EcdsaSighashType::None => {
                     writer.emit_compact_size(0u8)?;
-                },
+                }
                 _ => unreachable!(),
             };
             self_.lock_time.consensus_encode(writer)?;
diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 5bb295c8f1..976f56143c 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -516,7 +516,6 @@ mod tests {
         assert!(lock_by_time.is_satisfied_by(height, time_same));
         assert!(lock_by_time.is_satisfied_by(height, time_after));
         assert!(!lock_by_time.is_satisfied_by(height, time_before));
-
     }
 
     #[test]
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 45a8aa6874..29950cbfba 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -95,7 +95,6 @@ impl<'a> Arbitrary<'a> for ScriptBuf {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

From 1bcfc80fe77a250a00130ae81b3b78e0f9a92602 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Feb 2025 13:45:11 +1100
Subject: [PATCH 306/554] Add engine function to siphash24::Hash

The other hashes that require initial state (keys etc) both have an
`engine` function on the hash type because they cannot use the
`GeneralHash::engine` function.

Add an `engine` function to the `siphash24::Hash` type.
---
 hashes/src/siphash24.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/hashes/src/siphash24.rs b/hashes/src/siphash24.rs
index 5781e52ffd..a46fefe01f 100644
--- a/hashes/src/siphash24.rs
+++ b/hashes/src/siphash24.rs
@@ -168,6 +168,9 @@ impl crate::HashEngine for HashEngine {
 }
 
 impl Hash {
+    /// Constructs a new SipHash24 engine with keys.
+    pub fn engine(k0: u64, k1: u64) -> HashEngine { HashEngine::with_keys(k0, k1) }
+
     /// Produces a hash from the current state of a given engine.
     pub fn from_engine(e: HashEngine) -> Hash { from_engine(e) }
 

From 51cb36881f5291daa4136a714c286cf01f968cf0 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Feb 2025 14:10:28 +1100
Subject: [PATCH 307/554] api: Run just check-api

---
 api/hashes/all-features.txt | 1 +
 api/hashes/alloc-only.txt   | 1 +
 api/hashes/no-features.txt  | 1 +
 3 files changed, 3 insertions(+)

diff --git a/api/hashes/all-features.txt b/api/hashes/all-features.txt
index d119061851..5f5497cca8 100644
--- a/api/hashes/all-features.txt
+++ b/api/hashes/all-features.txt
@@ -967,6 +967,7 @@ pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
 pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
 pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
 pub fn bitcoin_hashes::siphash24::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::siphash24::Hash, <D as serde::de::Deserializer>::Error>
+pub fn bitcoin_hashes::siphash24::Hash::engine(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
 pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
 pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self
diff --git a/api/hashes/alloc-only.txt b/api/hashes/alloc-only.txt
index a8b107412c..f8f73b48d8 100644
--- a/api/hashes/alloc-only.txt
+++ b/api/hashes/alloc-only.txt
@@ -831,6 +831,7 @@ pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8; 8]
 pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
 pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
 pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::siphash24::Hash::engine(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
 pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
 pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self
diff --git a/api/hashes/no-features.txt b/api/hashes/no-features.txt
index 9ead448038..68399650b4 100644
--- a/api/hashes/no-features.txt
+++ b/api/hashes/no-features.txt
@@ -780,6 +780,7 @@ pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8; 8]
 pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
 pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
 pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
+pub fn bitcoin_hashes::siphash24::Hash::engine(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
 pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
 pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
 pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self

From 30132c56bb98271dae079a741c3ca1bd81adf5f6 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 4 Feb 2025 16:43:56 +0000
Subject: [PATCH 308/554] Fix rustdoc indentation

New nightly lint picked up an incorrect indentation.

Remove extra space.
---
 hashes/src/internal_macros.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index 39999b3ddf..959ccdb471 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -9,7 +9,7 @@
 ///
 /// * `$bits` - number of bits this hash type has
 /// * `$reverse` - `bool`  - `true` if the hash type should be displayed backwards, `false`
-///    otherwise.
+///   otherwise.
 /// * `$gen: $gent` - generic type(s) and trait bound(s)
 ///
 /// Restrictions on usage:

From 55ab2f34a7ca9ec9e1356fcfa366ef212f242e1e Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 4 Feb 2025 16:45:47 +0000
Subject: [PATCH 309/554] Remove manual implementation of ok

New rustc nightly gives error: manual implementation of `ok`.

Remove it.
---
 bitcoin/src/blockdata/script/instruction.rs | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/bitcoin/src/blockdata/script/instruction.rs b/bitcoin/src/blockdata/script/instruction.rs
index 8bf30cdd76..410f6d521f 100644
--- a/bitcoin/src/blockdata/script/instruction.rs
+++ b/bitcoin/src/blockdata/script/instruction.rs
@@ -47,12 +47,7 @@ impl Instruction<'_> {
                     _ => None,
                 }
             }
-            Instruction::PushBytes(bytes) => {
-                match super::read_scriptint_non_minimal(bytes.as_bytes()) {
-                    Ok(v) => Some(v),
-                    _ => None,
-                }
-            }
+            Instruction::PushBytes(bytes) => super::read_scriptint_non_minimal(bytes.as_bytes()).ok(),
         }
     }
 
@@ -78,10 +73,7 @@ impl Instruction<'_> {
                     _ => None,
                 }
             }
-            Instruction::PushBytes(bytes) => match bytes.read_scriptint() {
-                Ok(v) => Some(v),
-                _ => None,
-            },
+            Instruction::PushBytes(bytes) => bytes.read_scriptint().ok(),
         }
     }
 }

From 3b350d4f542cca0247e1b2a3de7d903155e99d27 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 4 Feb 2025 16:54:05 +0000
Subject: [PATCH 310/554] Update to rustc (to nightly-2025-01-31)

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index b085f16de2..609e36af3f 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-01-24
+nightly-2025-01-31

From ebab2d9aa7310eb62a6c42bf4dfb266cff441965 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 4 Feb 2025 17:36:26 +0000
Subject: [PATCH 311/554] Update cargo-public-api version

Version 0.42.0 is not compatible with the new version of rust nightly.

Update to v0.43.0
---
 .github/workflows/rust.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index c9c230cd2d..8a45324bf2 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -322,6 +322,6 @@ jobs:
           toolchain: ${{ needs.Prepare.outputs.nightly_version }}
       - name: "Install cargo-public-api"
         # Pin version so that updates don't introduce changes to the text files.
-        run: cargo +stable install --locked cargo-public-api@0.42.0
+        run: cargo +stable install --locked cargo-public-api@0.43.0
       - name: "Run API checker script"
         run: ./contrib/check-for-api-changes.sh

From 5cb1a1d5650caaaa6df00aba6d1a57340097991c Mon Sep 17 00:00:00 2001
From: Peter Todd <pete@petertodd.org>
Date: Thu, 30 Jan 2025 05:04:40 +0000
Subject: [PATCH 312/554] Fix policy module link

---
 bitcoin/src/blockdata/transaction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 8a497ffd2d..7d7bf76993 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -265,7 +265,7 @@ pub trait TransactionExt: sealed::Sealed {
     /// > 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
+    /// [`policy`]: crate::policy
     fn vsize(&self) -> usize;
 
     /// Checks if this is a coinbase transaction.

From 73b14d03b929a92e94a0614f50bf8f9df1ea3ee9 Mon Sep 17 00:00:00 2001
From: yancy <github@yancy.lol>
Date: Tue, 4 Feb 2025 15:00:57 -0600
Subject: [PATCH 313/554] Add `to_fee` in place of `fee_wu`

Use the more idiomatic to_fee instead of `fee_wu`.  Since the method
takes a strongly typed argument, remove `wu` from the method name
to improve clarity.
---
 api/units/all-features.txt   |  1 +
 api/units/alloc-only.txt     |  1 +
 api/units/no-features.txt    |  1 +
 bitcoin/src/blockdata/mod.rs |  2 +-
 units/src/fee.rs             | 14 +++++++++++---
 5 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/api/units/all-features.txt b/api/units/all-features.txt
index 5d5fdeab7a..8eb819b1f9 100644
--- a/api/units/all-features.txt
+++ b/api/units/all-features.txt
@@ -1069,6 +1069,7 @@ pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_uni
 pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::fee_rate::FeeRate::to_fee(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
index 8aaeaeb7d3..37c97385c3 100644
--- a/api/units/alloc-only.txt
+++ b/api/units/alloc-only.txt
@@ -950,6 +950,7 @@ pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_uni
 pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::fee_rate::FeeRate::to_fee(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
index 19a5305016..1464a2aa30 100644
--- a/api/units/no-features.txt
+++ b/api/units/no-features.txt
@@ -916,6 +916,7 @@ pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_uni
 pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
 pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
+pub fn bitcoin_units::fee_rate::FeeRate::to_fee(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
 pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
 pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::ConversionError
 pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
diff --git a/bitcoin/src/blockdata/mod.rs b/bitcoin/src/blockdata/mod.rs
index a8d0af44bf..e9e803fc8d 100644
--- a/bitcoin/src/blockdata/mod.rs
+++ b/bitcoin/src/blockdata/mod.rs
@@ -43,7 +43,7 @@ pub mod fee_rate {
 
             let rate = FeeRate::from_sat_per_vb(1).expect("1 sat/byte is valid");
 
-            assert_eq!(rate.fee_vb(tx.vsize().to_u64()), rate.fee_wu(tx.weight()));
+            assert_eq!(rate.fee_vb(tx.vsize().to_u64()), rate.to_fee(tx.weight()));
         }
     }
 }
diff --git a/units/src/fee.rs b/units/src/fee.rs
index f53a15c89f..23327cedea 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -118,6 +118,14 @@ impl FeeRate {
     ///
     /// This is equivalent to `Self::checked_mul_by_weight()`.
     #[must_use]
+    pub fn to_fee(self, weight: Weight) -> Option<Amount> { self.checked_mul_by_weight(weight) }
+
+    /// Calculates the fee by multiplying this fee rate by weight, in weight units, returning [`None`]
+    /// if an overflow occurred.
+    ///
+    /// This is equivalent to `Self::checked_mul_by_weight()`.
+    #[must_use]
+    #[deprecated(since = "TBD", note = "use `to_fee()` instead")]
     pub fn fee_wu(self, weight: Weight) -> Option<Amount> { self.checked_mul_by_weight(weight) }
 
     /// Calculates the fee by multiplying this fee rate by weight, in virtual bytes, returning [`None`]
@@ -127,7 +135,7 @@ impl FeeRate {
     /// `Self::fee_wu(weight)`.
     #[must_use]
     pub fn fee_vb(self, vb: u64) -> Option<Amount> {
-        Weight::from_vb(vb).and_then(|w| self.fee_wu(w))
+        Weight::from_vb(vb).and_then(|w| self.to_fee(w))
     }
 
     /// Checked weight multiplication.
@@ -218,12 +226,12 @@ mod tests {
 
     #[test]
     fn fee_wu() {
-        let fee_overflow = FeeRate::from_sat_per_kwu(10).fee_wu(Weight::MAX);
+        let fee_overflow = FeeRate::from_sat_per_kwu(10).to_fee(Weight::MAX);
         assert!(fee_overflow.is_none());
 
         let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
         let weight = Weight::from_vb(3).unwrap();
-        assert_eq!(fee_rate.fee_wu(weight).unwrap(), Amount::from_sat_unchecked(6));
+        assert_eq!(fee_rate.to_fee(weight).unwrap(), Amount::from_sat_unchecked(6));
     }
 
     #[test]

From a7526b6a70642e04f0a8ad8a89aa368031fdb6cd Mon Sep 17 00:00:00 2001
From: yancy <github@yancy.lol>
Date: Tue, 4 Feb 2025 15:13:56 -0600
Subject: [PATCH 314/554] Remove `fee_vb`

This is redundant given Weight::from_vb is provided.  After converting
to a weight_unit, use to_fee().
---
 bitcoin/src/blockdata/mod.rs | 24 ------------------------
 units/src/fee.rs             | 10 +---------
 2 files changed, 1 insertion(+), 33 deletions(-)

diff --git a/bitcoin/src/blockdata/mod.rs b/bitcoin/src/blockdata/mod.rs
index e9e803fc8d..02fcb250ff 100644
--- a/bitcoin/src/blockdata/mod.rs
+++ b/bitcoin/src/blockdata/mod.rs
@@ -22,30 +22,6 @@ pub use self::{
 pub mod fee_rate {
     /// Re-export everything from the [`units::fee_rate`] module.
     pub use units::fee_rate::FeeRate;
-
-    #[cfg(test)]
-    mod tests {
-        use internals::ToU64 as _;
-
-        use super::*;
-
-        #[test]
-        fn fee_convenience_functions_agree() {
-            use hex::test_hex_unwrap as hex;
-
-            use crate::consensus::Decodable;
-            use crate::transaction::{Transaction, TransactionExt as _};
-
-            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_sat_per_vb(1).expect("1 sat/byte is valid");
-
-            assert_eq!(rate.fee_vb(tx.vsize().to_u64()), rate.to_fee(tx.weight()));
-        }
-    }
 }
 
 /// Provides absolute and relative locktimes.
diff --git a/units/src/fee.rs b/units/src/fee.rs
index 23327cedea..94601db87a 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -134,6 +134,7 @@ impl FeeRate {
     /// This is equivalent to converting `vb` to [`Weight`] using [`Weight::from_vb`] and then calling
     /// `Self::fee_wu(weight)`.
     #[must_use]
+    #[deprecated(since = "TBD", note = "use Weight::from_vb and then `to_fee()` instead")]
     pub fn fee_vb(self, vb: u64) -> Option<Amount> {
         Weight::from_vb(vb).and_then(|w| self.to_fee(w))
     }
@@ -234,15 +235,6 @@ mod tests {
         assert_eq!(fee_rate.to_fee(weight).unwrap(), Amount::from_sat_unchecked(6));
     }
 
-    #[test]
-    fn fee_vb() {
-        let fee_overflow = FeeRate::from_sat_per_kwu(10).fee_vb(Weight::MAX.to_wu());
-        assert!(fee_overflow.is_none());
-
-        let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
-        assert_eq!(fee_rate.fee_vb(3).unwrap(), Amount::from_sat_unchecked(6));
-    }
-
     #[test]
     fn checked_weight_mul() {
         let weight = Weight::from_vb(10).unwrap();

From 1bfd1e071a690f7073a3f4340be305c3d49d5f57 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 29 Jan 2025 09:51:17 +1100
Subject: [PATCH 315/554] hashes: Make module subdirectories

In preparation for removing a bunch of macros move all the modules to
`<mod>/mod.rs`.

Do so by running the following shell:

```bash
for mod in hash160 ripemd160 sha1 sha256 sha256d sha256t \
sha384 sha512 sha512_256 siphash24 hkdf hmac; do
mkdir $mod
mv "$mod.rs" "$mod/mod.rs"
done
```

Internal change only.
---
 hashes/src/{hash160.rs => hash160/mod.rs}       | 0
 hashes/src/{hkdf.rs => hkdf/mod.rs}             | 0
 hashes/src/{hmac.rs => hmac/mod.rs}             | 0
 hashes/src/{ripemd160.rs => ripemd160/mod.rs}   | 0
 hashes/src/{sha1.rs => sha1/mod.rs}             | 0
 hashes/src/{sha256.rs => sha256/mod.rs}         | 0
 hashes/src/{sha256d.rs => sha256d/mod.rs}       | 0
 hashes/src/{sha256t.rs => sha256t/mod.rs}       | 0
 hashes/src/{sha384.rs => sha384/mod.rs}         | 0
 hashes/src/{sha512.rs => sha512/mod.rs}         | 0
 hashes/src/{sha512_256.rs => sha512_256/mod.rs} | 0
 hashes/src/{siphash24.rs => siphash24/mod.rs}   | 0
 12 files changed, 0 insertions(+), 0 deletions(-)
 rename hashes/src/{hash160.rs => hash160/mod.rs} (100%)
 rename hashes/src/{hkdf.rs => hkdf/mod.rs} (100%)
 rename hashes/src/{hmac.rs => hmac/mod.rs} (100%)
 rename hashes/src/{ripemd160.rs => ripemd160/mod.rs} (100%)
 rename hashes/src/{sha1.rs => sha1/mod.rs} (100%)
 rename hashes/src/{sha256.rs => sha256/mod.rs} (100%)
 rename hashes/src/{sha256d.rs => sha256d/mod.rs} (100%)
 rename hashes/src/{sha256t.rs => sha256t/mod.rs} (100%)
 rename hashes/src/{sha384.rs => sha384/mod.rs} (100%)
 rename hashes/src/{sha512.rs => sha512/mod.rs} (100%)
 rename hashes/src/{sha512_256.rs => sha512_256/mod.rs} (100%)
 rename hashes/src/{siphash24.rs => siphash24/mod.rs} (100%)

diff --git a/hashes/src/hash160.rs b/hashes/src/hash160/mod.rs
similarity index 100%
rename from hashes/src/hash160.rs
rename to hashes/src/hash160/mod.rs
diff --git a/hashes/src/hkdf.rs b/hashes/src/hkdf/mod.rs
similarity index 100%
rename from hashes/src/hkdf.rs
rename to hashes/src/hkdf/mod.rs
diff --git a/hashes/src/hmac.rs b/hashes/src/hmac/mod.rs
similarity index 100%
rename from hashes/src/hmac.rs
rename to hashes/src/hmac/mod.rs
diff --git a/hashes/src/ripemd160.rs b/hashes/src/ripemd160/mod.rs
similarity index 100%
rename from hashes/src/ripemd160.rs
rename to hashes/src/ripemd160/mod.rs
diff --git a/hashes/src/sha1.rs b/hashes/src/sha1/mod.rs
similarity index 100%
rename from hashes/src/sha1.rs
rename to hashes/src/sha1/mod.rs
diff --git a/hashes/src/sha256.rs b/hashes/src/sha256/mod.rs
similarity index 100%
rename from hashes/src/sha256.rs
rename to hashes/src/sha256/mod.rs
diff --git a/hashes/src/sha256d.rs b/hashes/src/sha256d/mod.rs
similarity index 100%
rename from hashes/src/sha256d.rs
rename to hashes/src/sha256d/mod.rs
diff --git a/hashes/src/sha256t.rs b/hashes/src/sha256t/mod.rs
similarity index 100%
rename from hashes/src/sha256t.rs
rename to hashes/src/sha256t/mod.rs
diff --git a/hashes/src/sha384.rs b/hashes/src/sha384/mod.rs
similarity index 100%
rename from hashes/src/sha384.rs
rename to hashes/src/sha384/mod.rs
diff --git a/hashes/src/sha512.rs b/hashes/src/sha512/mod.rs
similarity index 100%
rename from hashes/src/sha512.rs
rename to hashes/src/sha512/mod.rs
diff --git a/hashes/src/sha512_256.rs b/hashes/src/sha512_256/mod.rs
similarity index 100%
rename from hashes/src/sha512_256.rs
rename to hashes/src/sha512_256/mod.rs
diff --git a/hashes/src/siphash24.rs b/hashes/src/siphash24/mod.rs
similarity index 100%
rename from hashes/src/siphash24.rs
rename to hashes/src/siphash24/mod.rs

From 665fa9de991023eedd426445e436ed975efb8aeb Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 29 Jan 2025 10:20:13 +1100
Subject: [PATCH 316/554] hashes: Pull crypto out into submodule

There are five modules in `hashes` that implement cryptography (i.e.
have a `process_block` function). For each of them create a new
submodule called `crypto` and move the code there.

Code organisational refactor only, no logic changes.
---
 hashes/src/ripemd160/crypto.rs | 321 +++++++++++++++++
 hashes/src/ripemd160/mod.rs    | 320 +----------------
 hashes/src/sha1/crypto.rs      |  48 +++
 hashes/src/sha1/mod.rs         |  47 +--
 hashes/src/sha256/crypto.rs    | 619 +++++++++++++++++++++++++++++++++
 hashes/src/sha256/mod.rs       | 617 +-------------------------------
 hashes/src/sha512/crypto.rs    | 185 ++++++++++
 hashes/src/sha512/mod.rs       | 184 +---------
 8 files changed, 1181 insertions(+), 1160 deletions(-)
 create mode 100644 hashes/src/ripemd160/crypto.rs
 create mode 100644 hashes/src/sha1/crypto.rs
 create mode 100644 hashes/src/sha256/crypto.rs
 create mode 100644 hashes/src/sha512/crypto.rs

diff --git a/hashes/src/ripemd160/crypto.rs b/hashes/src/ripemd160/crypto.rs
new file mode 100644
index 0000000000..4c62268929
--- /dev/null
+++ b/hashes/src/ripemd160/crypto.rs
@@ -0,0 +1,321 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use super::{HashEngine, BLOCK_SIZE};
+
+#[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 {
+    pub(super) 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;
+        );
+    }
+}
diff --git a/hashes/src/ripemd160/mod.rs b/hashes/src/ripemd160/mod.rs
index fa0893d7a0..8ef6597700 100644
--- a/hashes/src/ripemd160/mod.rs
+++ b/hashes/src/ripemd160/mod.rs
@@ -2,6 +2,8 @@
 
 //! RIPEMD160 implementation.
 
+mod crypto;
+
 use core::cmp;
 
 use crate::{incomplete_block_len, HashEngine as _};
@@ -88,324 +90,6 @@ impl crate::HashEngine for HashEngine {
     crate::internal_macros::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]
diff --git a/hashes/src/sha1/crypto.rs b/hashes/src/sha1/crypto.rs
new file mode 100644
index 0000000000..6f8a3fd8a7
--- /dev/null
+++ b/hashes/src/sha1/crypto.rs
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use super::{HashEngine, BLOCK_SIZE};
+
+impl HashEngine {
+    // Basic unoptimized algorithm from Wikipedia
+    pub(super) 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);
+    }
+}
diff --git a/hashes/src/sha1/mod.rs b/hashes/src/sha1/mod.rs
index 152a8f3489..f0748c33bf 100644
--- a/hashes/src/sha1/mod.rs
+++ b/hashes/src/sha1/mod.rs
@@ -2,6 +2,8 @@
 
 //! SHA1 implementation.
 
+mod crypto;
+
 use core::cmp;
 
 use crate::{incomplete_block_len, HashEngine as _};
@@ -80,51 +82,6 @@ impl crate::HashEngine for HashEngine {
     crate::internal_macros::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]
diff --git a/hashes/src/sha256/crypto.rs b/hashes/src/sha256/crypto.rs
new file mode 100644
index 0000000000..210eb6e6e3
--- /dev/null
+++ b/hashes/src/sha256/crypto.rs
@@ -0,0 +1,619 @@
+// SPDX-License-Identifier: CC0-1.0
+
+#[cfg(all(feature = "std", target_arch = "x86"))]
+use core::arch::x86::*;
+#[cfg(all(feature = "std", target_arch = "x86_64"))]
+use core::arch::x86_64::*;
+
+use super::{HashEngine, Midstate, BLOCK_SIZE};
+
+#[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
+    }
+
+    pub(super) const fn compute_midstate_unoptimized(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 { bytes: output, bytes_hashed: bytes.len() as u64 }
+    }
+}
+
+impl HashEngine {
+    pub(super) fn process_block(&mut self) {
+        #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
+        {
+            if std::is_x86_feature_detected!("sse4.1")
+                && std::is_x86_feature_detected!("sha")
+                && std::is_x86_feature_detected!("sse2")
+                && std::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);
+    }
+}
diff --git a/hashes/src/sha256/mod.rs b/hashes/src/sha256/mod.rs
index 8770b332b6..cd6beb24ff 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -2,10 +2,8 @@
 
 //! SHA256 implementation.
 
-#[cfg(all(feature = "std", target_arch = "x86"))]
-use core::arch::x86::*;
-#[cfg(all(feature = "std", target_arch = "x86_64"))]
-use core::arch::x86_64::*;
+mod crypto;
+
 use core::{cmp, convert, fmt};
 
 use crate::{incomplete_block_len, sha256d, HashEngine as _};
@@ -256,617 +254,6 @@ impl fmt::Display for MidstateError {
 #[cfg(feature = "std")]
 impl std::error::Error for MidstateError {}
 
-#[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 compute_midstate_unoptimized(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 { bytes: output, bytes_hashed: bytes.len() as u64 }
-    }
-}
-
-impl HashEngine {
-    fn process_block(&mut self) {
-        #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
-        {
-            if std::is_x86_feature_detected!("sse4.1")
-                && std::is_x86_feature_detected!("sha")
-                && std::is_x86_feature_detected!("sse2")
-                && std::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 core::array;
diff --git a/hashes/src/sha512/crypto.rs b/hashes/src/sha512/crypto.rs
new file mode 100644
index 0000000000..cbb1c82ab5
--- /dev/null
+++ b/hashes/src/sha512/crypto.rs
@@ -0,0 +1,185 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use super::{HashEngine, BLOCK_SIZE};
+
+#[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);
+    }
+}
diff --git a/hashes/src/sha512/mod.rs b/hashes/src/sha512/mod.rs
index 1ecd563df8..4db0bec548 100644
--- a/hashes/src/sha512/mod.rs
+++ b/hashes/src/sha512/mod.rs
@@ -2,6 +2,8 @@
 
 //! SHA512 implementation.
 
+mod crypto;
+
 use core::cmp;
 
 use crate::{incomplete_block_len, HashEngine as _};
@@ -121,188 +123,6 @@ impl crate::HashEngine for HashEngine {
     crate::internal_macros::engine_input_impl!();
 }
 
-#[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]

From 7be0db730a2295c78f1a28bdd0061b62f1aa9881 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 29 Jan 2025 10:28:14 +1100
Subject: [PATCH 317/554] hashes: Move bench and test code into files

We are trying to make the `hashes` crate easier to read and also
possibly parseable by machines to see what is different where.

Move the test and bench code into separate files. Make special effort to
keep formatting as is so the diff is easier to review. We will run the
formatter in the next patch.

Internal change only.
---
 hashes/src/ripemd160/benches.rs |  33 ++++
 hashes/src/ripemd160/mod.rs     | 150 +----------------
 hashes/src/ripemd160/tests.rs   | 105 ++++++++++++
 hashes/src/sha1/benches.rs      |  33 ++++
 hashes/src/sha1/mod.rs          | 135 +---------------
 hashes/src/sha1/tests.rs        |  90 +++++++++++
 hashes/src/sha256/benches.rs    |  33 ++++
 hashes/src/sha256/mod.rs        | 278 +-------------------------------
 hashes/src/sha256/tests.rs      | 233 ++++++++++++++++++++++++++
 hashes/src/sha512/benches.rs    |  33 ++++
 hashes/src/sha512/mod.rs        | 153 +-----------------
 hashes/src/sha512/tests.rs      | 108 +++++++++++++
 12 files changed, 684 insertions(+), 700 deletions(-)
 create mode 100644 hashes/src/ripemd160/benches.rs
 create mode 100644 hashes/src/ripemd160/tests.rs
 create mode 100644 hashes/src/sha1/benches.rs
 create mode 100644 hashes/src/sha1/tests.rs
 create mode 100644 hashes/src/sha256/benches.rs
 create mode 100644 hashes/src/sha256/tests.rs
 create mode 100644 hashes/src/sha512/benches.rs
 create mode 100644 hashes/src/sha512/tests.rs

diff --git a/hashes/src/ripemd160/benches.rs b/hashes/src/ripemd160/benches.rs
new file mode 100644
index 0000000000..cb023a933a
--- /dev/null
+++ b/hashes/src/ripemd160/benches.rs
@@ -0,0 +1,33 @@
+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/ripemd160/mod.rs b/hashes/src/ripemd160/mod.rs
index 8ef6597700..759900ce28 100644
--- a/hashes/src/ripemd160/mod.rs
+++ b/hashes/src/ripemd160/mod.rs
@@ -2,7 +2,11 @@
 
 //! RIPEMD160 implementation.
 
+#[cfg(bench)]
+mod benches;
 mod crypto;
+#[cfg(bench)]
+mod tests;
 
 use core::cmp;
 
@@ -89,149 +93,3 @@ impl crate::HashEngine for HashEngine {
 
     crate::internal_macros::engine_input_impl!();
 }
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    #[cfg(feature = "alloc")]
-    fn test() {
-        use alloc::string::ToString;
-
-        use crate::{ripemd160, HashEngine};
-
-        #[derive(Clone)]
-        struct Test {
-            input: &'static str,
-            output: [u8; 20],
-            output_str: &'static str,
-        }
-
-        #[rustfmt::skip]
-        let tests = [
-            // Test messages from FIPS 180-1
-            Test {
-                input: "abc",
-                output: [
-                    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: [
-                    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: [
-                    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: [
-                    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.as_byte_array(), &test.output);
-            assert_eq!(hash.to_string(), test.output_str);
-            assert_eq!(ripemd160::Hash::from_bytes_ref(&test.output), &hash);
-            assert_eq!(ripemd160::Hash::from_bytes_mut(&mut test.output), &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.to_byte_array(), test.output);
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    fn ripemd_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
-
-        use crate::ripemd160;
-
-        #[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/ripemd160/tests.rs b/hashes/src/ripemd160/tests.rs
new file mode 100644
index 0000000000..d6340591cc
--- /dev/null
+++ b/hashes/src/ripemd160/tests.rs
@@ -0,0 +1,105 @@
+#[test]
+#[cfg(feature = "alloc")]
+fn test() {
+    use alloc::string::ToString;
+
+    use crate::{ripemd160, HashEngine};
+
+    #[derive(Clone)]
+    struct Test {
+        input: &'static str,
+        output: [u8; 20],
+        output_str: &'static str,
+    }
+
+    #[rustfmt::skip]
+    let tests = [
+        // Test messages from FIPS 180-1
+        Test {
+            input: "abc",
+            output: [
+                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: [
+                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: [
+                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: [
+                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.as_byte_array(), &test.output);
+        assert_eq!(hash.to_string(), test.output_str);
+        assert_eq!(ripemd160::Hash::from_bytes_ref(&test.output), &hash);
+        assert_eq!(ripemd160::Hash::from_bytes_mut(&mut test.output), &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.to_byte_array(), test.output);
+    }
+}
+
+#[test]
+#[cfg(feature = "serde")]
+fn ripemd_serde() {
+    use serde_test::{assert_tokens, Configure, Token};
+
+    use crate::ripemd160;
+
+    #[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")]);
+}
diff --git a/hashes/src/sha1/benches.rs b/hashes/src/sha1/benches.rs
new file mode 100644
index 0000000000..fcf2518df9
--- /dev/null
+++ b/hashes/src/sha1/benches.rs
@@ -0,0 +1,33 @@
+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/sha1/mod.rs b/hashes/src/sha1/mod.rs
index f0748c33bf..6c198d1859 100644
--- a/hashes/src/sha1/mod.rs
+++ b/hashes/src/sha1/mod.rs
@@ -2,7 +2,11 @@
 
 //! SHA1 implementation.
 
+#[cfg(bench)]
+mod benches;
 mod crypto;
+#[cfg(bench)]
+mod tests;
 
 use core::cmp;
 
@@ -81,134 +85,3 @@ impl crate::HashEngine for HashEngine {
 
     crate::internal_macros::engine_input_impl!();
 }
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    #[cfg(feature = "alloc")]
-    fn test() {
-        use alloc::string::ToString;
-
-        use crate::{sha1, HashEngine};
-
-        #[derive(Clone)]
-        struct Test {
-            input: &'static str,
-            output: [u8; 20],
-            output_str: &'static str,
-        }
-
-        #[rustfmt::skip]
-        let tests = [
-            // Examples from wikipedia
-            Test {
-                input: "",
-                output: [
-                    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: [
-                    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: [
-                    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.as_byte_array(), &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.to_byte_array(), test.output);
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    fn sha1_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
-
-        use crate::sha1;
-
-        #[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/sha1/tests.rs b/hashes/src/sha1/tests.rs
new file mode 100644
index 0000000000..2bfe37b1cf
--- /dev/null
+++ b/hashes/src/sha1/tests.rs
@@ -0,0 +1,90 @@
+#[test]
+#[cfg(feature = "alloc")]
+fn test() {
+    use alloc::string::ToString;
+
+    use crate::{sha1, HashEngine};
+
+    #[derive(Clone)]
+    struct Test {
+        input: &'static str,
+        output: [u8; 20],
+        output_str: &'static str,
+    }
+
+    #[rustfmt::skip]
+    let tests = [
+        // Examples from wikipedia
+        Test {
+            input: "",
+            output: [
+                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: [
+                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: [
+                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.as_byte_array(), &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.to_byte_array(), test.output);
+    }
+}
+
+#[test]
+#[cfg(feature = "serde")]
+fn sha1_serde() {
+    use serde_test::{assert_tokens, Configure, Token};
+
+    use crate::sha1;
+
+    #[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")]);
+}
diff --git a/hashes/src/sha256/benches.rs b/hashes/src/sha256/benches.rs
new file mode 100644
index 0000000000..f6e270d903
--- /dev/null
+++ b/hashes/src/sha256/benches.rs
@@ -0,0 +1,33 @@
+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/sha256/mod.rs b/hashes/src/sha256/mod.rs
index cd6beb24ff..70bf9121bb 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -2,7 +2,11 @@
 
 //! SHA256 implementation.
 
+#[cfg(bench)]
+mod benches;
 mod crypto;
+#[cfg(bench)]
+mod tests;
 
 use core::{cmp, convert, fmt};
 
@@ -253,277 +257,3 @@ impl fmt::Display for MidstateError {
 
 #[cfg(feature = "std")]
 impl std::error::Error for MidstateError {}
-
-#[cfg(test)]
-mod tests {
-    use core::array;
-
-    use super::*;
-    use crate::{sha256, HashEngine};
-
-    #[test]
-    #[cfg(feature = "alloc")]
-    fn test() {
-        use alloc::string::ToString;
-
-        #[derive(Clone)]
-        struct Test {
-            input: &'static str,
-            output: [u8; 32],
-            output_str: &'static str,
-        }
-
-        #[rustfmt::skip]
-        let tests = [
-            // Examples from wikipedia
-            Test {
-                input: "",
-                output: [
-                    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: [
-                    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: [
-                    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.as_byte_array(), &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(), test.output);
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "alloc")]
-    fn fmt_roundtrips() {
-        use alloc::format;
-
-        let hash = sha256::Hash::hash(b"some arbitrary bytes");
-        let hex = format!("{}", hash);
-        let rinsed = hex.parse::<sha256::Hash>().expect("failed to parse hex");
-        assert_eq!(rinsed, hash)
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    pub(crate) 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]);
-
-        // RPC output
-        static WANT: Midstate = sha256::Midstate::new([
-            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,
-        ], 64);
-
-        assert_eq!(
-            engine.midstate().expect("total_bytes_hashed is valid"),
-            WANT,
-        );
-    }
-
-    #[test]
-    fn engine_with_state() {
-        let mut engine = sha256::Hash::engine();
-        let midstate_engine = sha256::HashEngine::from_midstate(engine.midstate_unchecked());
-        // 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: &[&[u8]] = &[&[3u8; 1], &[4u8; 63], &[5u8; 65], &[6u8; 66]];
-        for data in data_vec {
-            let mut engine = engine.clone();
-            let mut midstate_engine =
-                sha256::HashEngine::from_midstate(engine.midstate_unchecked());
-            assert_eq!(engine.h, midstate_engine.h);
-            assert_eq!(engine.bytes_hashed, midstate_engine.bytes_hashed);
-            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::new(MIDSTATE, 64));
-        let hash = sha256::Hash::from_engine(midstate_engine);
-        assert_eq!(hash, sha256::Hash(HASH_EXPECTED));
-    }
-
-    #[test]
-    fn hash_unoptimized() {
-        let bytes: [u8; 256] = array::from_fn(|i| i as u8);
-
-        for i in 0..=256 {
-            let bytes = &bytes[0..i];
-            assert_eq!(
-                Hash::hash(bytes),
-                Hash::hash_unoptimized(bytes),
-                "hashes don't match for n_bytes_hashed {}",
-                i + 1
-            );
-        }
-    }
-
-    // The midstate of an empty hash engine tagged with "TapLeaf".
-    const TAP_LEAF_MIDSTATE: Midstate = Midstate::new(
-        [
-            156, 224, 228, 230, 124, 17, 108, 57, 56, 179, 202, 242, 195, 15, 80, 137, 211, 243,
-            147, 108, 71, 99, 110, 96, 125, 179, 62, 234, 221, 198, 240, 201,
-        ],
-        64,
-    );
-
-    #[test]
-    fn const_midstate() { assert_eq!(Midstate::hash_tag(b"TapLeaf"), TAP_LEAF_MIDSTATE,) }
-
-    #[test]
-    #[cfg(feature = "alloc")]
-    fn regression_midstate_debug_format() {
-        use alloc::format;
-
-        let want = "Midstate { bytes: 9ce0e4e67c116c3938b3caf2c30f5089d3f3936c47636e607db33eeaddc6f0c9, length: 64 }";
-        let got = format!("{:?}", TAP_LEAF_MIDSTATE);
-        assert_eq!(got, want);
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    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 {
-        use super::*;
-        #[test]
-        #[wasm_bindgen_test::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/sha256/tests.rs b/hashes/src/sha256/tests.rs
new file mode 100644
index 0000000000..2d8d099d79
--- /dev/null
+++ b/hashes/src/sha256/tests.rs
@@ -0,0 +1,233 @@
+use core::array;
+
+use super::*;
+use crate::{sha256, HashEngine};
+
+#[test]
+#[cfg(feature = "alloc")]
+fn test() {
+    use alloc::string::ToString;
+
+    #[derive(Clone)]
+    struct Test {
+        input: &'static str,
+        output: [u8; 32],
+        output_str: &'static str,
+    }
+
+    #[rustfmt::skip]
+    let tests = [
+        // Examples from wikipedia
+        Test {
+            input: "",
+            output: [
+                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: [
+                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: [
+                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.as_byte_array(), &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(), test.output);
+    }
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn fmt_roundtrips() {
+    use alloc::format;
+
+    let hash = sha256::Hash::hash(b"some arbitrary bytes");
+    let hex = format!("{}", hash);
+    let rinsed = hex.parse::<sha256::Hash>().expect("failed to parse hex");
+    assert_eq!(rinsed, hash)
+}
+
+#[test]
+#[rustfmt::skip]
+pub(crate) 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]);
+
+    // RPC output
+    static WANT: Midstate = sha256::Midstate::new([
+        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,
+    ], 64);
+
+    assert_eq!(
+        engine.midstate().expect("total_bytes_hashed is valid"),
+        WANT,
+    );
+}
+
+#[test]
+fn engine_with_state() {
+    let mut engine = sha256::Hash::engine();
+    let midstate_engine = sha256::HashEngine::from_midstate(engine.midstate_unchecked());
+    // 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: &[&[u8]] = &[&[3u8; 1], &[4u8; 63], &[5u8; 65], &[6u8; 66]];
+    for data in data_vec {
+        let mut engine = engine.clone();
+        let mut midstate_engine =
+            sha256::HashEngine::from_midstate(engine.midstate_unchecked());
+        assert_eq!(engine.h, midstate_engine.h);
+        assert_eq!(engine.bytes_hashed, midstate_engine.bytes_hashed);
+        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::new(MIDSTATE, 64));
+    let hash = sha256::Hash::from_engine(midstate_engine);
+    assert_eq!(hash, sha256::Hash(HASH_EXPECTED));
+}
+
+#[test]
+fn hash_unoptimized() {
+    let bytes: [u8; 256] = array::from_fn(|i| i as u8);
+
+    for i in 0..=256 {
+        let bytes = &bytes[0..i];
+        assert_eq!(
+            Hash::hash(bytes),
+            Hash::hash_unoptimized(bytes),
+            "hashes don't match for n_bytes_hashed {}",
+            i + 1
+        );
+    }
+}
+
+// The midstate of an empty hash engine tagged with "TapLeaf".
+const TAP_LEAF_MIDSTATE: Midstate = Midstate::new(
+    [
+        156, 224, 228, 230, 124, 17, 108, 57, 56, 179, 202, 242, 195, 15, 80, 137, 211, 243,
+        147, 108, 71, 99, 110, 96, 125, 179, 62, 234, 221, 198, 240, 201,
+    ],
+    64,
+);
+
+#[test]
+fn const_midstate() { assert_eq!(Midstate::hash_tag(b"TapLeaf"), TAP_LEAF_MIDSTATE,) }
+
+#[test]
+#[cfg(feature = "alloc")]
+fn regression_midstate_debug_format() {
+    use alloc::format;
+
+    let want = "Midstate { bytes: 9ce0e4e67c116c3938b3caf2c30f5089d3f3936c47636e607db33eeaddc6f0c9, length: 64 }";
+    let got = format!("{:?}", TAP_LEAF_MIDSTATE);
+    assert_eq!(got, want);
+}
+
+#[test]
+#[cfg(feature = "serde")]
+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 {
+    use super::*;
+    #[test]
+    #[wasm_bindgen_test::wasm_bindgen_test]
+    fn sha256_tests() {
+        test();
+        midstate();
+        engine_with_state();
+    }
+}
diff --git a/hashes/src/sha512/benches.rs b/hashes/src/sha512/benches.rs
new file mode 100644
index 0000000000..56b71800be
--- /dev/null
+++ b/hashes/src/sha512/benches.rs
@@ -0,0 +1,33 @@
+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/mod.rs b/hashes/src/sha512/mod.rs
index 4db0bec548..f72f62e563 100644
--- a/hashes/src/sha512/mod.rs
+++ b/hashes/src/sha512/mod.rs
@@ -2,7 +2,11 @@
 
 //! SHA512 implementation.
 
+#[cfg(bench)]
+mod benches;
 mod crypto;
+#[cfg(bench)]
+mod tests;
 
 use core::cmp;
 
@@ -122,152 +126,3 @@ impl crate::HashEngine for HashEngine {
 
     crate::internal_macros::engine_input_impl!();
 }
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    #[cfg(feature = "alloc")]
-    fn test() {
-        use alloc::string::ToString;
-
-        use crate::{sha512, HashEngine};
-
-        #[derive(Clone)]
-        struct Test {
-            input: &'static str,
-            output: [u8; 64],
-            output_str: &'static str,
-        }
-
-        #[rustfmt::skip]
-        let tests = [
-            // Test vectors computed with `sha512sum`
-            Test {
-                input: "",
-                output: [
-                    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: [
-                    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: [
-                    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.as_byte_array(), &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(), test.output);
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "serde")]
-    fn sha512_serde() {
-        use serde_test::{assert_tokens, Configure, Token};
-
-        use crate::sha512;
-
-        #[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/tests.rs b/hashes/src/sha512/tests.rs
new file mode 100644
index 0000000000..4b46f01760
--- /dev/null
+++ b/hashes/src/sha512/tests.rs
@@ -0,0 +1,108 @@
+#[test]
+#[cfg(feature = "alloc")]
+fn test() {
+    use alloc::string::ToString;
+
+    use crate::{sha512, HashEngine};
+
+    #[derive(Clone)]
+    struct Test {
+        input: &'static str,
+        output: [u8; 64],
+        output_str: &'static str,
+    }
+
+    #[rustfmt::skip]
+    let tests = [
+        // Test vectors computed with `sha512sum`
+        Test {
+            input: "",
+            output: [
+                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: [
+                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: [
+                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.as_byte_array(), &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(), test.output);
+    }
+}
+
+#[test]
+#[cfg(feature = "serde")]
+fn sha512_serde() {
+    use serde_test::{assert_tokens, Configure, Token};
+
+    use crate::sha512;
+
+    #[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",
+        )],
+    );
+}

From 85e0330d7f057c9fe447bff5fdb6023150ead319 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 29 Jan 2025 10:36:12 +1100
Subject: [PATCH 318/554] Run the formatter

Run `just fmt`, no other manual changes.
---
 bitcoin/src/blockdata/script/instruction.rs |  3 ++-
 hashes/src/sha256/tests.rs                  | 10 ++++------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/bitcoin/src/blockdata/script/instruction.rs b/bitcoin/src/blockdata/script/instruction.rs
index 410f6d521f..6ec3d56130 100644
--- a/bitcoin/src/blockdata/script/instruction.rs
+++ b/bitcoin/src/blockdata/script/instruction.rs
@@ -47,7 +47,8 @@ impl Instruction<'_> {
                     _ => None,
                 }
             }
-            Instruction::PushBytes(bytes) => super::read_scriptint_non_minimal(bytes.as_bytes()).ok(),
+            Instruction::PushBytes(bytes) =>
+                super::read_scriptint_non_minimal(bytes.as_bytes()).ok(),
         }
     }
 
diff --git a/hashes/src/sha256/tests.rs b/hashes/src/sha256/tests.rs
index 2d8d099d79..65f166e17e 100644
--- a/hashes/src/sha256/tests.rs
+++ b/hashes/src/sha256/tests.rs
@@ -127,8 +127,7 @@ fn engine_with_state() {
     let data_vec: &[&[u8]] = &[&[3u8; 1], &[4u8; 63], &[5u8; 65], &[6u8; 66]];
     for data in data_vec {
         let mut engine = engine.clone();
-        let mut midstate_engine =
-            sha256::HashEngine::from_midstate(engine.midstate_unchecked());
+        let mut midstate_engine = sha256::HashEngine::from_midstate(engine.midstate_unchecked());
         assert_eq!(engine.h, midstate_engine.h);
         assert_eq!(engine.bytes_hashed, midstate_engine.bytes_hashed);
         engine.input(data);
@@ -156,8 +155,7 @@ fn engine_with_state() {
         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::new(MIDSTATE, 64));
+    let midstate_engine = sha256::HashEngine::from_midstate(sha256::Midstate::new(MIDSTATE, 64));
     let hash = sha256::Hash::from_engine(midstate_engine);
     assert_eq!(hash, sha256::Hash(HASH_EXPECTED));
 }
@@ -180,8 +178,8 @@ fn hash_unoptimized() {
 // The midstate of an empty hash engine tagged with "TapLeaf".
 const TAP_LEAF_MIDSTATE: Midstate = Midstate::new(
     [
-        156, 224, 228, 230, 124, 17, 108, 57, 56, 179, 202, 242, 195, 15, 80, 137, 211, 243,
-        147, 108, 71, 99, 110, 96, 125, 179, 62, 234, 221, 198, 240, 201,
+        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,
     ],
     64,
 );

From 2eccb3897a90221c4302947adc10a1e370e0d4a5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 6 Feb 2025 06:49:56 +1100
Subject: [PATCH 319/554] CI: Remove the API job

It has been argued that the API files provide value for verifying that
code changes produce API changes in the expected way. This helps devs
and reviewers.

It has also been argued that the CI job adds friction and forces devs
to configure their environment unnecessarily.

Both viewpoints have some merit.

Lets remove the API files for now, and when we start doing 1.0-alpha
releases and can start to expect minimal API breaking changes (and
therefore minimal need to use the tooling).
---
 .github/workflows/README.md     |    9 +-
 .github/workflows/rust.yml      |   21 -
 api/README.md                   |   12 -
 api/hashes/all-features.txt     | 1093 -----------------
 api/hashes/alloc-only.txt       |  943 --------------
 api/hashes/no-features.txt      |  880 -------------
 api/io/all-features.txt         |  402 ------
 api/io/alloc-only.txt           |  156 ---
 api/io/no-features.txt          |  148 ---
 api/primitives/all-features.txt | 2041 -------------------------------
 api/primitives/alloc-only.txt   | 1898 ----------------------------
 api/primitives/no-features.txt  | 1297 --------------------
 api/units/all-features.txt      | 1328 --------------------
 api/units/alloc-only.txt        | 1156 -----------------
 api/units/no-features.txt       | 1108 -----------------
 15 files changed, 4 insertions(+), 12488 deletions(-)
 delete mode 100644 api/README.md
 delete mode 100644 api/hashes/all-features.txt
 delete mode 100644 api/hashes/alloc-only.txt
 delete mode 100644 api/hashes/no-features.txt
 delete mode 100644 api/io/all-features.txt
 delete mode 100644 api/io/alloc-only.txt
 delete mode 100644 api/io/no-features.txt
 delete mode 100644 api/primitives/all-features.txt
 delete mode 100644 api/primitives/alloc-only.txt
 delete mode 100644 api/primitives/no-features.txt
 delete mode 100644 api/units/all-features.txt
 delete mode 100644 api/units/alloc-only.txt
 delete mode 100644 api/units/no-features.txt

diff --git a/.github/workflows/README.md b/.github/workflows/README.md
index 5dd3aeb894..f93b40cd1c 100644
--- a/.github/workflows/README.md
+++ b/.github/workflows/README.md
@@ -28,8 +28,7 @@ Run from rust.yml unless stated otherwise. Unfortunately we are now exceeding th
 14. `ASAN`
 15. `WASM`
 16. `Kani`
-17. `API`
-18. `Coveralls` - run by `coveralls.yml`
-19. `release` - run by `release.yml`
-20. `labeler` - run by `manage-pr.yml`
-21. `Shellcheck` - run by `shellcheck.yml`
+17. `Coveralls` - run by `coveralls.yml`
+18. `release` - run by `release.yml`
+19. `labeler` - run by `manage-pr.yml`
+20. `Shellcheck` - run by `shellcheck.yml`
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 8a45324bf2..d4d4ca6059 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -304,24 +304,3 @@ jobs:
         uses: model-checking/kani-github-action@v1.1
         with:
           args: "--only-codegen"
-
-  API:
-    name: API - nightly toolchain
-    needs: Prepare
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        dep: [recent]
-    steps:
-      - name: "Checkout repo"
-        uses: actions/checkout@v4
-      - name: "Select toolchain"
-        uses: dtolnay/rust-toolchain@v1
-        with:
-          toolchain: ${{ needs.Prepare.outputs.nightly_version }}
-      - name: "Install cargo-public-api"
-        # Pin version so that updates don't introduce changes to the text files.
-        run: cargo +stable install --locked cargo-public-api@0.43.0
-      - name: "Run API checker script"
-        run: ./contrib/check-for-api-changes.sh
diff --git a/api/README.md b/api/README.md
deleted file mode 100644
index f83f990b14..0000000000
--- a/api/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# API text files
-
-Each file here lists the public API when built with some set of features
-enabled. To create these files run `../contrib/check-for-api-changes.sh`:
-
-Requires `cargo-public-api`, install with:
-
-```
-cargo +nightly install cargo-public-api --locked
-```
-
-ref: https://github.com/enselic/cargo-public-api
diff --git a/api/hashes/all-features.txt b/api/hashes/all-features.txt
deleted file mode 100644
index 5f5497cca8..0000000000
--- a/api/hashes/all-features.txt
+++ /dev/null
@@ -1,1093 +0,0 @@
-#[repr(transparent)] pub struct bitcoin_hashes::Hash160(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Hmac<T: bitcoin_hashes::GeneralHash>(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Ripemd160(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha1(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha256(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha256d(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha384(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha512(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha512_256(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Siphash24(_)
-#[repr(transparent)] pub struct bitcoin_hashes::hash160::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::hmac::Hmac<T: bitcoin_hashes::GeneralHash>(_)
-#[repr(transparent)] pub struct bitcoin_hashes::ripemd160::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha1::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256d::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256t::Hash<T>(_, _)
-#[repr(transparent)] pub struct bitcoin_hashes::sha384::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha512::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha512_256::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::siphash24::Hash(_)
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::hash160::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::ripemd160::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha1::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256d::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha384::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512_256::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::siphash24::HashEngine
-impl bitcoin_hashes::error::FromSliceError
-impl bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::hash160::HashEngine
-impl bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::ripemd160::HashEngine
-impl bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::sha1::HashEngine
-impl bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::sha256::HashEngine
-impl bitcoin_hashes::sha256::Midstate
-impl bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::sha256d::HashEngine
-impl bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::sha384::HashEngine
-impl bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::sha512::HashEngine
-impl bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::sha512_256::HashEngine
-impl bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::siphash24::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::hash160::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::ripemd160::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::sha1::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::sha256::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::sha256d::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::sha384::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::sha512::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::sha512_256::HashEngine
-impl bitcoin_io::Write for bitcoin_hashes::siphash24::HashEngine
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::hash160::Hash
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::sha1::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256d::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
-impl core::borrow::Borrow<[u8; 48]> for bitcoin_hashes::sha384::Hash
-impl core::borrow::Borrow<[u8; 64]> for bitcoin_hashes::sha512::Hash
-impl core::borrow::Borrow<[u8; 8]> for bitcoin_hashes::siphash24::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::hash160::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::ripemd160::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha1::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256d::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha384::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512_256::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::siphash24::Hash
-impl core::clone::Clone for bitcoin_hashes::error::FromSliceError
-impl core::clone::Clone for bitcoin_hashes::hash160::Hash
-impl core::clone::Clone for bitcoin_hashes::hash160::HashEngine
-impl core::clone::Clone for bitcoin_hashes::hkdf::MaxLengthError
-impl core::clone::Clone for bitcoin_hashes::ripemd160::Hash
-impl core::clone::Clone for bitcoin_hashes::ripemd160::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha1::Hash
-impl core::clone::Clone for bitcoin_hashes::sha1::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha256::Hash
-impl core::clone::Clone for bitcoin_hashes::sha256::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha256::Midstate
-impl core::clone::Clone for bitcoin_hashes::sha256::MidstateError
-impl core::clone::Clone for bitcoin_hashes::sha256d::Hash
-impl core::clone::Clone for bitcoin_hashes::sha256d::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha384::Hash
-impl core::clone::Clone for bitcoin_hashes::sha384::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha512::Hash
-impl core::clone::Clone for bitcoin_hashes::sha512::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha512_256::Hash
-impl core::clone::Clone for bitcoin_hashes::sha512_256::HashEngine
-impl core::clone::Clone for bitcoin_hashes::siphash24::Hash
-impl core::clone::Clone for bitcoin_hashes::siphash24::HashEngine
-impl core::clone::Clone for bitcoin_hashes::siphash24::State
-impl core::cmp::Eq for bitcoin_hashes::error::FromSliceError
-impl core::cmp::Eq for bitcoin_hashes::hash160::Hash
-impl core::cmp::Eq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::cmp::Eq for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha1::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha256::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha256::Midstate
-impl core::cmp::Eq for bitcoin_hashes::sha256::MidstateError
-impl core::cmp::Eq for bitcoin_hashes::sha256d::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha384::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha512::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::Eq for bitcoin_hashes::siphash24::Hash
-impl core::cmp::Ord for bitcoin_hashes::hash160::Hash
-impl core::cmp::Ord for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha1::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha256::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha256::Midstate
-impl core::cmp::Ord for bitcoin_hashes::sha256d::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha384::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha512::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::Ord for bitcoin_hashes::siphash24::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::error::FromSliceError
-impl core::cmp::PartialEq for bitcoin_hashes::hash160::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::cmp::PartialEq for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha1::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::Midstate
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::MidstateError
-impl core::cmp::PartialEq for bitcoin_hashes::sha256d::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha384::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha512::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::siphash24::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::hash160::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha1::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Midstate
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256d::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha384::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha512::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::siphash24::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::hash160::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::sha1::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256d::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
-impl core::convert::AsRef<[u8; 48]> for bitcoin_hashes::sha384::Hash
-impl core::convert::AsRef<[u8; 64]> for bitcoin_hashes::sha512::Hash
-impl core::convert::AsRef<[u8; 8]> for bitcoin_hashes::siphash24::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::hash160::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::ripemd160::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha1::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Midstate
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256d::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha384::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512_256::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::siphash24::Hash
-impl core::convert::From<core::convert::Infallible> for bitcoin_hashes::error::FromSliceError
-impl core::default::Default for bitcoin_hashes::hash160::HashEngine
-impl core::default::Default for bitcoin_hashes::ripemd160::HashEngine
-impl core::default::Default for bitcoin_hashes::sha1::HashEngine
-impl core::default::Default for bitcoin_hashes::sha256::HashEngine
-impl core::default::Default for bitcoin_hashes::sha256::Midstate
-impl core::default::Default for bitcoin_hashes::sha256d::HashEngine
-impl core::default::Default for bitcoin_hashes::sha384::HashEngine
-impl core::default::Default for bitcoin_hashes::sha512::HashEngine
-impl core::default::Default for bitcoin_hashes::sha512_256::HashEngine
-impl core::error::Error for bitcoin_hashes::error::FromSliceError
-impl core::error::Error for bitcoin_hashes::hkdf::MaxLengthError
-impl core::error::Error for bitcoin_hashes::sha256::MidstateError
-impl core::fmt::Debug for bitcoin_hashes::error::FromSliceError
-impl core::fmt::Debug for bitcoin_hashes::hash160::Hash
-impl core::fmt::Debug for bitcoin_hashes::hkdf::MaxLengthError
-impl core::fmt::Debug for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha1::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha256::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha256::Midstate
-impl core::fmt::Debug for bitcoin_hashes::sha256::MidstateError
-impl core::fmt::Debug for bitcoin_hashes::sha256d::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha384::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha512::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::Debug for bitcoin_hashes::siphash24::Hash
-impl core::fmt::Debug for bitcoin_hashes::siphash24::HashEngine
-impl core::fmt::Debug for bitcoin_hashes::siphash24::State
-impl core::fmt::Display for bitcoin_hashes::error::FromSliceError
-impl core::fmt::Display for bitcoin_hashes::hash160::Hash
-impl core::fmt::Display for bitcoin_hashes::hkdf::MaxLengthError
-impl core::fmt::Display for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::Display for bitcoin_hashes::sha1::Hash
-impl core::fmt::Display for bitcoin_hashes::sha256::Hash
-impl core::fmt::Display for bitcoin_hashes::sha256::MidstateError
-impl core::fmt::Display for bitcoin_hashes::sha256d::Hash
-impl core::fmt::Display for bitcoin_hashes::sha384::Hash
-impl core::fmt::Display for bitcoin_hashes::sha512::Hash
-impl core::fmt::Display for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::Display for bitcoin_hashes::siphash24::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::hash160::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha1::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha256::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha256d::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha384::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha512::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::siphash24::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::hash160::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha1::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha256::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha256d::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha384::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha512::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::siphash24::Hash
-impl core::hash::Hash for bitcoin_hashes::hash160::Hash
-impl core::hash::Hash for bitcoin_hashes::ripemd160::Hash
-impl core::hash::Hash for bitcoin_hashes::sha1::Hash
-impl core::hash::Hash for bitcoin_hashes::sha256::Hash
-impl core::hash::Hash for bitcoin_hashes::sha256::Midstate
-impl core::hash::Hash for bitcoin_hashes::sha256d::Hash
-impl core::hash::Hash for bitcoin_hashes::sha384::Hash
-impl core::hash::Hash for bitcoin_hashes::sha512::Hash
-impl core::hash::Hash for bitcoin_hashes::sha512_256::Hash
-impl core::hash::Hash for bitcoin_hashes::siphash24::Hash
-impl core::marker::Copy for bitcoin_hashes::hash160::Hash
-impl core::marker::Copy for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Copy for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Copy for bitcoin_hashes::sha1::Hash
-impl core::marker::Copy for bitcoin_hashes::sha256::Hash
-impl core::marker::Copy for bitcoin_hashes::sha256::Midstate
-impl core::marker::Copy for bitcoin_hashes::sha256d::Hash
-impl core::marker::Copy for bitcoin_hashes::sha384::Hash
-impl core::marker::Copy for bitcoin_hashes::sha512::Hash
-impl core::marker::Copy for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Copy for bitcoin_hashes::siphash24::Hash
-impl core::marker::Freeze for bitcoin_hashes::error::FromSliceError
-impl core::marker::Freeze for bitcoin_hashes::hash160::Hash
-impl core::marker::Freeze for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Freeze for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Freeze for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha1::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha256::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha256::Midstate
-impl core::marker::Freeze for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Freeze for bitcoin_hashes::sha256d::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha384::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha512::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::siphash24::Hash
-impl core::marker::Freeze for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::siphash24::State
-impl core::marker::Send for bitcoin_hashes::error::FromSliceError
-impl core::marker::Send for bitcoin_hashes::hash160::Hash
-impl core::marker::Send for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Send for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Send for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Send for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha1::Hash
-impl core::marker::Send for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha256::Hash
-impl core::marker::Send for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha256::Midstate
-impl core::marker::Send for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Send for bitcoin_hashes::sha256d::Hash
-impl core::marker::Send for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha384::Hash
-impl core::marker::Send for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha512::Hash
-impl core::marker::Send for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Send for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Send for bitcoin_hashes::siphash24::Hash
-impl core::marker::Send for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Send for bitcoin_hashes::siphash24::State
-impl core::marker::StructuralPartialEq for bitcoin_hashes::error::FromSliceError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::hash160::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::ripemd160::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha1::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Midstate
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::MidstateError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256d::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha384::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512_256::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::siphash24::Hash
-impl core::marker::Sync for bitcoin_hashes::error::FromSliceError
-impl core::marker::Sync for bitcoin_hashes::hash160::Hash
-impl core::marker::Sync for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Sync for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Sync for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Sync for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha1::Hash
-impl core::marker::Sync for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha256::Hash
-impl core::marker::Sync for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha256::Midstate
-impl core::marker::Sync for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Sync for bitcoin_hashes::sha256d::Hash
-impl core::marker::Sync for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha384::Hash
-impl core::marker::Sync for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha512::Hash
-impl core::marker::Sync for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Sync for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Sync for bitcoin_hashes::siphash24::Hash
-impl core::marker::Sync for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Sync for bitcoin_hashes::siphash24::State
-impl core::marker::Unpin for bitcoin_hashes::error::FromSliceError
-impl core::marker::Unpin for bitcoin_hashes::hash160::Hash
-impl core::marker::Unpin for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Unpin for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Unpin for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha1::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha256::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha256::Midstate
-impl core::marker::Unpin for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Unpin for bitcoin_hashes::sha256d::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha384::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha512::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::siphash24::Hash
-impl core::marker::Unpin for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::siphash24::State
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::error::FromSliceError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Midstate
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::MidstateError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::State
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::error::FromSliceError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Midstate
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::MidstateError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::State
-impl core::str::traits::FromStr for bitcoin_hashes::hash160::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::ripemd160::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha1::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha256::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha256d::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha384::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha512::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha512_256::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::siphash24::Hash
-impl serde::ser::Serialize for bitcoin_hashes::hash160::Hash
-impl serde::ser::Serialize for bitcoin_hashes::ripemd160::Hash
-impl serde::ser::Serialize for bitcoin_hashes::sha1::Hash
-impl serde::ser::Serialize for bitcoin_hashes::sha256::Hash
-impl serde::ser::Serialize for bitcoin_hashes::sha256d::Hash
-impl serde::ser::Serialize for bitcoin_hashes::sha384::Hash
-impl serde::ser::Serialize for bitcoin_hashes::sha512::Hash
-impl serde::ser::Serialize for bitcoin_hashes::sha512_256::Hash
-impl serde::ser::Serialize for bitcoin_hashes::siphash24::Hash
-impl std::io::Write for bitcoin_hashes::hash160::HashEngine
-impl std::io::Write for bitcoin_hashes::ripemd160::HashEngine
-impl std::io::Write for bitcoin_hashes::sha1::HashEngine
-impl std::io::Write for bitcoin_hashes::sha256::HashEngine
-impl std::io::Write for bitcoin_hashes::sha256d::HashEngine
-impl std::io::Write for bitcoin_hashes::sha384::HashEngine
-impl std::io::Write for bitcoin_hashes::sha512::HashEngine
-impl std::io::Write for bitcoin_hashes::sha512_256::HashEngine
-impl std::io::Write for bitcoin_hashes::siphash24::HashEngine
-impl<'de, T: bitcoin_hashes::GeneralHash + serde::de::Deserialize<'de>> serde::de::Deserialize<'de> for bitcoin_hashes::hmac::Hmac<T>
-impl<'de, T: bitcoin_hashes::sha256t::Tag> serde::de::Deserialize<'de> for bitcoin_hashes::sha256t::Hash<T>
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::hash160::Hash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::ripemd160::Hash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha1::Hash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha256::Hash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha256d::Hash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha384::Hash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha512::Hash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::sha512_256::Hash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_hashes::siphash24::Hash
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::Debug> core::fmt::Debug for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::Display> core::fmt::Display for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::LowerHex> core::fmt::LowerHex for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::str::traits::FromStr> core::str::traits::FromStr for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + serde::ser::Serialize> serde::ser::Serialize for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_io::Write for bitcoin_hashes::hmac::HmacEngine<T>
-impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> std::io::Write for bitcoin_hashes::hmac::HmacEngine<T>
-impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::Hash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::clone::Clone for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Eq for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Ord for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Display for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::LowerHex for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::UpperHex for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::hash::Hash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::marker::Copy for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::str::traits::FromStr for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> serde::ser::Serialize for bitcoin_hashes::sha256t::Hash<T>
-impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::clone::Clone
-impl<T: core::cmp::Eq + bitcoin_hashes::GeneralHash> core::cmp::Eq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::Ord + bitcoin_hashes::GeneralHash> core::cmp::Ord for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::PartialEq + bitcoin_hashes::GeneralHash> core::cmp::PartialEq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::PartialOrd + bitcoin_hashes::GeneralHash> core::cmp::PartialOrd for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::hash::Hash + bitcoin_hashes::GeneralHash> core::hash::Hash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::marker::Copy + bitcoin_hashes::GeneralHash> core::marker::Copy for bitcoin_hashes::hmac::Hmac<T>
-impl<T> bitcoin_hashes::sha256t::Hash<T> where T: bitcoin_hashes::sha256t::Tag
-impl<T> core::marker::Freeze for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::sha256t::Hash<T>
-impl<T> core::marker::Send for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Send
-impl<T> core::marker::Sync for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Sync
-impl<T> core::marker::Unpin for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Unpin
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<ValueT, const N: usize> core::default::Default for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>
-impl<ValueT, const N: usize> core::marker::Freeze for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>
-impl<ValueT, const N: usize> core::marker::Send for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::marker::Send
-impl<ValueT, const N: usize> core::marker::Sync for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::marker::Sync
-impl<ValueT, const N: usize> core::marker::Unpin for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::marker::Unpin
-impl<ValueT, const N: usize> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::panic::unwind_safe::RefUnwindSafe
-impl<ValueT, const N: usize> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: core::panic::unwind_safe::UnwindSafe
-impl<ValueT, const N: usize> serde::de::Visitor<'_> for bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N> where ValueT: bitcoin_hashes::Hash + bitcoin_hashes::Hash<Bytes = [u8; N]>
-impl<ValueT> core::default::Default for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>
-impl<ValueT> core::marker::Freeze for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>
-impl<ValueT> core::marker::Send for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::marker::Send
-impl<ValueT> core::marker::Sync for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::marker::Sync
-impl<ValueT> core::marker::Unpin for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::marker::Unpin
-impl<ValueT> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::panic::unwind_safe::RefUnwindSafe
-impl<ValueT> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::panic::unwind_safe::UnwindSafe
-impl<ValueT> serde::de::Visitor<'_> for bitcoin_hashes::macros::serde_details::HexVisitor<ValueT> where ValueT: core::str::traits::FromStr, <ValueT as core::str::traits::FromStr>::Err: core::fmt::Display
-impl<const N: usize> bitcoin_hashes::IsByteArray for [u8; N]
-pub const [u8; N]::LEN: usize
-pub const bitcoin_hashes::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::Hash::LEN: usize
-pub const bitcoin_hashes::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::IsByteArray::LEN: usize
-pub const bitcoin_hashes::hash160::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::hash160::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::hmac::HmacEngine<T>::BLOCK_SIZE: usize
-pub const bitcoin_hashes::ripemd160::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::ripemd160::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha1::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha1::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha256::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256d::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha256d::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256t::Hash<T>::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha384::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha384::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha512::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha512::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha512_256::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha512_256::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize
-pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::hash160::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::ripemd160::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::sha1::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::hash_unoptimized(bytes: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha256::HashEngine::can_extract_midstate(&self) -> bool
-pub const fn bitcoin_hashes::sha256::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::as_parts(&self) -> (&[u8; 32], u64)
-pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::new(state: [u8; 32], bytes_hashed: u64) -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::to_parts(self) -> ([u8; 32], u64)
-pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha256d::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48]
-pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self
-pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48]
-pub const fn bitcoin_hashes::sha384::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64]
-pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self
-pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64]
-pub const fn bitcoin_hashes::sha512::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha512_256::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8]
-pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self
-pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8]
-pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
-pub extern crate bitcoin_hashes::hex
-pub extern crate bitcoin_hashes::serde
-pub fn bitcoin_hashes::GeneralHash::engine() -> Self::Engine where Self::Engine: core::default::Default
-pub fn bitcoin_hashes::GeneralHash::from_engine(e: Self::Engine) -> Self
-pub fn bitcoin_hashes::GeneralHash::hash(data: &[u8]) -> Self where Self::Engine: core::default::Default
-pub fn bitcoin_hashes::GeneralHash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>, Self::Engine: core::default::Default
-pub fn bitcoin_hashes::GeneralHash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error> where Self::Engine: core::default::Default
-pub fn bitcoin_hashes::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::Hash::from_slice(sl: &[u8]) -> core::result::Result<Self, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::cmp::fixed_time_eq(a: &[u8], b: &[u8]) -> bool
-pub fn bitcoin_hashes::debug_hex(bytes: &[u8], f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::error::FromSliceError::clone(&self) -> bitcoin_hashes::error::FromSliceError
-pub fn bitcoin_hashes::error::FromSliceError::eq(&self, other: &bitcoin_hashes::error::FromSliceError) -> bool
-pub fn bitcoin_hashes::error::FromSliceError::expected_length(&self) -> usize
-pub fn bitcoin_hashes::error::FromSliceError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::error::FromSliceError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_hashes::error::FromSliceError::invalid_length(&self) -> usize
-pub fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash
-pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::hash160::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::hash160::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::hash160::HashEngine
-pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool
-pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::hash160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::hash160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::hash160::HashEngine) -> bitcoin_hashes::hash160::Hash
-pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hash160::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::hash160::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::hash160::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::hash160::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::hash160::HashEngine::clone(&self) -> bitcoin_hashes::hash160::HashEngine
-pub fn bitcoin_hashes::hash160::HashEngine::default() -> Self
-pub fn bitcoin_hashes::hash160::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::hash160::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::hash160::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::hash160::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::hash160::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::hash160::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand(&self, info: &[u8], okm: &mut [u8]) -> core::result::Result<(), bitcoin_hashes::hkdf::MaxLengthError>
-pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand_to_len(&self, info: &[u8], len: usize) -> core::result::Result<alloc::vec::Vec<u8>, bitcoin_hashes::hkdf::MaxLengthError>
-pub fn bitcoin_hashes::hkdf::Hkdf<T>::new(salt: &[u8], ikm: &[u8]) -> Self
-pub fn bitcoin_hashes::hkdf::MaxLengthError::clone(&self) -> bitcoin_hashes::hkdf::MaxLengthError
-pub fn bitcoin_hashes::hkdf::MaxLengthError::eq(&self, other: &bitcoin_hashes::hkdf::MaxLengthError) -> bool
-pub fn bitcoin_hashes::hkdf::MaxLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hmac::Hmac<T>::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
-pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::hmac::Hmac<T>::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::hmac::Hmac<T>::engine(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
-pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_engine(e: bitcoin_hashes::hmac::HmacEngine<T>) -> bitcoin_hashes::hmac::Hmac<T>
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::hmac::Hmac<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::hmac::Hmac<T>::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::input(&mut self, buf: &[u8])
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::new(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>::default() -> Self
-pub fn bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>::expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>::visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E> where E: serde::de::Error
-pub fn bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::default() -> Self
-pub fn bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::visit_bytes<E>(self, v: &[u8]) -> core::result::Result<Self::Value, E> where E: serde::de::Error
-pub fn bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::visit_str<E>(self, v: &str) -> core::result::Result<Self::Value, E> where E: serde::de::Error
-pub fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash
-pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::ripemd160::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::ripemd160::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine
-pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool
-pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160::HashEngine) -> bitcoin_hashes::ripemd160::Hash
-pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::ripemd160::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::ripemd160::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::ripemd160::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::ripemd160::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::ripemd160::HashEngine::clone(&self) -> bitcoin_hashes::ripemd160::HashEngine
-pub fn bitcoin_hashes::ripemd160::HashEngine::default() -> Self
-pub fn bitcoin_hashes::ripemd160::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::ripemd160::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::ripemd160::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::ripemd160::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::ripemd160::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::ripemd160::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash
-pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha1::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha1::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine
-pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool
-pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha1::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::sha1::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngine) -> bitcoin_hashes::sha1::Hash
-pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha1::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha1::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha1::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha1::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha1::HashEngine::clone(&self) -> bitcoin_hashes::sha1::HashEngine
-pub fn bitcoin_hashes::sha1::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha1::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::sha1::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::sha1::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha1::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha1::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::sha1::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash
-pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha256::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool
-pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256::Hash
-pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256::HashEngine::clone(&self) -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha256::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::sha256::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::sha256::HashEngine::from_midstate(midstate: bitcoin_hashes::sha256::Midstate) -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha256::HashEngine::midstate(&self) -> core::result::Result<bitcoin_hashes::sha256::Midstate, bitcoin_hashes::sha256::MidstateError>
-pub fn bitcoin_hashes::sha256::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha256::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::sha256::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::sha256::Midstate::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Midstate::clone(&self) -> bitcoin_hashes::sha256::Midstate
-pub fn bitcoin_hashes::sha256::Midstate::cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256::Midstate::default() -> bitcoin_hashes::sha256::Midstate
-pub fn bitcoin_hashes::sha256::Midstate::eq(&self, other: &bitcoin_hashes::sha256::Midstate) -> bool
-pub fn bitcoin_hashes::sha256::Midstate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256::MidstateError::clone(&self) -> bitcoin_hashes::sha256::MidstateError
-pub fn bitcoin_hashes::sha256::MidstateError::eq(&self, other: &bitcoin_hashes::sha256::MidstateError) -> bool
-pub fn bitcoin_hashes::sha256::MidstateError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256d::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha256d::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256d::HashEngine
-pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool
-pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256d::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256d::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256d::HashEngine) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256d::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256d::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256d::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256d::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256d::HashEngine::clone(&self) -> bitcoin_hashes::sha256d::HashEngine
-pub fn bitcoin_hashes::sha256d::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha256d::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::sha256d::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::sha256d::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::sha256d::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha256d::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::sha256d::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256t::Hash<T>::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
-pub fn bitcoin_hashes::sha256t::Hash<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash<T>
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash<H: core::hash::Hasher>(&self, h: &mut H)
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::sha256t::Hash<T>::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256t::Hash<T>::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8; 48]
-pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8; 48]
-pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash
-pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha384::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha384::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine
-pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool
-pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha384::Hash::from_bytes_mut(bytes: &mut [u8; 48]) -> &mut Self
-pub fn bitcoin_hashes::sha384::Hash::from_bytes_ref(bytes: &[u8; 48]) -> &Self
-pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::HashEngine) -> bitcoin_hashes::sha384::Hash
-pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha384::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha384::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha384::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha384::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha384::HashEngine::clone(&self) -> bitcoin_hashes::sha384::HashEngine
-pub fn bitcoin_hashes::sha384::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha384::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::sha384::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::sha384::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha384::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha384::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::sha384::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8; 64]
-pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8; 64]
-pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash
-pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha512::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha512::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine
-pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool
-pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha512::Hash::from_bytes_mut(bytes: &mut [u8; 64]) -> &mut Self
-pub fn bitcoin_hashes::sha512::Hash::from_bytes_ref(bytes: &[u8; 64]) -> &Self
-pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::HashEngine) -> bitcoin_hashes::sha512::Hash
-pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha512::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha512::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha512::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha512::HashEngine::clone(&self) -> bitcoin_hashes::sha512::HashEngine
-pub fn bitcoin_hashes::sha512::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha512::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::sha512::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::sha512::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha512::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha512::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::sha512::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash
-pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha512_256::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::sha512_256::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine
-pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool
-pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_256::HashEngine) -> bitcoin_hashes::sha512_256::Hash
-pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512_256::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha512_256::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha512_256::Hash::hash_reader<R: bitcoin_io::BufRead>(reader: &mut R) -> core::result::Result<Self, bitcoin_io::error::Error>
-pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha512_256::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha512_256::HashEngine::clone(&self) -> bitcoin_hashes::sha512_256::HashEngine
-pub fn bitcoin_hashes::sha512_256::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha512_256::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::sha512_256::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::sha512_256::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha512_256::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha512_256::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::sha512_256::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8; 8]
-pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::siphash24::Hash::as_u64(&self) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8; 8]
-pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::siphash24::Hash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_hashes::siphash24::Hash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_hashes::siphash24::Hash::engine(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
-pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
-pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::siphash24::Hash::from_bytes_mut(bytes: &mut [u8; 8]) -> &mut Self
-pub fn bitcoin_hashes::siphash24::Hash::from_bytes_ref(bytes: &[u8; 8]) -> &Self
-pub fn bitcoin_hashes::siphash24::Hash::from_engine(e: bitcoin_hashes::siphash24::HashEngine) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::from_engine_to_u64(e: bitcoin_hashes::siphash24::HashEngine) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::siphash24::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::siphash24::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::partial_cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::siphash24::Hash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::siphash24::Hash::to_u64(self) -> u64
-pub fn bitcoin_hashes::siphash24::HashEngine::clone(&self) -> bitcoin_hashes::siphash24::HashEngine
-pub fn bitcoin_hashes::siphash24::HashEngine::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_hashes::siphash24::HashEngine::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_hashes::siphash24::HashEngine::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::siphash24::HashEngine::input(&mut self, msg: &[u8])
-pub fn bitcoin_hashes::siphash24::HashEngine::keys(&self) -> (u64, u64)
-pub fn bitcoin_hashes::siphash24::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::siphash24::HashEngine::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_hashes::siphash24::HashEngine::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_hashes::siphash24::State::clone(&self) -> bitcoin_hashes::siphash24::State
-pub fn bitcoin_hashes::siphash24::State::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub macro bitcoin_hashes::hash_newtype!
-pub macro bitcoin_hashes::impl_debug_only_for_newtype!
-pub macro bitcoin_hashes::impl_hex_for_newtype!
-pub macro bitcoin_hashes::impl_serde_for_newtype!
-pub macro bitcoin_hashes::sha256t_hash_newtype!
-pub macro bitcoin_hashes::sha256t_tag!
-pub mod bitcoin_hashes
-pub mod bitcoin_hashes::cmp
-pub mod bitcoin_hashes::error
-pub mod bitcoin_hashes::hash160
-pub mod bitcoin_hashes::hkdf
-pub mod bitcoin_hashes::hmac
-pub mod bitcoin_hashes::macros
-pub mod bitcoin_hashes::macros::serde_details
-pub mod bitcoin_hashes::ripemd160
-pub mod bitcoin_hashes::serde_macros
-pub mod bitcoin_hashes::serde_macros::serde_details
-pub mod bitcoin_hashes::sha1
-pub mod bitcoin_hashes::sha256
-pub mod bitcoin_hashes::sha256d
-pub mod bitcoin_hashes::sha256t
-pub mod bitcoin_hashes::sha384
-pub mod bitcoin_hashes::sha512
-pub mod bitcoin_hashes::sha512_256
-pub mod bitcoin_hashes::siphash24
-pub struct bitcoin_hashes::FromSliceError(_)
-pub struct bitcoin_hashes::Hkdf<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::HmacEngine<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::error::FromSliceError(_)
-pub struct bitcoin_hashes::hash160::HashEngine(_)
-pub struct bitcoin_hashes::hkdf::Hkdf<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::hkdf::MaxLengthError
-pub struct bitcoin_hashes::hmac::HmacEngine<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, const N: usize>(_)
-pub struct bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>(_)
-pub struct bitcoin_hashes::ripemd160::HashEngine
-pub struct bitcoin_hashes::serde_macros::serde_details::BytesVisitor<ValueT, const N: usize>(_)
-pub struct bitcoin_hashes::serde_macros::serde_details::HexVisitor<ValueT>(_)
-pub struct bitcoin_hashes::sha1::HashEngine
-pub struct bitcoin_hashes::sha256::HashEngine
-pub struct bitcoin_hashes::sha256::Midstate
-pub struct bitcoin_hashes::sha256::MidstateError
-pub struct bitcoin_hashes::sha256d::HashEngine(_)
-pub struct bitcoin_hashes::sha384::HashEngine(_)
-pub struct bitcoin_hashes::sha512::HashEngine
-pub struct bitcoin_hashes::sha512_256::HashEngine(_)
-pub struct bitcoin_hashes::siphash24::HashEngine
-pub struct bitcoin_hashes::siphash24::State
-pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
-pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
-pub trait bitcoin_hashes::HashEngine: core::clone::Clone
-pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + bitcoin_hashes::sealed::IsByteArray
-pub trait bitcoin_hashes::sha256t::Tag
-pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
-pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
-pub type bitcoin_hashes::HkdfSha256 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha256::Hash>
-pub type bitcoin_hashes::HkdfSha512 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha512::Hash>
-pub type bitcoin_hashes::HmacSha256 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha256::Hash>
-pub type bitcoin_hashes::HmacSha512 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha512::Hash>
-pub type bitcoin_hashes::Sha256t<T> = bitcoin_hashes::sha256t::Hash<T>
-pub type bitcoin_hashes::hash160::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::hash160::Hash::Engine = bitcoin_hashes::hash160::HashEngine
-pub type bitcoin_hashes::hash160::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::hmac::Hmac<T>::Bytes = <T as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_hashes::hmac::Hmac<T>::Engine = bitcoin_hashes::hmac::HmacEngine<T>
-pub type bitcoin_hashes::hmac::Hmac<T>::Err = <T as core::str::traits::FromStr>::Err
-pub type bitcoin_hashes::macros::serde_details::BytesVisitor<ValueT, N>::Value = ValueT
-pub type bitcoin_hashes::macros::serde_details::HexVisitor<ValueT>::Value = ValueT
-pub type bitcoin_hashes::ripemd160::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::ripemd160::Hash::Engine = bitcoin_hashes::ripemd160::HashEngine
-pub type bitcoin_hashes::ripemd160::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha1::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::sha1::Hash::Engine = bitcoin_hashes::sha1::HashEngine
-pub type bitcoin_hashes::sha1::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha256::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256::Hash::Engine = bitcoin_hashes::sha256::HashEngine
-pub type bitcoin_hashes::sha256::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha256d::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256d::Hash::Engine = bitcoin_hashes::sha256d::HashEngine
-pub type bitcoin_hashes::sha256d::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha256t::Hash<T>::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256t::Hash<T>::Engine = bitcoin_hashes::sha256::HashEngine
-pub type bitcoin_hashes::sha256t::Hash<T>::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha384::Hash::Bytes = [u8; 48]
-pub type bitcoin_hashes::sha384::Hash::Engine = bitcoin_hashes::sha384::HashEngine
-pub type bitcoin_hashes::sha384::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha512::Hash::Bytes = [u8; 64]
-pub type bitcoin_hashes::sha512::Hash::Engine = bitcoin_hashes::sha512::HashEngine
-pub type bitcoin_hashes::sha512::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha512_256::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha512_256::Hash::Engine = bitcoin_hashes::sha512_256::HashEngine
-pub type bitcoin_hashes::sha512_256::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::siphash24::Hash::Bytes = [u8; 8]
-pub type bitcoin_hashes::siphash24::Hash::Engine = bitcoin_hashes::siphash24::HashEngine
-pub type bitcoin_hashes::siphash24::Hash::Err = hex_conservative::error::HexToArrayError
diff --git a/api/hashes/alloc-only.txt b/api/hashes/alloc-only.txt
deleted file mode 100644
index f8f73b48d8..0000000000
--- a/api/hashes/alloc-only.txt
+++ /dev/null
@@ -1,943 +0,0 @@
-#[repr(transparent)] pub struct bitcoin_hashes::Hash160(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Hmac<T: bitcoin_hashes::GeneralHash>(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Ripemd160(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha1(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha256(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha256d(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha384(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha512(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha512_256(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Siphash24(_)
-#[repr(transparent)] pub struct bitcoin_hashes::hash160::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::hmac::Hmac<T: bitcoin_hashes::GeneralHash>(_)
-#[repr(transparent)] pub struct bitcoin_hashes::ripemd160::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha1::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256d::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256t::Hash<T>(_, _)
-#[repr(transparent)] pub struct bitcoin_hashes::sha384::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha512::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha512_256::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::siphash24::Hash(_)
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::hash160::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::ripemd160::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha1::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256d::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha384::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512_256::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::siphash24::HashEngine
-impl bitcoin_hashes::error::FromSliceError
-impl bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::hash160::HashEngine
-impl bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::ripemd160::HashEngine
-impl bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::sha1::HashEngine
-impl bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::sha256::HashEngine
-impl bitcoin_hashes::sha256::Midstate
-impl bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::sha256d::HashEngine
-impl bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::sha384::HashEngine
-impl bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::sha512::HashEngine
-impl bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::sha512_256::HashEngine
-impl bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::siphash24::HashEngine
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::hash160::Hash
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::sha1::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256d::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
-impl core::borrow::Borrow<[u8; 48]> for bitcoin_hashes::sha384::Hash
-impl core::borrow::Borrow<[u8; 64]> for bitcoin_hashes::sha512::Hash
-impl core::borrow::Borrow<[u8; 8]> for bitcoin_hashes::siphash24::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::hash160::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::ripemd160::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha1::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256d::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha384::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512_256::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::siphash24::Hash
-impl core::clone::Clone for bitcoin_hashes::error::FromSliceError
-impl core::clone::Clone for bitcoin_hashes::hash160::Hash
-impl core::clone::Clone for bitcoin_hashes::hash160::HashEngine
-impl core::clone::Clone for bitcoin_hashes::hkdf::MaxLengthError
-impl core::clone::Clone for bitcoin_hashes::ripemd160::Hash
-impl core::clone::Clone for bitcoin_hashes::ripemd160::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha1::Hash
-impl core::clone::Clone for bitcoin_hashes::sha1::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha256::Hash
-impl core::clone::Clone for bitcoin_hashes::sha256::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha256::Midstate
-impl core::clone::Clone for bitcoin_hashes::sha256::MidstateError
-impl core::clone::Clone for bitcoin_hashes::sha256d::Hash
-impl core::clone::Clone for bitcoin_hashes::sha256d::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha384::Hash
-impl core::clone::Clone for bitcoin_hashes::sha384::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha512::Hash
-impl core::clone::Clone for bitcoin_hashes::sha512::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha512_256::Hash
-impl core::clone::Clone for bitcoin_hashes::sha512_256::HashEngine
-impl core::clone::Clone for bitcoin_hashes::siphash24::Hash
-impl core::clone::Clone for bitcoin_hashes::siphash24::HashEngine
-impl core::clone::Clone for bitcoin_hashes::siphash24::State
-impl core::cmp::Eq for bitcoin_hashes::error::FromSliceError
-impl core::cmp::Eq for bitcoin_hashes::hash160::Hash
-impl core::cmp::Eq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::cmp::Eq for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha1::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha256::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha256::Midstate
-impl core::cmp::Eq for bitcoin_hashes::sha256::MidstateError
-impl core::cmp::Eq for bitcoin_hashes::sha256d::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha384::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha512::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::Eq for bitcoin_hashes::siphash24::Hash
-impl core::cmp::Ord for bitcoin_hashes::hash160::Hash
-impl core::cmp::Ord for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha1::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha256::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha256::Midstate
-impl core::cmp::Ord for bitcoin_hashes::sha256d::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha384::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha512::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::Ord for bitcoin_hashes::siphash24::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::error::FromSliceError
-impl core::cmp::PartialEq for bitcoin_hashes::hash160::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::cmp::PartialEq for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha1::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::Midstate
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::MidstateError
-impl core::cmp::PartialEq for bitcoin_hashes::sha256d::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha384::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha512::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::siphash24::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::hash160::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha1::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Midstate
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256d::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha384::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha512::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::siphash24::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::hash160::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::sha1::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256d::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
-impl core::convert::AsRef<[u8; 48]> for bitcoin_hashes::sha384::Hash
-impl core::convert::AsRef<[u8; 64]> for bitcoin_hashes::sha512::Hash
-impl core::convert::AsRef<[u8; 8]> for bitcoin_hashes::siphash24::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::hash160::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::ripemd160::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha1::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Midstate
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256d::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha384::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512_256::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::siphash24::Hash
-impl core::convert::From<core::convert::Infallible> for bitcoin_hashes::error::FromSliceError
-impl core::default::Default for bitcoin_hashes::hash160::HashEngine
-impl core::default::Default for bitcoin_hashes::ripemd160::HashEngine
-impl core::default::Default for bitcoin_hashes::sha1::HashEngine
-impl core::default::Default for bitcoin_hashes::sha256::HashEngine
-impl core::default::Default for bitcoin_hashes::sha256::Midstate
-impl core::default::Default for bitcoin_hashes::sha256d::HashEngine
-impl core::default::Default for bitcoin_hashes::sha384::HashEngine
-impl core::default::Default for bitcoin_hashes::sha512::HashEngine
-impl core::default::Default for bitcoin_hashes::sha512_256::HashEngine
-impl core::fmt::Debug for bitcoin_hashes::error::FromSliceError
-impl core::fmt::Debug for bitcoin_hashes::hash160::Hash
-impl core::fmt::Debug for bitcoin_hashes::hkdf::MaxLengthError
-impl core::fmt::Debug for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha1::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha256::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha256::Midstate
-impl core::fmt::Debug for bitcoin_hashes::sha256::MidstateError
-impl core::fmt::Debug for bitcoin_hashes::sha256d::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha384::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha512::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::Debug for bitcoin_hashes::siphash24::Hash
-impl core::fmt::Debug for bitcoin_hashes::siphash24::HashEngine
-impl core::fmt::Debug for bitcoin_hashes::siphash24::State
-impl core::fmt::Display for bitcoin_hashes::error::FromSliceError
-impl core::fmt::Display for bitcoin_hashes::hash160::Hash
-impl core::fmt::Display for bitcoin_hashes::hkdf::MaxLengthError
-impl core::fmt::Display for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::Display for bitcoin_hashes::sha1::Hash
-impl core::fmt::Display for bitcoin_hashes::sha256::Hash
-impl core::fmt::Display for bitcoin_hashes::sha256::MidstateError
-impl core::fmt::Display for bitcoin_hashes::sha256d::Hash
-impl core::fmt::Display for bitcoin_hashes::sha384::Hash
-impl core::fmt::Display for bitcoin_hashes::sha512::Hash
-impl core::fmt::Display for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::Display for bitcoin_hashes::siphash24::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::hash160::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha1::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha256::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha256d::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha384::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha512::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::LowerHex for bitcoin_hashes::siphash24::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::hash160::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha1::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha256::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha256d::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha384::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha512::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::UpperHex for bitcoin_hashes::siphash24::Hash
-impl core::hash::Hash for bitcoin_hashes::hash160::Hash
-impl core::hash::Hash for bitcoin_hashes::ripemd160::Hash
-impl core::hash::Hash for bitcoin_hashes::sha1::Hash
-impl core::hash::Hash for bitcoin_hashes::sha256::Hash
-impl core::hash::Hash for bitcoin_hashes::sha256::Midstate
-impl core::hash::Hash for bitcoin_hashes::sha256d::Hash
-impl core::hash::Hash for bitcoin_hashes::sha384::Hash
-impl core::hash::Hash for bitcoin_hashes::sha512::Hash
-impl core::hash::Hash for bitcoin_hashes::sha512_256::Hash
-impl core::hash::Hash for bitcoin_hashes::siphash24::Hash
-impl core::marker::Copy for bitcoin_hashes::hash160::Hash
-impl core::marker::Copy for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Copy for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Copy for bitcoin_hashes::sha1::Hash
-impl core::marker::Copy for bitcoin_hashes::sha256::Hash
-impl core::marker::Copy for bitcoin_hashes::sha256::Midstate
-impl core::marker::Copy for bitcoin_hashes::sha256d::Hash
-impl core::marker::Copy for bitcoin_hashes::sha384::Hash
-impl core::marker::Copy for bitcoin_hashes::sha512::Hash
-impl core::marker::Copy for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Copy for bitcoin_hashes::siphash24::Hash
-impl core::marker::Freeze for bitcoin_hashes::error::FromSliceError
-impl core::marker::Freeze for bitcoin_hashes::hash160::Hash
-impl core::marker::Freeze for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Freeze for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Freeze for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha1::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha256::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha256::Midstate
-impl core::marker::Freeze for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Freeze for bitcoin_hashes::sha256d::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha384::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha512::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::siphash24::Hash
-impl core::marker::Freeze for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::siphash24::State
-impl core::marker::Send for bitcoin_hashes::error::FromSliceError
-impl core::marker::Send for bitcoin_hashes::hash160::Hash
-impl core::marker::Send for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Send for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Send for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Send for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha1::Hash
-impl core::marker::Send for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha256::Hash
-impl core::marker::Send for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha256::Midstate
-impl core::marker::Send for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Send for bitcoin_hashes::sha256d::Hash
-impl core::marker::Send for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha384::Hash
-impl core::marker::Send for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha512::Hash
-impl core::marker::Send for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Send for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Send for bitcoin_hashes::siphash24::Hash
-impl core::marker::Send for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Send for bitcoin_hashes::siphash24::State
-impl core::marker::StructuralPartialEq for bitcoin_hashes::error::FromSliceError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::hash160::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::ripemd160::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha1::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Midstate
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::MidstateError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256d::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha384::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512_256::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::siphash24::Hash
-impl core::marker::Sync for bitcoin_hashes::error::FromSliceError
-impl core::marker::Sync for bitcoin_hashes::hash160::Hash
-impl core::marker::Sync for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Sync for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Sync for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Sync for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha1::Hash
-impl core::marker::Sync for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha256::Hash
-impl core::marker::Sync for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha256::Midstate
-impl core::marker::Sync for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Sync for bitcoin_hashes::sha256d::Hash
-impl core::marker::Sync for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha384::Hash
-impl core::marker::Sync for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha512::Hash
-impl core::marker::Sync for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Sync for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Sync for bitcoin_hashes::siphash24::Hash
-impl core::marker::Sync for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Sync for bitcoin_hashes::siphash24::State
-impl core::marker::Unpin for bitcoin_hashes::error::FromSliceError
-impl core::marker::Unpin for bitcoin_hashes::hash160::Hash
-impl core::marker::Unpin for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Unpin for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Unpin for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha1::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha256::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha256::Midstate
-impl core::marker::Unpin for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Unpin for bitcoin_hashes::sha256d::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha384::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha512::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::siphash24::Hash
-impl core::marker::Unpin for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::siphash24::State
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::error::FromSliceError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Midstate
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::MidstateError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::State
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::error::FromSliceError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Midstate
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::MidstateError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::State
-impl core::str::traits::FromStr for bitcoin_hashes::hash160::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::ripemd160::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha1::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha256::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha256d::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha384::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha512::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::sha512_256::Hash
-impl core::str::traits::FromStr for bitcoin_hashes::siphash24::Hash
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::Debug> core::fmt::Debug for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::Display> core::fmt::Display for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::LowerHex> core::fmt::LowerHex for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::str::traits::FromStr> core::str::traits::FromStr for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
-impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::Hash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::clone::Clone for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Eq for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Ord for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Display for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::LowerHex for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::UpperHex for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::hash::Hash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::marker::Copy for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::str::traits::FromStr for bitcoin_hashes::sha256t::Hash<T>
-impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::clone::Clone
-impl<T: core::cmp::Eq + bitcoin_hashes::GeneralHash> core::cmp::Eq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::Ord + bitcoin_hashes::GeneralHash> core::cmp::Ord for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::PartialEq + bitcoin_hashes::GeneralHash> core::cmp::PartialEq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::PartialOrd + bitcoin_hashes::GeneralHash> core::cmp::PartialOrd for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::hash::Hash + bitcoin_hashes::GeneralHash> core::hash::Hash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::marker::Copy + bitcoin_hashes::GeneralHash> core::marker::Copy for bitcoin_hashes::hmac::Hmac<T>
-impl<T> bitcoin_hashes::sha256t::Hash<T> where T: bitcoin_hashes::sha256t::Tag
-impl<T> core::marker::Freeze for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::sha256t::Hash<T>
-impl<T> core::marker::Send for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Send
-impl<T> core::marker::Sync for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Sync
-impl<T> core::marker::Unpin for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Unpin
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<const N: usize> bitcoin_hashes::IsByteArray for [u8; N]
-pub const [u8; N]::LEN: usize
-pub const bitcoin_hashes::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::Hash::LEN: usize
-pub const bitcoin_hashes::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::IsByteArray::LEN: usize
-pub const bitcoin_hashes::hash160::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::hash160::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::hmac::HmacEngine<T>::BLOCK_SIZE: usize
-pub const bitcoin_hashes::ripemd160::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::ripemd160::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha1::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha1::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha256::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256d::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha256d::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256t::Hash<T>::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha384::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha384::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha512::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha512::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha512_256::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha512_256::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize
-pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::hash160::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::ripemd160::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::sha1::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::hash_unoptimized(bytes: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha256::HashEngine::can_extract_midstate(&self) -> bool
-pub const fn bitcoin_hashes::sha256::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::as_parts(&self) -> (&[u8; 32], u64)
-pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::new(state: [u8; 32], bytes_hashed: u64) -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::to_parts(self) -> ([u8; 32], u64)
-pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha256d::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48]
-pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self
-pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48]
-pub const fn bitcoin_hashes::sha384::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64]
-pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self
-pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64]
-pub const fn bitcoin_hashes::sha512::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha512_256::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8]
-pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self
-pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8]
-pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
-pub extern crate bitcoin_hashes::hex
-pub fn bitcoin_hashes::GeneralHash::engine() -> Self::Engine where Self::Engine: core::default::Default
-pub fn bitcoin_hashes::GeneralHash::from_engine(e: Self::Engine) -> Self
-pub fn bitcoin_hashes::GeneralHash::hash(data: &[u8]) -> Self where Self::Engine: core::default::Default
-pub fn bitcoin_hashes::GeneralHash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>, Self::Engine: core::default::Default
-pub fn bitcoin_hashes::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::Hash::from_slice(sl: &[u8]) -> core::result::Result<Self, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::cmp::fixed_time_eq(a: &[u8], b: &[u8]) -> bool
-pub fn bitcoin_hashes::debug_hex(bytes: &[u8], f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::error::FromSliceError::clone(&self) -> bitcoin_hashes::error::FromSliceError
-pub fn bitcoin_hashes::error::FromSliceError::eq(&self, other: &bitcoin_hashes::error::FromSliceError) -> bool
-pub fn bitcoin_hashes::error::FromSliceError::expected_length(&self) -> usize
-pub fn bitcoin_hashes::error::FromSliceError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::error::FromSliceError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_hashes::error::FromSliceError::invalid_length(&self) -> usize
-pub fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash
-pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::hash160::HashEngine
-pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool
-pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::hash160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::hash160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::hash160::HashEngine) -> bitcoin_hashes::hash160::Hash
-pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hash160::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::hash160::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::hash160::HashEngine::clone(&self) -> bitcoin_hashes::hash160::HashEngine
-pub fn bitcoin_hashes::hash160::HashEngine::default() -> Self
-pub fn bitcoin_hashes::hash160::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::hash160::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand(&self, info: &[u8], okm: &mut [u8]) -> core::result::Result<(), bitcoin_hashes::hkdf::MaxLengthError>
-pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand_to_len(&self, info: &[u8], len: usize) -> core::result::Result<alloc::vec::Vec<u8>, bitcoin_hashes::hkdf::MaxLengthError>
-pub fn bitcoin_hashes::hkdf::Hkdf<T>::new(salt: &[u8], ikm: &[u8]) -> Self
-pub fn bitcoin_hashes::hkdf::MaxLengthError::clone(&self) -> bitcoin_hashes::hkdf::MaxLengthError
-pub fn bitcoin_hashes::hkdf::MaxLengthError::eq(&self, other: &bitcoin_hashes::hkdf::MaxLengthError) -> bool
-pub fn bitcoin_hashes::hkdf::MaxLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hmac::Hmac<T>::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
-pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::hmac::Hmac<T>::engine(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
-pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_engine(e: bitcoin_hashes::hmac::HmacEngine<T>) -> bitcoin_hashes::hmac::Hmac<T>
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::hmac::Hmac<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::input(&mut self, buf: &[u8])
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::new(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-pub fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash
-pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine
-pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool
-pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160::HashEngine) -> bitcoin_hashes::ripemd160::Hash
-pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::ripemd160::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::ripemd160::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::ripemd160::HashEngine::clone(&self) -> bitcoin_hashes::ripemd160::HashEngine
-pub fn bitcoin_hashes::ripemd160::HashEngine::default() -> Self
-pub fn bitcoin_hashes::ripemd160::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::ripemd160::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash
-pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine
-pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool
-pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha1::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::sha1::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngine) -> bitcoin_hashes::sha1::Hash
-pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha1::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha1::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha1::HashEngine::clone(&self) -> bitcoin_hashes::sha1::HashEngine
-pub fn bitcoin_hashes::sha1::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha1::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha1::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash
-pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool
-pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256::Hash
-pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256::HashEngine::clone(&self) -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha256::HashEngine::from_midstate(midstate: bitcoin_hashes::sha256::Midstate) -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha256::HashEngine::midstate(&self) -> core::result::Result<bitcoin_hashes::sha256::Midstate, bitcoin_hashes::sha256::MidstateError>
-pub fn bitcoin_hashes::sha256::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha256::Midstate::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Midstate::clone(&self) -> bitcoin_hashes::sha256::Midstate
-pub fn bitcoin_hashes::sha256::Midstate::cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256::Midstate::default() -> bitcoin_hashes::sha256::Midstate
-pub fn bitcoin_hashes::sha256::Midstate::eq(&self, other: &bitcoin_hashes::sha256::Midstate) -> bool
-pub fn bitcoin_hashes::sha256::Midstate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256::MidstateError::clone(&self) -> bitcoin_hashes::sha256::MidstateError
-pub fn bitcoin_hashes::sha256::MidstateError::eq(&self, other: &bitcoin_hashes::sha256::MidstateError) -> bool
-pub fn bitcoin_hashes::sha256::MidstateError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256d::HashEngine
-pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool
-pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256d::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256d::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256d::HashEngine) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256d::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256d::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256d::HashEngine::clone(&self) -> bitcoin_hashes::sha256d::HashEngine
-pub fn bitcoin_hashes::sha256d::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha256d::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::sha256d::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
-pub fn bitcoin_hashes::sha256t::Hash<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash<T>
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash<H: core::hash::Hasher>(&self, h: &mut H)
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256t::Hash<T>::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8; 48]
-pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8; 48]
-pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash
-pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine
-pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool
-pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha384::Hash::from_bytes_mut(bytes: &mut [u8; 48]) -> &mut Self
-pub fn bitcoin_hashes::sha384::Hash::from_bytes_ref(bytes: &[u8; 48]) -> &Self
-pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::HashEngine) -> bitcoin_hashes::sha384::Hash
-pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha384::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha384::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha384::HashEngine::clone(&self) -> bitcoin_hashes::sha384::HashEngine
-pub fn bitcoin_hashes::sha384::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha384::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha384::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8; 64]
-pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8; 64]
-pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash
-pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine
-pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool
-pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha512::Hash::from_bytes_mut(bytes: &mut [u8; 64]) -> &mut Self
-pub fn bitcoin_hashes::sha512::Hash::from_bytes_ref(bytes: &[u8; 64]) -> &Self
-pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::HashEngine) -> bitcoin_hashes::sha512::Hash
-pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha512::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha512::HashEngine::clone(&self) -> bitcoin_hashes::sha512::HashEngine
-pub fn bitcoin_hashes::sha512::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha512::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha512::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash
-pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine
-pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool
-pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_256::HashEngine) -> bitcoin_hashes::sha512_256::Hash
-pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512_256::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha512_256::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha512_256::HashEngine::clone(&self) -> bitcoin_hashes::sha512_256::HashEngine
-pub fn bitcoin_hashes::sha512_256::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha512_256::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha512_256::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8; 8]
-pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::siphash24::Hash::as_u64(&self) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8; 8]
-pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::siphash24::Hash::engine(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
-pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
-pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::siphash24::Hash::from_bytes_mut(bytes: &mut [u8; 8]) -> &mut Self
-pub fn bitcoin_hashes::siphash24::Hash::from_bytes_ref(bytes: &[u8; 8]) -> &Self
-pub fn bitcoin_hashes::siphash24::Hash::from_engine(e: bitcoin_hashes::siphash24::HashEngine) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::from_engine_to_u64(e: bitcoin_hashes::siphash24::HashEngine) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::siphash24::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::siphash24::Hash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::partial_cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::siphash24::Hash::to_u64(self) -> u64
-pub fn bitcoin_hashes::siphash24::HashEngine::clone(&self) -> bitcoin_hashes::siphash24::HashEngine
-pub fn bitcoin_hashes::siphash24::HashEngine::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::siphash24::HashEngine::input(&mut self, msg: &[u8])
-pub fn bitcoin_hashes::siphash24::HashEngine::keys(&self) -> (u64, u64)
-pub fn bitcoin_hashes::siphash24::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::siphash24::State::clone(&self) -> bitcoin_hashes::siphash24::State
-pub fn bitcoin_hashes::siphash24::State::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub macro bitcoin_hashes::hash_newtype!
-pub macro bitcoin_hashes::impl_debug_only_for_newtype!
-pub macro bitcoin_hashes::impl_hex_for_newtype!
-pub macro bitcoin_hashes::sha256t_hash_newtype!
-pub macro bitcoin_hashes::sha256t_tag!
-pub mod bitcoin_hashes
-pub mod bitcoin_hashes::cmp
-pub mod bitcoin_hashes::error
-pub mod bitcoin_hashes::hash160
-pub mod bitcoin_hashes::hkdf
-pub mod bitcoin_hashes::hmac
-pub mod bitcoin_hashes::macros
-pub mod bitcoin_hashes::ripemd160
-pub mod bitcoin_hashes::serde_macros
-pub mod bitcoin_hashes::sha1
-pub mod bitcoin_hashes::sha256
-pub mod bitcoin_hashes::sha256d
-pub mod bitcoin_hashes::sha256t
-pub mod bitcoin_hashes::sha384
-pub mod bitcoin_hashes::sha512
-pub mod bitcoin_hashes::sha512_256
-pub mod bitcoin_hashes::siphash24
-pub struct bitcoin_hashes::FromSliceError(_)
-pub struct bitcoin_hashes::Hkdf<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::HmacEngine<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::error::FromSliceError(_)
-pub struct bitcoin_hashes::hash160::HashEngine(_)
-pub struct bitcoin_hashes::hkdf::Hkdf<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::hkdf::MaxLengthError
-pub struct bitcoin_hashes::hmac::HmacEngine<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::ripemd160::HashEngine
-pub struct bitcoin_hashes::sha1::HashEngine
-pub struct bitcoin_hashes::sha256::HashEngine
-pub struct bitcoin_hashes::sha256::Midstate
-pub struct bitcoin_hashes::sha256::MidstateError
-pub struct bitcoin_hashes::sha256d::HashEngine(_)
-pub struct bitcoin_hashes::sha384::HashEngine(_)
-pub struct bitcoin_hashes::sha512::HashEngine
-pub struct bitcoin_hashes::sha512_256::HashEngine(_)
-pub struct bitcoin_hashes::siphash24::HashEngine
-pub struct bitcoin_hashes::siphash24::State
-pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
-pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
-pub trait bitcoin_hashes::HashEngine: core::clone::Clone
-pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + bitcoin_hashes::sealed::IsByteArray
-pub trait bitcoin_hashes::sha256t::Tag
-pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
-pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
-pub type bitcoin_hashes::HkdfSha256 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha256::Hash>
-pub type bitcoin_hashes::HkdfSha512 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha512::Hash>
-pub type bitcoin_hashes::HmacSha256 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha256::Hash>
-pub type bitcoin_hashes::HmacSha512 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha512::Hash>
-pub type bitcoin_hashes::Sha256t<T> = bitcoin_hashes::sha256t::Hash<T>
-pub type bitcoin_hashes::hash160::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::hash160::Hash::Engine = bitcoin_hashes::hash160::HashEngine
-pub type bitcoin_hashes::hash160::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::hmac::Hmac<T>::Bytes = <T as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_hashes::hmac::Hmac<T>::Engine = bitcoin_hashes::hmac::HmacEngine<T>
-pub type bitcoin_hashes::hmac::Hmac<T>::Err = <T as core::str::traits::FromStr>::Err
-pub type bitcoin_hashes::ripemd160::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::ripemd160::Hash::Engine = bitcoin_hashes::ripemd160::HashEngine
-pub type bitcoin_hashes::ripemd160::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha1::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::sha1::Hash::Engine = bitcoin_hashes::sha1::HashEngine
-pub type bitcoin_hashes::sha1::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha256::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256::Hash::Engine = bitcoin_hashes::sha256::HashEngine
-pub type bitcoin_hashes::sha256::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha256d::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256d::Hash::Engine = bitcoin_hashes::sha256d::HashEngine
-pub type bitcoin_hashes::sha256d::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha256t::Hash<T>::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256t::Hash<T>::Engine = bitcoin_hashes::sha256::HashEngine
-pub type bitcoin_hashes::sha256t::Hash<T>::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha384::Hash::Bytes = [u8; 48]
-pub type bitcoin_hashes::sha384::Hash::Engine = bitcoin_hashes::sha384::HashEngine
-pub type bitcoin_hashes::sha384::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha512::Hash::Bytes = [u8; 64]
-pub type bitcoin_hashes::sha512::Hash::Engine = bitcoin_hashes::sha512::HashEngine
-pub type bitcoin_hashes::sha512::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::sha512_256::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha512_256::Hash::Engine = bitcoin_hashes::sha512_256::HashEngine
-pub type bitcoin_hashes::sha512_256::Hash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_hashes::siphash24::Hash::Bytes = [u8; 8]
-pub type bitcoin_hashes::siphash24::Hash::Engine = bitcoin_hashes::siphash24::HashEngine
-pub type bitcoin_hashes::siphash24::Hash::Err = hex_conservative::error::HexToArrayError
diff --git a/api/hashes/no-features.txt b/api/hashes/no-features.txt
deleted file mode 100644
index 68399650b4..0000000000
--- a/api/hashes/no-features.txt
+++ /dev/null
@@ -1,880 +0,0 @@
-#[repr(transparent)] pub struct bitcoin_hashes::Hash160(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Hmac<T: bitcoin_hashes::GeneralHash>(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Ripemd160(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha1(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha256(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha256d(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha384(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha512(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Sha512_256(_)
-#[repr(transparent)] pub struct bitcoin_hashes::Siphash24(_)
-#[repr(transparent)] pub struct bitcoin_hashes::hash160::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::hmac::Hmac<T: bitcoin_hashes::GeneralHash>(_)
-#[repr(transparent)] pub struct bitcoin_hashes::ripemd160::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha1::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256d::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha256t::Hash<T>(_, _)
-#[repr(transparent)] pub struct bitcoin_hashes::sha384::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha512::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::sha512_256::Hash(_)
-#[repr(transparent)] pub struct bitcoin_hashes::siphash24::Hash(_)
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::GeneralHash for bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::Hash for bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::hash160::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::ripemd160::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha1::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha256d::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha384::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::sha512_256::HashEngine
-impl bitcoin_hashes::HashEngine for bitcoin_hashes::siphash24::HashEngine
-impl bitcoin_hashes::error::FromSliceError
-impl bitcoin_hashes::hash160::Hash
-impl bitcoin_hashes::hash160::HashEngine
-impl bitcoin_hashes::ripemd160::Hash
-impl bitcoin_hashes::ripemd160::HashEngine
-impl bitcoin_hashes::sha1::Hash
-impl bitcoin_hashes::sha1::HashEngine
-impl bitcoin_hashes::sha256::Hash
-impl bitcoin_hashes::sha256::HashEngine
-impl bitcoin_hashes::sha256::Midstate
-impl bitcoin_hashes::sha256d::Hash
-impl bitcoin_hashes::sha256d::HashEngine
-impl bitcoin_hashes::sha384::Hash
-impl bitcoin_hashes::sha384::HashEngine
-impl bitcoin_hashes::sha512::Hash
-impl bitcoin_hashes::sha512::HashEngine
-impl bitcoin_hashes::sha512_256::Hash
-impl bitcoin_hashes::sha512_256::HashEngine
-impl bitcoin_hashes::siphash24::Hash
-impl bitcoin_hashes::siphash24::HashEngine
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::hash160::Hash
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_hashes::sha1::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256d::Hash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
-impl core::borrow::Borrow<[u8; 48]> for bitcoin_hashes::sha384::Hash
-impl core::borrow::Borrow<[u8; 64]> for bitcoin_hashes::sha512::Hash
-impl core::borrow::Borrow<[u8; 8]> for bitcoin_hashes::siphash24::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::hash160::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::ripemd160::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha1::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256d::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha384::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::sha512_256::Hash
-impl core::borrow::Borrow<[u8]> for bitcoin_hashes::siphash24::Hash
-impl core::clone::Clone for bitcoin_hashes::error::FromSliceError
-impl core::clone::Clone for bitcoin_hashes::hash160::Hash
-impl core::clone::Clone for bitcoin_hashes::hash160::HashEngine
-impl core::clone::Clone for bitcoin_hashes::hkdf::MaxLengthError
-impl core::clone::Clone for bitcoin_hashes::ripemd160::Hash
-impl core::clone::Clone for bitcoin_hashes::ripemd160::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha1::Hash
-impl core::clone::Clone for bitcoin_hashes::sha1::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha256::Hash
-impl core::clone::Clone for bitcoin_hashes::sha256::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha256::Midstate
-impl core::clone::Clone for bitcoin_hashes::sha256::MidstateError
-impl core::clone::Clone for bitcoin_hashes::sha256d::Hash
-impl core::clone::Clone for bitcoin_hashes::sha256d::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha384::Hash
-impl core::clone::Clone for bitcoin_hashes::sha384::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha512::Hash
-impl core::clone::Clone for bitcoin_hashes::sha512::HashEngine
-impl core::clone::Clone for bitcoin_hashes::sha512_256::Hash
-impl core::clone::Clone for bitcoin_hashes::sha512_256::HashEngine
-impl core::clone::Clone for bitcoin_hashes::siphash24::Hash
-impl core::clone::Clone for bitcoin_hashes::siphash24::HashEngine
-impl core::clone::Clone for bitcoin_hashes::siphash24::State
-impl core::cmp::Eq for bitcoin_hashes::error::FromSliceError
-impl core::cmp::Eq for bitcoin_hashes::hash160::Hash
-impl core::cmp::Eq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::cmp::Eq for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha1::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha256::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha256::Midstate
-impl core::cmp::Eq for bitcoin_hashes::sha256::MidstateError
-impl core::cmp::Eq for bitcoin_hashes::sha256d::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha384::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha512::Hash
-impl core::cmp::Eq for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::Eq for bitcoin_hashes::siphash24::Hash
-impl core::cmp::Ord for bitcoin_hashes::hash160::Hash
-impl core::cmp::Ord for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha1::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha256::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha256::Midstate
-impl core::cmp::Ord for bitcoin_hashes::sha256d::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha384::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha512::Hash
-impl core::cmp::Ord for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::Ord for bitcoin_hashes::siphash24::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::error::FromSliceError
-impl core::cmp::PartialEq for bitcoin_hashes::hash160::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::cmp::PartialEq for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha1::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::Midstate
-impl core::cmp::PartialEq for bitcoin_hashes::sha256::MidstateError
-impl core::cmp::PartialEq for bitcoin_hashes::sha256d::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha384::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha512::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::PartialEq for bitcoin_hashes::siphash24::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::hash160::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::ripemd160::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha1::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256::Midstate
-impl core::cmp::PartialOrd for bitcoin_hashes::sha256d::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha384::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha512::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::sha512_256::Hash
-impl core::cmp::PartialOrd for bitcoin_hashes::siphash24::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::hash160::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::ripemd160::Hash
-impl core::convert::AsRef<[u8; 20]> for bitcoin_hashes::sha1::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256d::Hash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha512_256::Hash
-impl core::convert::AsRef<[u8; 48]> for bitcoin_hashes::sha384::Hash
-impl core::convert::AsRef<[u8; 64]> for bitcoin_hashes::sha512::Hash
-impl core::convert::AsRef<[u8; 8]> for bitcoin_hashes::siphash24::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::hash160::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::ripemd160::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha1::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256::Midstate
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha256d::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha384::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::sha512_256::Hash
-impl core::convert::AsRef<[u8]> for bitcoin_hashes::siphash24::Hash
-impl core::convert::From<core::convert::Infallible> for bitcoin_hashes::error::FromSliceError
-impl core::default::Default for bitcoin_hashes::hash160::HashEngine
-impl core::default::Default for bitcoin_hashes::ripemd160::HashEngine
-impl core::default::Default for bitcoin_hashes::sha1::HashEngine
-impl core::default::Default for bitcoin_hashes::sha256::HashEngine
-impl core::default::Default for bitcoin_hashes::sha256::Midstate
-impl core::default::Default for bitcoin_hashes::sha256d::HashEngine
-impl core::default::Default for bitcoin_hashes::sha384::HashEngine
-impl core::default::Default for bitcoin_hashes::sha512::HashEngine
-impl core::default::Default for bitcoin_hashes::sha512_256::HashEngine
-impl core::fmt::Debug for bitcoin_hashes::error::FromSliceError
-impl core::fmt::Debug for bitcoin_hashes::hash160::Hash
-impl core::fmt::Debug for bitcoin_hashes::hkdf::MaxLengthError
-impl core::fmt::Debug for bitcoin_hashes::ripemd160::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha1::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha256::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha256::Midstate
-impl core::fmt::Debug for bitcoin_hashes::sha256::MidstateError
-impl core::fmt::Debug for bitcoin_hashes::sha256d::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha384::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha512::Hash
-impl core::fmt::Debug for bitcoin_hashes::sha512_256::Hash
-impl core::fmt::Debug for bitcoin_hashes::siphash24::Hash
-impl core::fmt::Debug for bitcoin_hashes::siphash24::HashEngine
-impl core::fmt::Debug for bitcoin_hashes::siphash24::State
-impl core::fmt::Display for bitcoin_hashes::error::FromSliceError
-impl core::fmt::Display for bitcoin_hashes::hkdf::MaxLengthError
-impl core::fmt::Display for bitcoin_hashes::sha256::MidstateError
-impl core::hash::Hash for bitcoin_hashes::hash160::Hash
-impl core::hash::Hash for bitcoin_hashes::ripemd160::Hash
-impl core::hash::Hash for bitcoin_hashes::sha1::Hash
-impl core::hash::Hash for bitcoin_hashes::sha256::Hash
-impl core::hash::Hash for bitcoin_hashes::sha256::Midstate
-impl core::hash::Hash for bitcoin_hashes::sha256d::Hash
-impl core::hash::Hash for bitcoin_hashes::sha384::Hash
-impl core::hash::Hash for bitcoin_hashes::sha512::Hash
-impl core::hash::Hash for bitcoin_hashes::sha512_256::Hash
-impl core::hash::Hash for bitcoin_hashes::siphash24::Hash
-impl core::marker::Copy for bitcoin_hashes::hash160::Hash
-impl core::marker::Copy for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Copy for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Copy for bitcoin_hashes::sha1::Hash
-impl core::marker::Copy for bitcoin_hashes::sha256::Hash
-impl core::marker::Copy for bitcoin_hashes::sha256::Midstate
-impl core::marker::Copy for bitcoin_hashes::sha256d::Hash
-impl core::marker::Copy for bitcoin_hashes::sha384::Hash
-impl core::marker::Copy for bitcoin_hashes::sha512::Hash
-impl core::marker::Copy for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Copy for bitcoin_hashes::siphash24::Hash
-impl core::marker::Freeze for bitcoin_hashes::error::FromSliceError
-impl core::marker::Freeze for bitcoin_hashes::hash160::Hash
-impl core::marker::Freeze for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Freeze for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Freeze for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha1::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha256::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha256::Midstate
-impl core::marker::Freeze for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Freeze for bitcoin_hashes::sha256d::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha384::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha512::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Freeze for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::siphash24::Hash
-impl core::marker::Freeze for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Freeze for bitcoin_hashes::siphash24::State
-impl core::marker::Send for bitcoin_hashes::error::FromSliceError
-impl core::marker::Send for bitcoin_hashes::hash160::Hash
-impl core::marker::Send for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Send for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Send for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Send for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha1::Hash
-impl core::marker::Send for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha256::Hash
-impl core::marker::Send for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha256::Midstate
-impl core::marker::Send for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Send for bitcoin_hashes::sha256d::Hash
-impl core::marker::Send for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha384::Hash
-impl core::marker::Send for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha512::Hash
-impl core::marker::Send for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Send for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Send for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Send for bitcoin_hashes::siphash24::Hash
-impl core::marker::Send for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Send for bitcoin_hashes::siphash24::State
-impl core::marker::StructuralPartialEq for bitcoin_hashes::error::FromSliceError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::hash160::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::ripemd160::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha1::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::Midstate
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256::MidstateError
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha256d::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha384::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::sha512_256::Hash
-impl core::marker::StructuralPartialEq for bitcoin_hashes::siphash24::Hash
-impl core::marker::Sync for bitcoin_hashes::error::FromSliceError
-impl core::marker::Sync for bitcoin_hashes::hash160::Hash
-impl core::marker::Sync for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Sync for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Sync for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Sync for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha1::Hash
-impl core::marker::Sync for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha256::Hash
-impl core::marker::Sync for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha256::Midstate
-impl core::marker::Sync for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Sync for bitcoin_hashes::sha256d::Hash
-impl core::marker::Sync for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha384::Hash
-impl core::marker::Sync for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha512::Hash
-impl core::marker::Sync for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Sync for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Sync for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Sync for bitcoin_hashes::siphash24::Hash
-impl core::marker::Sync for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Sync for bitcoin_hashes::siphash24::State
-impl core::marker::Unpin for bitcoin_hashes::error::FromSliceError
-impl core::marker::Unpin for bitcoin_hashes::hash160::Hash
-impl core::marker::Unpin for bitcoin_hashes::hash160::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::hkdf::MaxLengthError
-impl core::marker::Unpin for bitcoin_hashes::ripemd160::Hash
-impl core::marker::Unpin for bitcoin_hashes::ripemd160::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha1::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha1::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha256::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha256::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha256::Midstate
-impl core::marker::Unpin for bitcoin_hashes::sha256::MidstateError
-impl core::marker::Unpin for bitcoin_hashes::sha256d::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha256d::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha384::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha384::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha512::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha512::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::sha512_256::Hash
-impl core::marker::Unpin for bitcoin_hashes::sha512_256::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::siphash24::Hash
-impl core::marker::Unpin for bitcoin_hashes::siphash24::HashEngine
-impl core::marker::Unpin for bitcoin_hashes::siphash24::State
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::error::FromSliceError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hash160::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::ripemd160::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha1::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::Midstate
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256::MidstateError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256d::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha384::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha512_256::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::Hash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::HashEngine
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::siphash24::State
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::error::FromSliceError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hash160::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::MaxLengthError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::ripemd160::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha1::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::Midstate
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256::MidstateError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256d::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha384::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha512_256::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::Hash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::HashEngine
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::siphash24::State
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::Debug> core::fmt::Debug for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::Display> core::fmt::Display for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::fmt::LowerHex> core::fmt::LowerHex for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash + core::str::traits::FromStr> core::str::traits::FromStr for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::GeneralHash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::Hash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::HashEngine for bitcoin_hashes::hmac::HmacEngine<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hkdf::Hkdf<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> bitcoin_hashes::hmac::HmacEngine<T>
-impl<T: bitcoin_hashes::GeneralHash> core::convert::AsRef<[u8]> for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::GeneralHash> core::marker::StructuralPartialEq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::GeneralHash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> bitcoin_hashes::Hash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::borrow::Borrow<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::clone::Clone for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Eq for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::Ord for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialEq for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::cmp::PartialOrd for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8; 32]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::convert::AsRef<[u8]> for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::fmt::Debug for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::hash::Hash for bitcoin_hashes::sha256t::Hash<T>
-impl<T: bitcoin_hashes::sha256t::Tag> core::marker::Copy for bitcoin_hashes::sha256t::Hash<T>
-impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::clone::Clone + bitcoin_hashes::GeneralHash> core::clone::Clone for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::clone::Clone
-impl<T: core::cmp::Eq + bitcoin_hashes::GeneralHash> core::cmp::Eq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::Ord + bitcoin_hashes::GeneralHash> core::cmp::Ord for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::PartialEq + bitcoin_hashes::GeneralHash> core::cmp::PartialEq for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::cmp::PartialOrd + bitcoin_hashes::GeneralHash> core::cmp::PartialOrd for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::hash::Hash + bitcoin_hashes::GeneralHash> core::hash::Hash for bitcoin_hashes::hmac::Hmac<T>
-impl<T: core::marker::Copy + bitcoin_hashes::GeneralHash> core::marker::Copy for bitcoin_hashes::hmac::Hmac<T>
-impl<T> bitcoin_hashes::sha256t::Hash<T> where T: bitcoin_hashes::sha256t::Tag
-impl<T> core::marker::Freeze for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_hashes::sha256t::Hash<T>
-impl<T> core::marker::Send for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Send
-impl<T> core::marker::Send for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Send
-impl<T> core::marker::Sync for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Sync
-impl<T> core::marker::Unpin for bitcoin_hashes::hkdf::Hkdf<T> where T: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::hmac::Hmac<T> where T: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_hashes::sha256t::Hash<T> where T: core::marker::Unpin
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hkdf::Hkdf<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::Hmac<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_hashes::sha256t::Hash<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<const N: usize> bitcoin_hashes::IsByteArray for [u8; N]
-pub const [u8; N]::LEN: usize
-pub const bitcoin_hashes::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::Hash::LEN: usize
-pub const bitcoin_hashes::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::IsByteArray::LEN: usize
-pub const bitcoin_hashes::hash160::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::hash160::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::hmac::HmacEngine<T>::BLOCK_SIZE: usize
-pub const bitcoin_hashes::ripemd160::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::ripemd160::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha1::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha1::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha256::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256d::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha256d::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha256t::Hash<T>::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha384::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha384::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha512::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha512::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::sha512_256::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::sha512_256::HashEngine::BLOCK_SIZE: usize
-pub const bitcoin_hashes::siphash24::Hash::DISPLAY_BACKWARD: bool
-pub const bitcoin_hashes::siphash24::HashEngine::BLOCK_SIZE: usize
-pub const fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::hash160::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::ripemd160::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &[u8; 20]
-pub const fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: [u8; 20]) -> Self
-pub const fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> [u8; 20]
-pub const fn bitcoin_hashes::sha1::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256::Hash::const_hash(bytes: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::hash_unoptimized(bytes: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha256::HashEngine::can_extract_midstate(&self) -> bool
-pub const fn bitcoin_hashes::sha256::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::as_parts(&self) -> (&[u8; 32], u64)
-pub const fn bitcoin_hashes::sha256::Midstate::hash_tag(tag: &[u8]) -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::new(state: [u8; 32], bytes_hashed: u64) -> Self
-pub const fn bitcoin_hashes::sha256::Midstate::to_parts(self) -> ([u8; 32], u64)
-pub const fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha256d::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &[u8; 48]
-pub const fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: [u8; 48]) -> Self
-pub const fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> [u8; 48]
-pub const fn bitcoin_hashes::sha384::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &[u8; 64]
-pub const fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: [u8; 64]) -> Self
-pub const fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> [u8; 64]
-pub const fn bitcoin_hashes::sha512::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &[u8; 32]
-pub const fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: [u8; 32]) -> Self
-pub const fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> [u8; 32]
-pub const fn bitcoin_hashes::sha512_256::HashEngine::new() -> Self
-pub const fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &[u8; 8]
-pub const fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: [u8; 8]) -> Self
-pub const fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> [u8; 8]
-pub const fn bitcoin_hashes::siphash24::HashEngine::with_keys(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
-pub fn bitcoin_hashes::GeneralHash::engine() -> Self::Engine where Self::Engine: core::default::Default
-pub fn bitcoin_hashes::GeneralHash::from_engine(e: Self::Engine) -> Self
-pub fn bitcoin_hashes::GeneralHash::hash(data: &[u8]) -> Self where Self::Engine: core::default::Default
-pub fn bitcoin_hashes::GeneralHash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>, Self::Engine: core::default::Default
-pub fn bitcoin_hashes::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::Hash::from_slice(sl: &[u8]) -> core::result::Result<Self, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::cmp::fixed_time_eq(a: &[u8], b: &[u8]) -> bool
-pub fn bitcoin_hashes::debug_hex(bytes: &[u8], f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::error::FromSliceError::clone(&self) -> bitcoin_hashes::error::FromSliceError
-pub fn bitcoin_hashes::error::FromSliceError::eq(&self, other: &bitcoin_hashes::error::FromSliceError) -> bool
-pub fn bitcoin_hashes::error::FromSliceError::expected_length(&self) -> usize
-pub fn bitcoin_hashes::error::FromSliceError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::error::FromSliceError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_hashes::error::FromSliceError::invalid_length(&self) -> usize
-pub fn bitcoin_hashes::hash160::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::hash160::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::hash160::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::hash160::Hash::clone(&self) -> bitcoin_hashes::hash160::Hash
-pub fn bitcoin_hashes::hash160::Hash::cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::hash160::Hash::engine() -> bitcoin_hashes::hash160::HashEngine
-pub fn bitcoin_hashes::hash160::Hash::eq(&self, other: &bitcoin_hashes::hash160::Hash) -> bool
-pub fn bitcoin_hashes::hash160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hash160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::hash160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::hash160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::hash160::Hash::from_engine(e: bitcoin_hashes::hash160::HashEngine) -> bitcoin_hashes::hash160::Hash
-pub fn bitcoin_hashes::hash160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hash160::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::hash160::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::hash160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::hash160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::hash160::Hash::partial_cmp(&self, other: &bitcoin_hashes::hash160::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::hash160::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::hash160::HashEngine::clone(&self) -> bitcoin_hashes::hash160::HashEngine
-pub fn bitcoin_hashes::hash160::HashEngine::default() -> Self
-pub fn bitcoin_hashes::hash160::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::hash160::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::hkdf::Hkdf<T>::expand(&self, info: &[u8], okm: &mut [u8]) -> core::result::Result<(), bitcoin_hashes::hkdf::MaxLengthError>
-pub fn bitcoin_hashes::hkdf::Hkdf<T>::new(salt: &[u8], ikm: &[u8]) -> Self
-pub fn bitcoin_hashes::hkdf::MaxLengthError::clone(&self) -> bitcoin_hashes::hkdf::MaxLengthError
-pub fn bitcoin_hashes::hkdf::MaxLengthError::eq(&self, other: &bitcoin_hashes::hkdf::MaxLengthError) -> bool
-pub fn bitcoin_hashes::hkdf::MaxLengthError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hmac::Hmac<T>::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::hmac::Hmac<T>::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::hmac::Hmac<T>::clone(&self) -> bitcoin_hashes::hmac::Hmac<T>
-pub fn bitcoin_hashes::hmac::Hmac<T>::cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::hmac::Hmac<T>::engine(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-pub fn bitcoin_hashes::hmac::Hmac<T>::eq(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> bool
-pub fn bitcoin_hashes::hmac::Hmac<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_byte_array(bytes: <T as bitcoin_hashes::Hash>::Bytes) -> Self
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_engine(e: bitcoin_hashes::hmac::HmacEngine<T>) -> bitcoin_hashes::hmac::Hmac<T>
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::hmac::Hmac<T>, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::hmac::Hmac<T>::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_hashes::hmac::Hmac<T>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::hmac::Hmac<T>::partial_cmp(&self, other: &bitcoin_hashes::hmac::Hmac<T>) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::hmac::Hmac<T>::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::clone(&self) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::from_inner_engines(iengine: <T as bitcoin_hashes::GeneralHash>::Engine, oengine: <T as bitcoin_hashes::GeneralHash>::Engine) -> bitcoin_hashes::hmac::HmacEngine<T>
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::input(&mut self, buf: &[u8])
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::hmac::HmacEngine<T>::new(key: &[u8]) -> bitcoin_hashes::hmac::HmacEngine<T> where <T as bitcoin_hashes::GeneralHash>::Engine: core::default::Default
-pub fn bitcoin_hashes::ripemd160::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::ripemd160::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::ripemd160::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::ripemd160::Hash::clone(&self) -> bitcoin_hashes::ripemd160::Hash
-pub fn bitcoin_hashes::ripemd160::Hash::cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::ripemd160::Hash::engine() -> bitcoin_hashes::ripemd160::HashEngine
-pub fn bitcoin_hashes::ripemd160::Hash::eq(&self, other: &bitcoin_hashes::ripemd160::Hash) -> bool
-pub fn bitcoin_hashes::ripemd160::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::ripemd160::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::ripemd160::Hash::from_engine(e: bitcoin_hashes::ripemd160::HashEngine) -> bitcoin_hashes::ripemd160::Hash
-pub fn bitcoin_hashes::ripemd160::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::ripemd160::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::ripemd160::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::ripemd160::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::ripemd160::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::ripemd160::Hash::partial_cmp(&self, other: &bitcoin_hashes::ripemd160::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::ripemd160::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::ripemd160::HashEngine::clone(&self) -> bitcoin_hashes::ripemd160::HashEngine
-pub fn bitcoin_hashes::ripemd160::HashEngine::default() -> Self
-pub fn bitcoin_hashes::ripemd160::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::ripemd160::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha1::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::sha1::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_hashes::sha1::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha1::Hash::clone(&self) -> bitcoin_hashes::sha1::Hash
-pub fn bitcoin_hashes::sha1::Hash::cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha1::Hash::engine() -> bitcoin_hashes::sha1::HashEngine
-pub fn bitcoin_hashes::sha1::Hash::eq(&self, other: &bitcoin_hashes::sha1::Hash) -> bool
-pub fn bitcoin_hashes::sha1::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha1::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha1::Hash::from_bytes_mut(bytes: &mut [u8; 20]) -> &mut Self
-pub fn bitcoin_hashes::sha1::Hash::from_bytes_ref(bytes: &[u8; 20]) -> &Self
-pub fn bitcoin_hashes::sha1::Hash::from_engine(e: bitcoin_hashes::sha1::HashEngine) -> bitcoin_hashes::sha1::Hash
-pub fn bitcoin_hashes::sha1::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha1::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha1::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha1::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha1::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha1::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha1::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha1::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha1::HashEngine::clone(&self) -> bitcoin_hashes::sha1::HashEngine
-pub fn bitcoin_hashes::sha1::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha1::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha1::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha256::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Hash::clone(&self) -> bitcoin_hashes::sha256::Hash
-pub fn bitcoin_hashes::sha256::Hash::cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256::Hash::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::Hash::eq(&self, other: &bitcoin_hashes::sha256::Hash) -> bool
-pub fn bitcoin_hashes::sha256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256::Hash::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256::Hash
-pub fn bitcoin_hashes::sha256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256::Hash::hash_again(&self) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256::HashEngine::clone(&self) -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha256::HashEngine::from_midstate(midstate: bitcoin_hashes::sha256::Midstate) -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha256::HashEngine::midstate(&self) -> core::result::Result<bitcoin_hashes::sha256::Midstate, bitcoin_hashes::sha256::MidstateError>
-pub fn bitcoin_hashes::sha256::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha256::Midstate::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256::Midstate::clone(&self) -> bitcoin_hashes::sha256::Midstate
-pub fn bitcoin_hashes::sha256::Midstate::cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256::Midstate::default() -> bitcoin_hashes::sha256::Midstate
-pub fn bitcoin_hashes::sha256::Midstate::eq(&self, other: &bitcoin_hashes::sha256::Midstate) -> bool
-pub fn bitcoin_hashes::sha256::Midstate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256::Midstate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256::Midstate::partial_cmp(&self, other: &bitcoin_hashes::sha256::Midstate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256::MidstateError::clone(&self) -> bitcoin_hashes::sha256::MidstateError
-pub fn bitcoin_hashes::sha256::MidstateError::eq(&self, other: &bitcoin_hashes::sha256::MidstateError) -> bool
-pub fn bitcoin_hashes::sha256::MidstateError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256d::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256d::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256d::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256d::Hash::clone(&self) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256d::Hash::engine() -> bitcoin_hashes::sha256d::HashEngine
-pub fn bitcoin_hashes::sha256d::Hash::eq(&self, other: &bitcoin_hashes::sha256d::Hash) -> bool
-pub fn bitcoin_hashes::sha256d::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256d::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256d::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256d::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256d::Hash::from_engine(e: bitcoin_hashes::sha256d::HashEngine) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256d::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256d::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256d::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha256d::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256d::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha256d::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256d::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256d::HashEngine::clone(&self) -> bitcoin_hashes::sha256d::HashEngine
-pub fn bitcoin_hashes::sha256d::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha256d::HashEngine::input(&mut self, data: &[u8])
-pub fn bitcoin_hashes::sha256d::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256t::Hash<T>::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha256t::Hash<T>::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha256t::Hash<T>::clone(&self) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha256t::Hash<T>::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha256t::Hash<T>::eq(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> bool
-pub fn bitcoin_hashes::sha256t::Hash<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_engine(e: bitcoin_hashes::sha256::HashEngine) -> bitcoin_hashes::sha256t::Hash<T>
-pub fn bitcoin_hashes::sha256t::Hash<T>::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha256t::Hash<T>, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash<H: core::hash::Hasher>(&self, h: &mut H)
-pub fn bitcoin_hashes::sha256t::Hash<T>::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha256t::Hash<T>::partial_cmp(&self, other: &bitcoin_hashes::sha256t::Hash<T>) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha256t::Hash<T>::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha256t::Tag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_hashes::sha384::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8; 48]
-pub fn bitcoin_hashes::sha384::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8; 48]
-pub fn bitcoin_hashes::sha384::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha384::Hash::clone(&self) -> bitcoin_hashes::sha384::Hash
-pub fn bitcoin_hashes::sha384::Hash::cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha384::Hash::engine() -> bitcoin_hashes::sha384::HashEngine
-pub fn bitcoin_hashes::sha384::Hash::eq(&self, other: &bitcoin_hashes::sha384::Hash) -> bool
-pub fn bitcoin_hashes::sha384::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha384::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha384::Hash::from_bytes_mut(bytes: &mut [u8; 48]) -> &mut Self
-pub fn bitcoin_hashes::sha384::Hash::from_bytes_ref(bytes: &[u8; 48]) -> &Self
-pub fn bitcoin_hashes::sha384::Hash::from_engine(e: bitcoin_hashes::sha384::HashEngine) -> bitcoin_hashes::sha384::Hash
-pub fn bitcoin_hashes::sha384::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha384::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha384::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha384::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha384::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha384::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha384::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha384::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha384::HashEngine::clone(&self) -> bitcoin_hashes::sha384::HashEngine
-pub fn bitcoin_hashes::sha384::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha384::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha384::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha512::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8; 64]
-pub fn bitcoin_hashes::sha512::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8; 64]
-pub fn bitcoin_hashes::sha512::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512::Hash::clone(&self) -> bitcoin_hashes::sha512::Hash
-pub fn bitcoin_hashes::sha512::Hash::cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha512::Hash::engine() -> bitcoin_hashes::sha512::HashEngine
-pub fn bitcoin_hashes::sha512::Hash::eq(&self, other: &bitcoin_hashes::sha512::Hash) -> bool
-pub fn bitcoin_hashes::sha512::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha512::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha512::Hash::from_bytes_mut(bytes: &mut [u8; 64]) -> &mut Self
-pub fn bitcoin_hashes::sha512::Hash::from_bytes_ref(bytes: &[u8; 64]) -> &Self
-pub fn bitcoin_hashes::sha512::Hash::from_engine(e: bitcoin_hashes::sha512::HashEngine) -> bitcoin_hashes::sha512::Hash
-pub fn bitcoin_hashes::sha512::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha512::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha512::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha512::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha512::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha512::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha512::HashEngine::clone(&self) -> bitcoin_hashes::sha512::HashEngine
-pub fn bitcoin_hashes::sha512::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha512::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha512::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::sha512_256::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha512_256::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_hashes::sha512_256::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::sha512_256::Hash::clone(&self) -> bitcoin_hashes::sha512_256::Hash
-pub fn bitcoin_hashes::sha512_256::Hash::cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::sha512_256::Hash::engine() -> bitcoin_hashes::sha512_256::HashEngine
-pub fn bitcoin_hashes::sha512_256::Hash::eq(&self, other: &bitcoin_hashes::sha512_256::Hash) -> bool
-pub fn bitcoin_hashes::sha512_256::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::sha512_256::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_mut(bytes: &mut [u8; 32]) -> &mut Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_bytes_ref(bytes: &[u8; 32]) -> &Self
-pub fn bitcoin_hashes::sha512_256::Hash::from_engine(e: bitcoin_hashes::sha512_256::HashEngine) -> bitcoin_hashes::sha512_256::Hash
-pub fn bitcoin_hashes::sha512_256::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::sha512_256::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::sha512_256::Hash::hash(data: &[u8]) -> Self
-pub fn bitcoin_hashes::sha512_256::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::sha512_256::Hash::hash_byte_chunks<B, I>(byte_slices: I) -> Self where B: core::convert::AsRef<[u8]>, I: core::iter::traits::collect::IntoIterator<Item = B>
-pub fn bitcoin_hashes::sha512_256::Hash::partial_cmp(&self, other: &bitcoin_hashes::sha512_256::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::sha512_256::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::sha512_256::HashEngine::clone(&self) -> bitcoin_hashes::sha512_256::HashEngine
-pub fn bitcoin_hashes::sha512_256::HashEngine::default() -> Self
-pub fn bitcoin_hashes::sha512_256::HashEngine::input(&mut self, inp: &[u8])
-pub fn bitcoin_hashes::sha512_256::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8; 8]
-pub fn bitcoin_hashes::siphash24::Hash::as_ref(&self) -> &[u8]
-pub fn bitcoin_hashes::siphash24::Hash::as_u64(&self) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8; 8]
-pub fn bitcoin_hashes::siphash24::Hash::borrow(&self) -> &[u8]
-pub fn bitcoin_hashes::siphash24::Hash::clone(&self) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::cmp::Ordering
-pub fn bitcoin_hashes::siphash24::Hash::engine(k0: u64, k1: u64) -> bitcoin_hashes::siphash24::HashEngine
-pub fn bitcoin_hashes::siphash24::Hash::eq(&self, other: &bitcoin_hashes::siphash24::Hash) -> bool
-pub fn bitcoin_hashes::siphash24::Hash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::siphash24::Hash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_hashes::siphash24::Hash::from_bytes_mut(bytes: &mut [u8; 8]) -> &mut Self
-pub fn bitcoin_hashes::siphash24::Hash::from_bytes_ref(bytes: &[u8; 8]) -> &Self
-pub fn bitcoin_hashes::siphash24::Hash::from_engine(e: bitcoin_hashes::siphash24::HashEngine) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::from_engine_to_u64(e: bitcoin_hashes::siphash24::HashEngine) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_hashes::siphash24::Hash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_hashes::siphash24::Hash::from_u64(hash: u64) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_hashes::siphash24::Hash::hash_to_u64_with_keys(k0: u64, k1: u64, data: &[u8]) -> u64
-pub fn bitcoin_hashes::siphash24::Hash::hash_with_keys(k0: u64, k1: u64, data: &[u8]) -> bitcoin_hashes::siphash24::Hash
-pub fn bitcoin_hashes::siphash24::Hash::partial_cmp(&self, other: &bitcoin_hashes::siphash24::Hash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_hashes::siphash24::Hash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_hashes::siphash24::Hash::to_u64(self) -> u64
-pub fn bitcoin_hashes::siphash24::HashEngine::clone(&self) -> bitcoin_hashes::siphash24::HashEngine
-pub fn bitcoin_hashes::siphash24::HashEngine::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_hashes::siphash24::HashEngine::input(&mut self, msg: &[u8])
-pub fn bitcoin_hashes::siphash24::HashEngine::keys(&self) -> (u64, u64)
-pub fn bitcoin_hashes::siphash24::HashEngine::n_bytes_hashed(&self) -> u64
-pub fn bitcoin_hashes::siphash24::State::clone(&self) -> bitcoin_hashes::siphash24::State
-pub fn bitcoin_hashes::siphash24::State::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub macro bitcoin_hashes::hash_newtype!
-pub macro bitcoin_hashes::impl_debug_only_for_newtype!
-pub macro bitcoin_hashes::sha256t_hash_newtype!
-pub macro bitcoin_hashes::sha256t_tag!
-pub mod bitcoin_hashes
-pub mod bitcoin_hashes::cmp
-pub mod bitcoin_hashes::error
-pub mod bitcoin_hashes::hash160
-pub mod bitcoin_hashes::hkdf
-pub mod bitcoin_hashes::hmac
-pub mod bitcoin_hashes::macros
-pub mod bitcoin_hashes::ripemd160
-pub mod bitcoin_hashes::serde_macros
-pub mod bitcoin_hashes::sha1
-pub mod bitcoin_hashes::sha256
-pub mod bitcoin_hashes::sha256d
-pub mod bitcoin_hashes::sha256t
-pub mod bitcoin_hashes::sha384
-pub mod bitcoin_hashes::sha512
-pub mod bitcoin_hashes::sha512_256
-pub mod bitcoin_hashes::siphash24
-pub struct bitcoin_hashes::FromSliceError(_)
-pub struct bitcoin_hashes::Hkdf<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::HmacEngine<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::error::FromSliceError(_)
-pub struct bitcoin_hashes::hash160::HashEngine(_)
-pub struct bitcoin_hashes::hkdf::Hkdf<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::hkdf::MaxLengthError
-pub struct bitcoin_hashes::hmac::HmacEngine<T: bitcoin_hashes::GeneralHash>
-pub struct bitcoin_hashes::ripemd160::HashEngine
-pub struct bitcoin_hashes::sha1::HashEngine
-pub struct bitcoin_hashes::sha256::HashEngine
-pub struct bitcoin_hashes::sha256::Midstate
-pub struct bitcoin_hashes::sha256::MidstateError
-pub struct bitcoin_hashes::sha256d::HashEngine(_)
-pub struct bitcoin_hashes::sha384::HashEngine(_)
-pub struct bitcoin_hashes::sha512::HashEngine
-pub struct bitcoin_hashes::sha512_256::HashEngine(_)
-pub struct bitcoin_hashes::siphash24::HashEngine
-pub struct bitcoin_hashes::siphash24::State
-pub trait bitcoin_hashes::GeneralHash: bitcoin_hashes::Hash
-pub trait bitcoin_hashes::Hash: core::marker::Copy + core::clone::Clone + core::cmp::PartialEq + core::cmp::Eq + core::cmp::PartialOrd + core::cmp::Ord + core::hash::Hash + core::convert::AsRef<[u8]>
-pub trait bitcoin_hashes::HashEngine: core::clone::Clone
-pub trait bitcoin_hashes::IsByteArray: core::convert::AsRef<[u8]> + bitcoin_hashes::sealed::IsByteArray
-pub trait bitcoin_hashes::sha256t::Tag
-pub type bitcoin_hashes::GeneralHash::Engine: bitcoin_hashes::HashEngine
-pub type bitcoin_hashes::Hash::Bytes: core::marker::Copy + bitcoin_hashes::IsByteArray
-pub type bitcoin_hashes::HkdfSha256 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha256::Hash>
-pub type bitcoin_hashes::HkdfSha512 = bitcoin_hashes::hkdf::Hkdf<bitcoin_hashes::sha512::Hash>
-pub type bitcoin_hashes::HmacSha256 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha256::Hash>
-pub type bitcoin_hashes::HmacSha512 = bitcoin_hashes::hmac::Hmac<bitcoin_hashes::sha512::Hash>
-pub type bitcoin_hashes::Sha256t<T> = bitcoin_hashes::sha256t::Hash<T>
-pub type bitcoin_hashes::hash160::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::hash160::Hash::Engine = bitcoin_hashes::hash160::HashEngine
-pub type bitcoin_hashes::hmac::Hmac<T>::Bytes = <T as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_hashes::hmac::Hmac<T>::Engine = bitcoin_hashes::hmac::HmacEngine<T>
-pub type bitcoin_hashes::hmac::Hmac<T>::Err = <T as core::str::traits::FromStr>::Err
-pub type bitcoin_hashes::ripemd160::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::ripemd160::Hash::Engine = bitcoin_hashes::ripemd160::HashEngine
-pub type bitcoin_hashes::sha1::Hash::Bytes = [u8; 20]
-pub type bitcoin_hashes::sha1::Hash::Engine = bitcoin_hashes::sha1::HashEngine
-pub type bitcoin_hashes::sha256::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256::Hash::Engine = bitcoin_hashes::sha256::HashEngine
-pub type bitcoin_hashes::sha256d::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256d::Hash::Engine = bitcoin_hashes::sha256d::HashEngine
-pub type bitcoin_hashes::sha256t::Hash<T>::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha256t::Hash<T>::Engine = bitcoin_hashes::sha256::HashEngine
-pub type bitcoin_hashes::sha384::Hash::Bytes = [u8; 48]
-pub type bitcoin_hashes::sha384::Hash::Engine = bitcoin_hashes::sha384::HashEngine
-pub type bitcoin_hashes::sha512::Hash::Bytes = [u8; 64]
-pub type bitcoin_hashes::sha512::Hash::Engine = bitcoin_hashes::sha512::HashEngine
-pub type bitcoin_hashes::sha512_256::Hash::Bytes = [u8; 32]
-pub type bitcoin_hashes::sha512_256::Hash::Engine = bitcoin_hashes::sha512_256::HashEngine
-pub type bitcoin_hashes::siphash24::Hash::Bytes = [u8; 8]
-pub type bitcoin_hashes::siphash24::Hash::Engine = bitcoin_hashes::siphash24::HashEngine
diff --git a/api/io/all-features.txt b/api/io/all-features.txt
deleted file mode 100644
index 46b6a29355..0000000000
--- a/api/io/all-features.txt
+++ /dev/null
@@ -1,402 +0,0 @@
-#[repr(transparent)] pub struct bitcoin_io::FromStd<T>(_)
-#[repr(transparent)] pub struct bitcoin_io::ToStd<T>(_)
-impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
-impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
-impl bitcoin_io::BufRead for &[u8]
-impl bitcoin_io::BufRead for alloc::collections::vec_deque::VecDeque<u8>
-impl bitcoin_io::BufRead for std::io::stdio::StdinLock<'_>
-impl bitcoin_io::BufRead for std::io::util::Empty
-impl bitcoin_io::Error
-impl bitcoin_io::Read for &[u8]
-impl bitcoin_io::Read for &std::fs::File
-impl bitcoin_io::Read for &std::io::stdio::Stdin
-impl bitcoin_io::Read for &std::net::tcp::TcpStream
-impl bitcoin_io::Read for &std::os::unix::net::stream::UnixStream
-impl bitcoin_io::Read for alloc::collections::vec_deque::VecDeque<u8>
-impl bitcoin_io::Read for alloc::sync::Arc<std::fs::File>
-impl bitcoin_io::Read for std::fs::File
-impl bitcoin_io::Read for std::io::stdio::Stdin
-impl bitcoin_io::Read for std::io::stdio::StdinLock<'_>
-impl bitcoin_io::Read for std::io::util::Empty
-impl bitcoin_io::Read for std::io::util::Repeat
-impl bitcoin_io::Read for std::net::tcp::TcpStream
-impl bitcoin_io::Read for std::os::unix::net::stream::UnixStream
-impl bitcoin_io::Read for std::process::ChildStderr
-impl bitcoin_io::Read for std::process::ChildStdout
-impl bitcoin_io::Write for &mut [u8]
-impl bitcoin_io::Write for &std::fs::File
-impl bitcoin_io::Write for &std::io::stdio::Stderr
-impl bitcoin_io::Write for &std::io::stdio::Stdout
-impl bitcoin_io::Write for &std::io::util::Empty
-impl bitcoin_io::Write for &std::net::tcp::TcpStream
-impl bitcoin_io::Write for &std::os::unix::net::stream::UnixStream
-impl bitcoin_io::Write for &std::process::ChildStdin
-impl bitcoin_io::Write for alloc::collections::vec_deque::VecDeque<u8>
-impl bitcoin_io::Write for alloc::sync::Arc<std::fs::File>
-impl bitcoin_io::Write for alloc::vec::Vec<u8>
-impl bitcoin_io::Write for bitcoin_io::Sink
-impl bitcoin_io::Write for std::fs::File
-impl bitcoin_io::Write for std::io::cursor::Cursor<&mut alloc::vec::Vec<u8>>
-impl bitcoin_io::Write for std::io::cursor::Cursor<alloc::boxed::Box<[u8]>>
-impl bitcoin_io::Write for std::io::cursor::Cursor<alloc::vec::Vec<u8>>
-impl bitcoin_io::Write for std::io::stdio::Stderr
-impl bitcoin_io::Write for std::io::stdio::Stdout
-impl bitcoin_io::Write for std::io::util::Empty
-impl bitcoin_io::Write for std::net::tcp::TcpStream
-impl bitcoin_io::Write for std::os::unix::net::stream::UnixStream
-impl bitcoin_io::Write for std::process::ChildStdin
-impl core::clone::Clone for bitcoin_io::ErrorKind
-impl core::clone::Clone for bitcoin_io::Sink
-impl core::cmp::Eq for bitcoin_io::ErrorKind
-impl core::cmp::PartialEq for bitcoin_io::ErrorKind
-impl core::convert::From<bitcoin_io::Error> for std::io::error::Error
-impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
-impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
-impl core::convert::From<std::io::error::Error> for bitcoin_io::Error
-impl core::default::Default for bitcoin_io::Sink
-impl core::error::Error for bitcoin_io::Error
-impl core::fmt::Debug for bitcoin_io::Error
-impl core::fmt::Debug for bitcoin_io::ErrorKind
-impl core::fmt::Debug for bitcoin_io::Sink
-impl core::fmt::Display for bitcoin_io::Error
-impl core::hash::Hash for bitcoin_io::ErrorKind
-impl core::marker::Copy for bitcoin_io::ErrorKind
-impl core::marker::Copy for bitcoin_io::Sink
-impl core::marker::Freeze for bitcoin_io::Error
-impl core::marker::Freeze for bitcoin_io::ErrorKind
-impl core::marker::Freeze for bitcoin_io::Sink
-impl core::marker::Send for bitcoin_io::Error
-impl core::marker::Send for bitcoin_io::ErrorKind
-impl core::marker::Send for bitcoin_io::Sink
-impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
-impl core::marker::Sync for bitcoin_io::Error
-impl core::marker::Sync for bitcoin_io::ErrorKind
-impl core::marker::Sync for bitcoin_io::Sink
-impl core::marker::Unpin for bitcoin_io::Error
-impl core::marker::Unpin for bitcoin_io::ErrorKind
-impl core::marker::Unpin for bitcoin_io::Sink
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ErrorKind
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
-impl std::io::Write for bitcoin_io::Sink
-impl<'a, R: core::fmt::Debug + bitcoin_io::Read + ?core::marker::Sized> core::fmt::Debug for bitcoin_io::Take<'a, R>
-impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
-impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
-impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
-impl<'a, R> core::marker::Sync for bitcoin_io::Take<'a, R> where R: core::marker::Sync + ?core::marker::Sized
-impl<'a, R> core::marker::Unpin for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
-impl<'a, R> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Take<'a, R> where R: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
-impl<R1: std::io::BufRead, R2: std::io::BufRead> bitcoin_io::BufRead for std::io::Chain<R1, R2>
-impl<R1: std::io::Read, R2: std::io::Read> bitcoin_io::Read for std::io::Chain<R1, R2>
-impl<R: bitcoin_io::BufRead + ?core::marker::Sized> bitcoin_io::BufRead for bitcoin_io::Take<'_, R>
-impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Read for bitcoin_io::Take<'_, R>
-impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Take<'_, R>
-impl<R: std::io::BufRead> bitcoin_io::BufRead for std::io::Take<R>
-impl<R: std::io::Read> bitcoin_io::Read for std::io::Take<R>
-impl<R> bitcoin_io::BufRead for std::io::buffered::bufreader::BufReader<R> where R: ?core::marker::Sized + std::io::Read
-impl<R> bitcoin_io::Read for std::io::buffered::bufreader::BufReader<R> where R: ?core::marker::Sized + std::io::Read
-impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for &mut T
-impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for bitcoin_io::ToStd<T>
-impl<T: bitcoin_io::BufRead> std::io::BufRead for bitcoin_io::ToStd<T>
-impl<T: bitcoin_io::Read> bitcoin_io::Read for &mut T
-impl<T: bitcoin_io::Read> bitcoin_io::Read for bitcoin_io::ToStd<T>
-impl<T: bitcoin_io::Read> std::io::Read for bitcoin_io::ToStd<T>
-impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
-impl<T: bitcoin_io::Write> bitcoin_io::Write for bitcoin_io::ToStd<T>
-impl<T: bitcoin_io::Write> std::io::Write for bitcoin_io::ToStd<T>
-impl<T: core::clone::Clone> core::clone::Clone for bitcoin_io::Cursor<T>
-impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_io::Cursor<T>
-impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for std::io::cursor::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for std::io::cursor::Cursor<T>
-impl<T: core::default::Default> core::default::Default for bitcoin_io::Cursor<T>
-impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
-impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::FromStd<T>
-impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::ToStd<T>
-impl<T: std::io::BufRead> bitcoin_io::BufRead for bitcoin_io::FromStd<T>
-impl<T: std::io::BufRead> std::io::BufRead for bitcoin_io::FromStd<T>
-impl<T: std::io::Read> bitcoin_io::Read for bitcoin_io::FromStd<T>
-impl<T: std::io::Read> std::io::Read for bitcoin_io::FromStd<T>
-impl<T: std::io::Write> bitcoin_io::Write for bitcoin_io::FromStd<T>
-impl<T: std::io::Write> std::io::Write for bitcoin_io::FromStd<T>
-impl<T> bitcoin_io::FromStd<T>
-impl<T> bitcoin_io::ToStd<T>
-impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_io::FromStd<T> where T: core::marker::Freeze
-impl<T> core::marker::Freeze for bitcoin_io::ToStd<T> where T: core::marker::Freeze
-impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
-impl<T> core::marker::Send for bitcoin_io::FromStd<T> where T: core::marker::Send
-impl<T> core::marker::Send for bitcoin_io::ToStd<T> where T: core::marker::Send
-impl<T> core::marker::StructuralPartialEq for bitcoin_io::Cursor<T>
-impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_io::FromStd<T> where T: core::marker::Sync
-impl<T> core::marker::Sync for bitcoin_io::ToStd<T> where T: core::marker::Sync
-impl<T> core::marker::Unpin for bitcoin_io::Cursor<T> where T: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_io::FromStd<T> where T: core::marker::Unpin
-impl<T> core::marker::Unpin for bitcoin_io::ToStd<T> where T: core::marker::Unpin
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::FromStd<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ToStd<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::FromStd<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::ToStd<T> where T: core::panic::unwind_safe::UnwindSafe
-impl<W> bitcoin_io::Write for std::io::buffered::bufwriter::BufWriter<W> where W: ?core::marker::Sized + std::io::Write
-impl<W> bitcoin_io::Write for std::io::buffered::linewriter::LineWriter<W> where W: ?core::marker::Sized + std::io::Write
-pub bitcoin_io::ErrorKind::AddrInUse
-pub bitcoin_io::ErrorKind::AddrNotAvailable
-pub bitcoin_io::ErrorKind::AlreadyExists
-pub bitcoin_io::ErrorKind::BrokenPipe
-pub bitcoin_io::ErrorKind::ConnectionAborted
-pub bitcoin_io::ErrorKind::ConnectionRefused
-pub bitcoin_io::ErrorKind::ConnectionReset
-pub bitcoin_io::ErrorKind::Interrupted
-pub bitcoin_io::ErrorKind::InvalidData
-pub bitcoin_io::ErrorKind::InvalidInput
-pub bitcoin_io::ErrorKind::NotConnected
-pub bitcoin_io::ErrorKind::NotFound
-pub bitcoin_io::ErrorKind::Other
-pub bitcoin_io::ErrorKind::PermissionDenied
-pub bitcoin_io::ErrorKind::TimedOut
-pub bitcoin_io::ErrorKind::UnexpectedEof
-pub bitcoin_io::ErrorKind::WouldBlock
-pub bitcoin_io::ErrorKind::WriteZero
-pub const fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
-pub const fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
-pub const fn bitcoin_io::Cursor<T>::position(&self) -> u64
-pub const fn bitcoin_io::FromStd<T>::new(inner: T) -> Self
-pub const fn bitcoin_io::ToStd<T>::new(inner: T) -> Self
-pub const fn bitcoin_io::from_std<T>(std_io: T) -> bitcoin_io::FromStd<T>
-pub enum bitcoin_io::ErrorKind
-pub fn &[u8]::consume(&mut self, amount: usize)
-pub fn &[u8]::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn &[u8]::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::consume(&mut self, amount: usize)
-pub fn &mut T::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn &mut T::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &mut T::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn &mut T::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &mut [u8]::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &mut [u8]::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &std::fs::File::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &std::fs::File::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &std::fs::File::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn &std::fs::File::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &std::fs::File::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &std::io::stdio::Stderr::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &std::io::stdio::Stderr::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &std::io::stdio::Stderr::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &std::io::stdio::Stdin::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &std::io::stdio::Stdin::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn &std::io::stdio::Stdout::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &std::io::stdio::Stdout::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &std::io::stdio::Stdout::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &std::io::util::Empty::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &std::io::util::Empty::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &std::io::util::Empty::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &std::net::tcp::TcpStream::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &std::net::tcp::TcpStream::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &std::net::tcp::TcpStream::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn &std::net::tcp::TcpStream::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &std::net::tcp::TcpStream::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &std::os::unix::net::stream::UnixStream::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &std::os::unix::net::stream::UnixStream::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &std::os::unix::net::stream::UnixStream::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn &std::os::unix::net::stream::UnixStream::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &std::os::unix::net::stream::UnixStream::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &std::process::ChildStdin::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &std::process::ChildStdin::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &std::process::ChildStdin::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn alloc::collections::vec_deque::VecDeque<u8>::consume(&mut self, amount: usize)
-pub fn alloc::collections::vec_deque::VecDeque<u8>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn alloc::collections::vec_deque::VecDeque<u8>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn alloc::collections::vec_deque::VecDeque<u8>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn alloc::collections::vec_deque::VecDeque<u8>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn alloc::collections::vec_deque::VecDeque<u8>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn alloc::collections::vec_deque::VecDeque<u8>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn alloc::sync::Arc<std::fs::File>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn alloc::sync::Arc<std::fs::File>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn alloc::sync::Arc<std::fs::File>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn alloc::sync::Arc<std::fs::File>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn alloc::sync::Arc<std::fs::File>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn alloc::vec::Vec<u8>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn alloc::vec::Vec<u8>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
-pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Cursor<T>::clone(&self) -> bitcoin_io::Cursor<T>
-pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
-pub fn bitcoin_io::Cursor<T>::default() -> bitcoin_io::Cursor<T>
-pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
-pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
-pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
-pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
-pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
-pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Error::fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
-pub fn bitcoin_io::Error::from(kind: bitcoin_io::ErrorKind) -> bitcoin_io::Error
-pub fn bitcoin_io::Error::from(o: std::io::error::Error) -> bitcoin_io::Error
-pub fn bitcoin_io::Error::get_ref(&self) -> core::option::Option<&(dyn core::error::Error + core::marker::Send + core::marker::Sync + 'static)>
-pub fn bitcoin_io::Error::kind(&self) -> bitcoin_io::ErrorKind
-pub fn bitcoin_io::Error::new<E>(kind: bitcoin_io::ErrorKind, error: E) -> bitcoin_io::Error where E: core::convert::Into<alloc::boxed::Box<(dyn core::error::Error + core::marker::Send + core::marker::Sync + 'static)>>
-pub fn bitcoin_io::Error::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_io::ErrorKind::clone(&self) -> bitcoin_io::ErrorKind
-pub fn bitcoin_io::ErrorKind::eq(&self, other: &bitcoin_io::ErrorKind) -> bool
-pub fn bitcoin_io::ErrorKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::ErrorKind::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_io::ErrorKind::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_io::FromStd<T>::consume(&mut self, amount: usize)
-pub fn bitcoin_io::FromStd<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::FromStd<T>::fill_buf(&mut self) -> std::io::error::Result<&[u8]>
-pub fn bitcoin_io::FromStd<T>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::FromStd<T>::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_io::FromStd<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::FromStd<T>::get_mut(&mut self) -> &mut T
-pub fn bitcoin_io::FromStd<T>::get_ref(&self) -> &T
-pub fn bitcoin_io::FromStd<T>::inner(&self) -> &T
-pub fn bitcoin_io::FromStd<T>::inner_mut(&mut self) -> &mut T
-pub fn bitcoin_io::FromStd<T>::into_inner(self) -> T
-pub fn bitcoin_io::FromStd<T>::new_boxed(inner: alloc::boxed::Box<T>) -> alloc::boxed::Box<Self>
-pub fn bitcoin_io::FromStd<T>::new_mut(inner: &mut T) -> &mut Self
-pub fn bitcoin_io::FromStd<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::FromStd<T>::read(&mut self, buf: &mut [u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_io::FromStd<T>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::FromStd<T>::read_exact(&mut self, buf: &mut [u8]) -> std::io::error::Result<()>
-pub fn bitcoin_io::FromStd<T>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::FromStd<T>::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_io::FromStd<T>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::FromStd<T>::write_all(&mut self, buf: &[u8]) -> std::io::error::Result<()>
-pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Read::read_to_limit(&mut self, buf: &mut alloc::vec::Vec<u8>, limit: u64) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
-pub fn bitcoin_io::Sink::clone(&self) -> bitcoin_io::Sink
-pub fn bitcoin_io::Sink::default() -> bitcoin_io::Sink
-pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Sink::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> std::io::error::Result<()>
-pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
-pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Take<'_, R>::read_to_end(&mut self, buf: &mut alloc::vec::Vec<u8>) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Take<'a, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::ToStd<T>::consume(&mut self, amount: usize)
-pub fn bitcoin_io::ToStd<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::ToStd<T>::fill_buf(&mut self) -> std::io::error::Result<&[u8]>
-pub fn bitcoin_io::ToStd<T>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::ToStd<T>::flush(&mut self) -> std::io::error::Result<()>
-pub fn bitcoin_io::ToStd<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::ToStd<T>::inner(&self) -> &T
-pub fn bitcoin_io::ToStd<T>::inner_mut(&mut self) -> &mut T
-pub fn bitcoin_io::ToStd<T>::into_inner(self) -> T
-pub fn bitcoin_io::ToStd<T>::new_boxed(inner: alloc::boxed::Box<T>) -> alloc::boxed::Box<Self>
-pub fn bitcoin_io::ToStd<T>::new_mut(inner: &mut T) -> &mut Self
-pub fn bitcoin_io::ToStd<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::ToStd<T>::read(&mut self, buf: &mut [u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_io::ToStd<T>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::ToStd<T>::read_exact(&mut self, buf: &mut [u8]) -> std::io::error::Result<()>
-pub fn bitcoin_io::ToStd<T>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::ToStd<T>::write(&mut self, buf: &[u8]) -> std::io::error::Result<usize>
-pub fn bitcoin_io::ToStd<T>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::ToStd<T>::write_all(&mut self, buf: &[u8]) -> std::io::error::Result<()>
-pub fn bitcoin_io::Write::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Write::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Write::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::from_std_mut<T>(std_io: &mut T) -> &mut bitcoin_io::FromStd<T>
-pub fn bitcoin_io::sink() -> bitcoin_io::Sink
-pub fn std::fs::File::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::fs::File::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::fs::File::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::fs::File::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::fs::File::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::Chain<R1, R2>::consume(&mut self, amount: usize)
-pub fn std::io::Chain<R1, R2>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn std::io::Chain<R1, R2>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::Chain<R1, R2>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::io::Take<R>::consume(&mut self, amount: usize)
-pub fn std::io::Take<R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn std::io::Take<R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::Take<R>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::io::buffered::bufreader::BufReader<R>::consume(&mut self, amount: usize)
-pub fn std::io::buffered::bufreader::BufReader<R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn std::io::buffered::bufreader::BufReader<R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::buffered::bufreader::BufReader<R>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::io::buffered::bufwriter::BufWriter<W>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::io::buffered::bufwriter::BufWriter<W>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::buffered::bufwriter::BufWriter<W>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::buffered::linewriter::LineWriter<W>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::io::buffered::linewriter::LineWriter<W>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::buffered::linewriter::LineWriter<W>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::cursor::Cursor<&mut alloc::vec::Vec<u8>>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::io::cursor::Cursor<&mut alloc::vec::Vec<u8>>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::cursor::Cursor<&mut alloc::vec::Vec<u8>>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::cursor::Cursor<T>::consume(&mut self, amount: usize)
-pub fn std::io::cursor::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn std::io::cursor::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::cursor::Cursor<T>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::io::cursor::Cursor<alloc::boxed::Box<[u8]>>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::io::cursor::Cursor<alloc::boxed::Box<[u8]>>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::cursor::Cursor<alloc::boxed::Box<[u8]>>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::cursor::Cursor<alloc::vec::Vec<u8>>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::io::cursor::Cursor<alloc::vec::Vec<u8>>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::cursor::Cursor<alloc::vec::Vec<u8>>::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::error::Error::from(o: bitcoin_io::Error) -> std::io::error::Error
-pub fn std::io::stdio::Stderr::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::io::stdio::Stderr::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::stdio::Stderr::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::stdio::Stdin::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::stdio::Stdin::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::io::stdio::StdinLock<'_>::consume(&mut self, amount: usize)
-pub fn std::io::stdio::StdinLock<'_>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn std::io::stdio::StdinLock<'_>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::stdio::StdinLock<'_>::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::io::stdio::Stdout::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::io::stdio::Stdout::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::stdio::Stdout::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::util::Empty::consume(&mut self, amount: usize)
-pub fn std::io::util::Empty::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn std::io::util::Empty::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::io::util::Empty::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::util::Empty::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::io::util::Empty::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::util::Empty::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::io::util::Repeat::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::io::util::Repeat::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::net::tcp::TcpStream::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::net::tcp::TcpStream::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::net::tcp::TcpStream::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::net::tcp::TcpStream::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::net::tcp::TcpStream::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::os::unix::net::stream::UnixStream::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::os::unix::net::stream::UnixStream::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::os::unix::net::stream::UnixStream::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::os::unix::net::stream::UnixStream::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::os::unix::net::stream::UnixStream::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::process::ChildStderr::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::process::ChildStderr::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn std::process::ChildStdin::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn std::process::ChildStdin::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn std::process::ChildStdin::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn std::process::ChildStdout::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn std::process::ChildStdout::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub macro bitcoin_io::impl_write!
-pub mod bitcoin_io
-pub struct bitcoin_io::Cursor<T>
-pub struct bitcoin_io::Error
-pub struct bitcoin_io::Sink
-pub struct bitcoin_io::Take<'a, R: bitcoin_io::Read + ?core::marker::Sized>
-pub trait bitcoin_io::BufRead: bitcoin_io::Read
-pub trait bitcoin_io::Read
-pub trait bitcoin_io::Write
-pub type bitcoin_io::Result<T> = core::result::Result<T, bitcoin_io::Error>
diff --git a/api/io/alloc-only.txt b/api/io/alloc-only.txt
deleted file mode 100644
index 93035f5443..0000000000
--- a/api/io/alloc-only.txt
+++ /dev/null
@@ -1,156 +0,0 @@
-impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
-impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
-impl bitcoin_io::BufRead for &[u8]
-impl bitcoin_io::Error
-impl bitcoin_io::Read for &[u8]
-impl bitcoin_io::Write for &mut [u8]
-impl bitcoin_io::Write for alloc::vec::Vec<u8>
-impl bitcoin_io::Write for bitcoin_io::Sink
-impl core::clone::Clone for bitcoin_io::ErrorKind
-impl core::clone::Clone for bitcoin_io::Sink
-impl core::cmp::Eq for bitcoin_io::ErrorKind
-impl core::cmp::PartialEq for bitcoin_io::ErrorKind
-impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
-impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
-impl core::default::Default for bitcoin_io::Sink
-impl core::fmt::Debug for bitcoin_io::Error
-impl core::fmt::Debug for bitcoin_io::ErrorKind
-impl core::fmt::Debug for bitcoin_io::Sink
-impl core::fmt::Display for bitcoin_io::Error
-impl core::hash::Hash for bitcoin_io::ErrorKind
-impl core::marker::Copy for bitcoin_io::ErrorKind
-impl core::marker::Copy for bitcoin_io::Sink
-impl core::marker::Freeze for bitcoin_io::Error
-impl core::marker::Freeze for bitcoin_io::ErrorKind
-impl core::marker::Freeze for bitcoin_io::Sink
-impl core::marker::Send for bitcoin_io::Error
-impl core::marker::Send for bitcoin_io::ErrorKind
-impl core::marker::Send for bitcoin_io::Sink
-impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
-impl core::marker::Sync for bitcoin_io::Error
-impl core::marker::Sync for bitcoin_io::ErrorKind
-impl core::marker::Sync for bitcoin_io::Sink
-impl core::marker::Unpin for bitcoin_io::Error
-impl core::marker::Unpin for bitcoin_io::ErrorKind
-impl core::marker::Unpin for bitcoin_io::Sink
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ErrorKind
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
-impl<'a, R: core::fmt::Debug + bitcoin_io::Read + ?core::marker::Sized> core::fmt::Debug for bitcoin_io::Take<'a, R>
-impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
-impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
-impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
-impl<'a, R> core::marker::Sync for bitcoin_io::Take<'a, R> where R: core::marker::Sync + ?core::marker::Sized
-impl<'a, R> core::marker::Unpin for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
-impl<'a, R> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Take<'a, R> where R: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
-impl<R: bitcoin_io::BufRead + ?core::marker::Sized> bitcoin_io::BufRead for bitcoin_io::Take<'_, R>
-impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Read for bitcoin_io::Take<'_, R>
-impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Take<'_, R>
-impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for &mut T
-impl<T: bitcoin_io::Read> bitcoin_io::Read for &mut T
-impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
-impl<T: core::clone::Clone> core::clone::Clone for bitcoin_io::Cursor<T>
-impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_io::Cursor<T>
-impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
-impl<T: core::default::Default> core::default::Default for bitcoin_io::Cursor<T>
-impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
-impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
-impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
-impl<T> core::marker::StructuralPartialEq for bitcoin_io::Cursor<T>
-impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
-impl<T> core::marker::Unpin for bitcoin_io::Cursor<T> where T: core::marker::Unpin
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::UnwindSafe
-pub bitcoin_io::ErrorKind::AddrInUse
-pub bitcoin_io::ErrorKind::AddrNotAvailable
-pub bitcoin_io::ErrorKind::AlreadyExists
-pub bitcoin_io::ErrorKind::BrokenPipe
-pub bitcoin_io::ErrorKind::ConnectionAborted
-pub bitcoin_io::ErrorKind::ConnectionRefused
-pub bitcoin_io::ErrorKind::ConnectionReset
-pub bitcoin_io::ErrorKind::Interrupted
-pub bitcoin_io::ErrorKind::InvalidData
-pub bitcoin_io::ErrorKind::InvalidInput
-pub bitcoin_io::ErrorKind::NotConnected
-pub bitcoin_io::ErrorKind::NotFound
-pub bitcoin_io::ErrorKind::Other
-pub bitcoin_io::ErrorKind::PermissionDenied
-pub bitcoin_io::ErrorKind::TimedOut
-pub bitcoin_io::ErrorKind::UnexpectedEof
-pub bitcoin_io::ErrorKind::WouldBlock
-pub bitcoin_io::ErrorKind::WriteZero
-pub const fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
-pub const fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
-pub const fn bitcoin_io::Cursor<T>::position(&self) -> u64
-pub enum bitcoin_io::ErrorKind
-pub fn &[u8]::consume(&mut self, amount: usize)
-pub fn &[u8]::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn &[u8]::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::consume(&mut self, amount: usize)
-pub fn &mut T::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn &mut T::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &mut T::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn &mut T::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &mut [u8]::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &mut [u8]::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn alloc::vec::Vec<u8>::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn alloc::vec::Vec<u8>::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
-pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Cursor<T>::clone(&self) -> bitcoin_io::Cursor<T>
-pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
-pub fn bitcoin_io::Cursor<T>::default() -> bitcoin_io::Cursor<T>
-pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
-pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
-pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
-pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
-pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
-pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Error::fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
-pub fn bitcoin_io::Error::from(kind: bitcoin_io::ErrorKind) -> bitcoin_io::Error
-pub fn bitcoin_io::Error::get_ref(&self) -> core::option::Option<&(dyn core::fmt::Debug + core::marker::Send + core::marker::Sync + 'static)>
-pub fn bitcoin_io::Error::kind(&self) -> bitcoin_io::ErrorKind
-pub fn bitcoin_io::Error::new<E: bitcoin_io::error::sealed::IntoBoxDynDebug>(kind: bitcoin_io::ErrorKind, error: E) -> bitcoin_io::Error
-pub fn bitcoin_io::ErrorKind::clone(&self) -> bitcoin_io::ErrorKind
-pub fn bitcoin_io::ErrorKind::eq(&self, other: &bitcoin_io::ErrorKind) -> bool
-pub fn bitcoin_io::ErrorKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::ErrorKind::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_io::ErrorKind::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Read::read_to_limit(&mut self, buf: &mut alloc::vec::Vec<u8>, limit: u64) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
-pub fn bitcoin_io::Sink::clone(&self) -> bitcoin_io::Sink
-pub fn bitcoin_io::Sink::default() -> bitcoin_io::Sink
-pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
-pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Take<'_, R>::read_to_end(&mut self, buf: &mut alloc::vec::Vec<u8>) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Take<'a, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Write::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Write::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Write::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::sink() -> bitcoin_io::Sink
-pub macro bitcoin_io::impl_write!
-pub mod bitcoin_io
-pub struct bitcoin_io::Cursor<T>
-pub struct bitcoin_io::Error
-pub struct bitcoin_io::Sink
-pub struct bitcoin_io::Take<'a, R: bitcoin_io::Read + ?core::marker::Sized>
-pub trait bitcoin_io::BufRead: bitcoin_io::Read
-pub trait bitcoin_io::Read
-pub trait bitcoin_io::Write
-pub type bitcoin_io::Result<T> = core::result::Result<T, bitcoin_io::Error>
diff --git a/api/io/no-features.txt b/api/io/no-features.txt
deleted file mode 100644
index 493aab9300..0000000000
--- a/api/io/no-features.txt
+++ /dev/null
@@ -1,148 +0,0 @@
-impl !core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Error
-impl !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Error
-impl bitcoin_io::BufRead for &[u8]
-impl bitcoin_io::Error
-impl bitcoin_io::Read for &[u8]
-impl bitcoin_io::Write for &mut [u8]
-impl bitcoin_io::Write for bitcoin_io::Sink
-impl core::clone::Clone for bitcoin_io::ErrorKind
-impl core::clone::Clone for bitcoin_io::Sink
-impl core::cmp::Eq for bitcoin_io::ErrorKind
-impl core::cmp::PartialEq for bitcoin_io::ErrorKind
-impl core::convert::From<bitcoin_io::ErrorKind> for bitcoin_io::Error
-impl core::convert::From<core::convert::Infallible> for bitcoin_io::ErrorKind
-impl core::default::Default for bitcoin_io::Sink
-impl core::fmt::Debug for bitcoin_io::Error
-impl core::fmt::Debug for bitcoin_io::ErrorKind
-impl core::fmt::Debug for bitcoin_io::Sink
-impl core::fmt::Display for bitcoin_io::Error
-impl core::hash::Hash for bitcoin_io::ErrorKind
-impl core::marker::Copy for bitcoin_io::ErrorKind
-impl core::marker::Copy for bitcoin_io::Sink
-impl core::marker::Freeze for bitcoin_io::Error
-impl core::marker::Freeze for bitcoin_io::ErrorKind
-impl core::marker::Freeze for bitcoin_io::Sink
-impl core::marker::Send for bitcoin_io::Error
-impl core::marker::Send for bitcoin_io::ErrorKind
-impl core::marker::Send for bitcoin_io::Sink
-impl core::marker::StructuralPartialEq for bitcoin_io::ErrorKind
-impl core::marker::Sync for bitcoin_io::Error
-impl core::marker::Sync for bitcoin_io::ErrorKind
-impl core::marker::Sync for bitcoin_io::Sink
-impl core::marker::Unpin for bitcoin_io::Error
-impl core::marker::Unpin for bitcoin_io::ErrorKind
-impl core::marker::Unpin for bitcoin_io::Sink
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::ErrorKind
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Sink
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::ErrorKind
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_io::Sink
-impl<'a, R: core::fmt::Debug + bitcoin_io::Read + ?core::marker::Sized> core::fmt::Debug for bitcoin_io::Take<'a, R>
-impl<'a, R> !core::panic::unwind_safe::UnwindSafe for bitcoin_io::Take<'a, R>
-impl<'a, R> core::marker::Freeze for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
-impl<'a, R> core::marker::Send for bitcoin_io::Take<'a, R> where R: core::marker::Send + ?core::marker::Sized
-impl<'a, R> core::marker::Sync for bitcoin_io::Take<'a, R> where R: core::marker::Sync + ?core::marker::Sized
-impl<'a, R> core::marker::Unpin for bitcoin_io::Take<'a, R> where R: ?core::marker::Sized
-impl<'a, R> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Take<'a, R> where R: core::panic::unwind_safe::RefUnwindSafe + ?core::marker::Sized
-impl<R: bitcoin_io::BufRead + ?core::marker::Sized> bitcoin_io::BufRead for bitcoin_io::Take<'_, R>
-impl<R: bitcoin_io::Read + ?core::marker::Sized> bitcoin_io::Read for bitcoin_io::Take<'_, R>
-impl<T: bitcoin_io::BufRead> bitcoin_io::BufRead for &mut T
-impl<T: bitcoin_io::Read> bitcoin_io::Read for &mut T
-impl<T: bitcoin_io::Write> bitcoin_io::Write for &mut T
-impl<T: core::clone::Clone> core::clone::Clone for bitcoin_io::Cursor<T>
-impl<T: core::cmp::Eq> core::cmp::Eq for bitcoin_io::Cursor<T>
-impl<T: core::cmp::PartialEq> core::cmp::PartialEq for bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::BufRead for bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Cursor<T>
-impl<T: core::convert::AsRef<[u8]>> bitcoin_io::Read for bitcoin_io::Cursor<T>
-impl<T: core::default::Default> core::default::Default for bitcoin_io::Cursor<T>
-impl<T: core::fmt::Debug> core::fmt::Debug for bitcoin_io::Cursor<T>
-impl<T> core::marker::Freeze for bitcoin_io::Cursor<T> where T: core::marker::Freeze
-impl<T> core::marker::Send for bitcoin_io::Cursor<T> where T: core::marker::Send
-impl<T> core::marker::StructuralPartialEq for bitcoin_io::Cursor<T>
-impl<T> core::marker::Sync for bitcoin_io::Cursor<T> where T: core::marker::Sync
-impl<T> core::marker::Unpin for bitcoin_io::Cursor<T> where T: core::marker::Unpin
-impl<T> core::panic::unwind_safe::RefUnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::RefUnwindSafe
-impl<T> core::panic::unwind_safe::UnwindSafe for bitcoin_io::Cursor<T> where T: core::panic::unwind_safe::UnwindSafe
-pub bitcoin_io::ErrorKind::AddrInUse
-pub bitcoin_io::ErrorKind::AddrNotAvailable
-pub bitcoin_io::ErrorKind::AlreadyExists
-pub bitcoin_io::ErrorKind::BrokenPipe
-pub bitcoin_io::ErrorKind::ConnectionAborted
-pub bitcoin_io::ErrorKind::ConnectionRefused
-pub bitcoin_io::ErrorKind::ConnectionReset
-pub bitcoin_io::ErrorKind::Interrupted
-pub bitcoin_io::ErrorKind::InvalidData
-pub bitcoin_io::ErrorKind::InvalidInput
-pub bitcoin_io::ErrorKind::NotConnected
-pub bitcoin_io::ErrorKind::NotFound
-pub bitcoin_io::ErrorKind::Other
-pub bitcoin_io::ErrorKind::PermissionDenied
-pub bitcoin_io::ErrorKind::TimedOut
-pub bitcoin_io::ErrorKind::UnexpectedEof
-pub bitcoin_io::ErrorKind::WouldBlock
-pub bitcoin_io::ErrorKind::WriteZero
-pub const fn bitcoin_io::Cursor<T>::get_ref(&self) -> &T
-pub const fn bitcoin_io::Cursor<T>::new(inner: T) -> Self
-pub const fn bitcoin_io::Cursor<T>::position(&self) -> u64
-pub enum bitcoin_io::ErrorKind
-pub fn &[u8]::consume(&mut self, amount: usize)
-pub fn &[u8]::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn &[u8]::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::consume(&mut self, amount: usize)
-pub fn &mut T::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn &mut T::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &mut T::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn &mut T::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn &mut T::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn &mut [u8]::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn &mut [u8]::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::BufRead::consume(&mut self, amount: usize)
-pub fn bitcoin_io::BufRead::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Cursor<T>::clone(&self) -> bitcoin_io::Cursor<T>
-pub fn bitcoin_io::Cursor<T>::consume(&mut self, amount: usize)
-pub fn bitcoin_io::Cursor<T>::default() -> bitcoin_io::Cursor<T>
-pub fn bitcoin_io::Cursor<T>::eq(&self, other: &bitcoin_io::Cursor<T>) -> bool
-pub fn bitcoin_io::Cursor<T>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Cursor<T>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Cursor<T>::get_mut(&mut self) -> &mut T
-pub fn bitcoin_io::Cursor<T>::inner(&self) -> &T
-pub fn bitcoin_io::Cursor<T>::into_inner(self) -> T
-pub fn bitcoin_io::Cursor<T>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Cursor<T>::set_position(&mut self, position: u64)
-pub fn bitcoin_io::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Error::fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
-pub fn bitcoin_io::Error::from(kind: bitcoin_io::ErrorKind) -> bitcoin_io::Error
-pub fn bitcoin_io::Error::kind(&self) -> bitcoin_io::ErrorKind
-pub fn bitcoin_io::ErrorKind::clone(&self) -> bitcoin_io::ErrorKind
-pub fn bitcoin_io::ErrorKind::eq(&self, other: &bitcoin_io::ErrorKind) -> bool
-pub fn bitcoin_io::ErrorKind::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::ErrorKind::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_io::ErrorKind::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_io::Read::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Read::read_exact(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Read::take(&mut self, limit: u64) -> bitcoin_io::Take<'_, Self>
-pub fn bitcoin_io::Sink::clone(&self) -> bitcoin_io::Sink
-pub fn bitcoin_io::Sink::default() -> bitcoin_io::Sink
-pub fn bitcoin_io::Sink::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Sink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Sink::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Sink::write_all(&mut self, _: &[u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Take<'_, R>::consume(&mut self, amount: usize)
-pub fn bitcoin_io::Take<'_, R>::fill_buf(&mut self) -> bitcoin_io::Result<&[u8]>
-pub fn bitcoin_io::Take<'_, R>::read(&mut self, buf: &mut [u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Take<'a, R>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_io::Write::flush(&mut self) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::Write::write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize>
-pub fn bitcoin_io::Write::write_all(&mut self, buf: &[u8]) -> bitcoin_io::Result<()>
-pub fn bitcoin_io::sink() -> bitcoin_io::Sink
-pub macro bitcoin_io::impl_write!
-pub mod bitcoin_io
-pub struct bitcoin_io::Cursor<T>
-pub struct bitcoin_io::Error
-pub struct bitcoin_io::Sink
-pub struct bitcoin_io::Take<'a, R: bitcoin_io::Read + ?core::marker::Sized>
-pub trait bitcoin_io::BufRead: bitcoin_io::Read
-pub trait bitcoin_io::Read
-pub trait bitcoin_io::Write
-pub type bitcoin_io::Result<T> = core::result::Result<T, bitcoin_io::Error>
diff --git a/api/primitives/all-features.txt b/api/primitives/all-features.txt
deleted file mode 100644
index 9564cd7cef..0000000000
--- a/api/primitives/all-features.txt
+++ /dev/null
@@ -1,2041 +0,0 @@
-#[non_exhaustive] pub enum bitcoin_primitives::transaction::ParseOutPointError
-#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleHeightError
-#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleTimeError
-#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleHeightError
-#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleTimeError
-#[repr(transparent)] pub struct bitcoin_primitives::script::Script(_)
-impl !core::marker::Sized for bitcoin_primitives::script::Script
-impl alloc::borrow::ToOwned for bitcoin_primitives::script::Script
-impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
-impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl bitcoin_hashes::Hash for bitcoin_primitives::script::ScriptHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::script::WScriptHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapLeafHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapNodeHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapTweakHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Txid
-impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Wtxid
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapBranchTag
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapLeafTag
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapTweakTag
-impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
-impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
-impl bitcoin_primitives::block::BlockHash
-impl bitcoin_primitives::block::Header
-impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Checked
-impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Unchecked
-impl bitcoin_primitives::block::Version
-impl bitcoin_primitives::block::WitnessCommitment
-impl bitcoin_primitives::locktime::absolute::LockTime
-impl bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl bitcoin_primitives::locktime::relative::LockTime
-impl bitcoin_primitives::merkle_tree::TxMerkleNode
-impl bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl bitcoin_primitives::opcodes::Opcode
-impl bitcoin_primitives::pow::CompactTarget
-impl bitcoin_primitives::script::Script
-impl bitcoin_primitives::script::ScriptBuf
-impl bitcoin_primitives::script::ScriptHash
-impl bitcoin_primitives::script::WScriptHash
-impl bitcoin_primitives::sequence::Sequence
-impl bitcoin_primitives::taproot::TapLeafHash
-impl bitcoin_primitives::taproot::TapNodeHash
-impl bitcoin_primitives::taproot::TapTweakHash
-impl bitcoin_primitives::transaction::OutPoint
-impl bitcoin_primitives::transaction::Transaction
-impl bitcoin_primitives::transaction::TxIn
-impl bitcoin_primitives::transaction::Txid
-impl bitcoin_primitives::transaction::Version
-impl bitcoin_primitives::transaction::Wtxid
-impl bitcoin_primitives::witness::Witness
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_primitives::script::ScriptHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::BlockHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::script::WScriptHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Txid
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::BlockHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::WitnessCommitment
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::ScriptHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::WScriptHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Txid
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Wtxid
-impl core::borrow::Borrow<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::borrow::BorrowMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::clone::Clone for bitcoin_primitives::block::BlockHash
-impl core::clone::Clone for bitcoin_primitives::block::Checked
-impl core::clone::Clone for bitcoin_primitives::block::Header
-impl core::clone::Clone for bitcoin_primitives::block::Unchecked
-impl core::clone::Clone for bitcoin_primitives::block::Version
-impl core::clone::Clone for bitcoin_primitives::block::WitnessCommitment
-impl core::clone::Clone for bitcoin_primitives::locktime::absolute::LockTime
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::LockTime
-impl core::clone::Clone for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::clone::Clone for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::clone::Clone for bitcoin_primitives::opcodes::Class
-impl core::clone::Clone for bitcoin_primitives::opcodes::ClassifyContext
-impl core::clone::Clone for bitcoin_primitives::opcodes::Opcode
-impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
-impl core::clone::Clone for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::clone::Clone for bitcoin_primitives::script::ScriptBuf
-impl core::clone::Clone for bitcoin_primitives::script::ScriptHash
-impl core::clone::Clone for bitcoin_primitives::script::WScriptHash
-impl core::clone::Clone for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::clone::Clone for bitcoin_primitives::sequence::Sequence
-impl core::clone::Clone for bitcoin_primitives::taproot::TapBranchTag
-impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafTag
-impl core::clone::Clone for bitcoin_primitives::taproot::TapNodeHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakTag
-impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
-impl core::clone::Clone for bitcoin_primitives::transaction::ParseOutPointError
-impl core::clone::Clone for bitcoin_primitives::transaction::Transaction
-impl core::clone::Clone for bitcoin_primitives::transaction::TxIn
-impl core::clone::Clone for bitcoin_primitives::transaction::TxOut
-impl core::clone::Clone for bitcoin_primitives::transaction::Txid
-impl core::clone::Clone for bitcoin_primitives::transaction::Version
-impl core::clone::Clone for bitcoin_primitives::transaction::Wtxid
-impl core::clone::Clone for bitcoin_primitives::witness::Witness
-impl core::cmp::Eq for bitcoin_primitives::block::BlockHash
-impl core::cmp::Eq for bitcoin_primitives::block::Checked
-impl core::cmp::Eq for bitcoin_primitives::block::Header
-impl core::cmp::Eq for bitcoin_primitives::block::Unchecked
-impl core::cmp::Eq for bitcoin_primitives::block::Version
-impl core::cmp::Eq for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::Eq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::Eq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::Eq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
-impl core::cmp::Eq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::Eq for bitcoin_primitives::opcodes::Opcode
-impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::Eq for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::cmp::Eq for bitcoin_primitives::script::Script
-impl core::cmp::Eq for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::Eq for bitcoin_primitives::script::ScriptHash
-impl core::cmp::Eq for bitcoin_primitives::script::WScriptHash
-impl core::cmp::Eq for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::cmp::Eq for bitcoin_primitives::sequence::Sequence
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::Eq for bitcoin_primitives::transaction::ParseOutPointError
-impl core::cmp::Eq for bitcoin_primitives::transaction::Transaction
-impl core::cmp::Eq for bitcoin_primitives::transaction::TxIn
-impl core::cmp::Eq for bitcoin_primitives::transaction::TxOut
-impl core::cmp::Eq for bitcoin_primitives::transaction::Txid
-impl core::cmp::Eq for bitcoin_primitives::transaction::Version
-impl core::cmp::Eq for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::Eq for bitcoin_primitives::witness::Witness
-impl core::cmp::Ord for bitcoin_primitives::block::BlockHash
-impl core::cmp::Ord for bitcoin_primitives::block::Checked
-impl core::cmp::Ord for bitcoin_primitives::block::Header
-impl core::cmp::Ord for bitcoin_primitives::block::Unchecked
-impl core::cmp::Ord for bitcoin_primitives::block::Version
-impl core::cmp::Ord for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::Ord for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::Ord for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::Ord for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::Ord for bitcoin_primitives::script::Script
-impl core::cmp::Ord for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::Ord for bitcoin_primitives::script::ScriptHash
-impl core::cmp::Ord for bitcoin_primitives::script::WScriptHash
-impl core::cmp::Ord for bitcoin_primitives::sequence::Sequence
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::Ord for bitcoin_primitives::transaction::Transaction
-impl core::cmp::Ord for bitcoin_primitives::transaction::TxIn
-impl core::cmp::Ord for bitcoin_primitives::transaction::TxOut
-impl core::cmp::Ord for bitcoin_primitives::transaction::Txid
-impl core::cmp::Ord for bitcoin_primitives::transaction::Version
-impl core::cmp::Ord for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::Ord for bitcoin_primitives::witness::Witness
-impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHash
-impl core::cmp::PartialEq for bitcoin_primitives::block::Checked
-impl core::cmp::PartialEq for bitcoin_primitives::block::Header
-impl core::cmp::PartialEq for bitcoin_primitives::block::Unchecked
-impl core::cmp::PartialEq for bitcoin_primitives::block::Version
-impl core::cmp::PartialEq for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Opcode
-impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::PartialEq for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::cmp::PartialEq for bitcoin_primitives::script::Script
-impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptHash
-impl core::cmp::PartialEq for bitcoin_primitives::script::WScriptHash
-impl core::cmp::PartialEq for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::cmp::PartialEq for bitcoin_primitives::sequence::Sequence
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::ParseOutPointError
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Transaction
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxIn
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxOut
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Txid
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::PartialEq for bitcoin_primitives::witness::Witness
-impl core::cmp::PartialEq<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::PartialEq<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::Script
-impl core::cmp::PartialOrd for bitcoin_primitives::block::BlockHash
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Checked
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Unchecked
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
-impl core::cmp::PartialOrd for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::PartialOrd for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::PartialOrd for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::PartialOrd for bitcoin_primitives::script::Script
-impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptHash
-impl core::cmp::PartialOrd for bitcoin_primitives::script::WScriptHash
-impl core::cmp::PartialOrd for bitcoin_primitives::sequence::Sequence
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Transaction
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxIn
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxOut
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Txid
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::PartialOrd for bitcoin_primitives::witness::Witness
-impl core::cmp::PartialOrd<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::PartialOrd<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::Script
-impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::Script
-impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
-impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::AsRef<[u8; 20]> for bitcoin_primitives::script::ScriptHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::BlockHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::script::WScriptHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Txid
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::BlockHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::Script
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::WScriptHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Txid
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::AsRef<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
-impl core::convert::AsRef<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::From<&[&[u8]]> for bitcoin_primitives::witness::Witness
-impl core::convert::From<&[alloc::vec::Vec<u8>]> for bitcoin_primitives::witness::Witness
-impl core::convert::From<&bitcoin_primitives::block::Block> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Txid
-impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::From<alloc::vec::Vec<&[u8]>> for bitcoin_primitives::witness::Witness
-impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for bitcoin_primitives::witness::Witness
-impl core::convert::From<alloc::vec::Vec<u8>> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::From<bitcoin_hashes::hash160::Hash> for bitcoin_primitives::script::ScriptHash
-impl core::convert::From<bitcoin_hashes::sha256::Hash> for bitcoin_primitives::script::WScriptHash
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Txid
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::From<bitcoin_primitives::block::Block> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_primitives::block::BlockHash> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_primitives::block::WitnessCommitment> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::locktime::relative::LockTime> for bitcoin_primitives::sequence::Sequence
-impl core::convert::From<bitcoin_primitives::merkle_tree::TxMerkleNode> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>
-impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::boxed::Box<bitcoin_primitives::script::Script>
-impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::vec::Vec<u8>
-impl core::convert::From<bitcoin_primitives::script::ScriptHash> for bitcoin_hashes::hash160::Hash
-impl core::convert::From<bitcoin_primitives::script::WScriptHash> for bitcoin_hashes::sha256::Hash
-impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
-impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
-impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::From<bitcoin_primitives::taproot::TapNodeHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
-impl core::convert::From<bitcoin_primitives::taproot::TapTweakHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
-impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Txid
-impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::From<bitcoin_primitives::transaction::Txid> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::transaction::Wtxid> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::From<bitcoin_units::locktime::absolute::Time> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_primitives::locktime::relative::LockTime
-impl core::convert::From<bitcoin_units::locktime::relative::Time> for bitcoin_primitives::locktime::relative::LockTime
-impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::ParseOutPointError
-impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
-impl core::convert::TryFrom<&bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptHash
-impl core::convert::TryFrom<&bitcoin_primitives::script::Script> for bitcoin_primitives::script::WScriptHash
-impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::ScriptHash
-impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::WScriptHash
-impl core::convert::TryFrom<&str> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::TryFrom<&str> for bitcoin_primitives::sequence::Sequence
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::sequence::Sequence
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::sequence::Sequence
-impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::ScriptHash
-impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::WScriptHash
-impl core::convert::TryFrom<bitcoin_primitives::sequence::Sequence> for bitcoin_primitives::locktime::relative::LockTime
-impl core::default::Default for bitcoin_primitives::block::Version
-impl core::default::Default for bitcoin_primitives::pow::CompactTarget
-impl core::default::Default for bitcoin_primitives::script::ScriptBuf
-impl core::default::Default for bitcoin_primitives::sequence::Sequence
-impl core::default::Default for bitcoin_primitives::taproot::TapBranchTag
-impl core::default::Default for bitcoin_primitives::taproot::TapLeafTag
-impl core::default::Default for bitcoin_primitives::taproot::TapTweakTag
-impl core::default::Default for bitcoin_primitives::witness::Witness
-impl core::error::Error for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::error::Error for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::error::Error for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::error::Error for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::error::Error for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::error::Error for bitcoin_primitives::transaction::ParseOutPointError
-impl core::fmt::Debug for bitcoin_primitives::block::BlockHash
-impl core::fmt::Debug for bitcoin_primitives::block::Checked
-impl core::fmt::Debug for bitcoin_primitives::block::Header
-impl core::fmt::Debug for bitcoin_primitives::block::Unchecked
-impl core::fmt::Debug for bitcoin_primitives::block::Version
-impl core::fmt::Debug for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::Debug for bitcoin_primitives::locktime::absolute::LockTime
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::LockTime
-impl core::fmt::Debug for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::Debug for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
-impl core::fmt::Debug for bitcoin_primitives::opcodes::ClassifyContext
-impl core::fmt::Debug for bitcoin_primitives::opcodes::Opcode
-impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::Debug for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::fmt::Debug for bitcoin_primitives::script::Script
-impl core::fmt::Debug for bitcoin_primitives::script::ScriptBuf
-impl core::fmt::Debug for bitcoin_primitives::script::ScriptHash
-impl core::fmt::Debug for bitcoin_primitives::script::WScriptHash
-impl core::fmt::Debug for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::fmt::Debug for bitcoin_primitives::sequence::Sequence
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
-impl core::fmt::Debug for bitcoin_primitives::transaction::ParseOutPointError
-impl core::fmt::Debug for bitcoin_primitives::transaction::Transaction
-impl core::fmt::Debug for bitcoin_primitives::transaction::TxIn
-impl core::fmt::Debug for bitcoin_primitives::transaction::TxOut
-impl core::fmt::Debug for bitcoin_primitives::transaction::Txid
-impl core::fmt::Debug for bitcoin_primitives::transaction::Version
-impl core::fmt::Debug for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::Debug for bitcoin_primitives::witness::Witness
-impl core::fmt::Display for bitcoin_primitives::block::BlockHash
-impl core::fmt::Display for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::Display for bitcoin_primitives::locktime::absolute::LockTime
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::LockTime
-impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
-impl core::fmt::Display for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::fmt::Display for bitcoin_primitives::script::Script
-impl core::fmt::Display for bitcoin_primitives::script::ScriptBuf
-impl core::fmt::Display for bitcoin_primitives::script::ScriptHash
-impl core::fmt::Display for bitcoin_primitives::script::WScriptHash
-impl core::fmt::Display for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::fmt::Display for bitcoin_primitives::sequence::Sequence
-impl core::fmt::Display for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::Display for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::Display for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::Display for bitcoin_primitives::transaction::OutPoint
-impl core::fmt::Display for bitcoin_primitives::transaction::ParseOutPointError
-impl core::fmt::Display for bitcoin_primitives::transaction::Txid
-impl core::fmt::Display for bitcoin_primitives::transaction::Version
-impl core::fmt::Display for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::LowerHex for bitcoin_primitives::block::BlockHash
-impl core::fmt::LowerHex for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::LowerHex for bitcoin_primitives::script::Script
-impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptBuf
-impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptHash
-impl core::fmt::LowerHex for bitcoin_primitives::script::WScriptHash
-impl core::fmt::LowerHex for bitcoin_primitives::sequence::Sequence
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::LowerHex for bitcoin_primitives::transaction::Txid
-impl core::fmt::LowerHex for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::UpperHex for bitcoin_primitives::block::BlockHash
-impl core::fmt::UpperHex for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::UpperHex for bitcoin_primitives::script::Script
-impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptBuf
-impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptHash
-impl core::fmt::UpperHex for bitcoin_primitives::script::WScriptHash
-impl core::fmt::UpperHex for bitcoin_primitives::sequence::Sequence
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::UpperHex for bitcoin_primitives::transaction::Txid
-impl core::fmt::UpperHex for bitcoin_primitives::transaction::Wtxid
-impl core::hash::Hash for bitcoin_primitives::block::BlockHash
-impl core::hash::Hash for bitcoin_primitives::block::Checked
-impl core::hash::Hash for bitcoin_primitives::block::Header
-impl core::hash::Hash for bitcoin_primitives::block::Unchecked
-impl core::hash::Hash for bitcoin_primitives::block::Version
-impl core::hash::Hash for bitcoin_primitives::block::WitnessCommitment
-impl core::hash::Hash for bitcoin_primitives::locktime::absolute::LockTime
-impl core::hash::Hash for bitcoin_primitives::locktime::relative::LockTime
-impl core::hash::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::hash::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
-impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
-impl core::hash::Hash for bitcoin_primitives::script::Script
-impl core::hash::Hash for bitcoin_primitives::script::ScriptBuf
-impl core::hash::Hash for bitcoin_primitives::script::ScriptHash
-impl core::hash::Hash for bitcoin_primitives::script::WScriptHash
-impl core::hash::Hash for bitcoin_primitives::sequence::Sequence
-impl core::hash::Hash for bitcoin_primitives::taproot::TapBranchTag
-impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafTag
-impl core::hash::Hash for bitcoin_primitives::taproot::TapNodeHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakTag
-impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
-impl core::hash::Hash for bitcoin_primitives::transaction::Transaction
-impl core::hash::Hash for bitcoin_primitives::transaction::TxIn
-impl core::hash::Hash for bitcoin_primitives::transaction::TxOut
-impl core::hash::Hash for bitcoin_primitives::transaction::Txid
-impl core::hash::Hash for bitcoin_primitives::transaction::Version
-impl core::hash::Hash for bitcoin_primitives::transaction::Wtxid
-impl core::hash::Hash for bitcoin_primitives::witness::Witness
-impl core::iter::traits::exact_size::ExactSizeIterator for bitcoin_primitives::witness::Iter<'_>
-impl core::marker::Copy for bitcoin_primitives::block::BlockHash
-impl core::marker::Copy for bitcoin_primitives::block::Header
-impl core::marker::Copy for bitcoin_primitives::block::Version
-impl core::marker::Copy for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Copy for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Copy for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Copy for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Copy for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Copy for bitcoin_primitives::opcodes::Class
-impl core::marker::Copy for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Copy for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Copy for bitcoin_primitives::script::ScriptHash
-impl core::marker::Copy for bitcoin_primitives::script::WScriptHash
-impl core::marker::Copy for bitcoin_primitives::sequence::Sequence
-impl core::marker::Copy for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Copy for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Copy for bitcoin_primitives::transaction::Txid
-impl core::marker::Copy for bitcoin_primitives::transaction::Version
-impl core::marker::Copy for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Freeze for bitcoin_primitives::block::BlockHash
-impl core::marker::Freeze for bitcoin_primitives::block::Checked
-impl core::marker::Freeze for bitcoin_primitives::block::Header
-impl core::marker::Freeze for bitcoin_primitives::block::Unchecked
-impl core::marker::Freeze for bitcoin_primitives::block::Version
-impl core::marker::Freeze for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Freeze for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Freeze for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
-impl core::marker::Freeze for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Freeze for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Freeze for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::Freeze for bitcoin_primitives::script::Script
-impl core::marker::Freeze for bitcoin_primitives::script::ScriptBuf
-impl core::marker::Freeze for bitcoin_primitives::script::ScriptHash
-impl core::marker::Freeze for bitcoin_primitives::script::WScriptHash
-impl core::marker::Freeze for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::Freeze for bitcoin_primitives::sequence::Sequence
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Freeze for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::Freeze for bitcoin_primitives::transaction::Transaction
-impl core::marker::Freeze for bitcoin_primitives::transaction::TxIn
-impl core::marker::Freeze for bitcoin_primitives::transaction::TxOut
-impl core::marker::Freeze for bitcoin_primitives::transaction::Txid
-impl core::marker::Freeze for bitcoin_primitives::transaction::Version
-impl core::marker::Freeze for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Freeze for bitcoin_primitives::witness::Witness
-impl core::marker::Send for bitcoin_primitives::block::BlockHash
-impl core::marker::Send for bitcoin_primitives::block::Checked
-impl core::marker::Send for bitcoin_primitives::block::Header
-impl core::marker::Send for bitcoin_primitives::block::Unchecked
-impl core::marker::Send for bitcoin_primitives::block::Version
-impl core::marker::Send for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Send for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Send for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Send for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Send for bitcoin_primitives::opcodes::Class
-impl core::marker::Send for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Send for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Send for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::Send for bitcoin_primitives::script::Script
-impl core::marker::Send for bitcoin_primitives::script::ScriptBuf
-impl core::marker::Send for bitcoin_primitives::script::ScriptHash
-impl core::marker::Send for bitcoin_primitives::script::WScriptHash
-impl core::marker::Send for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::Send for bitcoin_primitives::sequence::Sequence
-impl core::marker::Send for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Send for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Send for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Send for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::Send for bitcoin_primitives::transaction::Transaction
-impl core::marker::Send for bitcoin_primitives::transaction::TxIn
-impl core::marker::Send for bitcoin_primitives::transaction::TxOut
-impl core::marker::Send for bitcoin_primitives::transaction::Txid
-impl core::marker::Send for bitcoin_primitives::transaction::Version
-impl core::marker::Send for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Send for bitcoin_primitives::witness::Witness
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Checked
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Unchecked
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Opcode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::Script
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBuf
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WScriptHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::sequence::Sequence
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Transaction
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxIn
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxOut
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Txid
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Wtxid
-impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::Witness
-impl core::marker::Sync for bitcoin_primitives::block::BlockHash
-impl core::marker::Sync for bitcoin_primitives::block::Checked
-impl core::marker::Sync for bitcoin_primitives::block::Header
-impl core::marker::Sync for bitcoin_primitives::block::Unchecked
-impl core::marker::Sync for bitcoin_primitives::block::Version
-impl core::marker::Sync for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Sync for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Sync for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Sync for bitcoin_primitives::opcodes::Class
-impl core::marker::Sync for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Sync for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Sync for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::Sync for bitcoin_primitives::script::Script
-impl core::marker::Sync for bitcoin_primitives::script::ScriptBuf
-impl core::marker::Sync for bitcoin_primitives::script::ScriptHash
-impl core::marker::Sync for bitcoin_primitives::script::WScriptHash
-impl core::marker::Sync for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::Sync for bitcoin_primitives::sequence::Sequence
-impl core::marker::Sync for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Sync for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Sync for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::Sync for bitcoin_primitives::transaction::Transaction
-impl core::marker::Sync for bitcoin_primitives::transaction::TxIn
-impl core::marker::Sync for bitcoin_primitives::transaction::TxOut
-impl core::marker::Sync for bitcoin_primitives::transaction::Txid
-impl core::marker::Sync for bitcoin_primitives::transaction::Version
-impl core::marker::Sync for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Sync for bitcoin_primitives::witness::Witness
-impl core::marker::Unpin for bitcoin_primitives::block::BlockHash
-impl core::marker::Unpin for bitcoin_primitives::block::Checked
-impl core::marker::Unpin for bitcoin_primitives::block::Header
-impl core::marker::Unpin for bitcoin_primitives::block::Unchecked
-impl core::marker::Unpin for bitcoin_primitives::block::Version
-impl core::marker::Unpin for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Unpin for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Unpin for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
-impl core::marker::Unpin for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Unpin for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Unpin for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::Unpin for bitcoin_primitives::script::Script
-impl core::marker::Unpin for bitcoin_primitives::script::ScriptBuf
-impl core::marker::Unpin for bitcoin_primitives::script::ScriptHash
-impl core::marker::Unpin for bitcoin_primitives::script::WScriptHash
-impl core::marker::Unpin for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::Unpin for bitcoin_primitives::sequence::Sequence
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Unpin for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::Unpin for bitcoin_primitives::transaction::Transaction
-impl core::marker::Unpin for bitcoin_primitives::transaction::TxIn
-impl core::marker::Unpin for bitcoin_primitives::transaction::TxOut
-impl core::marker::Unpin for bitcoin_primitives::transaction::Txid
-impl core::marker::Unpin for bitcoin_primitives::transaction::Version
-impl core::marker::Unpin for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Unpin for bitcoin_primitives::witness::Witness
-impl core::ops::deref::Deref for bitcoin_primitives::script::ScriptBuf
-impl core::ops::deref::DerefMut for bitcoin_primitives::script::ScriptBuf
-impl core::ops::index::Index<(core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::Range<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeFrom<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeFull> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeInclusive<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeTo<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeToInclusive<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<usize> for bitcoin_primitives::witness::Witness
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Checked
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Unchecked
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::WitnessCommitment
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::LockTime
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Class
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Opcode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::Script
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBuf
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WScriptHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::sequence::Sequence
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapBranchTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapNodeHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Transaction
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxIn
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOut
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Txid
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Wtxid
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Witness
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Checked
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Unchecked
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::WitnessCommitment
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::LockTime
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Opcode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::Script
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBuf
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WScriptHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::sequence::Sequence
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapBranchTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapNodeHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Transaction
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxIn
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOut
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Txid
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Wtxid
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Witness
-impl core::str::traits::FromStr for bitcoin_primitives::block::BlockHash
-impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
-impl core::str::traits::FromStr for bitcoin_primitives::locktime::absolute::LockTime
-impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::str::traits::FromStr for bitcoin_primitives::script::ScriptHash
-impl core::str::traits::FromStr for bitcoin_primitives::script::WScriptHash
-impl core::str::traits::FromStr for bitcoin_primitives::sequence::Sequence
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapNodeHash
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapTweakHash
-impl core::str::traits::FromStr for bitcoin_primitives::transaction::OutPoint
-impl core::str::traits::FromStr for bitcoin_primitives::transaction::Txid
-impl core::str::traits::FromStr for bitcoin_primitives::transaction::Wtxid
-impl ordered::ArbitraryOrd for bitcoin_primitives::locktime::absolute::LockTime
-impl ordered::ArbitraryOrd for bitcoin_primitives::locktime::relative::LockTime
-impl serde::ser::Serialize for bitcoin_primitives::block::BlockHash
-impl serde::ser::Serialize for bitcoin_primitives::block::Header
-impl serde::ser::Serialize for bitcoin_primitives::block::Version
-impl serde::ser::Serialize for bitcoin_primitives::block::WitnessCommitment
-impl serde::ser::Serialize for bitcoin_primitives::locktime::absolute::LockTime
-impl serde::ser::Serialize for bitcoin_primitives::locktime::relative::LockTime
-impl serde::ser::Serialize for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl serde::ser::Serialize for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl serde::ser::Serialize for bitcoin_primitives::opcodes::Opcode
-impl serde::ser::Serialize for bitcoin_primitives::pow::CompactTarget
-impl serde::ser::Serialize for bitcoin_primitives::script::Script
-impl serde::ser::Serialize for bitcoin_primitives::script::ScriptBuf
-impl serde::ser::Serialize for bitcoin_primitives::script::ScriptHash
-impl serde::ser::Serialize for bitcoin_primitives::script::WScriptHash
-impl serde::ser::Serialize for bitcoin_primitives::sequence::Sequence
-impl serde::ser::Serialize for bitcoin_primitives::taproot::TapLeafHash
-impl serde::ser::Serialize for bitcoin_primitives::taproot::TapNodeHash
-impl serde::ser::Serialize for bitcoin_primitives::taproot::TapTweakHash
-impl serde::ser::Serialize for bitcoin_primitives::transaction::OutPoint
-impl serde::ser::Serialize for bitcoin_primitives::transaction::Transaction
-impl serde::ser::Serialize for bitcoin_primitives::transaction::TxIn
-impl serde::ser::Serialize for bitcoin_primitives::transaction::TxOut
-impl serde::ser::Serialize for bitcoin_primitives::transaction::Txid
-impl serde::ser::Serialize for bitcoin_primitives::transaction::Version
-impl serde::ser::Serialize for bitcoin_primitives::transaction::Wtxid
-impl serde::ser::Serialize for bitcoin_primitives::witness::Witness
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Block
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Header
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::block::Version
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::locktime::absolute::LockTime
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::script::ScriptBuf
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::sequence::Sequence
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::OutPoint
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::Transaction
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::TxIn
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::TxOut
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::Txid
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::transaction::Version
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_primitives::witness::Witness
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::boxed::Box<bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::rc::Rc<bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::sync::Arc<bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl<'a> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>> for alloc::boxed::Box<bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>> for bitcoin_primitives::script::ScriptBuf
-impl<'a> core::iter::traits::collect::IntoIterator for &'a bitcoin_primitives::witness::Witness
-impl<'a> core::iter::traits::iterator::Iterator for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::marker::Freeze for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::marker::Send for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::marker::Sync for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::marker::Unpin for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Iter<'a>
-impl<'de, V> serde::de::Deserialize<'de> for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
-impl<'de> serde::de::Deserialize<'de> for &'de bitcoin_primitives::script::Script
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::BlockHash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::Header
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::Version
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::block::WitnessCommitment
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::locktime::absolute::LockTime
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::locktime::relative::LockTime
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::pow::CompactTarget
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::ScriptBuf
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::ScriptHash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::script::WScriptHash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::sequence::Sequence
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::taproot::TapLeafHash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::taproot::TapNodeHash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::taproot::TapTweakHash
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::OutPoint
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Transaction
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::TxIn
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::TxOut
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Txid
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Version
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::transaction::Wtxid
-impl<'de> serde::de::Deserialize<'de> for bitcoin_primitives::witness::Witness
-impl<V: bitcoin_primitives::block::Validation> bitcoin_primitives::block::Block<V>
-impl<V> core::clone::Clone for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::clone::Clone
-impl<V> core::cmp::Eq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::Eq
-impl<V> core::cmp::PartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::PartialEq
-impl<V> core::fmt::Debug for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::fmt::Debug
-impl<V> core::marker::Freeze for bitcoin_primitives::block::Block<V>
-impl<V> core::marker::Send for bitcoin_primitives::block::Block<V>
-impl<V> core::marker::StructuralPartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
-impl<V> core::marker::Sync for bitcoin_primitives::block::Block<V>
-impl<V> core::marker::Unpin for bitcoin_primitives::block::Block<V>
-impl<V> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::RefUnwindSafe
-impl<V> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::UnwindSafe
-impl<V> serde::ser::Serialize for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
-pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
-pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
-pub bitcoin_primitives::BlockHeader::nonce: u32
-pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::block::BlockHash
-pub bitcoin_primitives::BlockHeader::time: u32
-pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
-pub bitcoin_primitives::Transaction::input: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
-pub bitcoin_primitives::Transaction::lock_time: bitcoin_primitives::locktime::absolute::LockTime
-pub bitcoin_primitives::Transaction::output: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
-pub bitcoin_primitives::Transaction::version: bitcoin_primitives::transaction::Version
-pub bitcoin_primitives::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
-pub bitcoin_primitives::TxIn::script_sig: bitcoin_primitives::script::ScriptBuf
-pub bitcoin_primitives::TxIn::sequence: bitcoin_primitives::sequence::Sequence
-pub bitcoin_primitives::TxIn::witness: bitcoin_primitives::witness::Witness
-pub bitcoin_primitives::TxOut::script_pubkey: bitcoin_primitives::script::ScriptBuf
-pub bitcoin_primitives::TxOut::value: bitcoin_units::amount::unsigned::Amount
-pub bitcoin_primitives::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
-pub bitcoin_primitives::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
-pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
-pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
-pub bitcoin_primitives::block::Header::nonce: u32
-pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::block::BlockHash
-pub bitcoin_primitives::block::Header::time: u32
-pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
-pub bitcoin_primitives::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
-pub bitcoin_primitives::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
-pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
-pub bitcoin_primitives::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
-pub bitcoin_primitives::opcodes::Class::IllegalOp
-pub bitcoin_primitives::opcodes::Class::NoOp
-pub bitcoin_primitives::opcodes::Class::Ordinary(Ordinary)
-pub bitcoin_primitives::opcodes::Class::PushBytes(u32)
-pub bitcoin_primitives::opcodes::Class::PushNum(i32)
-pub bitcoin_primitives::opcodes::Class::ReturnOp
-pub bitcoin_primitives::opcodes::Class::SuccessOp
-pub bitcoin_primitives::opcodes::ClassifyContext::Legacy
-pub bitcoin_primitives::opcodes::ClassifyContext::TapScript
-pub bitcoin_primitives::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
-pub bitcoin_primitives::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
-pub bitcoin_primitives::script::RedeemScriptSizeError::size: usize
-pub bitcoin_primitives::script::WitnessScriptSizeError::size: usize
-pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
-pub bitcoin_primitives::transaction::OutPoint::vout: u32
-pub bitcoin_primitives::transaction::ParseOutPointError::Format
-pub bitcoin_primitives::transaction::ParseOutPointError::TooLong
-pub bitcoin_primitives::transaction::ParseOutPointError::Txid(hex_conservative::error::HexToArrayError)
-pub bitcoin_primitives::transaction::ParseOutPointError::Vout(bitcoin_units::parse::ParseIntError)
-pub bitcoin_primitives::transaction::ParseOutPointError::VoutNotCanonical
-pub bitcoin_primitives::transaction::Transaction::input: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
-pub bitcoin_primitives::transaction::Transaction::lock_time: bitcoin_primitives::locktime::absolute::LockTime
-pub bitcoin_primitives::transaction::Transaction::output: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
-pub bitcoin_primitives::transaction::Transaction::version: bitcoin_primitives::transaction::Version
-pub bitcoin_primitives::transaction::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
-pub bitcoin_primitives::transaction::TxIn::script_sig: bitcoin_primitives::script::ScriptBuf
-pub bitcoin_primitives::transaction::TxIn::sequence: bitcoin_primitives::sequence::Sequence
-pub bitcoin_primitives::transaction::TxIn::witness: bitcoin_primitives::witness::Witness
-pub bitcoin_primitives::transaction::TxOut::script_pubkey: bitcoin_primitives::script::ScriptBuf
-pub bitcoin_primitives::transaction::TxOut::value: bitcoin_units::amount::unsigned::Amount
-pub const bitcoin_primitives::BlockValidation::IS_CHECKED: bool
-pub const bitcoin_primitives::block::BlockHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::block::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
-pub const bitcoin_primitives::block::Checked::IS_CHECKED: bool
-pub const bitcoin_primitives::block::Header::SIZE: usize
-pub const bitcoin_primitives::block::Unchecked::IS_CHECKED: bool
-pub const bitcoin_primitives::block::Validation::IS_CHECKED: bool
-pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
-pub const bitcoin_primitives::block::Version::ONE: Self
-pub const bitcoin_primitives::block::Version::TWO: Self
-pub const bitcoin_primitives::block::WitnessCommitment::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::locktime::absolute::LockTime::SIZE: usize
-pub const bitcoin_primitives::locktime::absolute::LockTime::ZERO: bitcoin_primitives::locktime::absolute::LockTime
-pub const bitcoin_primitives::locktime::relative::LockTime::SIZE: usize
-pub const bitcoin_primitives::locktime::relative::LockTime::ZERO: bitcoin_primitives::locktime::relative::LockTime
-pub const bitcoin_primitives::merkle_tree::TxMerkleNode::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::merkle_tree::WitnessMerkleNode::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::opcodes::all::OP_0NOTEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_1ADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_1SUB: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DIV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DROP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2MUL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2OVER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2ROT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2SWAP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_3DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ABS: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_AND: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_BOOLAND: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_BOOLOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CAT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIG: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIGVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIG: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CLTV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CODESEPARATOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CSV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DEPTH: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DIV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DROP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ELSE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ENDIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_EQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_EQUALVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_FROMALTSTACK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_GREATERTHAN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_GREATERTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_HASH160: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_HASH256: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_IF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_IFDUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_INVALIDOPCODE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_INVERT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LEFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LESSTHAN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LESSTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LSHIFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MAX: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MIN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MOD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MUL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NEGATE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NIP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOTIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMEQUALVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMNOTEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_OR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_OVER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PICK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_0: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_11: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_12: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_13: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_14: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_15: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_16: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_17: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_18: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_19: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_20: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_21: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_22: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_23: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_24: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_25: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_26: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_27: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_28: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_29: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_30: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_31: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_32: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_33: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_34: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_35: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_36: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_37: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_38: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_39: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_3: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_40: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_41: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_42: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_43: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_44: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_45: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_46: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_47: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_48: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_49: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_50: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_51: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_52: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_53: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_54: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_55: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_56: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_57: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_58: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_59: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_60: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_61: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_62: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_63: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_64: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_65: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_66: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_67: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_68: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_69: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_70: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_71: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_72: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_73: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_74: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_75: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_11: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_12: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_13: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_14: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_15: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_16: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_3: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_NEG1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_187: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_188: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_189: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_190: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_191: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_192: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_193: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_194: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_195: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_196: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_197: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_198: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_199: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_200: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_201: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_202: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_203: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_204: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_205: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_206: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_207: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_208: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_209: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_210: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_211: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_212: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_213: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_214: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_215: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_216: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_217: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_218: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_219: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_220: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_221: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_222: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_223: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_224: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_225: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_226: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_227: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_228: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_229: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_230: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_231: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_232: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_233: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_234: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_235: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_236: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_237: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_238: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_239: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_240: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_241: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_242: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_243: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_244: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_245: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_246: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_247: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_248: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_249: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_250: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_251: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_252: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_253: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_254: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RIGHT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RIPEMD160: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ROLL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ROT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RSHIFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SHA1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SHA256: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SIZE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SUB: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SUBSTR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SWAP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_TOALTSTACK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_TUCK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERNOTIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_WITHIN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_XOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::script::MAX_REDEEM_SCRIPT_SIZE: usize
-pub const bitcoin_primitives::script::MAX_WITNESS_SCRIPT_SIZE: usize
-pub const bitcoin_primitives::script::ScriptHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::script::WScriptHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
-pub const bitcoin_primitives::sequence::Sequence::FINAL: Self
-pub const bitcoin_primitives::sequence::Sequence::MAX: Self
-pub const bitcoin_primitives::sequence::Sequence::SIZE: usize
-pub const bitcoin_primitives::sequence::Sequence::ZERO: Self
-pub const bitcoin_primitives::taproot::TapLeafHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::taproot::TapNodeHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::taproot::TapTweakHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
-pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
-pub const bitcoin_primitives::transaction::Transaction::MAX_STANDARD_WEIGHT: bitcoin_units::weight::Weight
-pub const bitcoin_primitives::transaction::TxIn::EMPTY_COINBASE: bitcoin_primitives::transaction::TxIn
-pub const bitcoin_primitives::transaction::Txid::COINBASE_PREVOUT: Self
-pub const bitcoin_primitives::transaction::Txid::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::transaction::Version::ONE: Self
-pub const bitcoin_primitives::transaction::Version::THREE: Self
-pub const bitcoin_primitives::transaction::Version::TWO: Self
-pub const bitcoin_primitives::transaction::Wtxid::COINBASE: Self
-pub const bitcoin_primitives::transaction::Wtxid::DISPLAY_BACKWARD: bool
-pub const fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
-pub const fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_height(&self) -> bool
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_time(&self) -> bool
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_height(n: u16) -> Self
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_height(&self) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_time(&self) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::opcodes::Opcode::decode_pushnum(self) -> core::option::Option<u8>
-pub const fn bitcoin_primitives::opcodes::Opcode::to_u8(self) -> u8
-pub const fn bitcoin_primitives::script::ScriptBuf::new() -> Self
-pub const fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &<bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::witness::Witness::new() -> Self
-pub enum bitcoin_primitives::BlockChecked
-pub enum bitcoin_primitives::BlockUnchecked
-pub enum bitcoin_primitives::absolute::LockTime
-pub enum bitcoin_primitives::block::Checked
-pub enum bitcoin_primitives::block::Unchecked
-pub enum bitcoin_primitives::locktime::absolute::LockTime
-pub enum bitcoin_primitives::locktime::relative::LockTime
-pub enum bitcoin_primitives::opcodes::Class
-pub enum bitcoin_primitives::opcodes::ClassifyContext
-pub enum bitcoin_primitives::relative::LockTime
-pub fn &'a bitcoin_primitives::witness::Witness::into_iter(self) -> Self::IntoIter
-pub fn &'de bitcoin_primitives::script::Script::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
-pub fn alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>::from(value: bitcoin_primitives::script::ScriptBuf) -> Self
-pub fn alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
-pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>) -> Self
-pub fn alloc::rc::Rc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn alloc::sync::Arc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn alloc::vec::Vec<u8>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
-pub fn bitcoin_hashes::hash160::Hash::from(hashtype: bitcoin_primitives::script::ScriptHash) -> bitcoin_hashes::hash160::Hash
-pub fn bitcoin_hashes::sha256::Hash::from(hashtype: bitcoin_primitives::script::WScriptHash) -> bitcoin_hashes::sha256::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Txid) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Wtxid) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>::from(hashtype: bitcoin_primitives::taproot::TapNodeHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>::from(hashtype: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>::from(hashtype: bitcoin_primitives::taproot::TapTweakHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
-pub fn bitcoin_primitives::block::Block::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::block::Block<V>::block_hash(&self) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::Block<V>::clone(&self) -> bitcoin_primitives::block::Block<V>
-pub fn bitcoin_primitives::block::Block<V>::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::block::Block<V>::eq(&self, other: &bitcoin_primitives::block::Block<V>) -> bool
-pub fn bitcoin_primitives::block::Block<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Block<V>::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::cached_witness_root(&self) -> core::option::Option<bitcoin_primitives::merkle_tree::WitnessMerkleNode>
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::header(&self) -> &bitcoin_primitives::block::Header
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::transactions(&self) -> &[bitcoin_primitives::transaction::Transaction]
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::assume_checked(self, witness_root: core::option::Option<bitcoin_primitives::merkle_tree::WitnessMerkleNode>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::into_parts(self) -> (bitcoin_primitives::block::Header, alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>)
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::new_unchecked(header: bitcoin_primitives::block::Header, transactions: alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
-pub fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::block::BlockHash::clone(&self) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::BlockHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::block::BlockHash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::block::BlockHash::eq(&self, other: &bitcoin_primitives::block::BlockHash) -> bool
-pub fn bitcoin_primitives::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::BlockHash::from(block: &bitcoin_primitives::block::Block) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(block: bitcoin_primitives::block::Block) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(header: &bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(header: bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::BlockHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::block::BlockHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::BlockHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::block::Checked::clone(&self) -> bitcoin_primitives::block::Checked
-pub fn bitcoin_primitives::block::Checked::cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Checked::eq(&self, other: &bitcoin_primitives::block::Checked) -> bool
-pub fn bitcoin_primitives::block::Checked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Checked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Checked::partial_cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Header::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
-pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Header::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
-pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Header::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::block::Unchecked::clone(&self) -> bitcoin_primitives::block::Unchecked
-pub fn bitcoin_primitives::block::Unchecked::cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Unchecked::eq(&self, other: &bitcoin_primitives::block::Unchecked) -> bool
-pub fn bitcoin_primitives::block::Unchecked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Unchecked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Unchecked::partial_cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Version::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
-pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Version::default() -> bitcoin_primitives::block::Version
-pub fn bitcoin_primitives::block::Version::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
-pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(&self, bit: u8) -> bool
-pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Version::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
-pub fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::block::WitnessCommitment::clone(&self) -> bitcoin_primitives::block::WitnessCommitment
-pub fn bitcoin_primitives::block::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::WitnessCommitment::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::block::WitnessCommitment, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::block::WitnessCommitment::eq(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> bool
-pub fn bitcoin_primitives::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::WitnessCommitment
-pub fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::WitnessCommitment, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::block::WitnessCommitment::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::WitnessCommitment::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::locktime::absolute::LockTime::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::arbitrary_cmp(&self, other: &Self) -> core::cmp::Ordering
-pub fn bitcoin_primitives::locktime::absolute::LockTime::clone(&self) -> bitcoin_primitives::locktime::absolute::LockTime
-pub fn bitcoin_primitives::locktime::absolute::LockTime::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::eq(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::Time) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_time(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::locktime::absolute::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::is_satisfied_by(&self, height: bitcoin_units::locktime::absolute::Height, time: bitcoin_units::locktime::absolute::Time) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
-pub fn bitcoin_primitives::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::DisabledLockTimeError
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::DisabledLockTimeError) -> bool
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleHeightError
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleHeightError) -> bool
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleTimeError
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleTimeError) -> bool
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::LockTime::arbitrary_cmp(&self, other: &Self) -> core::cmp::Ordering
-pub fn bitcoin_primitives::locktime::relative::LockTime::clone(&self) -> bitcoin_primitives::locktime::relative::LockTime
-pub fn bitcoin_primitives::locktime::relative::LockTime::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::locktime::relative::LockTime::eq(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::Height) -> Self
-pub fn bitcoin_primitives::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::Time) -> Self
-pub fn bitcoin_primitives::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::from_sequence(n: bitcoin_primitives::sequence::Sequence) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by_sequence(&self, other: bitcoin_primitives::sequence::Sequence) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self, h: bitcoin_units::locktime::relative::Height, t: bitcoin_units::locktime::relative::Time) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::relative::LockTime::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::TxMerkleNode
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::cmp::Ordering
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::merkle_tree::TxMerkleNode, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> bool
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::TxMerkleNode
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::TxMerkleNode, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::cmp::Ordering
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::merkle_tree::WitnessMerkleNode, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bool
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::WitnessMerkleNode, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::opcodes::Class::clone(&self) -> bitcoin_primitives::opcodes::Class
-pub fn bitcoin_primitives::opcodes::Class::eq(&self, other: &bitcoin_primitives::opcodes::Class) -> bool
-pub fn bitcoin_primitives::opcodes::Class::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::ClassifyContext::clone(&self) -> bitcoin_primitives::opcodes::ClassifyContext
-pub fn bitcoin_primitives::opcodes::ClassifyContext::cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::cmp::Ordering
-pub fn bitcoin_primitives::opcodes::ClassifyContext::eq(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> bool
-pub fn bitcoin_primitives::opcodes::ClassifyContext::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::ClassifyContext::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::opcodes::ClassifyContext::partial_cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::opcodes::Opcode::classify(self, ctx: bitcoin_primitives::opcodes::ClassifyContext) -> bitcoin_primitives::opcodes::Class
-pub fn bitcoin_primitives::opcodes::Opcode::clone(&self) -> bitcoin_primitives::opcodes::Opcode
-pub fn bitcoin_primitives::opcodes::Opcode::eq(&self, other: &bitcoin_primitives::opcodes::Opcode) -> bool
-pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
-pub fn bitcoin_primitives::opcodes::Opcode::from(b: u8) -> bitcoin_primitives::opcodes::Opcode
-pub fn bitcoin_primitives::opcodes::Opcode::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
-pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
-pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
-pub fn bitcoin_primitives::pow::CompactTarget::default() -> bitcoin_primitives::pow::CompactTarget
-pub fn bitcoin_primitives::pow::CompactTarget::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
-pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
-pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::pow::CompactTarget::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
-pub fn bitcoin_primitives::pow::CompactTarget::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::script::RedeemScriptSizeError::clone(&self) -> bitcoin_primitives::script::RedeemScriptSizeError
-pub fn bitcoin_primitives::script::RedeemScriptSizeError::eq(&self, other: &bitcoin_primitives::script::RedeemScriptSizeError) -> bool
-pub fn bitcoin_primitives::script::RedeemScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::RedeemScriptSizeError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_primitives::script::Script::as_bytes(&self) -> &[u8]
-pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut [u8]
-pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::as_mut_bytes(&mut self) -> &mut [u8]
-pub fn bitcoin_primitives::script::Script::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::script::Script::as_ref(&self) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::cmp(&self, other: &bitcoin_primitives::script::Script) -> core::cmp::Ordering
-pub fn bitcoin_primitives::script::Script::eq(&self, other: &bitcoin_primitives::script::Script) -> bool
-pub fn bitcoin_primitives::script::Script::eq(&self, other: &bitcoin_primitives::script::ScriptBuf) -> bool
-pub fn bitcoin_primitives::script::Script::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::Script::from_bytes(bytes: &[u8]) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::from_bytes_mut(bytes: &mut [u8]) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::script::Script::index(&self, index: (core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::Range<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeFrom<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeFull) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeInclusive<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeTo<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeToInclusive<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::into_script_buf(self: alloc::boxed::Box<Self>) -> bitcoin_primitives::script::ScriptBuf
-pub fn bitcoin_primitives::script::Script::is_empty(&self) -> bool
-pub fn bitcoin_primitives::script::Script::len(&self) -> usize
-pub fn bitcoin_primitives::script::Script::new() -> &'static bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::partial_cmp(&self, other: &bitcoin_primitives::script::Script) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::Script::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::Script::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
-pub fn bitcoin_primitives::script::Script::to_bytes(&self) -> alloc::vec::Vec<u8>
-pub fn bitcoin_primitives::script::Script::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::script::Script::to_owned(&self) -> Self::Owned
-pub fn bitcoin_primitives::script::Script::to_vec(&self) -> alloc::vec::Vec<u8>
-pub fn bitcoin_primitives::script::ScriptBuf::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::script::ScriptBuf::as_mut(&mut self) -> &mut [u8]
-pub fn bitcoin_primitives::script::ScriptBuf::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::as_mut_script(&mut self) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::script::ScriptBuf::as_ref(&self) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::as_script(&self) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::borrow(&self) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::borrow_mut(&mut self) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::clone(&self) -> bitcoin_primitives::script::ScriptBuf
-pub fn bitcoin_primitives::script::ScriptBuf::cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::cmp::Ordering
-pub fn bitcoin_primitives::script::ScriptBuf::default() -> bitcoin_primitives::script::ScriptBuf
-pub fn bitcoin_primitives::script::ScriptBuf::deref(&self) -> &Self::Target
-pub fn bitcoin_primitives::script::ScriptBuf::deref_mut(&mut self) -> &mut Self::Target
-pub fn bitcoin_primitives::script::ScriptBuf::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::script::ScriptBuf::eq(&self, other: &bitcoin_primitives::script::Script) -> bool
-pub fn bitcoin_primitives::script::ScriptBuf::eq(&self, other: &bitcoin_primitives::script::ScriptBuf) -> bool
-pub fn bitcoin_primitives::script::ScriptBuf::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::ScriptBuf::from(v: alloc::vec::Vec<u8>) -> Self
-pub fn bitcoin_primitives::script::ScriptBuf::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn bitcoin_primitives::script::ScriptBuf::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>) -> Self
-pub fn bitcoin_primitives::script::ScriptBuf::from_bytes(bytes: alloc::vec::Vec<u8>) -> Self
-pub fn bitcoin_primitives::script::ScriptBuf::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::script::ScriptBuf::into_boxed_script(self) -> alloc::boxed::Box<bitcoin_primitives::script::Script>
-pub fn bitcoin_primitives::script::ScriptBuf::into_bytes(self) -> alloc::vec::Vec<u8>
-pub fn bitcoin_primitives::script::ScriptBuf::partial_cmp(&self, other: &bitcoin_primitives::script::Script) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::ScriptBuf::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::ScriptBuf::reserve(&mut self, additional_len: usize)
-pub fn bitcoin_primitives::script::ScriptBuf::reserve_exact(&mut self, additional_len: usize)
-pub fn bitcoin_primitives::script::ScriptBuf::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
-pub fn bitcoin_primitives::script::ScriptBuf::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::script::ScriptBuf::with_capacity(capacity: usize) -> Self
-pub fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::script::ScriptHash::clone(&self) -> bitcoin_primitives::script::ScriptHash
-pub fn bitcoin_primitives::script::ScriptHash::cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::script::ScriptHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::script::ScriptHash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::script::ScriptHash::eq(&self, other: &bitcoin_primitives::script::ScriptHash) -> bool
-pub fn bitcoin_primitives::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::ScriptHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin_primitives::script::ScriptHash
-pub fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::script::ScriptHash::from_script(redeem_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, bitcoin_primitives::script::RedeemScriptSizeError>
-pub fn bitcoin_primitives::script::ScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::Script) -> Self
-pub fn bitcoin_primitives::script::ScriptHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::script::ScriptHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::script::ScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::script::ScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::ScriptHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::script::WScriptHash::clone(&self) -> bitcoin_primitives::script::WScriptHash
-pub fn bitcoin_primitives::script::WScriptHash::cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::script::WScriptHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::script::WScriptHash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::script::WScriptHash::eq(&self, other: &bitcoin_primitives::script::WScriptHash) -> bool
-pub fn bitcoin_primitives::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::WScriptHash::from(inner: bitcoin_hashes::sha256::Hash) -> bitcoin_primitives::script::WScriptHash
-pub fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::script::WScriptHash::from_script(witness_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, bitcoin_primitives::script::WitnessScriptSizeError>
-pub fn bitcoin_primitives::script::WScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::Script) -> Self
-pub fn bitcoin_primitives::script::WScriptHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::script::WScriptHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::script::WScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::script::WScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::WScriptHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::WitnessScriptSizeError::clone(&self) -> bitcoin_primitives::script::WitnessScriptSizeError
-pub fn bitcoin_primitives::script::WitnessScriptSizeError::eq(&self, other: &bitcoin_primitives::script::WitnessScriptSizeError) -> bool
-pub fn bitcoin_primitives::script::WitnessScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::WitnessScriptSizeError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::sequence::Sequence::clone(&self) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::sequence::Sequence::cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::cmp::Ordering
-pub fn bitcoin_primitives::sequence::Sequence::default() -> Self
-pub fn bitcoin_primitives::sequence::Sequence::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::sequence::Sequence::enables_absolute_lock_time(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::eq(&self, other: &bitcoin_primitives::sequence::Sequence) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::sequence::Sequence::from(lt: bitcoin_primitives::locktime::relative::LockTime) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_consensus(n: u32) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_height(height: u16) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_primitives::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub fn bitcoin_primitives::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub fn bitcoin_primitives::sequence::Sequence::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_primitives::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::sequence::Sequence::is_final(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_height_locked(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_rbf(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::sequence::Sequence::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::sequence::Sequence::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
-pub fn bitcoin_primitives::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
-pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
-pub fn bitcoin_primitives::taproot::TapBranchTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapBranchTag::eq(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> bool
-pub fn bitcoin_primitives::taproot::TapBranchTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapBranchTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapLeafHash::clone(&self) -> bitcoin_primitives::taproot::TapLeafHash
-pub fn bitcoin_primitives::taproot::TapLeafHash::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapLeafHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::taproot::TapLeafHash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::taproot::TapLeafHash::eq(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> bool
-pub fn bitcoin_primitives::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>) -> bitcoin_primitives::taproot::TapLeafHash
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapLeafHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapLeafHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapLeafTag::clone(&self) -> bitcoin_primitives::taproot::TapLeafTag
-pub fn bitcoin_primitives::taproot::TapLeafTag::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapLeafTag::default() -> bitcoin_primitives::taproot::TapLeafTag
-pub fn bitcoin_primitives::taproot::TapLeafTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapLeafTag::eq(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> bool
-pub fn bitcoin_primitives::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapNodeHash::clone(&self) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapNodeHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::taproot::TapNodeHash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::taproot::TapNodeHash::eq(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> bool
-pub fn bitcoin_primitives::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::from(leaf: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapNodeHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapNodeHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapTweakHash::clone(&self) -> bitcoin_primitives::taproot::TapTweakHash
-pub fn bitcoin_primitives::taproot::TapTweakHash::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapTweakHash::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::taproot::TapTweakHash, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::taproot::TapTweakHash::eq(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> bool
-pub fn bitcoin_primitives::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>) -> bitcoin_primitives::taproot::TapTweakHash
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapTweakHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapTweakHash::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakTag::clone(&self) -> bitcoin_primitives::taproot::TapTweakTag
-pub fn bitcoin_primitives::taproot::TapTweakTag::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapTweakTag::default() -> bitcoin_primitives::taproot::TapTweakTag
-pub fn bitcoin_primitives::taproot::TapTweakTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapTweakTag::eq(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> bool
-pub fn bitcoin_primitives::taproot::TapTweakTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapTweakTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::OutPoint::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
-pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::OutPoint::deserialize<D>(deserializer: D) -> core::result::Result<bitcoin_primitives::transaction::OutPoint, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
-pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::OutPoint::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::OutPoint::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
-pub fn bitcoin_primitives::transaction::ParseOutPointError::clone(&self) -> bitcoin_primitives::transaction::ParseOutPointError
-pub fn bitcoin_primitives::transaction::ParseOutPointError::eq(&self, other: &bitcoin_primitives::transaction::ParseOutPointError) -> bool
-pub fn bitcoin_primitives::transaction::ParseOutPointError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::ParseOutPointError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_primitives::transaction::ParseOutPointError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_primitives::transaction::Transaction::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::transaction::Transaction::clone(&self) -> bitcoin_primitives::transaction::Transaction
-pub fn bitcoin_primitives::transaction::Transaction::cmp(&self, other: &Self) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Transaction::compute_ntxid(&self) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_primitives::transaction::Transaction::compute_txid(&self) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Transaction::compute_wtxid(&self) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Transaction::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::transaction::Transaction::eq(&self, other: &bitcoin_primitives::transaction::Transaction) -> bool
-pub fn bitcoin_primitives::transaction::Transaction::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Transaction::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Transaction::inputs(&self) -> &[bitcoin_primitives::transaction::TxIn]
-pub fn bitcoin_primitives::transaction::Transaction::inputs_mut(&mut self) -> &mut [bitcoin_primitives::transaction::TxIn]
-pub fn bitcoin_primitives::transaction::Transaction::outputs(&self) -> &[bitcoin_primitives::transaction::TxOut]
-pub fn bitcoin_primitives::transaction::Transaction::outputs_mut(&mut self) -> &mut [bitcoin_primitives::transaction::TxOut]
-pub fn bitcoin_primitives::transaction::Transaction::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Transaction::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::transaction::TxIn::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::transaction::TxIn::clone(&self) -> bitcoin_primitives::transaction::TxIn
-pub fn bitcoin_primitives::transaction::TxIn::cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::TxIn::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::transaction::TxIn::eq(&self, other: &bitcoin_primitives::transaction::TxIn) -> bool
-pub fn bitcoin_primitives::transaction::TxIn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::TxIn::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::TxIn::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::TxIn::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::transaction::TxOut::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::transaction::TxOut::clone(&self) -> bitcoin_primitives::transaction::TxOut
-pub fn bitcoin_primitives::transaction::TxOut::cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::TxOut::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::transaction::TxOut::eq(&self, other: &bitcoin_primitives::transaction::TxOut) -> bool
-pub fn bitcoin_primitives::transaction::TxOut::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::TxOut::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::TxOut::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::TxOut::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::transaction::Txid::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Txid::clone(&self) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Txid::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::transaction::Txid, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::transaction::Txid::eq(&self, other: &bitcoin_primitives::transaction::Txid) -> bool
-pub fn bitcoin_primitives::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::from(tx: &bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::from(tx: bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Txid, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::transaction::Txid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Txid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Txid::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::transaction::Version::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
-pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Version::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
-pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Version::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Wtxid::clone(&self) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Wtxid::deserialize<D: serde::de::Deserializer<'de>>(d: D) -> core::result::Result<bitcoin_primitives::transaction::Wtxid, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_primitives::transaction::Wtxid::eq(&self, other: &bitcoin_primitives::transaction::Wtxid) -> bool
-pub fn bitcoin_primitives::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::from(tx: &bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::from(tx: bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Wtxid, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::transaction::Wtxid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Wtxid::serialize<S: serde::ser::Serializer>(&self, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::witness::Iter<'a>::next(&mut self) -> core::option::Option<Self::Item>
-pub fn bitcoin_primitives::witness::Iter<'a>::size_hint(&self) -> (usize, core::option::Option<usize>)
-pub fn bitcoin_primitives::witness::Witness::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_primitives::witness::Witness::clear(&mut self)
-pub fn bitcoin_primitives::witness::Witness::clone(&self) -> bitcoin_primitives::witness::Witness
-pub fn bitcoin_primitives::witness::Witness::cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::cmp::Ordering
-pub fn bitcoin_primitives::witness::Witness::default() -> Self
-pub fn bitcoin_primitives::witness::Witness::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
-pub fn bitcoin_primitives::witness::Witness::eq(&self, other: &bitcoin_primitives::witness::Witness) -> bool
-pub fn bitcoin_primitives::witness::Witness::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
-pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8]]) -> Self
-pub fn bitcoin_primitives::witness::Witness::from(slice: &[alloc::vec::Vec<u8>]) -> Self
-pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<&[u8]>) -> Self
-pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<alloc::vec::Vec<u8>>) -> Self
-pub fn bitcoin_primitives::witness::Witness::from_slice<T: core::convert::AsRef<[u8]>>(slice: &[T]) -> Self
-pub fn bitcoin_primitives::witness::Witness::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::witness::Witness::index(&self, index: usize) -> &Self::Output
-pub fn bitcoin_primitives::witness::Witness::is_empty(&self) -> bool
-pub fn bitcoin_primitives::witness::Witness::iter(&self) -> bitcoin_primitives::witness::Iter<'_>
-pub fn bitcoin_primitives::witness::Witness::last(&self) -> core::option::Option<&[u8]>
-pub fn bitcoin_primitives::witness::Witness::len(&self) -> usize
-pub fn bitcoin_primitives::witness::Witness::nth(&self, index: usize) -> core::option::Option<&[u8]>
-pub fn bitcoin_primitives::witness::Witness::partial_cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::witness::Witness::push<T: core::convert::AsRef<[u8]>>(&mut self, new_element: T)
-pub fn bitcoin_primitives::witness::Witness::second_to_last(&self) -> core::option::Option<&[u8]>
-pub fn bitcoin_primitives::witness::Witness::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
-pub fn bitcoin_primitives::witness::Witness::size(&self) -> usize
-pub fn bitcoin_primitives::witness::Witness::third_to_last(&self) -> core::option::Option<&[u8]>
-pub fn bitcoin_primitives::witness::Witness::to_vec(&self) -> alloc::vec::Vec<alloc::vec::Vec<u8>>
-pub fn u32::from(sequence: bitcoin_primitives::sequence::Sequence) -> u32
-pub mod bitcoin_primitives
-pub mod bitcoin_primitives::absolute
-pub mod bitcoin_primitives::block
-pub mod bitcoin_primitives::locktime
-pub mod bitcoin_primitives::locktime::absolute
-pub mod bitcoin_primitives::locktime::relative
-pub mod bitcoin_primitives::merkle_tree
-pub mod bitcoin_primitives::opcodes
-pub mod bitcoin_primitives::opcodes::all
-pub mod bitcoin_primitives::pow
-pub mod bitcoin_primitives::relative
-pub mod bitcoin_primitives::script
-pub mod bitcoin_primitives::sequence
-pub mod bitcoin_primitives::taproot
-pub mod bitcoin_primitives::transaction
-pub mod bitcoin_primitives::witness
-pub static bitcoin_primitives::opcodes::OP_0: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_FALSE: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_NOP2: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_NOP3: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_TRUE: bitcoin_primitives::opcodes::Opcode
-pub struct bitcoin_primitives::Block<V> where V: bitcoin_primitives::block::Validation
-pub struct bitcoin_primitives::BlockHash(_)
-pub struct bitcoin_primitives::BlockHeader
-pub struct bitcoin_primitives::CompactTarget(_)
-pub struct bitcoin_primitives::Sequence(pub u32)
-pub struct bitcoin_primitives::TapBranchTag
-pub struct bitcoin_primitives::TapLeafHash(_)
-pub struct bitcoin_primitives::TapLeafTag
-pub struct bitcoin_primitives::TapNodeHash(_)
-pub struct bitcoin_primitives::TapTweakHash(_)
-pub struct bitcoin_primitives::TapTweakTag
-pub struct bitcoin_primitives::Transaction
-pub struct bitcoin_primitives::TxIn
-pub struct bitcoin_primitives::TxMerkleNode(_)
-pub struct bitcoin_primitives::TxOut
-pub struct bitcoin_primitives::Txid(_)
-pub struct bitcoin_primitives::Witness
-pub struct bitcoin_primitives::WitnessCommitment(_)
-pub struct bitcoin_primitives::WitnessMerkleNode(_)
-pub struct bitcoin_primitives::Wtxid(_)
-pub struct bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
-pub struct bitcoin_primitives::block::BlockHash(_)
-pub struct bitcoin_primitives::block::Header
-pub struct bitcoin_primitives::block::Version(_)
-pub struct bitcoin_primitives::block::WitnessCommitment(_)
-pub struct bitcoin_primitives::locktime::relative::DisabledLockTimeError(_)
-pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
-pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
-pub struct bitcoin_primitives::opcodes::Opcode
-pub struct bitcoin_primitives::pow::CompactTarget(_)
-pub struct bitcoin_primitives::relative::DisabledLockTimeError(_)
-pub struct bitcoin_primitives::script::RedeemScriptSizeError
-pub struct bitcoin_primitives::script::ScriptBuf(_)
-pub struct bitcoin_primitives::script::ScriptHash(_)
-pub struct bitcoin_primitives::script::WScriptHash(_)
-pub struct bitcoin_primitives::script::WitnessScriptSizeError
-pub struct bitcoin_primitives::sequence::Sequence(pub u32)
-pub struct bitcoin_primitives::taproot::TapBranchTag
-pub struct bitcoin_primitives::taproot::TapLeafHash(_)
-pub struct bitcoin_primitives::taproot::TapLeafTag
-pub struct bitcoin_primitives::taproot::TapNodeHash(_)
-pub struct bitcoin_primitives::taproot::TapTweakHash(_)
-pub struct bitcoin_primitives::taproot::TapTweakTag
-pub struct bitcoin_primitives::transaction::OutPoint
-pub struct bitcoin_primitives::transaction::Transaction
-pub struct bitcoin_primitives::transaction::TxIn
-pub struct bitcoin_primitives::transaction::TxOut
-pub struct bitcoin_primitives::transaction::Txid(_)
-pub struct bitcoin_primitives::transaction::Version(pub i32)
-pub struct bitcoin_primitives::transaction::Wtxid(_)
-pub struct bitcoin_primitives::witness::Iter<'a>
-pub struct bitcoin_primitives::witness::Witness
-pub trait bitcoin_primitives::BlockValidation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
-pub trait bitcoin_primitives::block::Validation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
-pub type &'a bitcoin_primitives::witness::Witness::IntoIter = bitcoin_primitives::witness::Iter<'a>
-pub type &'a bitcoin_primitives::witness::Witness::Item = &'a [u8]
-pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::block::BlockHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::block::WitnessCommitment::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::block::WitnessCommitment::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::locktime::absolute::LockTime::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::locktime::absolute::LockTime::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::locktime::relative::LockTime::Error = bitcoin_primitives::locktime::relative::DisabledLockTimeError
-pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::script::Script::Output = bitcoin_primitives::script::Script
-pub type bitcoin_primitives::script::Script::Owned = bitcoin_primitives::script::ScriptBuf
-pub type bitcoin_primitives::script::ScriptBuf::Target = bitcoin_primitives::script::Script
-pub type bitcoin_primitives::script::ScriptHash::Bytes = <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::script::ScriptHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::script::ScriptHash::Error = bitcoin_primitives::script::RedeemScriptSizeError
-pub type bitcoin_primitives::script::WScriptHash::Bytes = <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::script::WScriptHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::script::WScriptHash::Error = bitcoin_primitives::script::WitnessScriptSizeError
-pub type bitcoin_primitives::sequence::Sequence::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::sequence::Sequence::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::taproot::TapLeafHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapLeafHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::taproot::TapNodeHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapNodeHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::taproot::TapTweakHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapTweakHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::transaction::OutPoint::Err = bitcoin_primitives::transaction::ParseOutPointError
-pub type bitcoin_primitives::transaction::Txid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::transaction::Txid::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::transaction::Wtxid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::transaction::Wtxid::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::witness::Iter<'a>::Item = &'a [u8]
-pub type bitcoin_primitives::witness::Witness::Output = [u8]
-pub use bitcoin_primitives::Amount
-pub use bitcoin_primitives::BlockHeight
-pub use bitcoin_primitives::BlockInterval
-pub use bitcoin_primitives::FeeRate
-pub use bitcoin_primitives::SignedAmount
-pub use bitcoin_primitives::Weight
-pub use bitcoin_primitives::absolute::ConversionError
-pub use bitcoin_primitives::absolute::Height
-pub use bitcoin_primitives::absolute::LOCK_TIME_THRESHOLD
-pub use bitcoin_primitives::absolute::ParseHeightError
-pub use bitcoin_primitives::absolute::ParseTimeError
-pub use bitcoin_primitives::absolute::Time
-pub use bitcoin_primitives::amount
-pub use bitcoin_primitives::fee_rate
-pub use bitcoin_primitives::locktime::absolute::ConversionError
-pub use bitcoin_primitives::locktime::absolute::Height
-pub use bitcoin_primitives::locktime::absolute::LOCK_TIME_THRESHOLD
-pub use bitcoin_primitives::locktime::absolute::ParseHeightError
-pub use bitcoin_primitives::locktime::absolute::ParseTimeError
-pub use bitcoin_primitives::locktime::absolute::Time
-pub use bitcoin_primitives::locktime::relative::Height
-pub use bitcoin_primitives::locktime::relative::Time
-pub use bitcoin_primitives::locktime::relative::TimeOverflowError
-pub use bitcoin_primitives::relative::Height
-pub use bitcoin_primitives::relative::Time
-pub use bitcoin_primitives::relative::TimeOverflowError
-pub use bitcoin_primitives::weight
diff --git a/api/primitives/alloc-only.txt b/api/primitives/alloc-only.txt
deleted file mode 100644
index 6154e801c0..0000000000
--- a/api/primitives/alloc-only.txt
+++ /dev/null
@@ -1,1898 +0,0 @@
-#[non_exhaustive] pub enum bitcoin_primitives::transaction::ParseOutPointError
-#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleHeightError
-#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleTimeError
-#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleHeightError
-#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleTimeError
-#[repr(transparent)] pub struct bitcoin_primitives::script::Script(_)
-impl !core::marker::Sized for bitcoin_primitives::script::Script
-impl alloc::borrow::ToOwned for bitcoin_primitives::script::Script
-impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
-impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl bitcoin_hashes::Hash for bitcoin_primitives::script::ScriptHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::script::WScriptHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapLeafHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapNodeHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapTweakHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Txid
-impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Wtxid
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapBranchTag
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapLeafTag
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapTweakTag
-impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
-impl bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
-impl bitcoin_primitives::block::BlockHash
-impl bitcoin_primitives::block::Header
-impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Checked
-impl bitcoin_primitives::block::Validation for bitcoin_primitives::block::Unchecked
-impl bitcoin_primitives::block::Version
-impl bitcoin_primitives::block::WitnessCommitment
-impl bitcoin_primitives::locktime::absolute::LockTime
-impl bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl bitcoin_primitives::locktime::relative::LockTime
-impl bitcoin_primitives::merkle_tree::TxMerkleNode
-impl bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl bitcoin_primitives::opcodes::Opcode
-impl bitcoin_primitives::pow::CompactTarget
-impl bitcoin_primitives::script::Script
-impl bitcoin_primitives::script::ScriptBuf
-impl bitcoin_primitives::script::ScriptHash
-impl bitcoin_primitives::script::WScriptHash
-impl bitcoin_primitives::sequence::Sequence
-impl bitcoin_primitives::taproot::TapLeafHash
-impl bitcoin_primitives::taproot::TapNodeHash
-impl bitcoin_primitives::taproot::TapTweakHash
-impl bitcoin_primitives::transaction::OutPoint
-impl bitcoin_primitives::transaction::Transaction
-impl bitcoin_primitives::transaction::TxIn
-impl bitcoin_primitives::transaction::Txid
-impl bitcoin_primitives::transaction::Version
-impl bitcoin_primitives::transaction::Wtxid
-impl bitcoin_primitives::witness::Witness
-impl core::borrow::Borrow<[u8; 20]> for bitcoin_primitives::script::ScriptHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::BlockHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::script::WScriptHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Txid
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::BlockHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::WitnessCommitment
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::ScriptHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::script::WScriptHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Txid
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Wtxid
-impl core::borrow::Borrow<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::borrow::BorrowMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::clone::Clone for bitcoin_primitives::block::BlockHash
-impl core::clone::Clone for bitcoin_primitives::block::Checked
-impl core::clone::Clone for bitcoin_primitives::block::Header
-impl core::clone::Clone for bitcoin_primitives::block::Unchecked
-impl core::clone::Clone for bitcoin_primitives::block::Version
-impl core::clone::Clone for bitcoin_primitives::block::WitnessCommitment
-impl core::clone::Clone for bitcoin_primitives::locktime::absolute::LockTime
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::LockTime
-impl core::clone::Clone for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::clone::Clone for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::clone::Clone for bitcoin_primitives::opcodes::Class
-impl core::clone::Clone for bitcoin_primitives::opcodes::ClassifyContext
-impl core::clone::Clone for bitcoin_primitives::opcodes::Opcode
-impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
-impl core::clone::Clone for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::clone::Clone for bitcoin_primitives::script::ScriptBuf
-impl core::clone::Clone for bitcoin_primitives::script::ScriptHash
-impl core::clone::Clone for bitcoin_primitives::script::WScriptHash
-impl core::clone::Clone for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::clone::Clone for bitcoin_primitives::sequence::Sequence
-impl core::clone::Clone for bitcoin_primitives::taproot::TapBranchTag
-impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafTag
-impl core::clone::Clone for bitcoin_primitives::taproot::TapNodeHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakTag
-impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
-impl core::clone::Clone for bitcoin_primitives::transaction::ParseOutPointError
-impl core::clone::Clone for bitcoin_primitives::transaction::Transaction
-impl core::clone::Clone for bitcoin_primitives::transaction::TxIn
-impl core::clone::Clone for bitcoin_primitives::transaction::TxOut
-impl core::clone::Clone for bitcoin_primitives::transaction::Txid
-impl core::clone::Clone for bitcoin_primitives::transaction::Version
-impl core::clone::Clone for bitcoin_primitives::transaction::Wtxid
-impl core::clone::Clone for bitcoin_primitives::witness::Witness
-impl core::cmp::Eq for bitcoin_primitives::block::BlockHash
-impl core::cmp::Eq for bitcoin_primitives::block::Checked
-impl core::cmp::Eq for bitcoin_primitives::block::Header
-impl core::cmp::Eq for bitcoin_primitives::block::Unchecked
-impl core::cmp::Eq for bitcoin_primitives::block::Version
-impl core::cmp::Eq for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::Eq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::Eq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::Eq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
-impl core::cmp::Eq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::Eq for bitcoin_primitives::opcodes::Opcode
-impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::Eq for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::cmp::Eq for bitcoin_primitives::script::Script
-impl core::cmp::Eq for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::Eq for bitcoin_primitives::script::ScriptHash
-impl core::cmp::Eq for bitcoin_primitives::script::WScriptHash
-impl core::cmp::Eq for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::cmp::Eq for bitcoin_primitives::sequence::Sequence
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::Eq for bitcoin_primitives::transaction::ParseOutPointError
-impl core::cmp::Eq for bitcoin_primitives::transaction::Transaction
-impl core::cmp::Eq for bitcoin_primitives::transaction::TxIn
-impl core::cmp::Eq for bitcoin_primitives::transaction::TxOut
-impl core::cmp::Eq for bitcoin_primitives::transaction::Txid
-impl core::cmp::Eq for bitcoin_primitives::transaction::Version
-impl core::cmp::Eq for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::Eq for bitcoin_primitives::witness::Witness
-impl core::cmp::Ord for bitcoin_primitives::block::BlockHash
-impl core::cmp::Ord for bitcoin_primitives::block::Checked
-impl core::cmp::Ord for bitcoin_primitives::block::Header
-impl core::cmp::Ord for bitcoin_primitives::block::Unchecked
-impl core::cmp::Ord for bitcoin_primitives::block::Version
-impl core::cmp::Ord for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::Ord for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::Ord for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::Ord for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::Ord for bitcoin_primitives::script::Script
-impl core::cmp::Ord for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::Ord for bitcoin_primitives::script::ScriptHash
-impl core::cmp::Ord for bitcoin_primitives::script::WScriptHash
-impl core::cmp::Ord for bitcoin_primitives::sequence::Sequence
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::Ord for bitcoin_primitives::transaction::Transaction
-impl core::cmp::Ord for bitcoin_primitives::transaction::TxIn
-impl core::cmp::Ord for bitcoin_primitives::transaction::TxOut
-impl core::cmp::Ord for bitcoin_primitives::transaction::Txid
-impl core::cmp::Ord for bitcoin_primitives::transaction::Version
-impl core::cmp::Ord for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::Ord for bitcoin_primitives::witness::Witness
-impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHash
-impl core::cmp::PartialEq for bitcoin_primitives::block::Checked
-impl core::cmp::PartialEq for bitcoin_primitives::block::Header
-impl core::cmp::PartialEq for bitcoin_primitives::block::Unchecked
-impl core::cmp::PartialEq for bitcoin_primitives::block::Version
-impl core::cmp::PartialEq for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Opcode
-impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::PartialEq for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::cmp::PartialEq for bitcoin_primitives::script::Script
-impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::PartialEq for bitcoin_primitives::script::ScriptHash
-impl core::cmp::PartialEq for bitcoin_primitives::script::WScriptHash
-impl core::cmp::PartialEq for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::cmp::PartialEq for bitcoin_primitives::sequence::Sequence
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::ParseOutPointError
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Transaction
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxIn
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::TxOut
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Txid
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::PartialEq for bitcoin_primitives::witness::Witness
-impl core::cmp::PartialEq<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::PartialEq<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::Script
-impl core::cmp::PartialOrd for bitcoin_primitives::block::BlockHash
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Checked
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Unchecked
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
-impl core::cmp::PartialOrd for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::PartialOrd for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::PartialOrd for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::PartialOrd for bitcoin_primitives::script::Script
-impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::PartialOrd for bitcoin_primitives::script::ScriptHash
-impl core::cmp::PartialOrd for bitcoin_primitives::script::WScriptHash
-impl core::cmp::PartialOrd for bitcoin_primitives::sequence::Sequence
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Transaction
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxIn
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::TxOut
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Txid
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::PartialOrd for bitcoin_primitives::witness::Witness
-impl core::cmp::PartialOrd<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::cmp::PartialOrd<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::Script
-impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::Script
-impl core::convert::AsMut<[u8]> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
-impl core::convert::AsMut<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::AsRef<[u8; 20]> for bitcoin_primitives::script::ScriptHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::BlockHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::script::WScriptHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Txid
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::BlockHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::Script
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::ScriptHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::script::WScriptHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Txid
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::AsRef<bitcoin_primitives::script::Script> for bitcoin_primitives::script::Script
-impl core::convert::AsRef<bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::From<&[&[u8]]> for bitcoin_primitives::witness::Witness
-impl core::convert::From<&[alloc::vec::Vec<u8>]> for bitcoin_primitives::witness::Witness
-impl core::convert::From<&bitcoin_primitives::block::Block> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Txid
-impl core::convert::From<&bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::From<alloc::vec::Vec<&[u8]>> for bitcoin_primitives::witness::Witness
-impl core::convert::From<alloc::vec::Vec<alloc::vec::Vec<u8>>> for bitcoin_primitives::witness::Witness
-impl core::convert::From<alloc::vec::Vec<u8>> for bitcoin_primitives::script::ScriptBuf
-impl core::convert::From<bitcoin_hashes::hash160::Hash> for bitcoin_primitives::script::ScriptHash
-impl core::convert::From<bitcoin_hashes::sha256::Hash> for bitcoin_primitives::script::WScriptHash
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Txid
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::From<bitcoin_primitives::block::Block> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_primitives::block::BlockHash> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_primitives::block::WitnessCommitment> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::locktime::relative::LockTime> for bitcoin_primitives::sequence::Sequence
-impl core::convert::From<bitcoin_primitives::merkle_tree::TxMerkleNode> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>
-impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::boxed::Box<bitcoin_primitives::script::Script>
-impl core::convert::From<bitcoin_primitives::script::ScriptBuf> for alloc::vec::Vec<u8>
-impl core::convert::From<bitcoin_primitives::script::ScriptHash> for bitcoin_hashes::hash160::Hash
-impl core::convert::From<bitcoin_primitives::script::WScriptHash> for bitcoin_hashes::sha256::Hash
-impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
-impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
-impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::From<bitcoin_primitives::taproot::TapNodeHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
-impl core::convert::From<bitcoin_primitives::taproot::TapTweakHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
-impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Txid
-impl core::convert::From<bitcoin_primitives::transaction::Transaction> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::From<bitcoin_primitives::transaction::Txid> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::transaction::Wtxid> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::From<bitcoin_units::locktime::absolute::Time> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_primitives::locktime::relative::LockTime
-impl core::convert::From<bitcoin_units::locktime::relative::Time> for bitcoin_primitives::locktime::relative::LockTime
-impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::convert::From<core::convert::Infallible> for bitcoin_primitives::transaction::ParseOutPointError
-impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
-impl core::convert::TryFrom<&bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptHash
-impl core::convert::TryFrom<&bitcoin_primitives::script::Script> for bitcoin_primitives::script::WScriptHash
-impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::ScriptHash
-impl core::convert::TryFrom<&bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::WScriptHash
-impl core::convert::TryFrom<&str> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::TryFrom<&str> for bitcoin_primitives::sequence::Sequence
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_primitives::sequence::Sequence
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_primitives::sequence::Sequence
-impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::ScriptHash
-impl core::convert::TryFrom<bitcoin_primitives::script::ScriptBuf> for bitcoin_primitives::script::WScriptHash
-impl core::convert::TryFrom<bitcoin_primitives::sequence::Sequence> for bitcoin_primitives::locktime::relative::LockTime
-impl core::default::Default for bitcoin_primitives::block::Version
-impl core::default::Default for bitcoin_primitives::pow::CompactTarget
-impl core::default::Default for bitcoin_primitives::script::ScriptBuf
-impl core::default::Default for bitcoin_primitives::sequence::Sequence
-impl core::default::Default for bitcoin_primitives::taproot::TapBranchTag
-impl core::default::Default for bitcoin_primitives::taproot::TapLeafTag
-impl core::default::Default for bitcoin_primitives::taproot::TapTweakTag
-impl core::default::Default for bitcoin_primitives::witness::Witness
-impl core::fmt::Debug for bitcoin_primitives::block::BlockHash
-impl core::fmt::Debug for bitcoin_primitives::block::Checked
-impl core::fmt::Debug for bitcoin_primitives::block::Header
-impl core::fmt::Debug for bitcoin_primitives::block::Unchecked
-impl core::fmt::Debug for bitcoin_primitives::block::Version
-impl core::fmt::Debug for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::Debug for bitcoin_primitives::locktime::absolute::LockTime
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::LockTime
-impl core::fmt::Debug for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::Debug for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
-impl core::fmt::Debug for bitcoin_primitives::opcodes::ClassifyContext
-impl core::fmt::Debug for bitcoin_primitives::opcodes::Opcode
-impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::Debug for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::fmt::Debug for bitcoin_primitives::script::Script
-impl core::fmt::Debug for bitcoin_primitives::script::ScriptBuf
-impl core::fmt::Debug for bitcoin_primitives::script::ScriptHash
-impl core::fmt::Debug for bitcoin_primitives::script::WScriptHash
-impl core::fmt::Debug for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::fmt::Debug for bitcoin_primitives::sequence::Sequence
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
-impl core::fmt::Debug for bitcoin_primitives::transaction::ParseOutPointError
-impl core::fmt::Debug for bitcoin_primitives::transaction::Transaction
-impl core::fmt::Debug for bitcoin_primitives::transaction::TxIn
-impl core::fmt::Debug for bitcoin_primitives::transaction::TxOut
-impl core::fmt::Debug for bitcoin_primitives::transaction::Txid
-impl core::fmt::Debug for bitcoin_primitives::transaction::Version
-impl core::fmt::Debug for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::Debug for bitcoin_primitives::witness::Witness
-impl core::fmt::Display for bitcoin_primitives::block::BlockHash
-impl core::fmt::Display for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::Display for bitcoin_primitives::locktime::absolute::LockTime
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::LockTime
-impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
-impl core::fmt::Display for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::fmt::Display for bitcoin_primitives::script::Script
-impl core::fmt::Display for bitcoin_primitives::script::ScriptBuf
-impl core::fmt::Display for bitcoin_primitives::script::ScriptHash
-impl core::fmt::Display for bitcoin_primitives::script::WScriptHash
-impl core::fmt::Display for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::fmt::Display for bitcoin_primitives::sequence::Sequence
-impl core::fmt::Display for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::Display for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::Display for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::Display for bitcoin_primitives::transaction::OutPoint
-impl core::fmt::Display for bitcoin_primitives::transaction::ParseOutPointError
-impl core::fmt::Display for bitcoin_primitives::transaction::Txid
-impl core::fmt::Display for bitcoin_primitives::transaction::Version
-impl core::fmt::Display for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::LowerHex for bitcoin_primitives::block::BlockHash
-impl core::fmt::LowerHex for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::LowerHex for bitcoin_primitives::script::Script
-impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptBuf
-impl core::fmt::LowerHex for bitcoin_primitives::script::ScriptHash
-impl core::fmt::LowerHex for bitcoin_primitives::script::WScriptHash
-impl core::fmt::LowerHex for bitcoin_primitives::sequence::Sequence
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::LowerHex for bitcoin_primitives::transaction::Txid
-impl core::fmt::LowerHex for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::UpperHex for bitcoin_primitives::block::BlockHash
-impl core::fmt::UpperHex for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::UpperHex for bitcoin_primitives::script::Script
-impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptBuf
-impl core::fmt::UpperHex for bitcoin_primitives::script::ScriptHash
-impl core::fmt::UpperHex for bitcoin_primitives::script::WScriptHash
-impl core::fmt::UpperHex for bitcoin_primitives::sequence::Sequence
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::UpperHex for bitcoin_primitives::transaction::Txid
-impl core::fmt::UpperHex for bitcoin_primitives::transaction::Wtxid
-impl core::hash::Hash for bitcoin_primitives::block::BlockHash
-impl core::hash::Hash for bitcoin_primitives::block::Checked
-impl core::hash::Hash for bitcoin_primitives::block::Header
-impl core::hash::Hash for bitcoin_primitives::block::Unchecked
-impl core::hash::Hash for bitcoin_primitives::block::Version
-impl core::hash::Hash for bitcoin_primitives::block::WitnessCommitment
-impl core::hash::Hash for bitcoin_primitives::locktime::absolute::LockTime
-impl core::hash::Hash for bitcoin_primitives::locktime::relative::LockTime
-impl core::hash::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::hash::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
-impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
-impl core::hash::Hash for bitcoin_primitives::script::Script
-impl core::hash::Hash for bitcoin_primitives::script::ScriptBuf
-impl core::hash::Hash for bitcoin_primitives::script::ScriptHash
-impl core::hash::Hash for bitcoin_primitives::script::WScriptHash
-impl core::hash::Hash for bitcoin_primitives::sequence::Sequence
-impl core::hash::Hash for bitcoin_primitives::taproot::TapBranchTag
-impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafTag
-impl core::hash::Hash for bitcoin_primitives::taproot::TapNodeHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakTag
-impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
-impl core::hash::Hash for bitcoin_primitives::transaction::Transaction
-impl core::hash::Hash for bitcoin_primitives::transaction::TxIn
-impl core::hash::Hash for bitcoin_primitives::transaction::TxOut
-impl core::hash::Hash for bitcoin_primitives::transaction::Txid
-impl core::hash::Hash for bitcoin_primitives::transaction::Version
-impl core::hash::Hash for bitcoin_primitives::transaction::Wtxid
-impl core::hash::Hash for bitcoin_primitives::witness::Witness
-impl core::iter::traits::exact_size::ExactSizeIterator for bitcoin_primitives::witness::Iter<'_>
-impl core::marker::Copy for bitcoin_primitives::block::BlockHash
-impl core::marker::Copy for bitcoin_primitives::block::Header
-impl core::marker::Copy for bitcoin_primitives::block::Version
-impl core::marker::Copy for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Copy for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Copy for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Copy for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Copy for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Copy for bitcoin_primitives::opcodes::Class
-impl core::marker::Copy for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Copy for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Copy for bitcoin_primitives::script::ScriptHash
-impl core::marker::Copy for bitcoin_primitives::script::WScriptHash
-impl core::marker::Copy for bitcoin_primitives::sequence::Sequence
-impl core::marker::Copy for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Copy for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Copy for bitcoin_primitives::transaction::Txid
-impl core::marker::Copy for bitcoin_primitives::transaction::Version
-impl core::marker::Copy for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Freeze for bitcoin_primitives::block::BlockHash
-impl core::marker::Freeze for bitcoin_primitives::block::Checked
-impl core::marker::Freeze for bitcoin_primitives::block::Header
-impl core::marker::Freeze for bitcoin_primitives::block::Unchecked
-impl core::marker::Freeze for bitcoin_primitives::block::Version
-impl core::marker::Freeze for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Freeze for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Freeze for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
-impl core::marker::Freeze for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Freeze for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Freeze for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::Freeze for bitcoin_primitives::script::Script
-impl core::marker::Freeze for bitcoin_primitives::script::ScriptBuf
-impl core::marker::Freeze for bitcoin_primitives::script::ScriptHash
-impl core::marker::Freeze for bitcoin_primitives::script::WScriptHash
-impl core::marker::Freeze for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::Freeze for bitcoin_primitives::sequence::Sequence
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Freeze for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::Freeze for bitcoin_primitives::transaction::Transaction
-impl core::marker::Freeze for bitcoin_primitives::transaction::TxIn
-impl core::marker::Freeze for bitcoin_primitives::transaction::TxOut
-impl core::marker::Freeze for bitcoin_primitives::transaction::Txid
-impl core::marker::Freeze for bitcoin_primitives::transaction::Version
-impl core::marker::Freeze for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Freeze for bitcoin_primitives::witness::Witness
-impl core::marker::Send for bitcoin_primitives::block::BlockHash
-impl core::marker::Send for bitcoin_primitives::block::Checked
-impl core::marker::Send for bitcoin_primitives::block::Header
-impl core::marker::Send for bitcoin_primitives::block::Unchecked
-impl core::marker::Send for bitcoin_primitives::block::Version
-impl core::marker::Send for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Send for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Send for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Send for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Send for bitcoin_primitives::opcodes::Class
-impl core::marker::Send for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Send for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Send for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::Send for bitcoin_primitives::script::Script
-impl core::marker::Send for bitcoin_primitives::script::ScriptBuf
-impl core::marker::Send for bitcoin_primitives::script::ScriptHash
-impl core::marker::Send for bitcoin_primitives::script::WScriptHash
-impl core::marker::Send for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::Send for bitcoin_primitives::sequence::Sequence
-impl core::marker::Send for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Send for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Send for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Send for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::Send for bitcoin_primitives::transaction::Transaction
-impl core::marker::Send for bitcoin_primitives::transaction::TxIn
-impl core::marker::Send for bitcoin_primitives::transaction::TxOut
-impl core::marker::Send for bitcoin_primitives::transaction::Txid
-impl core::marker::Send for bitcoin_primitives::transaction::Version
-impl core::marker::Send for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Send for bitcoin_primitives::witness::Witness
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Checked
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Unchecked
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Opcode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::Script
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptBuf
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::ScriptHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WScriptHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::sequence::Sequence
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Transaction
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxIn
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::TxOut
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Txid
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Wtxid
-impl core::marker::StructuralPartialEq for bitcoin_primitives::witness::Witness
-impl core::marker::Sync for bitcoin_primitives::block::BlockHash
-impl core::marker::Sync for bitcoin_primitives::block::Checked
-impl core::marker::Sync for bitcoin_primitives::block::Header
-impl core::marker::Sync for bitcoin_primitives::block::Unchecked
-impl core::marker::Sync for bitcoin_primitives::block::Version
-impl core::marker::Sync for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Sync for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Sync for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Sync for bitcoin_primitives::opcodes::Class
-impl core::marker::Sync for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Sync for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Sync for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::Sync for bitcoin_primitives::script::Script
-impl core::marker::Sync for bitcoin_primitives::script::ScriptBuf
-impl core::marker::Sync for bitcoin_primitives::script::ScriptHash
-impl core::marker::Sync for bitcoin_primitives::script::WScriptHash
-impl core::marker::Sync for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::Sync for bitcoin_primitives::sequence::Sequence
-impl core::marker::Sync for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Sync for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Sync for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::Sync for bitcoin_primitives::transaction::Transaction
-impl core::marker::Sync for bitcoin_primitives::transaction::TxIn
-impl core::marker::Sync for bitcoin_primitives::transaction::TxOut
-impl core::marker::Sync for bitcoin_primitives::transaction::Txid
-impl core::marker::Sync for bitcoin_primitives::transaction::Version
-impl core::marker::Sync for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Sync for bitcoin_primitives::witness::Witness
-impl core::marker::Unpin for bitcoin_primitives::block::BlockHash
-impl core::marker::Unpin for bitcoin_primitives::block::Checked
-impl core::marker::Unpin for bitcoin_primitives::block::Header
-impl core::marker::Unpin for bitcoin_primitives::block::Unchecked
-impl core::marker::Unpin for bitcoin_primitives::block::Version
-impl core::marker::Unpin for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Unpin for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Unpin for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
-impl core::marker::Unpin for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Unpin for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Unpin for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::marker::Unpin for bitcoin_primitives::script::Script
-impl core::marker::Unpin for bitcoin_primitives::script::ScriptBuf
-impl core::marker::Unpin for bitcoin_primitives::script::ScriptHash
-impl core::marker::Unpin for bitcoin_primitives::script::WScriptHash
-impl core::marker::Unpin for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::marker::Unpin for bitcoin_primitives::sequence::Sequence
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Unpin for bitcoin_primitives::transaction::ParseOutPointError
-impl core::marker::Unpin for bitcoin_primitives::transaction::Transaction
-impl core::marker::Unpin for bitcoin_primitives::transaction::TxIn
-impl core::marker::Unpin for bitcoin_primitives::transaction::TxOut
-impl core::marker::Unpin for bitcoin_primitives::transaction::Txid
-impl core::marker::Unpin for bitcoin_primitives::transaction::Version
-impl core::marker::Unpin for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Unpin for bitcoin_primitives::witness::Witness
-impl core::ops::deref::Deref for bitcoin_primitives::script::ScriptBuf
-impl core::ops::deref::DerefMut for bitcoin_primitives::script::ScriptBuf
-impl core::ops::index::Index<(core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::Range<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeFrom<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeFull> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeInclusive<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeTo<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<core::ops::range::RangeToInclusive<usize>> for bitcoin_primitives::script::Script
-impl core::ops::index::Index<usize> for bitcoin_primitives::witness::Witness
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Checked
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Unchecked
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::WitnessCommitment
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::LockTime
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Class
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Opcode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::Script
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptBuf
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::ScriptHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WScriptHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::sequence::Sequence
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapBranchTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapNodeHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Transaction
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxIn
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::TxOut
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Txid
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Wtxid
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Witness
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Checked
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Unchecked
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::WitnessCommitment
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::LockTime
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Opcode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::RedeemScriptSizeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::Script
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptBuf
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::ScriptHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WScriptHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::script::WitnessScriptSizeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::sequence::Sequence
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapBranchTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapNodeHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::ParseOutPointError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Transaction
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxIn
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::TxOut
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Txid
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Wtxid
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Witness
-impl core::str::traits::FromStr for bitcoin_primitives::block::BlockHash
-impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
-impl core::str::traits::FromStr for bitcoin_primitives::locktime::absolute::LockTime
-impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::str::traits::FromStr for bitcoin_primitives::script::ScriptHash
-impl core::str::traits::FromStr for bitcoin_primitives::script::WScriptHash
-impl core::str::traits::FromStr for bitcoin_primitives::sequence::Sequence
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapNodeHash
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapTweakHash
-impl core::str::traits::FromStr for bitcoin_primitives::transaction::OutPoint
-impl core::str::traits::FromStr for bitcoin_primitives::transaction::Txid
-impl core::str::traits::FromStr for bitcoin_primitives::transaction::Wtxid
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::boxed::Box<bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::rc::Rc<bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for alloc::sync::Arc<bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<&'a bitcoin_primitives::script::Script> for bitcoin_primitives::script::ScriptBuf
-impl<'a> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>> for alloc::boxed::Box<bitcoin_primitives::script::Script>
-impl<'a> core::convert::From<alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>> for bitcoin_primitives::script::ScriptBuf
-impl<'a> core::iter::traits::collect::IntoIterator for &'a bitcoin_primitives::witness::Witness
-impl<'a> core::iter::traits::iterator::Iterator for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::marker::Freeze for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::marker::Send for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::marker::Sync for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::marker::Unpin for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::witness::Iter<'a>
-impl<'a> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::witness::Iter<'a>
-impl<V: bitcoin_primitives::block::Validation> bitcoin_primitives::block::Block<V>
-impl<V> core::clone::Clone for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::clone::Clone
-impl<V> core::cmp::Eq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::Eq
-impl<V> core::cmp::PartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::cmp::PartialEq
-impl<V> core::fmt::Debug for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation + core::fmt::Debug
-impl<V> core::marker::Freeze for bitcoin_primitives::block::Block<V>
-impl<V> core::marker::Send for bitcoin_primitives::block::Block<V>
-impl<V> core::marker::StructuralPartialEq for bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
-impl<V> core::marker::Sync for bitcoin_primitives::block::Block<V>
-impl<V> core::marker::Unpin for bitcoin_primitives::block::Block<V>
-impl<V> core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::RefUnwindSafe
-impl<V> core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Block<V> where V: core::panic::unwind_safe::UnwindSafe
-pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
-pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
-pub bitcoin_primitives::BlockHeader::nonce: u32
-pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::block::BlockHash
-pub bitcoin_primitives::BlockHeader::time: u32
-pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
-pub bitcoin_primitives::Transaction::input: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
-pub bitcoin_primitives::Transaction::lock_time: bitcoin_primitives::locktime::absolute::LockTime
-pub bitcoin_primitives::Transaction::output: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
-pub bitcoin_primitives::Transaction::version: bitcoin_primitives::transaction::Version
-pub bitcoin_primitives::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
-pub bitcoin_primitives::TxIn::script_sig: bitcoin_primitives::script::ScriptBuf
-pub bitcoin_primitives::TxIn::sequence: bitcoin_primitives::sequence::Sequence
-pub bitcoin_primitives::TxIn::witness: bitcoin_primitives::witness::Witness
-pub bitcoin_primitives::TxOut::script_pubkey: bitcoin_primitives::script::ScriptBuf
-pub bitcoin_primitives::TxOut::value: bitcoin_units::amount::unsigned::Amount
-pub bitcoin_primitives::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
-pub bitcoin_primitives::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
-pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
-pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
-pub bitcoin_primitives::block::Header::nonce: u32
-pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::block::BlockHash
-pub bitcoin_primitives::block::Header::time: u32
-pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
-pub bitcoin_primitives::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
-pub bitcoin_primitives::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
-pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
-pub bitcoin_primitives::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
-pub bitcoin_primitives::opcodes::Class::IllegalOp
-pub bitcoin_primitives::opcodes::Class::NoOp
-pub bitcoin_primitives::opcodes::Class::Ordinary(Ordinary)
-pub bitcoin_primitives::opcodes::Class::PushBytes(u32)
-pub bitcoin_primitives::opcodes::Class::PushNum(i32)
-pub bitcoin_primitives::opcodes::Class::ReturnOp
-pub bitcoin_primitives::opcodes::Class::SuccessOp
-pub bitcoin_primitives::opcodes::ClassifyContext::Legacy
-pub bitcoin_primitives::opcodes::ClassifyContext::TapScript
-pub bitcoin_primitives::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
-pub bitcoin_primitives::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
-pub bitcoin_primitives::script::RedeemScriptSizeError::size: usize
-pub bitcoin_primitives::script::WitnessScriptSizeError::size: usize
-pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
-pub bitcoin_primitives::transaction::OutPoint::vout: u32
-pub bitcoin_primitives::transaction::ParseOutPointError::Format
-pub bitcoin_primitives::transaction::ParseOutPointError::TooLong
-pub bitcoin_primitives::transaction::ParseOutPointError::Txid(hex_conservative::error::HexToArrayError)
-pub bitcoin_primitives::transaction::ParseOutPointError::Vout(bitcoin_units::parse::ParseIntError)
-pub bitcoin_primitives::transaction::ParseOutPointError::VoutNotCanonical
-pub bitcoin_primitives::transaction::Transaction::input: alloc::vec::Vec<bitcoin_primitives::transaction::TxIn>
-pub bitcoin_primitives::transaction::Transaction::lock_time: bitcoin_primitives::locktime::absolute::LockTime
-pub bitcoin_primitives::transaction::Transaction::output: alloc::vec::Vec<bitcoin_primitives::transaction::TxOut>
-pub bitcoin_primitives::transaction::Transaction::version: bitcoin_primitives::transaction::Version
-pub bitcoin_primitives::transaction::TxIn::previous_output: bitcoin_primitives::transaction::OutPoint
-pub bitcoin_primitives::transaction::TxIn::script_sig: bitcoin_primitives::script::ScriptBuf
-pub bitcoin_primitives::transaction::TxIn::sequence: bitcoin_primitives::sequence::Sequence
-pub bitcoin_primitives::transaction::TxIn::witness: bitcoin_primitives::witness::Witness
-pub bitcoin_primitives::transaction::TxOut::script_pubkey: bitcoin_primitives::script::ScriptBuf
-pub bitcoin_primitives::transaction::TxOut::value: bitcoin_units::amount::unsigned::Amount
-pub const bitcoin_primitives::BlockValidation::IS_CHECKED: bool
-pub const bitcoin_primitives::block::BlockHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::block::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
-pub const bitcoin_primitives::block::Checked::IS_CHECKED: bool
-pub const bitcoin_primitives::block::Header::SIZE: usize
-pub const bitcoin_primitives::block::Unchecked::IS_CHECKED: bool
-pub const bitcoin_primitives::block::Validation::IS_CHECKED: bool
-pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
-pub const bitcoin_primitives::block::Version::ONE: Self
-pub const bitcoin_primitives::block::Version::TWO: Self
-pub const bitcoin_primitives::block::WitnessCommitment::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::locktime::absolute::LockTime::SIZE: usize
-pub const bitcoin_primitives::locktime::absolute::LockTime::ZERO: bitcoin_primitives::locktime::absolute::LockTime
-pub const bitcoin_primitives::locktime::relative::LockTime::SIZE: usize
-pub const bitcoin_primitives::locktime::relative::LockTime::ZERO: bitcoin_primitives::locktime::relative::LockTime
-pub const bitcoin_primitives::merkle_tree::TxMerkleNode::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::merkle_tree::WitnessMerkleNode::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::opcodes::all::OP_0NOTEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_1ADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_1SUB: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DIV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DROP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2MUL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2OVER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2ROT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2SWAP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_3DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ABS: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_AND: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_BOOLAND: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_BOOLOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CAT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIG: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIGVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIG: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CLTV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CODESEPARATOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CSV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DEPTH: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DIV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DROP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ELSE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ENDIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_EQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_EQUALVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_FROMALTSTACK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_GREATERTHAN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_GREATERTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_HASH160: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_HASH256: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_IF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_IFDUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_INVALIDOPCODE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_INVERT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LEFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LESSTHAN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LESSTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LSHIFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MAX: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MIN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MOD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MUL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NEGATE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NIP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOTIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMEQUALVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMNOTEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_OR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_OVER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PICK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_0: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_11: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_12: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_13: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_14: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_15: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_16: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_17: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_18: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_19: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_20: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_21: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_22: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_23: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_24: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_25: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_26: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_27: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_28: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_29: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_30: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_31: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_32: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_33: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_34: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_35: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_36: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_37: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_38: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_39: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_3: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_40: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_41: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_42: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_43: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_44: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_45: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_46: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_47: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_48: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_49: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_50: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_51: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_52: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_53: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_54: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_55: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_56: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_57: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_58: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_59: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_60: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_61: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_62: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_63: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_64: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_65: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_66: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_67: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_68: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_69: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_70: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_71: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_72: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_73: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_74: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_75: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_11: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_12: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_13: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_14: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_15: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_16: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_3: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_NEG1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_187: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_188: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_189: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_190: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_191: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_192: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_193: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_194: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_195: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_196: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_197: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_198: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_199: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_200: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_201: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_202: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_203: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_204: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_205: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_206: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_207: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_208: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_209: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_210: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_211: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_212: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_213: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_214: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_215: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_216: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_217: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_218: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_219: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_220: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_221: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_222: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_223: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_224: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_225: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_226: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_227: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_228: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_229: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_230: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_231: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_232: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_233: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_234: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_235: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_236: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_237: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_238: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_239: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_240: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_241: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_242: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_243: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_244: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_245: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_246: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_247: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_248: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_249: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_250: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_251: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_252: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_253: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_254: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RIGHT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RIPEMD160: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ROLL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ROT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RSHIFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SHA1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SHA256: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SIZE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SUB: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SUBSTR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SWAP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_TOALTSTACK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_TUCK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERNOTIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_WITHIN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_XOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::script::MAX_REDEEM_SCRIPT_SIZE: usize
-pub const bitcoin_primitives::script::MAX_WITNESS_SCRIPT_SIZE: usize
-pub const bitcoin_primitives::script::ScriptHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::script::WScriptHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
-pub const bitcoin_primitives::sequence::Sequence::FINAL: Self
-pub const bitcoin_primitives::sequence::Sequence::MAX: Self
-pub const bitcoin_primitives::sequence::Sequence::SIZE: usize
-pub const bitcoin_primitives::sequence::Sequence::ZERO: Self
-pub const bitcoin_primitives::taproot::TapLeafHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::taproot::TapNodeHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::taproot::TapTweakHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
-pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
-pub const bitcoin_primitives::transaction::Transaction::MAX_STANDARD_WEIGHT: bitcoin_units::weight::Weight
-pub const bitcoin_primitives::transaction::TxIn::EMPTY_COINBASE: bitcoin_primitives::transaction::TxIn
-pub const bitcoin_primitives::transaction::Txid::COINBASE_PREVOUT: Self
-pub const bitcoin_primitives::transaction::Txid::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::transaction::Version::ONE: Self
-pub const bitcoin_primitives::transaction::Version::THREE: Self
-pub const bitcoin_primitives::transaction::Version::TWO: Self
-pub const bitcoin_primitives::transaction::Wtxid::COINBASE: Self
-pub const bitcoin_primitives::transaction::Wtxid::DISPLAY_BACKWARD: bool
-pub const fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
-pub const fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_height(&self) -> bool
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_time(&self) -> bool
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_height(n: u16) -> Self
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_height(&self) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_time(&self) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::opcodes::Opcode::decode_pushnum(self) -> core::option::Option<u8>
-pub const fn bitcoin_primitives::opcodes::Opcode::to_u8(self) -> u8
-pub const fn bitcoin_primitives::script::ScriptBuf::new() -> Self
-pub const fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &<bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::witness::Witness::new() -> Self
-pub enum bitcoin_primitives::BlockChecked
-pub enum bitcoin_primitives::BlockUnchecked
-pub enum bitcoin_primitives::absolute::LockTime
-pub enum bitcoin_primitives::block::Checked
-pub enum bitcoin_primitives::block::Unchecked
-pub enum bitcoin_primitives::locktime::absolute::LockTime
-pub enum bitcoin_primitives::locktime::relative::LockTime
-pub enum bitcoin_primitives::opcodes::Class
-pub enum bitcoin_primitives::opcodes::ClassifyContext
-pub enum bitcoin_primitives::relative::LockTime
-pub fn &'a bitcoin_primitives::witness::Witness::into_iter(self) -> Self::IntoIter
-pub fn alloc::borrow::Cow<'_, bitcoin_primitives::script::Script>::from(value: bitcoin_primitives::script::ScriptBuf) -> Self
-pub fn alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
-pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn alloc::boxed::Box<bitcoin_primitives::script::Script>::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>) -> Self
-pub fn alloc::rc::Rc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn alloc::sync::Arc<bitcoin_primitives::script::Script>::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn alloc::vec::Vec<u8>::from(v: bitcoin_primitives::script::ScriptBuf) -> Self
-pub fn bitcoin_hashes::hash160::Hash::from(hashtype: bitcoin_primitives::script::ScriptHash) -> bitcoin_hashes::hash160::Hash
-pub fn bitcoin_hashes::sha256::Hash::from(hashtype: bitcoin_primitives::script::WScriptHash) -> bitcoin_hashes::sha256::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Txid) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Wtxid) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>::from(hashtype: bitcoin_primitives::taproot::TapNodeHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>::from(hashtype: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>::from(hashtype: bitcoin_primitives::taproot::TapTweakHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
-pub fn bitcoin_primitives::block::Block<V>::block_hash(&self) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::Block<V>::clone(&self) -> bitcoin_primitives::block::Block<V>
-pub fn bitcoin_primitives::block::Block<V>::eq(&self, other: &bitcoin_primitives::block::Block<V>) -> bool
-pub fn bitcoin_primitives::block::Block<V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::cached_witness_root(&self) -> core::option::Option<bitcoin_primitives::merkle_tree::WitnessMerkleNode>
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::header(&self) -> &bitcoin_primitives::block::Header
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>::transactions(&self) -> &[bitcoin_primitives::transaction::Transaction]
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::assume_checked(self, witness_root: core::option::Option<bitcoin_primitives::merkle_tree::WitnessMerkleNode>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Checked>
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::into_parts(self) -> (bitcoin_primitives::block::Header, alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>)
-pub fn bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>::new_unchecked(header: bitcoin_primitives::block::Header, transactions: alloc::vec::Vec<bitcoin_primitives::transaction::Transaction>) -> bitcoin_primitives::block::Block<bitcoin_primitives::block::Unchecked>
-pub fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::block::BlockHash::clone(&self) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::BlockHash::eq(&self, other: &bitcoin_primitives::block::BlockHash) -> bool
-pub fn bitcoin_primitives::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::BlockHash::from(block: &bitcoin_primitives::block::Block) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(block: bitcoin_primitives::block::Block) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(header: &bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(header: bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::BlockHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::block::BlockHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::block::Checked::clone(&self) -> bitcoin_primitives::block::Checked
-pub fn bitcoin_primitives::block::Checked::cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Checked::eq(&self, other: &bitcoin_primitives::block::Checked) -> bool
-pub fn bitcoin_primitives::block::Checked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Checked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Checked::partial_cmp(&self, other: &bitcoin_primitives::block::Checked) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
-pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
-pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Unchecked::clone(&self) -> bitcoin_primitives::block::Unchecked
-pub fn bitcoin_primitives::block::Unchecked::cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Unchecked::eq(&self, other: &bitcoin_primitives::block::Unchecked) -> bool
-pub fn bitcoin_primitives::block::Unchecked::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Unchecked::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Unchecked::partial_cmp(&self, other: &bitcoin_primitives::block::Unchecked) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
-pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Version::default() -> bitcoin_primitives::block::Version
-pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
-pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(&self, bit: u8) -> bool
-pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
-pub fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::block::WitnessCommitment::clone(&self) -> bitcoin_primitives::block::WitnessCommitment
-pub fn bitcoin_primitives::block::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::WitnessCommitment::eq(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> bool
-pub fn bitcoin_primitives::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::WitnessCommitment
-pub fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::WitnessCommitment, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::block::WitnessCommitment::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::locktime::absolute::LockTime::clone(&self) -> bitcoin_primitives::locktime::absolute::LockTime
-pub fn bitcoin_primitives::locktime::absolute::LockTime::eq(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::Time) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_time(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::locktime::absolute::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::is_satisfied_by(&self, height: bitcoin_units::locktime::absolute::Height, time: bitcoin_units::locktime::absolute::Time) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::DisabledLockTimeError
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::DisabledLockTimeError) -> bool
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleHeightError
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleHeightError) -> bool
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleTimeError
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleTimeError) -> bool
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::LockTime::clone(&self) -> bitcoin_primitives::locktime::relative::LockTime
-pub fn bitcoin_primitives::locktime::relative::LockTime::eq(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::Height) -> Self
-pub fn bitcoin_primitives::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::Time) -> Self
-pub fn bitcoin_primitives::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::from_sequence(n: bitcoin_primitives::sequence::Sequence) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by_sequence(&self, other: bitcoin_primitives::sequence::Sequence) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self, h: bitcoin_units::locktime::relative::Height, t: bitcoin_units::locktime::relative::Time) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::TxMerkleNode
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::cmp::Ordering
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> bool
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::TxMerkleNode
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::TxMerkleNode, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::cmp::Ordering
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bool
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::WitnessMerkleNode, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::opcodes::Class::clone(&self) -> bitcoin_primitives::opcodes::Class
-pub fn bitcoin_primitives::opcodes::Class::eq(&self, other: &bitcoin_primitives::opcodes::Class) -> bool
-pub fn bitcoin_primitives::opcodes::Class::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::ClassifyContext::clone(&self) -> bitcoin_primitives::opcodes::ClassifyContext
-pub fn bitcoin_primitives::opcodes::ClassifyContext::cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::cmp::Ordering
-pub fn bitcoin_primitives::opcodes::ClassifyContext::eq(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> bool
-pub fn bitcoin_primitives::opcodes::ClassifyContext::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::ClassifyContext::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::opcodes::ClassifyContext::partial_cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::opcodes::Opcode::classify(self, ctx: bitcoin_primitives::opcodes::ClassifyContext) -> bitcoin_primitives::opcodes::Class
-pub fn bitcoin_primitives::opcodes::Opcode::clone(&self) -> bitcoin_primitives::opcodes::Opcode
-pub fn bitcoin_primitives::opcodes::Opcode::eq(&self, other: &bitcoin_primitives::opcodes::Opcode) -> bool
-pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
-pub fn bitcoin_primitives::opcodes::Opcode::from(b: u8) -> bitcoin_primitives::opcodes::Opcode
-pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
-pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
-pub fn bitcoin_primitives::pow::CompactTarget::default() -> bitcoin_primitives::pow::CompactTarget
-pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
-pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
-pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
-pub fn bitcoin_primitives::pow::CompactTarget::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::script::RedeemScriptSizeError::clone(&self) -> bitcoin_primitives::script::RedeemScriptSizeError
-pub fn bitcoin_primitives::script::RedeemScriptSizeError::eq(&self, other: &bitcoin_primitives::script::RedeemScriptSizeError) -> bool
-pub fn bitcoin_primitives::script::RedeemScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::RedeemScriptSizeError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_primitives::script::Script::as_bytes(&self) -> &[u8]
-pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut [u8]
-pub fn bitcoin_primitives::script::Script::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::as_mut_bytes(&mut self) -> &mut [u8]
-pub fn bitcoin_primitives::script::Script::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::script::Script::as_ref(&self) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::cmp(&self, other: &bitcoin_primitives::script::Script) -> core::cmp::Ordering
-pub fn bitcoin_primitives::script::Script::eq(&self, other: &bitcoin_primitives::script::Script) -> bool
-pub fn bitcoin_primitives::script::Script::eq(&self, other: &bitcoin_primitives::script::ScriptBuf) -> bool
-pub fn bitcoin_primitives::script::Script::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::Script::from_bytes(bytes: &[u8]) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::from_bytes_mut(bytes: &mut [u8]) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::script::Script::index(&self, index: (core::ops::range::Bound<usize>, core::ops::range::Bound<usize>)) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::Range<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeFrom<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeFull) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeInclusive<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeTo<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::index(&self, index: core::ops::range::RangeToInclusive<usize>) -> &Self::Output
-pub fn bitcoin_primitives::script::Script::into_script_buf(self: alloc::boxed::Box<Self>) -> bitcoin_primitives::script::ScriptBuf
-pub fn bitcoin_primitives::script::Script::is_empty(&self) -> bool
-pub fn bitcoin_primitives::script::Script::len(&self) -> usize
-pub fn bitcoin_primitives::script::Script::new() -> &'static bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::Script::partial_cmp(&self, other: &bitcoin_primitives::script::Script) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::Script::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::Script::to_bytes(&self) -> alloc::vec::Vec<u8>
-pub fn bitcoin_primitives::script::Script::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::script::Script::to_owned(&self) -> Self::Owned
-pub fn bitcoin_primitives::script::Script::to_vec(&self) -> alloc::vec::Vec<u8>
-pub fn bitcoin_primitives::script::ScriptBuf::as_mut(&mut self) -> &mut [u8]
-pub fn bitcoin_primitives::script::ScriptBuf::as_mut(&mut self) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::as_mut_script(&mut self) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::script::ScriptBuf::as_ref(&self) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::as_script(&self) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::borrow(&self) -> &bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::borrow_mut(&mut self) -> &mut bitcoin_primitives::script::Script
-pub fn bitcoin_primitives::script::ScriptBuf::clone(&self) -> bitcoin_primitives::script::ScriptBuf
-pub fn bitcoin_primitives::script::ScriptBuf::cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::cmp::Ordering
-pub fn bitcoin_primitives::script::ScriptBuf::default() -> bitcoin_primitives::script::ScriptBuf
-pub fn bitcoin_primitives::script::ScriptBuf::deref(&self) -> &Self::Target
-pub fn bitcoin_primitives::script::ScriptBuf::deref_mut(&mut self) -> &mut Self::Target
-pub fn bitcoin_primitives::script::ScriptBuf::eq(&self, other: &bitcoin_primitives::script::Script) -> bool
-pub fn bitcoin_primitives::script::ScriptBuf::eq(&self, other: &bitcoin_primitives::script::ScriptBuf) -> bool
-pub fn bitcoin_primitives::script::ScriptBuf::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::ScriptBuf::from(v: alloc::vec::Vec<u8>) -> Self
-pub fn bitcoin_primitives::script::ScriptBuf::from(value: &'a bitcoin_primitives::script::Script) -> Self
-pub fn bitcoin_primitives::script::ScriptBuf::from(value: alloc::borrow::Cow<'a, bitcoin_primitives::script::Script>) -> Self
-pub fn bitcoin_primitives::script::ScriptBuf::from_bytes(bytes: alloc::vec::Vec<u8>) -> Self
-pub fn bitcoin_primitives::script::ScriptBuf::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::script::ScriptBuf::into_boxed_script(self) -> alloc::boxed::Box<bitcoin_primitives::script::Script>
-pub fn bitcoin_primitives::script::ScriptBuf::into_bytes(self) -> alloc::vec::Vec<u8>
-pub fn bitcoin_primitives::script::ScriptBuf::partial_cmp(&self, other: &bitcoin_primitives::script::Script) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::ScriptBuf::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptBuf) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::ScriptBuf::reserve(&mut self, additional_len: usize)
-pub fn bitcoin_primitives::script::ScriptBuf::reserve_exact(&mut self, additional_len: usize)
-pub fn bitcoin_primitives::script::ScriptBuf::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::script::ScriptBuf::with_capacity(capacity: usize) -> Self
-pub fn bitcoin_primitives::script::ScriptHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8; 20]
-pub fn bitcoin_primitives::script::ScriptHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8; 20]
-pub fn bitcoin_primitives::script::ScriptHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::script::ScriptHash::clone(&self) -> bitcoin_primitives::script::ScriptHash
-pub fn bitcoin_primitives::script::ScriptHash::cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::script::ScriptHash::eq(&self, other: &bitcoin_primitives::script::ScriptHash) -> bool
-pub fn bitcoin_primitives::script::ScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::ScriptHash::from(inner: bitcoin_hashes::hash160::Hash) -> bitcoin_primitives::script::ScriptHash
-pub fn bitcoin_primitives::script::ScriptHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::script::ScriptHash::from_script(redeem_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, bitcoin_primitives::script::RedeemScriptSizeError>
-pub fn bitcoin_primitives::script::ScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::Script) -> Self
-pub fn bitcoin_primitives::script::ScriptHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::script::ScriptHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::script::ScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::script::ScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::script::ScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::ScriptHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::ScriptHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: &bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::ScriptHash::try_from(redeem_script: bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::WScriptHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::script::WScriptHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::script::WScriptHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::script::WScriptHash::clone(&self) -> bitcoin_primitives::script::WScriptHash
-pub fn bitcoin_primitives::script::WScriptHash::cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::script::WScriptHash::eq(&self, other: &bitcoin_primitives::script::WScriptHash) -> bool
-pub fn bitcoin_primitives::script::WScriptHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::WScriptHash::from(inner: bitcoin_hashes::sha256::Hash) -> bitcoin_primitives::script::WScriptHash
-pub fn bitcoin_primitives::script::WScriptHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::script::WScriptHash::from_script(witness_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, bitcoin_primitives::script::WitnessScriptSizeError>
-pub fn bitcoin_primitives::script::WScriptHash::from_script_unchecked(script: &bitcoin_primitives::script::Script) -> Self
-pub fn bitcoin_primitives::script::WScriptHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::script::WScriptHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::script::WScriptHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::script::WScriptHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::script::WScriptHash::partial_cmp(&self, other: &bitcoin_primitives::script::WScriptHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::script::WScriptHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::Script) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: &bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::WScriptHash::try_from(witness_script: bitcoin_primitives::script::ScriptBuf) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::script::WitnessScriptSizeError::clone(&self) -> bitcoin_primitives::script::WitnessScriptSizeError
-pub fn bitcoin_primitives::script::WitnessScriptSizeError::eq(&self, other: &bitcoin_primitives::script::WitnessScriptSizeError) -> bool
-pub fn bitcoin_primitives::script::WitnessScriptSizeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::script::WitnessScriptSizeError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::clone(&self) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::sequence::Sequence::cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::cmp::Ordering
-pub fn bitcoin_primitives::sequence::Sequence::default() -> Self
-pub fn bitcoin_primitives::sequence::Sequence::enables_absolute_lock_time(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::eq(&self, other: &bitcoin_primitives::sequence::Sequence) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::sequence::Sequence::from(lt: bitcoin_primitives::locktime::relative::LockTime) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_consensus(n: u32) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_height(height: u16) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_primitives::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub fn bitcoin_primitives::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub fn bitcoin_primitives::sequence::Sequence::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_primitives::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::sequence::Sequence::is_final(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_height_locked(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_rbf(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::sequence::Sequence::to_hex(&self) -> alloc::string::String
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
-pub fn bitcoin_primitives::sequence::Sequence::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::sequence::Sequence::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
-pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
-pub fn bitcoin_primitives::taproot::TapBranchTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapBranchTag::eq(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> bool
-pub fn bitcoin_primitives::taproot::TapBranchTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapBranchTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapLeafHash::clone(&self) -> bitcoin_primitives::taproot::TapLeafHash
-pub fn bitcoin_primitives::taproot::TapLeafHash::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapLeafHash::eq(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> bool
-pub fn bitcoin_primitives::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>) -> bitcoin_primitives::taproot::TapLeafHash
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapLeafHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapLeafTag::clone(&self) -> bitcoin_primitives::taproot::TapLeafTag
-pub fn bitcoin_primitives::taproot::TapLeafTag::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapLeafTag::default() -> bitcoin_primitives::taproot::TapLeafTag
-pub fn bitcoin_primitives::taproot::TapLeafTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapLeafTag::eq(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> bool
-pub fn bitcoin_primitives::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapNodeHash::clone(&self) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapNodeHash::eq(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> bool
-pub fn bitcoin_primitives::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::from(leaf: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapNodeHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapTweakHash::clone(&self) -> bitcoin_primitives::taproot::TapTweakHash
-pub fn bitcoin_primitives::taproot::TapTweakHash::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapTweakHash::eq(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> bool
-pub fn bitcoin_primitives::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>) -> bitcoin_primitives::taproot::TapTweakHash
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapTweakHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakTag::clone(&self) -> bitcoin_primitives::taproot::TapTweakTag
-pub fn bitcoin_primitives::taproot::TapTweakTag::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapTweakTag::default() -> bitcoin_primitives::taproot::TapTweakTag
-pub fn bitcoin_primitives::taproot::TapTweakTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapTweakTag::eq(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> bool
-pub fn bitcoin_primitives::taproot::TapTweakTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapTweakTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
-pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
-pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::OutPoint::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::ParseOutPointError::clone(&self) -> bitcoin_primitives::transaction::ParseOutPointError
-pub fn bitcoin_primitives::transaction::ParseOutPointError::eq(&self, other: &bitcoin_primitives::transaction::ParseOutPointError) -> bool
-pub fn bitcoin_primitives::transaction::ParseOutPointError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::ParseOutPointError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_primitives::transaction::Transaction::clone(&self) -> bitcoin_primitives::transaction::Transaction
-pub fn bitcoin_primitives::transaction::Transaction::cmp(&self, other: &Self) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Transaction::compute_ntxid(&self) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_primitives::transaction::Transaction::compute_txid(&self) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Transaction::compute_wtxid(&self) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Transaction::eq(&self, other: &bitcoin_primitives::transaction::Transaction) -> bool
-pub fn bitcoin_primitives::transaction::Transaction::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Transaction::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Transaction::inputs(&self) -> &[bitcoin_primitives::transaction::TxIn]
-pub fn bitcoin_primitives::transaction::Transaction::inputs_mut(&mut self) -> &mut [bitcoin_primitives::transaction::TxIn]
-pub fn bitcoin_primitives::transaction::Transaction::outputs(&self) -> &[bitcoin_primitives::transaction::TxOut]
-pub fn bitcoin_primitives::transaction::Transaction::outputs_mut(&mut self) -> &mut [bitcoin_primitives::transaction::TxOut]
-pub fn bitcoin_primitives::transaction::Transaction::partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::TxIn::clone(&self) -> bitcoin_primitives::transaction::TxIn
-pub fn bitcoin_primitives::transaction::TxIn::cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::TxIn::eq(&self, other: &bitcoin_primitives::transaction::TxIn) -> bool
-pub fn bitcoin_primitives::transaction::TxIn::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::TxIn::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::TxIn::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxIn) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::TxOut::clone(&self) -> bitcoin_primitives::transaction::TxOut
-pub fn bitcoin_primitives::transaction::TxOut::cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::TxOut::eq(&self, other: &bitcoin_primitives::transaction::TxOut) -> bool
-pub fn bitcoin_primitives::transaction::TxOut::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::TxOut::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::TxOut::partial_cmp(&self, other: &bitcoin_primitives::transaction::TxOut) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Txid::clone(&self) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Txid::eq(&self, other: &bitcoin_primitives::transaction::Txid) -> bool
-pub fn bitcoin_primitives::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::from(tx: &bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::from(tx: bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Txid, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::transaction::Txid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Txid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
-pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
-pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Wtxid::clone(&self) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Wtxid::eq(&self, other: &bitcoin_primitives::transaction::Wtxid) -> bool
-pub fn bitcoin_primitives::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::from(tx: &bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::from(tx: bitcoin_primitives::transaction::Transaction) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Wtxid, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::transaction::Wtxid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::witness::Iter<'a>::next(&mut self) -> core::option::Option<Self::Item>
-pub fn bitcoin_primitives::witness::Iter<'a>::size_hint(&self) -> (usize, core::option::Option<usize>)
-pub fn bitcoin_primitives::witness::Witness::clear(&mut self)
-pub fn bitcoin_primitives::witness::Witness::clone(&self) -> bitcoin_primitives::witness::Witness
-pub fn bitcoin_primitives::witness::Witness::cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::cmp::Ordering
-pub fn bitcoin_primitives::witness::Witness::default() -> Self
-pub fn bitcoin_primitives::witness::Witness::eq(&self, other: &bitcoin_primitives::witness::Witness) -> bool
-pub fn bitcoin_primitives::witness::Witness::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
-pub fn bitcoin_primitives::witness::Witness::from(slice: &[&[u8]]) -> Self
-pub fn bitcoin_primitives::witness::Witness::from(slice: &[alloc::vec::Vec<u8>]) -> Self
-pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<&[u8]>) -> Self
-pub fn bitcoin_primitives::witness::Witness::from(vec: alloc::vec::Vec<alloc::vec::Vec<u8>>) -> Self
-pub fn bitcoin_primitives::witness::Witness::from_slice<T: core::convert::AsRef<[u8]>>(slice: &[T]) -> Self
-pub fn bitcoin_primitives::witness::Witness::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::witness::Witness::index(&self, index: usize) -> &Self::Output
-pub fn bitcoin_primitives::witness::Witness::is_empty(&self) -> bool
-pub fn bitcoin_primitives::witness::Witness::iter(&self) -> bitcoin_primitives::witness::Iter<'_>
-pub fn bitcoin_primitives::witness::Witness::last(&self) -> core::option::Option<&[u8]>
-pub fn bitcoin_primitives::witness::Witness::len(&self) -> usize
-pub fn bitcoin_primitives::witness::Witness::nth(&self, index: usize) -> core::option::Option<&[u8]>
-pub fn bitcoin_primitives::witness::Witness::partial_cmp(&self, other: &bitcoin_primitives::witness::Witness) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::witness::Witness::push<T: core::convert::AsRef<[u8]>>(&mut self, new_element: T)
-pub fn bitcoin_primitives::witness::Witness::second_to_last(&self) -> core::option::Option<&[u8]>
-pub fn bitcoin_primitives::witness::Witness::size(&self) -> usize
-pub fn bitcoin_primitives::witness::Witness::third_to_last(&self) -> core::option::Option<&[u8]>
-pub fn bitcoin_primitives::witness::Witness::to_vec(&self) -> alloc::vec::Vec<alloc::vec::Vec<u8>>
-pub fn u32::from(sequence: bitcoin_primitives::sequence::Sequence) -> u32
-pub mod bitcoin_primitives
-pub mod bitcoin_primitives::absolute
-pub mod bitcoin_primitives::block
-pub mod bitcoin_primitives::locktime
-pub mod bitcoin_primitives::locktime::absolute
-pub mod bitcoin_primitives::locktime::relative
-pub mod bitcoin_primitives::merkle_tree
-pub mod bitcoin_primitives::opcodes
-pub mod bitcoin_primitives::opcodes::all
-pub mod bitcoin_primitives::pow
-pub mod bitcoin_primitives::relative
-pub mod bitcoin_primitives::script
-pub mod bitcoin_primitives::sequence
-pub mod bitcoin_primitives::taproot
-pub mod bitcoin_primitives::transaction
-pub mod bitcoin_primitives::witness
-pub static bitcoin_primitives::opcodes::OP_0: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_FALSE: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_NOP2: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_NOP3: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_TRUE: bitcoin_primitives::opcodes::Opcode
-pub struct bitcoin_primitives::Block<V> where V: bitcoin_primitives::block::Validation
-pub struct bitcoin_primitives::BlockHash(_)
-pub struct bitcoin_primitives::BlockHeader
-pub struct bitcoin_primitives::CompactTarget(_)
-pub struct bitcoin_primitives::Sequence(pub u32)
-pub struct bitcoin_primitives::TapBranchTag
-pub struct bitcoin_primitives::TapLeafHash(_)
-pub struct bitcoin_primitives::TapLeafTag
-pub struct bitcoin_primitives::TapNodeHash(_)
-pub struct bitcoin_primitives::TapTweakHash(_)
-pub struct bitcoin_primitives::TapTweakTag
-pub struct bitcoin_primitives::Transaction
-pub struct bitcoin_primitives::TxIn
-pub struct bitcoin_primitives::TxMerkleNode(_)
-pub struct bitcoin_primitives::TxOut
-pub struct bitcoin_primitives::Txid(_)
-pub struct bitcoin_primitives::Witness
-pub struct bitcoin_primitives::WitnessCommitment(_)
-pub struct bitcoin_primitives::WitnessMerkleNode(_)
-pub struct bitcoin_primitives::Wtxid(_)
-pub struct bitcoin_primitives::block::Block<V> where V: bitcoin_primitives::block::Validation
-pub struct bitcoin_primitives::block::BlockHash(_)
-pub struct bitcoin_primitives::block::Header
-pub struct bitcoin_primitives::block::Version(_)
-pub struct bitcoin_primitives::block::WitnessCommitment(_)
-pub struct bitcoin_primitives::locktime::relative::DisabledLockTimeError(_)
-pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
-pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
-pub struct bitcoin_primitives::opcodes::Opcode
-pub struct bitcoin_primitives::pow::CompactTarget(_)
-pub struct bitcoin_primitives::relative::DisabledLockTimeError(_)
-pub struct bitcoin_primitives::script::RedeemScriptSizeError
-pub struct bitcoin_primitives::script::ScriptBuf(_)
-pub struct bitcoin_primitives::script::ScriptHash(_)
-pub struct bitcoin_primitives::script::WScriptHash(_)
-pub struct bitcoin_primitives::script::WitnessScriptSizeError
-pub struct bitcoin_primitives::sequence::Sequence(pub u32)
-pub struct bitcoin_primitives::taproot::TapBranchTag
-pub struct bitcoin_primitives::taproot::TapLeafHash(_)
-pub struct bitcoin_primitives::taproot::TapLeafTag
-pub struct bitcoin_primitives::taproot::TapNodeHash(_)
-pub struct bitcoin_primitives::taproot::TapTweakHash(_)
-pub struct bitcoin_primitives::taproot::TapTweakTag
-pub struct bitcoin_primitives::transaction::OutPoint
-pub struct bitcoin_primitives::transaction::Transaction
-pub struct bitcoin_primitives::transaction::TxIn
-pub struct bitcoin_primitives::transaction::TxOut
-pub struct bitcoin_primitives::transaction::Txid(_)
-pub struct bitcoin_primitives::transaction::Version(pub i32)
-pub struct bitcoin_primitives::transaction::Wtxid(_)
-pub struct bitcoin_primitives::witness::Iter<'a>
-pub struct bitcoin_primitives::witness::Witness
-pub trait bitcoin_primitives::BlockValidation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
-pub trait bitcoin_primitives::block::Validation: bitcoin_primitives::block::sealed::Validation + core::marker::Sync + core::marker::Send + core::marker::Sized + core::marker::Unpin
-pub type &'a bitcoin_primitives::witness::Witness::IntoIter = bitcoin_primitives::witness::Iter<'a>
-pub type &'a bitcoin_primitives::witness::Witness::Item = &'a [u8]
-pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::block::BlockHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::block::WitnessCommitment::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::block::WitnessCommitment::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::locktime::absolute::LockTime::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::locktime::absolute::LockTime::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::locktime::relative::LockTime::Error = bitcoin_primitives::locktime::relative::DisabledLockTimeError
-pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::script::Script::Output = bitcoin_primitives::script::Script
-pub type bitcoin_primitives::script::Script::Owned = bitcoin_primitives::script::ScriptBuf
-pub type bitcoin_primitives::script::ScriptBuf::Target = bitcoin_primitives::script::Script
-pub type bitcoin_primitives::script::ScriptHash::Bytes = <bitcoin_hashes::hash160::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::script::ScriptHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::script::ScriptHash::Error = bitcoin_primitives::script::RedeemScriptSizeError
-pub type bitcoin_primitives::script::WScriptHash::Bytes = <bitcoin_hashes::sha256::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::script::WScriptHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::script::WScriptHash::Error = bitcoin_primitives::script::WitnessScriptSizeError
-pub type bitcoin_primitives::sequence::Sequence::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::sequence::Sequence::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::taproot::TapLeafHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapLeafHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::taproot::TapNodeHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapNodeHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::taproot::TapTweakHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapTweakHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::transaction::OutPoint::Err = bitcoin_primitives::transaction::ParseOutPointError
-pub type bitcoin_primitives::transaction::Txid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::transaction::Txid::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::transaction::Wtxid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::transaction::Wtxid::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::witness::Iter<'a>::Item = &'a [u8]
-pub type bitcoin_primitives::witness::Witness::Output = [u8]
-pub use bitcoin_primitives::Amount
-pub use bitcoin_primitives::BlockHeight
-pub use bitcoin_primitives::BlockInterval
-pub use bitcoin_primitives::FeeRate
-pub use bitcoin_primitives::SignedAmount
-pub use bitcoin_primitives::Weight
-pub use bitcoin_primitives::absolute::ConversionError
-pub use bitcoin_primitives::absolute::Height
-pub use bitcoin_primitives::absolute::LOCK_TIME_THRESHOLD
-pub use bitcoin_primitives::absolute::ParseHeightError
-pub use bitcoin_primitives::absolute::ParseTimeError
-pub use bitcoin_primitives::absolute::Time
-pub use bitcoin_primitives::amount
-pub use bitcoin_primitives::fee_rate
-pub use bitcoin_primitives::locktime::absolute::ConversionError
-pub use bitcoin_primitives::locktime::absolute::Height
-pub use bitcoin_primitives::locktime::absolute::LOCK_TIME_THRESHOLD
-pub use bitcoin_primitives::locktime::absolute::ParseHeightError
-pub use bitcoin_primitives::locktime::absolute::ParseTimeError
-pub use bitcoin_primitives::locktime::absolute::Time
-pub use bitcoin_primitives::locktime::relative::Height
-pub use bitcoin_primitives::locktime::relative::Time
-pub use bitcoin_primitives::locktime::relative::TimeOverflowError
-pub use bitcoin_primitives::relative::Height
-pub use bitcoin_primitives::relative::Time
-pub use bitcoin_primitives::relative::TimeOverflowError
-pub use bitcoin_primitives::weight
diff --git a/api/primitives/no-features.txt b/api/primitives/no-features.txt
deleted file mode 100644
index a73f56a8fd..0000000000
--- a/api/primitives/no-features.txt
+++ /dev/null
@@ -1,1297 +0,0 @@
-#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleHeightError
-#[non_exhaustive] pub struct bitcoin_primitives::locktime::relative::IncompatibleTimeError
-#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleHeightError
-#[non_exhaustive] pub struct bitcoin_primitives::relative::IncompatibleTimeError
-impl bitcoin_hashes::Hash for bitcoin_primitives::block::BlockHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::block::WitnessCommitment
-impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl bitcoin_hashes::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapLeafHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapNodeHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::taproot::TapTweakHash
-impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Txid
-impl bitcoin_hashes::Hash for bitcoin_primitives::transaction::Wtxid
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapBranchTag
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapLeafTag
-impl bitcoin_hashes::sha256t::Tag for bitcoin_primitives::taproot::TapTweakTag
-impl bitcoin_primitives::block::BlockHash
-impl bitcoin_primitives::block::Header
-impl bitcoin_primitives::block::Version
-impl bitcoin_primitives::block::WitnessCommitment
-impl bitcoin_primitives::locktime::absolute::LockTime
-impl bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl bitcoin_primitives::locktime::relative::LockTime
-impl bitcoin_primitives::merkle_tree::TxMerkleNode
-impl bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl bitcoin_primitives::opcodes::Opcode
-impl bitcoin_primitives::pow::CompactTarget
-impl bitcoin_primitives::sequence::Sequence
-impl bitcoin_primitives::taproot::TapLeafHash
-impl bitcoin_primitives::taproot::TapNodeHash
-impl bitcoin_primitives::taproot::TapTweakHash
-impl bitcoin_primitives::transaction::OutPoint
-impl bitcoin_primitives::transaction::Txid
-impl bitcoin_primitives::transaction::Version
-impl bitcoin_primitives::transaction::Wtxid
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::BlockHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Txid
-impl core::borrow::Borrow<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::BlockHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::block::WitnessCommitment
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Txid
-impl core::borrow::Borrow<[u8]> for bitcoin_primitives::transaction::Wtxid
-impl core::clone::Clone for bitcoin_primitives::block::BlockHash
-impl core::clone::Clone for bitcoin_primitives::block::Header
-impl core::clone::Clone for bitcoin_primitives::block::Version
-impl core::clone::Clone for bitcoin_primitives::block::WitnessCommitment
-impl core::clone::Clone for bitcoin_primitives::locktime::absolute::LockTime
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::clone::Clone for bitcoin_primitives::locktime::relative::LockTime
-impl core::clone::Clone for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::clone::Clone for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::clone::Clone for bitcoin_primitives::opcodes::Class
-impl core::clone::Clone for bitcoin_primitives::opcodes::ClassifyContext
-impl core::clone::Clone for bitcoin_primitives::opcodes::Opcode
-impl core::clone::Clone for bitcoin_primitives::pow::CompactTarget
-impl core::clone::Clone for bitcoin_primitives::sequence::Sequence
-impl core::clone::Clone for bitcoin_primitives::taproot::TapBranchTag
-impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapLeafTag
-impl core::clone::Clone for bitcoin_primitives::taproot::TapNodeHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakHash
-impl core::clone::Clone for bitcoin_primitives::taproot::TapTweakTag
-impl core::clone::Clone for bitcoin_primitives::transaction::OutPoint
-impl core::clone::Clone for bitcoin_primitives::transaction::Txid
-impl core::clone::Clone for bitcoin_primitives::transaction::Version
-impl core::clone::Clone for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::Eq for bitcoin_primitives::block::BlockHash
-impl core::cmp::Eq for bitcoin_primitives::block::Header
-impl core::cmp::Eq for bitcoin_primitives::block::Version
-impl core::cmp::Eq for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::Eq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::cmp::Eq for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::Eq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::Eq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::Eq for bitcoin_primitives::opcodes::Class
-impl core::cmp::Eq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::Eq for bitcoin_primitives::opcodes::Opcode
-impl core::cmp::Eq for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::Eq for bitcoin_primitives::sequence::Sequence
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::Eq for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::Eq for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::Eq for bitcoin_primitives::transaction::Txid
-impl core::cmp::Eq for bitcoin_primitives::transaction::Version
-impl core::cmp::Eq for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::Ord for bitcoin_primitives::block::BlockHash
-impl core::cmp::Ord for bitcoin_primitives::block::Header
-impl core::cmp::Ord for bitcoin_primitives::block::Version
-impl core::cmp::Ord for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::Ord for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::Ord for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::Ord for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::Ord for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::Ord for bitcoin_primitives::sequence::Sequence
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::Ord for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::Ord for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::Ord for bitcoin_primitives::transaction::Txid
-impl core::cmp::Ord for bitcoin_primitives::transaction::Version
-impl core::cmp::Ord for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::PartialEq for bitcoin_primitives::block::BlockHash
-impl core::cmp::PartialEq for bitcoin_primitives::block::Header
-impl core::cmp::PartialEq for bitcoin_primitives::block::Version
-impl core::cmp::PartialEq for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::cmp::PartialEq for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::PartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Class
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::PartialEq for bitcoin_primitives::opcodes::Opcode
-impl core::cmp::PartialEq for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::PartialEq for bitcoin_primitives::sequence::Sequence
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::PartialEq for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Txid
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Version
-impl core::cmp::PartialEq for bitcoin_primitives::transaction::Wtxid
-impl core::cmp::PartialOrd for bitcoin_primitives::block::BlockHash
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Header
-impl core::cmp::PartialOrd for bitcoin_primitives::block::Version
-impl core::cmp::PartialOrd for bitcoin_primitives::block::WitnessCommitment
-impl core::cmp::PartialOrd for bitcoin_primitives::locktime::absolute::LockTime
-impl core::cmp::PartialOrd for bitcoin_primitives::locktime::relative::LockTime
-impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::cmp::PartialOrd for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::cmp::PartialOrd for bitcoin_primitives::opcodes::ClassifyContext
-impl core::cmp::PartialOrd for bitcoin_primitives::pow::CompactTarget
-impl core::cmp::PartialOrd for bitcoin_primitives::sequence::Sequence
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapBranchTag
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapLeafTag
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapNodeHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakHash
-impl core::cmp::PartialOrd for bitcoin_primitives::taproot::TapTweakTag
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::OutPoint
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Txid
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Version
-impl core::cmp::PartialOrd for bitcoin_primitives::transaction::Wtxid
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::BlockHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Txid
-impl core::convert::AsRef<[u8; 32]> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::BlockHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Txid
-impl core::convert::AsRef<[u8]> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::From<&bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::block::WitnessCommitment
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Txid
-impl core::convert::From<bitcoin_hashes::sha256d::Hash> for bitcoin_primitives::transaction::Wtxid
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>> for bitcoin_primitives::taproot::TapLeafHash
-impl core::convert::From<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>> for bitcoin_primitives::taproot::TapTweakHash
-impl core::convert::From<bitcoin_primitives::block::BlockHash> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::block::Header> for bitcoin_primitives::block::BlockHash
-impl core::convert::From<bitcoin_primitives::block::WitnessCommitment> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::locktime::relative::LockTime> for bitcoin_primitives::sequence::Sequence
-impl core::convert::From<bitcoin_primitives::merkle_tree::TxMerkleNode> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::merkle_tree::WitnessMerkleNode> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::sequence::Sequence> for u32
-impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
-impl core::convert::From<bitcoin_primitives::taproot::TapLeafHash> for bitcoin_primitives::taproot::TapNodeHash
-impl core::convert::From<bitcoin_primitives::taproot::TapNodeHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
-impl core::convert::From<bitcoin_primitives::taproot::TapTweakHash> for bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
-impl core::convert::From<bitcoin_primitives::transaction::Txid> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_primitives::transaction::Wtxid> for bitcoin_hashes::sha256d::Hash
-impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::From<bitcoin_units::locktime::absolute::Time> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_primitives::locktime::relative::LockTime
-impl core::convert::From<bitcoin_units::locktime::relative::Time> for bitcoin_primitives::locktime::relative::LockTime
-impl core::convert::From<u8> for bitcoin_primitives::opcodes::Opcode
-impl core::convert::TryFrom<&str> for bitcoin_primitives::locktime::absolute::LockTime
-impl core::convert::TryFrom<bitcoin_primitives::sequence::Sequence> for bitcoin_primitives::locktime::relative::LockTime
-impl core::default::Default for bitcoin_primitives::block::Version
-impl core::default::Default for bitcoin_primitives::pow::CompactTarget
-impl core::default::Default for bitcoin_primitives::sequence::Sequence
-impl core::default::Default for bitcoin_primitives::taproot::TapBranchTag
-impl core::default::Default for bitcoin_primitives::taproot::TapLeafTag
-impl core::default::Default for bitcoin_primitives::taproot::TapTweakTag
-impl core::fmt::Debug for bitcoin_primitives::block::BlockHash
-impl core::fmt::Debug for bitcoin_primitives::block::Header
-impl core::fmt::Debug for bitcoin_primitives::block::Version
-impl core::fmt::Debug for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::Debug for bitcoin_primitives::locktime::absolute::LockTime
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::fmt::Debug for bitcoin_primitives::locktime::relative::LockTime
-impl core::fmt::Debug for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::Debug for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::Debug for bitcoin_primitives::opcodes::Class
-impl core::fmt::Debug for bitcoin_primitives::opcodes::ClassifyContext
-impl core::fmt::Debug for bitcoin_primitives::opcodes::Opcode
-impl core::fmt::Debug for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::Debug for bitcoin_primitives::sequence::Sequence
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::Debug for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::Debug for bitcoin_primitives::transaction::OutPoint
-impl core::fmt::Debug for bitcoin_primitives::transaction::Txid
-impl core::fmt::Debug for bitcoin_primitives::transaction::Version
-impl core::fmt::Debug for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::Display for bitcoin_primitives::block::BlockHash
-impl core::fmt::Display for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::Display for bitcoin_primitives::locktime::absolute::LockTime
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::fmt::Display for bitcoin_primitives::locktime::relative::LockTime
-impl core::fmt::Display for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::Display for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::Display for bitcoin_primitives::opcodes::Opcode
-impl core::fmt::Display for bitcoin_primitives::sequence::Sequence
-impl core::fmt::Display for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::Display for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::Display for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::Display for bitcoin_primitives::transaction::OutPoint
-impl core::fmt::Display for bitcoin_primitives::transaction::Txid
-impl core::fmt::Display for bitcoin_primitives::transaction::Version
-impl core::fmt::Display for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::LowerHex for bitcoin_primitives::block::BlockHash
-impl core::fmt::LowerHex for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::LowerHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::LowerHex for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::LowerHex for bitcoin_primitives::sequence::Sequence
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::LowerHex for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::LowerHex for bitcoin_primitives::transaction::Txid
-impl core::fmt::LowerHex for bitcoin_primitives::transaction::Wtxid
-impl core::fmt::UpperHex for bitcoin_primitives::block::BlockHash
-impl core::fmt::UpperHex for bitcoin_primitives::block::WitnessCommitment
-impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::fmt::UpperHex for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::fmt::UpperHex for bitcoin_primitives::pow::CompactTarget
-impl core::fmt::UpperHex for bitcoin_primitives::sequence::Sequence
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapLeafHash
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapNodeHash
-impl core::fmt::UpperHex for bitcoin_primitives::taproot::TapTweakHash
-impl core::fmt::UpperHex for bitcoin_primitives::transaction::Txid
-impl core::fmt::UpperHex for bitcoin_primitives::transaction::Wtxid
-impl core::hash::Hash for bitcoin_primitives::block::BlockHash
-impl core::hash::Hash for bitcoin_primitives::block::Header
-impl core::hash::Hash for bitcoin_primitives::block::Version
-impl core::hash::Hash for bitcoin_primitives::block::WitnessCommitment
-impl core::hash::Hash for bitcoin_primitives::locktime::absolute::LockTime
-impl core::hash::Hash for bitcoin_primitives::locktime::relative::LockTime
-impl core::hash::Hash for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::hash::Hash for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::hash::Hash for bitcoin_primitives::opcodes::ClassifyContext
-impl core::hash::Hash for bitcoin_primitives::pow::CompactTarget
-impl core::hash::Hash for bitcoin_primitives::sequence::Sequence
-impl core::hash::Hash for bitcoin_primitives::taproot::TapBranchTag
-impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapLeafTag
-impl core::hash::Hash for bitcoin_primitives::taproot::TapNodeHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakHash
-impl core::hash::Hash for bitcoin_primitives::taproot::TapTweakTag
-impl core::hash::Hash for bitcoin_primitives::transaction::OutPoint
-impl core::hash::Hash for bitcoin_primitives::transaction::Txid
-impl core::hash::Hash for bitcoin_primitives::transaction::Version
-impl core::hash::Hash for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Copy for bitcoin_primitives::block::BlockHash
-impl core::marker::Copy for bitcoin_primitives::block::Header
-impl core::marker::Copy for bitcoin_primitives::block::Version
-impl core::marker::Copy for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Copy for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Copy for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Copy for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Copy for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Copy for bitcoin_primitives::opcodes::Class
-impl core::marker::Copy for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Copy for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Copy for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Copy for bitcoin_primitives::sequence::Sequence
-impl core::marker::Copy for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Copy for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Copy for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Copy for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Copy for bitcoin_primitives::transaction::Txid
-impl core::marker::Copy for bitcoin_primitives::transaction::Version
-impl core::marker::Copy for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Freeze for bitcoin_primitives::block::BlockHash
-impl core::marker::Freeze for bitcoin_primitives::block::Header
-impl core::marker::Freeze for bitcoin_primitives::block::Version
-impl core::marker::Freeze for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Freeze for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Freeze for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Freeze for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Freeze for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Freeze for bitcoin_primitives::opcodes::Class
-impl core::marker::Freeze for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Freeze for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Freeze for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Freeze for bitcoin_primitives::sequence::Sequence
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Freeze for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Freeze for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Freeze for bitcoin_primitives::transaction::Txid
-impl core::marker::Freeze for bitcoin_primitives::transaction::Version
-impl core::marker::Freeze for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Send for bitcoin_primitives::block::BlockHash
-impl core::marker::Send for bitcoin_primitives::block::Header
-impl core::marker::Send for bitcoin_primitives::block::Version
-impl core::marker::Send for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Send for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Send for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Send for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Send for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Send for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Send for bitcoin_primitives::opcodes::Class
-impl core::marker::Send for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Send for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Send for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Send for bitcoin_primitives::sequence::Sequence
-impl core::marker::Send for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Send for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Send for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Send for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Send for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Send for bitcoin_primitives::transaction::Txid
-impl core::marker::Send for bitcoin_primitives::transaction::Version
-impl core::marker::Send for bitcoin_primitives::transaction::Wtxid
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::BlockHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Header
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::Version
-impl core::marker::StructuralPartialEq for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::StructuralPartialEq for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Class
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::StructuralPartialEq for bitcoin_primitives::opcodes::Opcode
-impl core::marker::StructuralPartialEq for bitcoin_primitives::pow::CompactTarget
-impl core::marker::StructuralPartialEq for bitcoin_primitives::sequence::Sequence
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::StructuralPartialEq for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::OutPoint
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Txid
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Version
-impl core::marker::StructuralPartialEq for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Sync for bitcoin_primitives::block::BlockHash
-impl core::marker::Sync for bitcoin_primitives::block::Header
-impl core::marker::Sync for bitcoin_primitives::block::Version
-impl core::marker::Sync for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Sync for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Sync for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Sync for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Sync for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Sync for bitcoin_primitives::opcodes::Class
-impl core::marker::Sync for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Sync for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Sync for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Sync for bitcoin_primitives::sequence::Sequence
-impl core::marker::Sync for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Sync for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Sync for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Sync for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Sync for bitcoin_primitives::transaction::Txid
-impl core::marker::Sync for bitcoin_primitives::transaction::Version
-impl core::marker::Sync for bitcoin_primitives::transaction::Wtxid
-impl core::marker::Unpin for bitcoin_primitives::block::BlockHash
-impl core::marker::Unpin for bitcoin_primitives::block::Header
-impl core::marker::Unpin for bitcoin_primitives::block::Version
-impl core::marker::Unpin for bitcoin_primitives::block::WitnessCommitment
-impl core::marker::Unpin for bitcoin_primitives::locktime::absolute::LockTime
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::marker::Unpin for bitcoin_primitives::locktime::relative::LockTime
-impl core::marker::Unpin for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::marker::Unpin for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::marker::Unpin for bitcoin_primitives::opcodes::Class
-impl core::marker::Unpin for bitcoin_primitives::opcodes::ClassifyContext
-impl core::marker::Unpin for bitcoin_primitives::opcodes::Opcode
-impl core::marker::Unpin for bitcoin_primitives::pow::CompactTarget
-impl core::marker::Unpin for bitcoin_primitives::sequence::Sequence
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapBranchTag
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapLeafTag
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapNodeHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakHash
-impl core::marker::Unpin for bitcoin_primitives::taproot::TapTweakTag
-impl core::marker::Unpin for bitcoin_primitives::transaction::OutPoint
-impl core::marker::Unpin for bitcoin_primitives::transaction::Txid
-impl core::marker::Unpin for bitcoin_primitives::transaction::Version
-impl core::marker::Unpin for bitcoin_primitives::transaction::Wtxid
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::BlockHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Header
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::Version
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::block::WitnessCommitment
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::locktime::relative::LockTime
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Class
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::opcodes::Opcode
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::pow::CompactTarget
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::sequence::Sequence
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapBranchTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapLeafTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapNodeHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakHash
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::taproot::TapTweakTag
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::OutPoint
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Txid
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Version
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_primitives::transaction::Wtxid
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::BlockHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Header
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::Version
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::block::WitnessCommitment
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::absolute::LockTime
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::DisabledLockTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::IncompatibleTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::locktime::relative::LockTime
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Class
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::ClassifyContext
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::opcodes::Opcode
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::pow::CompactTarget
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::sequence::Sequence
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapBranchTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapLeafTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapNodeHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakHash
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::taproot::TapTweakTag
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::OutPoint
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Txid
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Version
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_primitives::transaction::Wtxid
-impl core::str::traits::FromStr for bitcoin_primitives::block::BlockHash
-impl core::str::traits::FromStr for bitcoin_primitives::block::WitnessCommitment
-impl core::str::traits::FromStr for bitcoin_primitives::locktime::absolute::LockTime
-impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::TxMerkleNode
-impl core::str::traits::FromStr for bitcoin_primitives::merkle_tree::WitnessMerkleNode
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapLeafHash
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapNodeHash
-impl core::str::traits::FromStr for bitcoin_primitives::taproot::TapTweakHash
-impl core::str::traits::FromStr for bitcoin_primitives::transaction::Txid
-impl core::str::traits::FromStr for bitcoin_primitives::transaction::Wtxid
-pub bitcoin_primitives::BlockHeader::bits: bitcoin_primitives::pow::CompactTarget
-pub bitcoin_primitives::BlockHeader::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
-pub bitcoin_primitives::BlockHeader::nonce: u32
-pub bitcoin_primitives::BlockHeader::prev_blockhash: bitcoin_primitives::block::BlockHash
-pub bitcoin_primitives::BlockHeader::time: u32
-pub bitcoin_primitives::BlockHeader::version: bitcoin_primitives::block::Version
-pub bitcoin_primitives::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
-pub bitcoin_primitives::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
-pub bitcoin_primitives::block::Header::bits: bitcoin_primitives::pow::CompactTarget
-pub bitcoin_primitives::block::Header::merkle_root: bitcoin_primitives::merkle_tree::TxMerkleNode
-pub bitcoin_primitives::block::Header::nonce: u32
-pub bitcoin_primitives::block::Header::prev_blockhash: bitcoin_primitives::block::BlockHash
-pub bitcoin_primitives::block::Header::time: u32
-pub bitcoin_primitives::block::Header::version: bitcoin_primitives::block::Version
-pub bitcoin_primitives::locktime::absolute::LockTime::Blocks(bitcoin_units::locktime::absolute::Height)
-pub bitcoin_primitives::locktime::absolute::LockTime::Seconds(bitcoin_units::locktime::absolute::Time)
-pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::locktime::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::locktime::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::locktime::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
-pub bitcoin_primitives::locktime::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
-pub bitcoin_primitives::opcodes::Class::IllegalOp
-pub bitcoin_primitives::opcodes::Class::NoOp
-pub bitcoin_primitives::opcodes::Class::Ordinary(Ordinary)
-pub bitcoin_primitives::opcodes::Class::PushBytes(u32)
-pub bitcoin_primitives::opcodes::Class::PushNum(i32)
-pub bitcoin_primitives::opcodes::Class::ReturnOp
-pub bitcoin_primitives::opcodes::Class::SuccessOp
-pub bitcoin_primitives::opcodes::ClassifyContext::Legacy
-pub bitcoin_primitives::opcodes::ClassifyContext::TapScript
-pub bitcoin_primitives::relative::IncompatibleHeightError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::relative::IncompatibleHeightError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::relative::IncompatibleTimeError::height: bitcoin_units::locktime::relative::Height
-pub bitcoin_primitives::relative::IncompatibleTimeError::time: bitcoin_units::locktime::relative::Time
-pub bitcoin_primitives::relative::LockTime::Blocks(bitcoin_units::locktime::relative::Height)
-pub bitcoin_primitives::relative::LockTime::Time(bitcoin_units::locktime::relative::Time)
-pub bitcoin_primitives::transaction::OutPoint::txid: bitcoin_primitives::transaction::Txid
-pub bitcoin_primitives::transaction::OutPoint::vout: u32
-pub const bitcoin_primitives::block::BlockHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::block::BlockHash::GENESIS_PREVIOUS_BLOCK_HASH: Self
-pub const bitcoin_primitives::block::Header::SIZE: usize
-pub const bitcoin_primitives::block::Version::NO_SOFT_FORK_SIGNALLING: Self
-pub const bitcoin_primitives::block::Version::ONE: Self
-pub const bitcoin_primitives::block::Version::TWO: Self
-pub const bitcoin_primitives::block::WitnessCommitment::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::locktime::absolute::LockTime::SIZE: usize
-pub const bitcoin_primitives::locktime::absolute::LockTime::ZERO: bitcoin_primitives::locktime::absolute::LockTime
-pub const bitcoin_primitives::locktime::relative::LockTime::SIZE: usize
-pub const bitcoin_primitives::locktime::relative::LockTime::ZERO: bitcoin_primitives::locktime::relative::LockTime
-pub const bitcoin_primitives::merkle_tree::TxMerkleNode::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::merkle_tree::WitnessMerkleNode::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::opcodes::all::OP_0NOTEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_1ADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_1SUB: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DIV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DROP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2MUL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2OVER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2ROT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_2SWAP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_3DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ABS: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_AND: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_BOOLAND: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_BOOLOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CAT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIG: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKMULTISIGVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIG: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGADD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CHECKSIGVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CLTV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CODESEPARATOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_CSV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DEPTH: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DIV: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DROP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_DUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ELSE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ENDIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_EQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_EQUALVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_FROMALTSTACK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_GREATERTHAN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_GREATERTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_HASH160: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_HASH256: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_IF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_IFDUP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_INVALIDOPCODE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_INVERT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LEFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LESSTHAN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LESSTHANOREQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_LSHIFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MAX: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MIN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MOD: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_MUL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NEGATE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NIP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NOTIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMEQUALVERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_NUMNOTEQUAL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_OR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_OVER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PICK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_0: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_11: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_12: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_13: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_14: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_15: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_16: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_17: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_18: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_19: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_20: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_21: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_22: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_23: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_24: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_25: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_26: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_27: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_28: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_29: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_30: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_31: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_32: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_33: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_34: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_35: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_36: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_37: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_38: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_39: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_3: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_40: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_41: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_42: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_43: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_44: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_45: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_46: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_47: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_48: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_49: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_50: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_51: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_52: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_53: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_54: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_55: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_56: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_57: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_58: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_59: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_60: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_61: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_62: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_63: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_64: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_65: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_66: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_67: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_68: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_69: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_70: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_71: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_72: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_73: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_74: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_75: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHBYTES_9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHDATA4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_10: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_11: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_12: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_13: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_14: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_15: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_16: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_3: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_4: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_5: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_6: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_7: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_8: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_9: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_PUSHNUM_NEG1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED2: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RESERVED: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_187: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_188: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_189: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_190: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_191: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_192: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_193: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_194: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_195: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_196: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_197: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_198: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_199: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_200: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_201: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_202: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_203: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_204: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_205: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_206: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_207: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_208: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_209: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_210: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_211: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_212: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_213: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_214: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_215: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_216: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_217: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_218: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_219: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_220: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_221: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_222: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_223: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_224: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_225: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_226: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_227: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_228: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_229: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_230: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_231: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_232: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_233: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_234: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_235: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_236: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_237: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_238: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_239: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_240: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_241: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_242: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_243: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_244: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_245: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_246: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_247: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_248: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_249: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_250: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_251: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_252: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_253: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RETURN_254: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RIGHT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RIPEMD160: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ROLL: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_ROT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_RSHIFT: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SHA1: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SHA256: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SIZE: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SUB: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SUBSTR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_SWAP: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_TOALTSTACK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_TUCK: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VER: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERIFY: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_VERNOTIF: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_WITHIN: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::opcodes::all::OP_XOR: bitcoin_primitives::opcodes::Opcode
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_AND_RBF: Self
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_LOCKTIME_NO_RBF: Self
-pub const bitcoin_primitives::sequence::Sequence::ENABLE_RBF_NO_LOCKTIME: Self
-pub const bitcoin_primitives::sequence::Sequence::FINAL: Self
-pub const bitcoin_primitives::sequence::Sequence::MAX: Self
-pub const bitcoin_primitives::sequence::Sequence::SIZE: usize
-pub const bitcoin_primitives::sequence::Sequence::ZERO: Self
-pub const bitcoin_primitives::taproot::TapLeafHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::taproot::TapNodeHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::taproot::TapTweakHash::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::transaction::OutPoint::COINBASE_PREVOUT: Self
-pub const bitcoin_primitives::transaction::OutPoint::SIZE: usize
-pub const bitcoin_primitives::transaction::Txid::COINBASE_PREVOUT: Self
-pub const bitcoin_primitives::transaction::Txid::DISPLAY_BACKWARD: bool
-pub const bitcoin_primitives::transaction::Version::ONE: Self
-pub const bitcoin_primitives::transaction::Version::THREE: Self
-pub const bitcoin_primitives::transaction::Version::TWO: Self
-pub const bitcoin_primitives::transaction::Wtxid::COINBASE: Self
-pub const bitcoin_primitives::transaction::Wtxid::DISPLAY_BACKWARD: bool
-pub const fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::Version::from_consensus(v: i32) -> Self
-pub const fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_height(&self) -> bool
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_block_time(&self) -> bool
-pub const fn bitcoin_primitives::locktime::absolute::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_512_second_intervals(intervals: u16) -> Self
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_height(n: u16) -> Self
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_primitives::locktime::relative::LockTime::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_height(&self) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_block_time(&self) -> bool
-pub const fn bitcoin_primitives::locktime::relative::LockTime::is_same_unit(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::opcodes::Opcode::decode_pushnum(self) -> core::option::Option<u8>
-pub const fn bitcoin_primitives::opcodes::Opcode::to_u8(self) -> u8
-pub const fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &<bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &<bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub const fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes) -> Self
-pub const fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub enum bitcoin_primitives::absolute::LockTime
-pub enum bitcoin_primitives::locktime::absolute::LockTime
-pub enum bitcoin_primitives::locktime::relative::LockTime
-pub enum bitcoin_primitives::opcodes::Class
-pub enum bitcoin_primitives::opcodes::ClassifyContext
-pub enum bitcoin_primitives::relative::LockTime
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::BlockHash) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::block::WitnessCommitment) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::TxMerkleNode) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Txid) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256d::Hash::from(hashtype: bitcoin_primitives::transaction::Wtxid) -> bitcoin_hashes::sha256d::Hash
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>::from(hashtype: bitcoin_primitives::taproot::TapNodeHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>::from(hashtype: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>
-pub fn bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>::from(hashtype: bitcoin_primitives::taproot::TapTweakHash) -> bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>
-pub fn bitcoin_primitives::block::BlockHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::BlockHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::BlockHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::block::BlockHash::clone(&self) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::BlockHash::eq(&self, other: &bitcoin_primitives::block::BlockHash) -> bool
-pub fn bitcoin_primitives::block::BlockHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::BlockHash::from(header: &bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(header: bitcoin_primitives::block::Header) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::BlockHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::block::BlockHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::BlockHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::block::BlockHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::block::BlockHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::BlockHash::partial_cmp(&self, other: &bitcoin_primitives::block::BlockHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::BlockHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::block::Header::block_hash(&self) -> bitcoin_primitives::block::BlockHash
-pub fn bitcoin_primitives::block::Header::clone(&self) -> bitcoin_primitives::block::Header
-pub fn bitcoin_primitives::block::Header::cmp(&self, other: &bitcoin_primitives::block::Header) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Header::eq(&self, other: &bitcoin_primitives::block::Header) -> bool
-pub fn bitcoin_primitives::block::Header::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Header::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Header::partial_cmp(&self, other: &bitcoin_primitives::block::Header) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Version::clone(&self) -> bitcoin_primitives::block::Version
-pub fn bitcoin_primitives::block::Version::cmp(&self, other: &bitcoin_primitives::block::Version) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::Version::default() -> bitcoin_primitives::block::Version
-pub fn bitcoin_primitives::block::Version::eq(&self, other: &bitcoin_primitives::block::Version) -> bool
-pub fn bitcoin_primitives::block::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::Version::is_signalling_soft_fork(&self, bit: u8) -> bool
-pub fn bitcoin_primitives::block::Version::partial_cmp(&self, other: &bitcoin_primitives::block::Version) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::Version::to_consensus(self) -> i32
-pub fn bitcoin_primitives::block::WitnessCommitment::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::WitnessCommitment::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::block::WitnessCommitment::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::block::WitnessCommitment::clone(&self) -> bitcoin_primitives::block::WitnessCommitment
-pub fn bitcoin_primitives::block::WitnessCommitment::cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::cmp::Ordering
-pub fn bitcoin_primitives::block::WitnessCommitment::eq(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> bool
-pub fn bitcoin_primitives::block::WitnessCommitment::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::block::WitnessCommitment::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::block::WitnessCommitment
-pub fn bitcoin_primitives::block::WitnessCommitment::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::block::WitnessCommitment::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::block::WitnessCommitment, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::block::WitnessCommitment::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::block::WitnessCommitment::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::block::WitnessCommitment::partial_cmp(&self, other: &bitcoin_primitives::block::WitnessCommitment) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::block::WitnessCommitment::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::locktime::absolute::LockTime::clone(&self) -> bitcoin_primitives::locktime::absolute::LockTime
-pub fn bitcoin_primitives::locktime::absolute::LockTime::eq(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from(h: bitcoin_units::locktime::absolute::Height) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from(t: bitcoin_units::locktime::absolute::Time) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_consensus(n: u32) -> Self
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_height(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_time(n: u32) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ConversionError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::locktime::absolute::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::absolute::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::is_satisfied_by(&self, height: bitcoin_units::locktime::absolute::Height, time: bitcoin_units::locktime::absolute::Time) -> bool
-pub fn bitcoin_primitives::locktime::absolute::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::absolute::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::absolute::LockTime::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::locktime::absolute::LockTime::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::DisabledLockTimeError
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::disabled_locktime_value(&self) -> u32
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::DisabledLockTimeError) -> bool
-pub fn bitcoin_primitives::locktime::relative::DisabledLockTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleHeightError
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleHeightError) -> bool
-pub fn bitcoin_primitives::locktime::relative::IncompatibleHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::clone(&self) -> bitcoin_primitives::locktime::relative::IncompatibleTimeError
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::eq(&self, other: &bitcoin_primitives::locktime::relative::IncompatibleTimeError) -> bool
-pub fn bitcoin_primitives::locktime::relative::IncompatibleTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::LockTime::clone(&self) -> bitcoin_primitives::locktime::relative::LockTime
-pub fn bitcoin_primitives::locktime::relative::LockTime::eq(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::locktime::relative::LockTime::from(h: bitcoin_units::locktime::relative::Height) -> Self
-pub fn bitcoin_primitives::locktime::relative::LockTime::from(t: bitcoin_units::locktime::relative::Time) -> Self
-pub fn bitcoin_primitives::locktime::relative::LockTime::from_consensus(n: u32) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::from_sequence(n: bitcoin_primitives::sequence::Sequence) -> core::result::Result<Self, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by(&self, other: bitcoin_primitives::locktime::relative::LockTime) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_implied_by_sequence(&self, other: bitcoin_primitives::sequence::Sequence) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by(&self, h: bitcoin_units::locktime::relative::Height, t: bitcoin_units::locktime::relative::Time) -> bool
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_height(&self, height: bitcoin_units::locktime::relative::Height) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleHeightError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::is_satisfied_by_time(&self, time: bitcoin_units::locktime::relative::Time) -> core::result::Result<bool, bitcoin_primitives::locktime::relative::IncompatibleTimeError>
-pub fn bitcoin_primitives::locktime::relative::LockTime::partial_cmp(&self, other: &bitcoin_primitives::locktime::relative::LockTime) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::locktime::relative::LockTime::to_sequence(self) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::locktime::relative::LockTime::try_from(seq: bitcoin_primitives::sequence::Sequence) -> core::result::Result<bitcoin_primitives::locktime::relative::LockTime, bitcoin_primitives::locktime::relative::DisabledLockTimeError>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::TxMerkleNode
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::cmp::Ordering
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> bool
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::TxMerkleNode
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::TxMerkleNode, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::TxMerkleNode) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::merkle_tree::TxMerkleNode::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::clone(&self) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::cmp::Ordering
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::eq(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> bool
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::merkle_tree::WitnessMerkleNode
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::merkle_tree::WitnessMerkleNode, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::partial_cmp(&self, other: &bitcoin_primitives::merkle_tree::WitnessMerkleNode) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::merkle_tree::WitnessMerkleNode::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::opcodes::Class::clone(&self) -> bitcoin_primitives::opcodes::Class
-pub fn bitcoin_primitives::opcodes::Class::eq(&self, other: &bitcoin_primitives::opcodes::Class) -> bool
-pub fn bitcoin_primitives::opcodes::Class::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::ClassifyContext::clone(&self) -> bitcoin_primitives::opcodes::ClassifyContext
-pub fn bitcoin_primitives::opcodes::ClassifyContext::cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::cmp::Ordering
-pub fn bitcoin_primitives::opcodes::ClassifyContext::eq(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> bool
-pub fn bitcoin_primitives::opcodes::ClassifyContext::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::ClassifyContext::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::opcodes::ClassifyContext::partial_cmp(&self, other: &bitcoin_primitives::opcodes::ClassifyContext) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::opcodes::Opcode::classify(self, ctx: bitcoin_primitives::opcodes::ClassifyContext) -> bitcoin_primitives::opcodes::Class
-pub fn bitcoin_primitives::opcodes::Opcode::clone(&self) -> bitcoin_primitives::opcodes::Opcode
-pub fn bitcoin_primitives::opcodes::Opcode::eq(&self, other: &bitcoin_primitives::opcodes::Opcode) -> bool
-pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::opcodes::Opcode::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::result::Result<(), core::fmt::Error>
-pub fn bitcoin_primitives::opcodes::Opcode::from(b: u8) -> bitcoin_primitives::opcodes::Opcode
-pub fn bitcoin_primitives::pow::CompactTarget::clone(&self) -> bitcoin_primitives::pow::CompactTarget
-pub fn bitcoin_primitives::pow::CompactTarget::cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::cmp::Ordering
-pub fn bitcoin_primitives::pow::CompactTarget::default() -> bitcoin_primitives::pow::CompactTarget
-pub fn bitcoin_primitives::pow::CompactTarget::eq(&self, other: &bitcoin_primitives::pow::CompactTarget) -> bool
-pub fn bitcoin_primitives::pow::CompactTarget::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::pow::CompactTarget::from_consensus(bits: u32) -> Self
-pub fn bitcoin_primitives::pow::CompactTarget::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::pow::CompactTarget::partial_cmp(&self, other: &bitcoin_primitives::pow::CompactTarget) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::pow::CompactTarget::to_consensus(self) -> u32
-pub fn bitcoin_primitives::sequence::Sequence::clone(&self) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::sequence::Sequence::cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::cmp::Ordering
-pub fn bitcoin_primitives::sequence::Sequence::default() -> Self
-pub fn bitcoin_primitives::sequence::Sequence::enables_absolute_lock_time(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::eq(&self, other: &bitcoin_primitives::sequence::Sequence) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::sequence::Sequence::from(lt: bitcoin_primitives::locktime::relative::LockTime) -> bitcoin_primitives::sequence::Sequence
-pub fn bitcoin_primitives::sequence::Sequence::from_512_second_intervals(intervals: u16) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_consensus(n: u32) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_height(height: u16) -> Self
-pub fn bitcoin_primitives::sequence::Sequence::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_primitives::sequence::Sequence::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub fn bitcoin_primitives::sequence::Sequence::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub fn bitcoin_primitives::sequence::Sequence::from_unprefixed_hex(s: &str) -> core::result::Result<Self, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_primitives::sequence::Sequence::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::sequence::Sequence::is_final(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_height_locked(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_rbf(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_relative_lock_time(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::is_time_locked(&self) -> bool
-pub fn bitcoin_primitives::sequence::Sequence::partial_cmp(&self, other: &bitcoin_primitives::sequence::Sequence) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::sequence::Sequence::to_consensus_u32(self) -> u32
-pub fn bitcoin_primitives::sequence::Sequence::to_relative_lock_time(self) -> core::option::Option<bitcoin_primitives::locktime::relative::LockTime>
-pub fn bitcoin_primitives::taproot::TapBranchTag::clone(&self) -> bitcoin_primitives::taproot::TapBranchTag
-pub fn bitcoin_primitives::taproot::TapBranchTag::cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapBranchTag::default() -> bitcoin_primitives::taproot::TapBranchTag
-pub fn bitcoin_primitives::taproot::TapBranchTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapBranchTag::eq(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> bool
-pub fn bitcoin_primitives::taproot::TapBranchTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapBranchTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapBranchTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapLeafHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapLeafHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapLeafHash::clone(&self) -> bitcoin_primitives::taproot::TapLeafHash
-pub fn bitcoin_primitives::taproot::TapLeafHash::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapLeafHash::eq(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> bool
-pub fn bitcoin_primitives::taproot::TapLeafHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapLeafHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag>) -> bitcoin_primitives::taproot::TapLeafHash
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapLeafHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapLeafHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapLeafHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapLeafHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapLeafHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapLeafTag::clone(&self) -> bitcoin_primitives::taproot::TapLeafTag
-pub fn bitcoin_primitives::taproot::TapLeafTag::cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapLeafTag::default() -> bitcoin_primitives::taproot::TapLeafTag
-pub fn bitcoin_primitives::taproot::TapLeafTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapLeafTag::eq(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> bool
-pub fn bitcoin_primitives::taproot::TapLeafTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapLeafTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapLeafTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapNodeHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapNodeHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapNodeHash::clone(&self) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapNodeHash::eq(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> bool
-pub fn bitcoin_primitives::taproot::TapNodeHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapNodeHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag>) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::from(leaf: bitcoin_primitives::taproot::TapLeafHash) -> bitcoin_primitives::taproot::TapNodeHash
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapNodeHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapNodeHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapNodeHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapNodeHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapNodeHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapNodeHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapTweakHash::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::taproot::TapTweakHash::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::taproot::TapTweakHash::clone(&self) -> bitcoin_primitives::taproot::TapTweakHash
-pub fn bitcoin_primitives::taproot::TapTweakHash::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapTweakHash::eq(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> bool
-pub fn bitcoin_primitives::taproot::TapTweakHash::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::taproot::TapTweakHash::from(inner: bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag>) -> bitcoin_primitives::taproot::TapTweakHash
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::taproot::TapTweakHash, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::taproot::TapTweakHash::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::taproot::TapTweakHash::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapTweakHash::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakHash) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::taproot::TapTweakHash::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::taproot::TapTweakTag::clone(&self) -> bitcoin_primitives::taproot::TapTweakTag
-pub fn bitcoin_primitives::taproot::TapTweakTag::cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::cmp::Ordering
-pub fn bitcoin_primitives::taproot::TapTweakTag::default() -> bitcoin_primitives::taproot::TapTweakTag
-pub fn bitcoin_primitives::taproot::TapTweakTag::engine() -> bitcoin_hashes::sha256::HashEngine
-pub fn bitcoin_primitives::taproot::TapTweakTag::eq(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> bool
-pub fn bitcoin_primitives::taproot::TapTweakTag::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::taproot::TapTweakTag::partial_cmp(&self, other: &bitcoin_primitives::taproot::TapTweakTag) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::OutPoint::clone(&self) -> bitcoin_primitives::transaction::OutPoint
-pub fn bitcoin_primitives::transaction::OutPoint::cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::OutPoint::eq(&self, other: &bitcoin_primitives::transaction::OutPoint) -> bool
-pub fn bitcoin_primitives::transaction::OutPoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::OutPoint::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::OutPoint::partial_cmp(&self, other: &bitcoin_primitives::transaction::OutPoint) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Txid::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Txid::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Txid::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Txid::clone(&self) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Txid::eq(&self, other: &bitcoin_primitives::transaction::Txid) -> bool
-pub fn bitcoin_primitives::transaction::Txid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Txid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Txid
-pub fn bitcoin_primitives::transaction::Txid::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::transaction::Txid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Txid, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::transaction::Txid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::transaction::Txid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Txid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Txid) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Txid::to_byte_array(self) -> Self::Bytes
-pub fn bitcoin_primitives::transaction::Version::clone(&self) -> bitcoin_primitives::transaction::Version
-pub fn bitcoin_primitives::transaction::Version::cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Version::eq(&self, other: &bitcoin_primitives::transaction::Version) -> bool
-pub fn bitcoin_primitives::transaction::Version::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Version::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Version::partial_cmp(&self, other: &bitcoin_primitives::transaction::Version) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Wtxid::as_byte_array(&self) -> &Self::Bytes
-pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Wtxid::as_ref(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8; 32]
-pub fn bitcoin_primitives::transaction::Wtxid::borrow(&self) -> &[u8]
-pub fn bitcoin_primitives::transaction::Wtxid::clone(&self) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::cmp::Ordering
-pub fn bitcoin_primitives::transaction::Wtxid::eq(&self, other: &bitcoin_primitives::transaction::Wtxid) -> bool
-pub fn bitcoin_primitives::transaction::Wtxid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_primitives::transaction::Wtxid::from(inner: bitcoin_hashes::sha256d::Hash) -> bitcoin_primitives::transaction::Wtxid
-pub fn bitcoin_primitives::transaction::Wtxid::from_byte_array(bytes: Self::Bytes) -> Self
-pub fn bitcoin_primitives::transaction::Wtxid::from_slice(sl: &[u8]) -> core::result::Result<bitcoin_primitives::transaction::Wtxid, bitcoin_hashes::error::FromSliceError>
-pub fn bitcoin_primitives::transaction::Wtxid::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_primitives::transaction::Wtxid::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_primitives::transaction::Wtxid::partial_cmp(&self, other: &bitcoin_primitives::transaction::Wtxid) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_primitives::transaction::Wtxid::to_byte_array(self) -> Self::Bytes
-pub fn u32::from(sequence: bitcoin_primitives::sequence::Sequence) -> u32
-pub mod bitcoin_primitives
-pub mod bitcoin_primitives::absolute
-pub mod bitcoin_primitives::block
-pub mod bitcoin_primitives::locktime
-pub mod bitcoin_primitives::locktime::absolute
-pub mod bitcoin_primitives::locktime::relative
-pub mod bitcoin_primitives::merkle_tree
-pub mod bitcoin_primitives::opcodes
-pub mod bitcoin_primitives::opcodes::all
-pub mod bitcoin_primitives::pow
-pub mod bitcoin_primitives::relative
-pub mod bitcoin_primitives::sequence
-pub mod bitcoin_primitives::taproot
-pub mod bitcoin_primitives::transaction
-pub static bitcoin_primitives::opcodes::OP_0: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_FALSE: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_NOP2: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_NOP3: bitcoin_primitives::opcodes::Opcode
-pub static bitcoin_primitives::opcodes::OP_TRUE: bitcoin_primitives::opcodes::Opcode
-pub struct bitcoin_primitives::BlockHash(_)
-pub struct bitcoin_primitives::BlockHeader
-pub struct bitcoin_primitives::CompactTarget(_)
-pub struct bitcoin_primitives::Sequence(pub u32)
-pub struct bitcoin_primitives::TapBranchTag
-pub struct bitcoin_primitives::TapLeafHash(_)
-pub struct bitcoin_primitives::TapLeafTag
-pub struct bitcoin_primitives::TapNodeHash(_)
-pub struct bitcoin_primitives::TapTweakHash(_)
-pub struct bitcoin_primitives::TapTweakTag
-pub struct bitcoin_primitives::TxMerkleNode(_)
-pub struct bitcoin_primitives::Txid(_)
-pub struct bitcoin_primitives::WitnessCommitment(_)
-pub struct bitcoin_primitives::WitnessMerkleNode(_)
-pub struct bitcoin_primitives::Wtxid(_)
-pub struct bitcoin_primitives::block::BlockHash(_)
-pub struct bitcoin_primitives::block::Header
-pub struct bitcoin_primitives::block::Version(_)
-pub struct bitcoin_primitives::block::WitnessCommitment(_)
-pub struct bitcoin_primitives::locktime::relative::DisabledLockTimeError(_)
-pub struct bitcoin_primitives::merkle_tree::TxMerkleNode(_)
-pub struct bitcoin_primitives::merkle_tree::WitnessMerkleNode(_)
-pub struct bitcoin_primitives::opcodes::Opcode
-pub struct bitcoin_primitives::pow::CompactTarget(_)
-pub struct bitcoin_primitives::relative::DisabledLockTimeError(_)
-pub struct bitcoin_primitives::sequence::Sequence(pub u32)
-pub struct bitcoin_primitives::taproot::TapBranchTag
-pub struct bitcoin_primitives::taproot::TapLeafHash(_)
-pub struct bitcoin_primitives::taproot::TapLeafTag
-pub struct bitcoin_primitives::taproot::TapNodeHash(_)
-pub struct bitcoin_primitives::taproot::TapTweakHash(_)
-pub struct bitcoin_primitives::taproot::TapTweakTag
-pub struct bitcoin_primitives::transaction::OutPoint
-pub struct bitcoin_primitives::transaction::Txid(_)
-pub struct bitcoin_primitives::transaction::Version(pub i32)
-pub struct bitcoin_primitives::transaction::Wtxid(_)
-pub type bitcoin_primitives::block::BlockHash::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::block::BlockHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::block::WitnessCommitment::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::block::WitnessCommitment::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::locktime::absolute::LockTime::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::locktime::absolute::LockTime::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_primitives::locktime::relative::LockTime::Error = bitcoin_primitives::locktime::relative::DisabledLockTimeError
-pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::merkle_tree::TxMerkleNode::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::merkle_tree::WitnessMerkleNode::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::taproot::TapLeafHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapLeafTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapLeafHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::taproot::TapNodeHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapBranchTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapNodeHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::taproot::TapTweakHash::Bytes = <bitcoin_hashes::sha256t::Hash<bitcoin_primitives::taproot::TapTweakTag> as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::taproot::TapTweakHash::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::transaction::Txid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::transaction::Txid::Err = hex_conservative::error::HexToArrayError
-pub type bitcoin_primitives::transaction::Wtxid::Bytes = <bitcoin_hashes::sha256d::Hash as bitcoin_hashes::Hash>::Bytes
-pub type bitcoin_primitives::transaction::Wtxid::Err = hex_conservative::error::HexToArrayError
-pub use bitcoin_primitives::Amount
-pub use bitcoin_primitives::BlockHeight
-pub use bitcoin_primitives::BlockInterval
-pub use bitcoin_primitives::FeeRate
-pub use bitcoin_primitives::SignedAmount
-pub use bitcoin_primitives::Weight
-pub use bitcoin_primitives::absolute::ConversionError
-pub use bitcoin_primitives::absolute::Height
-pub use bitcoin_primitives::absolute::LOCK_TIME_THRESHOLD
-pub use bitcoin_primitives::absolute::ParseHeightError
-pub use bitcoin_primitives::absolute::ParseTimeError
-pub use bitcoin_primitives::absolute::Time
-pub use bitcoin_primitives::amount
-pub use bitcoin_primitives::fee_rate
-pub use bitcoin_primitives::locktime::absolute::ConversionError
-pub use bitcoin_primitives::locktime::absolute::Height
-pub use bitcoin_primitives::locktime::absolute::LOCK_TIME_THRESHOLD
-pub use bitcoin_primitives::locktime::absolute::ParseHeightError
-pub use bitcoin_primitives::locktime::absolute::ParseTimeError
-pub use bitcoin_primitives::locktime::absolute::Time
-pub use bitcoin_primitives::locktime::relative::Height
-pub use bitcoin_primitives::locktime::relative::Time
-pub use bitcoin_primitives::locktime::relative::TimeOverflowError
-pub use bitcoin_primitives::relative::Height
-pub use bitcoin_primitives::relative::Time
-pub use bitcoin_primitives::relative::TimeOverflowError
-pub use bitcoin_primitives::weight
diff --git a/api/units/all-features.txt b/api/units/all-features.txt
deleted file mode 100644
index 8eb819b1f9..0000000000
--- a/api/units/all-features.txt
+++ /dev/null
@@ -1,1328 +0,0 @@
-#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
-#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::fee_rate::serde::OverflowError
-#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
-#[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
-impl bitcoin_units::Amount
-impl bitcoin_units::SignedAmount
-impl bitcoin_units::amount::Denomination
-impl bitcoin_units::amount::Display
-impl bitcoin_units::amount::OutOfRangeError
-impl bitcoin_units::amount::serde::SerdeAmount for bitcoin_units::Amount
-impl bitcoin_units::amount::serde::SerdeAmount for bitcoin_units::SignedAmount
-impl bitcoin_units::amount::serde::SerdeAmountForOpt for bitcoin_units::Amount
-impl bitcoin_units::amount::serde::SerdeAmountForOpt for bitcoin_units::SignedAmount
-impl bitcoin_units::block::BlockHeight
-impl bitcoin_units::block::BlockInterval
-impl bitcoin_units::fee_rate::FeeRate
-impl bitcoin_units::locktime::absolute::Height
-impl bitcoin_units::locktime::absolute::Time
-impl bitcoin_units::locktime::relative::Height
-impl bitcoin_units::locktime::relative::Time
-impl bitcoin_units::locktime::relative::TimeOverflowError
-impl bitcoin_units::parse::Integer for i128
-impl bitcoin_units::parse::Integer for i16
-impl bitcoin_units::parse::Integer for i32
-impl bitcoin_units::parse::Integer for i64
-impl bitcoin_units::parse::Integer for i8
-impl bitcoin_units::parse::Integer for u128
-impl bitcoin_units::parse::Integer for u16
-impl bitcoin_units::parse::Integer for u32
-impl bitcoin_units::parse::Integer for u64
-impl bitcoin_units::parse::Integer for u8
-impl bitcoin_units::weight::Weight
-impl core::clone::Clone for bitcoin_units::Amount
-impl core::clone::Clone for bitcoin_units::SignedAmount
-impl core::clone::Clone for bitcoin_units::amount::Denomination
-impl core::clone::Clone for bitcoin_units::amount::Display
-impl core::clone::Clone for bitcoin_units::amount::InputTooLargeError
-impl core::clone::Clone for bitcoin_units::amount::InvalidCharacterError
-impl core::clone::Clone for bitcoin_units::amount::MissingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::MissingDigitsError
-impl core::clone::Clone for bitcoin_units::amount::OutOfRangeError
-impl core::clone::Clone for bitcoin_units::amount::ParseAmountError
-impl core::clone::Clone for bitcoin_units::amount::ParseDenominationError
-impl core::clone::Clone for bitcoin_units::amount::ParseError
-impl core::clone::Clone for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::TooPreciseError
-impl core::clone::Clone for bitcoin_units::amount::UnknownDenominationError
-impl core::clone::Clone for bitcoin_units::block::BlockHeight
-impl core::clone::Clone for bitcoin_units::block::BlockInterval
-impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::clone::Clone for bitcoin_units::fee_rate::FeeRate
-impl core::clone::Clone for bitcoin_units::fee_rate::serde::OverflowError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ConversionError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::Time
-impl core::clone::Clone for bitcoin_units::locktime::relative::Height
-impl core::clone::Clone for bitcoin_units::locktime::relative::Time
-impl core::clone::Clone for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::clone::Clone for bitcoin_units::parse::ParseIntError
-impl core::clone::Clone for bitcoin_units::parse::PrefixedHexError
-impl core::clone::Clone for bitcoin_units::parse::UnprefixedHexError
-impl core::clone::Clone for bitcoin_units::weight::Weight
-impl core::cmp::Eq for bitcoin_units::Amount
-impl core::cmp::Eq for bitcoin_units::SignedAmount
-impl core::cmp::Eq for bitcoin_units::amount::Denomination
-impl core::cmp::Eq for bitcoin_units::amount::InputTooLargeError
-impl core::cmp::Eq for bitcoin_units::amount::InvalidCharacterError
-impl core::cmp::Eq for bitcoin_units::amount::MissingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::MissingDigitsError
-impl core::cmp::Eq for bitcoin_units::amount::OutOfRangeError
-impl core::cmp::Eq for bitcoin_units::amount::ParseAmountError
-impl core::cmp::Eq for bitcoin_units::amount::ParseDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::ParseError
-impl core::cmp::Eq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::TooPreciseError
-impl core::cmp::Eq for bitcoin_units::amount::UnknownDenominationError
-impl core::cmp::Eq for bitcoin_units::block::BlockHeight
-impl core::cmp::Eq for bitcoin_units::block::BlockInterval
-impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::cmp::Eq for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::Eq for bitcoin_units::fee_rate::serde::OverflowError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ConversionError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::Time
-impl core::cmp::Eq for bitcoin_units::locktime::relative::Height
-impl core::cmp::Eq for bitcoin_units::locktime::relative::Time
-impl core::cmp::Eq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::cmp::Eq for bitcoin_units::parse::ParseIntError
-impl core::cmp::Eq for bitcoin_units::parse::PrefixedHexError
-impl core::cmp::Eq for bitcoin_units::parse::UnprefixedHexError
-impl core::cmp::Eq for bitcoin_units::weight::Weight
-impl core::cmp::Ord for bitcoin_units::Amount
-impl core::cmp::Ord for bitcoin_units::SignedAmount
-impl core::cmp::Ord for bitcoin_units::block::BlockHeight
-impl core::cmp::Ord for bitcoin_units::block::BlockInterval
-impl core::cmp::Ord for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
-impl core::cmp::Ord for bitcoin_units::locktime::absolute::Time
-impl core::cmp::Ord for bitcoin_units::locktime::relative::Height
-impl core::cmp::Ord for bitcoin_units::locktime::relative::Time
-impl core::cmp::Ord for bitcoin_units::weight::Weight
-impl core::cmp::PartialEq for bitcoin_units::Amount
-impl core::cmp::PartialEq for bitcoin_units::SignedAmount
-impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
-impl core::cmp::PartialEq for bitcoin_units::amount::InputTooLargeError
-impl core::cmp::PartialEq for bitcoin_units::amount::InvalidCharacterError
-impl core::cmp::PartialEq for bitcoin_units::amount::MissingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::MissingDigitsError
-impl core::cmp::PartialEq for bitcoin_units::amount::OutOfRangeError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseAmountError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseError
-impl core::cmp::PartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::TooPreciseError
-impl core::cmp::PartialEq for bitcoin_units::amount::UnknownDenominationError
-impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
-impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
-impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::cmp::PartialEq for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::PartialEq for bitcoin_units::fee_rate::serde::OverflowError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ConversionError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Time
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Height
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Time
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::cmp::PartialEq for bitcoin_units::parse::ParseIntError
-impl core::cmp::PartialEq for bitcoin_units::parse::PrefixedHexError
-impl core::cmp::PartialEq for bitcoin_units::parse::UnprefixedHexError
-impl core::cmp::PartialEq for bitcoin_units::weight::Weight
-impl core::cmp::PartialOrd for bitcoin_units::Amount
-impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
-impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
-impl core::cmp::PartialOrd for bitcoin_units::block::BlockInterval
-impl core::cmp::PartialOrd for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
-impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Time
-impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
-impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
-impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
-impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
-impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
-impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::ParseAmountError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::ParseDenominationError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
-impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
-impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
-impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
-impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_units::block::BlockInterval
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::PrefixedHexError
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
-impl core::convert::From<bitcoin_units::weight::Weight> for u64
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseDenominationError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::fee_rate::serde::OverflowError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
-impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
-impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
-impl core::convert::From<u32> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
-impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<&str> for bitcoin_units::fee_rate::FeeRate
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Time
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Height
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Time
-impl core::convert::TryFrom<&str> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockHeight
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::fee_rate::FeeRate
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Time
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::Height
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::Time
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockHeight
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::fee_rate::FeeRate
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Time
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Height
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Time
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
-impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
-impl core::default::Default for bitcoin_units::Amount
-impl core::default::Default for bitcoin_units::SignedAmount
-impl core::default::Default for bitcoin_units::block::BlockInterval
-impl core::default::Default for bitcoin_units::locktime::relative::Height
-impl core::default::Default for bitcoin_units::locktime::relative::Time
-impl core::error::Error for bitcoin_units::amount::InputTooLargeError
-impl core::error::Error for bitcoin_units::amount::InvalidCharacterError
-impl core::error::Error for bitcoin_units::amount::MissingDigitsError
-impl core::error::Error for bitcoin_units::amount::OutOfRangeError
-impl core::error::Error for bitcoin_units::amount::ParseAmountError
-impl core::error::Error for bitcoin_units::amount::ParseDenominationError
-impl core::error::Error for bitcoin_units::amount::ParseError
-impl core::error::Error for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::error::Error for bitcoin_units::amount::TooPreciseError
-impl core::error::Error for bitcoin_units::amount::UnknownDenominationError
-impl core::error::Error for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::error::Error for bitcoin_units::fee_rate::serde::OverflowError
-impl core::error::Error for bitcoin_units::locktime::absolute::ConversionError
-impl core::error::Error for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::error::Error for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::error::Error for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::error::Error for bitcoin_units::parse::ParseIntError
-impl core::error::Error for bitcoin_units::parse::PrefixedHexError
-impl core::error::Error for bitcoin_units::parse::UnprefixedHexError
-impl core::fmt::Debug for bitcoin_units::Amount
-impl core::fmt::Debug for bitcoin_units::SignedAmount
-impl core::fmt::Debug for bitcoin_units::amount::Denomination
-impl core::fmt::Debug for bitcoin_units::amount::Display
-impl core::fmt::Debug for bitcoin_units::amount::InputTooLargeError
-impl core::fmt::Debug for bitcoin_units::amount::InvalidCharacterError
-impl core::fmt::Debug for bitcoin_units::amount::MissingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::MissingDigitsError
-impl core::fmt::Debug for bitcoin_units::amount::OutOfRangeError
-impl core::fmt::Debug for bitcoin_units::amount::ParseAmountError
-impl core::fmt::Debug for bitcoin_units::amount::ParseDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::ParseError
-impl core::fmt::Debug for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::TooPreciseError
-impl core::fmt::Debug for bitcoin_units::amount::UnknownDenominationError
-impl core::fmt::Debug for bitcoin_units::block::BlockHeight
-impl core::fmt::Debug for bitcoin_units::block::BlockInterval
-impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::fmt::Debug for bitcoin_units::fee_rate::FeeRate
-impl core::fmt::Debug for bitcoin_units::fee_rate::serde::OverflowError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ConversionError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::Time
-impl core::fmt::Debug for bitcoin_units::locktime::relative::Height
-impl core::fmt::Debug for bitcoin_units::locktime::relative::Time
-impl core::fmt::Debug for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::fmt::Debug for bitcoin_units::parse::ParseIntError
-impl core::fmt::Debug for bitcoin_units::parse::PrefixedHexError
-impl core::fmt::Debug for bitcoin_units::parse::UnprefixedHexError
-impl core::fmt::Debug for bitcoin_units::weight::Weight
-impl core::fmt::Display for bitcoin_units::Amount
-impl core::fmt::Display for bitcoin_units::SignedAmount
-impl core::fmt::Display for bitcoin_units::amount::Denomination
-impl core::fmt::Display for bitcoin_units::amount::Display
-impl core::fmt::Display for bitcoin_units::amount::InputTooLargeError
-impl core::fmt::Display for bitcoin_units::amount::InvalidCharacterError
-impl core::fmt::Display for bitcoin_units::amount::MissingDigitsError
-impl core::fmt::Display for bitcoin_units::amount::OutOfRangeError
-impl core::fmt::Display for bitcoin_units::amount::ParseAmountError
-impl core::fmt::Display for bitcoin_units::amount::ParseDenominationError
-impl core::fmt::Display for bitcoin_units::amount::ParseError
-impl core::fmt::Display for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::fmt::Display for bitcoin_units::amount::TooPreciseError
-impl core::fmt::Display for bitcoin_units::amount::UnknownDenominationError
-impl core::fmt::Display for bitcoin_units::block::BlockHeight
-impl core::fmt::Display for bitcoin_units::block::BlockInterval
-impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::fmt::Display for bitcoin_units::fee_rate::FeeRate
-impl core::fmt::Display for bitcoin_units::fee_rate::serde::OverflowError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ConversionError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::Time
-impl core::fmt::Display for bitcoin_units::locktime::relative::Height
-impl core::fmt::Display for bitcoin_units::locktime::relative::Time
-impl core::fmt::Display for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::fmt::Display for bitcoin_units::parse::ParseIntError
-impl core::fmt::Display for bitcoin_units::parse::PrefixedHexError
-impl core::fmt::Display for bitcoin_units::parse::UnprefixedHexError
-impl core::fmt::Display for bitcoin_units::weight::Weight
-impl core::hash::Hash for bitcoin_units::Amount
-impl core::hash::Hash for bitcoin_units::SignedAmount
-impl core::hash::Hash for bitcoin_units::amount::Denomination
-impl core::hash::Hash for bitcoin_units::block::BlockHeight
-impl core::hash::Hash for bitcoin_units::block::BlockInterval
-impl core::hash::Hash for bitcoin_units::fee_rate::FeeRate
-impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
-impl core::hash::Hash for bitcoin_units::locktime::absolute::Time
-impl core::hash::Hash for bitcoin_units::locktime::relative::Height
-impl core::hash::Hash for bitcoin_units::locktime::relative::Time
-impl core::hash::Hash for bitcoin_units::weight::Weight
-impl core::iter::traits::accum::Sum for bitcoin_units::Amount
-impl core::iter::traits::accum::Sum for bitcoin_units::SignedAmount
-impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockInterval
-impl core::iter::traits::accum::Sum for bitcoin_units::fee_rate::FeeRate
-impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
-impl core::marker::Copy for bitcoin_units::Amount
-impl core::marker::Copy for bitcoin_units::SignedAmount
-impl core::marker::Copy for bitcoin_units::amount::Denomination
-impl core::marker::Copy for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Copy for bitcoin_units::block::BlockHeight
-impl core::marker::Copy for bitcoin_units::block::BlockInterval
-impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
-impl core::marker::Copy for bitcoin_units::locktime::absolute::Time
-impl core::marker::Copy for bitcoin_units::locktime::relative::Height
-impl core::marker::Copy for bitcoin_units::locktime::relative::Time
-impl core::marker::Copy for bitcoin_units::weight::Weight
-impl core::marker::Freeze for bitcoin_units::Amount
-impl core::marker::Freeze for bitcoin_units::SignedAmount
-impl core::marker::Freeze for bitcoin_units::amount::Denomination
-impl core::marker::Freeze for bitcoin_units::amount::Display
-impl core::marker::Freeze for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Freeze for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Freeze for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Freeze for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Freeze for bitcoin_units::amount::ParseAmountError
-impl core::marker::Freeze for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::ParseError
-impl core::marker::Freeze for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::TooPreciseError
-impl core::marker::Freeze for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Freeze for bitcoin_units::block::BlockHeight
-impl core::marker::Freeze for bitcoin_units::block::BlockInterval
-impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Freeze for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Freeze for bitcoin_units::fee_rate::serde::OverflowError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::Time
-impl core::marker::Freeze for bitcoin_units::locktime::relative::Height
-impl core::marker::Freeze for bitcoin_units::locktime::relative::Time
-impl core::marker::Freeze for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Freeze for bitcoin_units::parse::ParseIntError
-impl core::marker::Freeze for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Freeze for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Freeze for bitcoin_units::weight::Weight
-impl core::marker::Send for bitcoin_units::Amount
-impl core::marker::Send for bitcoin_units::SignedAmount
-impl core::marker::Send for bitcoin_units::amount::Denomination
-impl core::marker::Send for bitcoin_units::amount::Display
-impl core::marker::Send for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Send for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Send for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Send for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Send for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Send for bitcoin_units::amount::ParseAmountError
-impl core::marker::Send for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Send for bitcoin_units::amount::ParseError
-impl core::marker::Send for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Send for bitcoin_units::amount::TooPreciseError
-impl core::marker::Send for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Send for bitcoin_units::block::BlockHeight
-impl core::marker::Send for bitcoin_units::block::BlockInterval
-impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Send for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Send for bitcoin_units::fee_rate::serde::OverflowError
-impl core::marker::Send for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Send for bitcoin_units::locktime::absolute::Height
-impl core::marker::Send for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Send for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Send for bitcoin_units::locktime::absolute::Time
-impl core::marker::Send for bitcoin_units::locktime::relative::Height
-impl core::marker::Send for bitcoin_units::locktime::relative::Time
-impl core::marker::Send for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Send for bitcoin_units::parse::ParseIntError
-impl core::marker::Send for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Send for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Send for bitcoin_units::weight::Weight
-impl core::marker::StructuralPartialEq for bitcoin_units::Amount
-impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::InputTooLargeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDigitsError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::OutOfRangeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseAmountError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::TooPreciseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
-impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
-impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::FeeRate
-impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::serde::OverflowError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Time
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Height
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Time
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::ParseIntError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::PrefixedHexError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::StructuralPartialEq for bitcoin_units::weight::Weight
-impl core::marker::Sync for bitcoin_units::Amount
-impl core::marker::Sync for bitcoin_units::SignedAmount
-impl core::marker::Sync for bitcoin_units::amount::Denomination
-impl core::marker::Sync for bitcoin_units::amount::Display
-impl core::marker::Sync for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Sync for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Sync for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Sync for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Sync for bitcoin_units::amount::ParseAmountError
-impl core::marker::Sync for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Sync for bitcoin_units::amount::ParseError
-impl core::marker::Sync for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::TooPreciseError
-impl core::marker::Sync for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Sync for bitcoin_units::block::BlockHeight
-impl core::marker::Sync for bitcoin_units::block::BlockInterval
-impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Sync for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Sync for bitcoin_units::fee_rate::serde::OverflowError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::Time
-impl core::marker::Sync for bitcoin_units::locktime::relative::Height
-impl core::marker::Sync for bitcoin_units::locktime::relative::Time
-impl core::marker::Sync for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Sync for bitcoin_units::parse::ParseIntError
-impl core::marker::Sync for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Sync for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Sync for bitcoin_units::weight::Weight
-impl core::marker::Unpin for bitcoin_units::Amount
-impl core::marker::Unpin for bitcoin_units::SignedAmount
-impl core::marker::Unpin for bitcoin_units::amount::Denomination
-impl core::marker::Unpin for bitcoin_units::amount::Display
-impl core::marker::Unpin for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Unpin for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Unpin for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Unpin for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Unpin for bitcoin_units::amount::ParseAmountError
-impl core::marker::Unpin for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::ParseError
-impl core::marker::Unpin for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::TooPreciseError
-impl core::marker::Unpin for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Unpin for bitcoin_units::block::BlockHeight
-impl core::marker::Unpin for bitcoin_units::block::BlockInterval
-impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Unpin for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Unpin for bitcoin_units::fee_rate::serde::OverflowError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::Time
-impl core::marker::Unpin for bitcoin_units::locktime::relative::Height
-impl core::marker::Unpin for bitcoin_units::locktime::relative::Time
-impl core::marker::Unpin for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Unpin for bitcoin_units::parse::ParseIntError
-impl core::marker::Unpin for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Unpin for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Unpin for bitcoin_units::weight::Weight
-impl core::ops::arith::Add for bitcoin_units::Amount
-impl core::ops::arith::Add for bitcoin_units::SignedAmount
-impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
-impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add for bitcoin_units::weight::Weight
-impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
-impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl core::ops::arith::AddAssign for bitcoin_units::Amount
-impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
-impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
-impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
-impl core::ops::arith::AddAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Div for bitcoin_units::weight::Weight
-impl core::ops::arith::Div<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::Amount
-impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
-impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Div<u64> for bitcoin_units::Amount
-impl core::ops::arith::Div<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::DivAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::DivAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::DivAssign<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::Mul<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::weight::Weight
-impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for u64
-impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
-impl core::ops::arith::Mul<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::MulAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::MulAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::MulAssign<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::Neg for bitcoin_units::SignedAmount
-impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
-impl core::ops::arith::RemAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::RemAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::Sub for bitcoin_units::Amount
-impl core::ops::arith::Sub for bitcoin_units::SignedAmount
-impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
-impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub for bitcoin_units::weight::Weight
-impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
-impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl core::ops::arith::SubAssign for bitcoin_units::Amount
-impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
-impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
-impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
-impl core::ops::arith::SubAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::SubAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::SubAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InputTooLargeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InvalidCharacterError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDigitsError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::OutOfRangeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseAmountError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::TooPreciseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::UnknownDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::FeeRate
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::serde::OverflowError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ConversionError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Time
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Height
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Time
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::ParseIntError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::PrefixedHexError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::UnprefixedHexError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::weight::Weight
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InputTooLargeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InvalidCharacterError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDigitsError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::OutOfRangeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseAmountError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::TooPreciseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::UnknownDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::FeeRate
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::serde::OverflowError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ConversionError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Time
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Height
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Time
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::ParseIntError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::PrefixedHexError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::UnprefixedHexError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::weight::Weight
-impl core::str::traits::FromStr for bitcoin_units::Amount
-impl core::str::traits::FromStr for bitcoin_units::SignedAmount
-impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
-impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
-impl core::str::traits::FromStr for bitcoin_units::block::BlockInterval
-impl core::str::traits::FromStr for bitcoin_units::fee_rate::FeeRate
-impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
-impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Time
-impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Height
-impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Time
-impl core::str::traits::FromStr for bitcoin_units::weight::Weight
-impl serde::ser::Serialize for bitcoin_units::block::BlockHeight
-impl serde::ser::Serialize for bitcoin_units::block::BlockInterval
-impl serde::ser::Serialize for bitcoin_units::locktime::absolute::Height
-impl serde::ser::Serialize for bitcoin_units::locktime::absolute::Time
-impl serde::ser::Serialize for bitcoin_units::locktime::relative::Height
-impl serde::ser::Serialize for bitcoin_units::locktime::relative::Time
-impl serde::ser::Serialize for bitcoin_units::weight::Weight
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::Amount
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::SignedAmount
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::amount::Denomination
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::block::BlockHeight
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::block::BlockInterval
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::fee_rate::FeeRate
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::absolute::Height
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::absolute::Time
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::relative::Height
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::locktime::relative::Time
-impl<'a> arbitrary::Arbitrary<'a> for bitcoin_units::weight::Weight
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Amount> for bitcoin_units::Amount
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockHeight
-impl<'de> serde::de::Deserialize<'de> for bitcoin_units::block::BlockInterval
-impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::absolute::Height
-impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::absolute::Time
-impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::relative::Height
-impl<'de> serde::de::Deserialize<'de> for bitcoin_units::locktime::relative::Time
-impl<'de> serde::de::Deserialize<'de> for bitcoin_units::weight::Weight
-impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::Amount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::Amount>
-impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::SignedAmount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::SignedAmount>
-pub bitcoin_units::amount::Denomination::Bit
-pub bitcoin_units::amount::Denomination::Bitcoin
-pub bitcoin_units::amount::Denomination::CentiBitcoin
-pub bitcoin_units::amount::Denomination::MicroBitcoin
-pub bitcoin_units::amount::Denomination::MilliBitcoin
-pub bitcoin_units::amount::Denomination::Satoshi
-pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
-pub const bitcoin_units::Amount::FIFTY_BTC: Self
-pub const bitcoin_units::Amount::MAX: Self
-pub const bitcoin_units::Amount::MAX_MONEY: Self
-pub const bitcoin_units::Amount::MIN: Self
-pub const bitcoin_units::Amount::ONE_BTC: Self
-pub const bitcoin_units::Amount::ONE_SAT: Self
-pub const bitcoin_units::Amount::SIZE: usize
-pub const bitcoin_units::Amount::ZERO: Self
-pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
-pub const bitcoin_units::SignedAmount::MAX: Self
-pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
-pub const bitcoin_units::SignedAmount::MIN: Self
-pub const bitcoin_units::SignedAmount::ONE_BTC: Self
-pub const bitcoin_units::SignedAmount::ONE_SAT: Self
-pub const bitcoin_units::SignedAmount::ZERO: Self
-pub const bitcoin_units::amount::Denomination::BTC: Self
-pub const bitcoin_units::amount::Denomination::SAT: Self
-pub const bitcoin_units::block::BlockHeight::MAX: Self
-pub const bitcoin_units::block::BlockHeight::MIN: Self
-pub const bitcoin_units::block::BlockHeight::ZERO: Self
-pub const bitcoin_units::block::BlockInterval::MAX: Self
-pub const bitcoin_units::block::BlockInterval::MIN: Self
-pub const bitcoin_units::block::BlockInterval::ZERO: Self
-pub const bitcoin_units::fee_rate::FeeRate::BROADCAST_MIN: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::DUST: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::MAX: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::MIN: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::ZERO: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::locktime::absolute::Height::MAX: Self
-pub const bitcoin_units::locktime::absolute::Height::MIN: Self
-pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
-pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
-pub const bitcoin_units::locktime::absolute::Time::MAX: Self
-pub const bitcoin_units::locktime::absolute::Time::MIN: Self
-pub const bitcoin_units::locktime::relative::Height::MAX: Self
-pub const bitcoin_units::locktime::relative::Height::MIN: Self
-pub const bitcoin_units::locktime::relative::Height::ZERO: Self
-pub const bitcoin_units::locktime::relative::Time::MAX: Self
-pub const bitcoin_units::locktime::relative::Time::MIN: Self
-pub const bitcoin_units::locktime::relative::Time::ZERO: Self
-pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
-pub const bitcoin_units::weight::Weight::MAX: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MAX_BLOCK: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MIN: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MIN_TRANSACTION: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
-pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
-pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
-pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_floor(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
-pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
-pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
-pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::from_sat_unchecked(satoshi: u64) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::to_sat(self) -> u64
-pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::from_sat_unchecked(satoshi: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
-pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
-pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb_unchecked(sat_vb: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_kwu(self) -> u64
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_ceil(self) -> u64
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_floor(self) -> u64
-pub const fn bitcoin_units::locktime::absolute::Height::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Height, bitcoin_units::locktime::absolute::ConversionError>
-pub const fn bitcoin_units::locktime::absolute::Height::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::absolute::Time::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Time, bitcoin_units::locktime::absolute::ConversionError>
-pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
-pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
-pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
-pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
-pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_mul_by_fee_rate(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
-pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::to_kwu_ceil(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
-pub fn &bitcoin_units::Amount::add(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::sub(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::add(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::add(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::sub(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
-pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
-pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: &bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
-pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
-pub fn bitcoin_units::Amount::default() -> Self
-pub fn bitcoin_units::Amount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::Amount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::Amount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
-pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseError>
-pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
-pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
-pub fn bitcoin_units::Amount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_str<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
-pub fn bitcoin_units::Amount::to_btc(self) -> f64
-pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
-pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::Amount::type_prefix(_: bitcoin_units::amount::serde::private::Token) -> &'static str
-pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
-pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
-pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
-pub fn bitcoin_units::SignedAmount::default() -> Self
-pub fn bitcoin_units::SignedAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::SignedAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::SignedAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
-pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
-pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
-pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
-pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseError>
-pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
-pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
-pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
-pub fn bitcoin_units::SignedAmount::mul_assign(&mut self, rhs: i64)
-pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
-pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
-pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
-pub fn bitcoin_units::SignedAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::SignedAmount::signum(self) -> i64
-pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
-pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
-pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
-pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::type_prefix(_: bitcoin_units::amount::serde::private::Token) -> &'static str
-pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
-pub fn bitcoin_units::amount::CheckedSum::checked_sum(self) -> core::option::Option<R>
-pub fn bitcoin_units::amount::Denomination::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
-pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
-pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
-pub fn bitcoin_units::amount::InputTooLargeError::clone(&self) -> bitcoin_units::amount::InputTooLargeError
-pub fn bitcoin_units::amount::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::InputTooLargeError) -> bool
-pub fn bitcoin_units::amount::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::InvalidCharacterError
-pub fn bitcoin_units::amount::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::InvalidCharacterError) -> bool
-pub fn bitcoin_units::amount::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::MissingDenominationError::clone(&self) -> bitcoin_units::amount::MissingDenominationError
-pub fn bitcoin_units::amount::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::MissingDenominationError) -> bool
-pub fn bitcoin_units::amount::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::MissingDigitsError::clone(&self) -> bitcoin_units::amount::MissingDigitsError
-pub fn bitcoin_units::amount::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::MissingDigitsError) -> bool
-pub fn bitcoin_units::amount::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::OutOfRangeError::clone(&self) -> bitcoin_units::amount::OutOfRangeError
-pub fn bitcoin_units::amount::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::OutOfRangeError) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::OutOfRangeError::is_above_max(self) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::is_below_min(self) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::valid_range(self) -> (i64, u64)
-pub fn bitcoin_units::amount::ParseAmountError::clone(&self) -> bitcoin_units::amount::ParseAmountError
-pub fn bitcoin_units::amount::ParseAmountError::eq(&self, other: &bitcoin_units::amount::ParseAmountError) -> bool
-pub fn bitcoin_units::amount::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseAmountError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::ParseDenominationError::clone(&self) -> bitcoin_units::amount::ParseDenominationError
-pub fn bitcoin_units::amount::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::ParseDenominationError) -> bool
-pub fn bitcoin_units::amount::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseDenominationError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::ParseDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::ParseError::clone(&self) -> bitcoin_units::amount::ParseError
-pub fn bitcoin_units::amount::ParseError::eq(&self, other: &bitcoin_units::amount::ParseError) -> bool
-pub fn bitcoin_units::amount::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseAmountError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseDenominationError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::ParseError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::PossiblyConfusingDenominationError
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::PossiblyConfusingDenominationError) -> bool
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::TooPreciseError::clone(&self) -> bitcoin_units::amount::TooPreciseError
-pub fn bitcoin_units::amount::TooPreciseError::eq(&self, other: &bitcoin_units::amount::TooPreciseError) -> bool
-pub fn bitcoin_units::amount::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::UnknownDenominationError
-pub fn bitcoin_units::amount::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::UnknownDenominationError) -> bool
-pub fn bitcoin_units::amount::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::UnknownDenominationError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::amount::serde::SerdeAmount::des_btc<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::des_sat<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::des_str<'d, D: serde::de::Deserializer<'d>>(d: D, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::ser_btc<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::ser_sat<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmount::ser_str<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_btc_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_sat_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::ser_str_opt<S: serde::ser::Serializer>(self, s: S, _: bitcoin_units::amount::serde::private::Token) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::SerdeAmountForOpt::type_prefix(_: bitcoin_units::amount::serde::private::Token) -> &'static str
-pub fn bitcoin_units::amount::serde::as_btc::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::as_btc::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::as_btc::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::as_btc::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::as_sat::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::as_sat::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::as_sat::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::as_sat::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::as_str::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmount, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<A, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::as_str::opt::deserialize<'d, A: bitcoin_units::amount::serde::SerdeAmountForOpt, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<A>, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::amount::serde::as_str::opt::serialize<A: bitcoin_units::amount::serde::SerdeAmountForOpt, S: serde::ser::Serializer>(a: &core::option::Option<A>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::amount::serde::as_str::serialize<A: bitcoin_units::amount::serde::SerdeAmount, S: serde::ser::Serializer>(a: &A, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
-pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
-pub fn bitcoin_units::block::BlockHeight::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
-pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
-pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
-pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::block::BlockHeight::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
-pub fn bitcoin_units::block::BlockInterval::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
-pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
-pub fn bitcoin_units::block::BlockInterval::default() -> bitcoin_units::block::BlockInterval
-pub fn bitcoin_units::block::BlockInterval::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
-pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::block::BlockInterval::from(h: bitcoin_units::locktime::relative::Height) -> Self
-pub fn bitcoin_units::block::BlockInterval::from(inner: u32) -> Self
-pub fn bitcoin_units::block::BlockInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::block::BlockInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::block::BlockInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::block::BlockInterval::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_units::block::BlockInterval::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
-pub fn bitcoin_units::block::BlockInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::block::BlockInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::block::BlockInterval>
-pub fn bitcoin_units::block::BlockInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
-pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
-pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
-pub fn bitcoin_units::fee_rate::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::fee_wu(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb(sat_vb: u64) -> core::option::Option<Self>
-pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
-pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
-pub fn bitcoin_units::fee_rate::FeeRate::to_fee(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::fee_rate::serde::OverflowError::clone(&self) -> bitcoin_units::fee_rate::serde::OverflowError
-pub fn bitcoin_units::fee_rate::serde::OverflowError::eq(&self, other: &bitcoin_units::fee_rate::serde::OverflowError) -> bool
-pub fn bitcoin_units::fee_rate::serde::OverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::serde::OverflowError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::fee_rate::FeeRate, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::fee_rate::FeeRate>, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::fee_rate::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_kwu::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::fee_rate::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::fee_rate::FeeRate, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::fee_rate::FeeRate>, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::fee_rate::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::fee_rate::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<bitcoin_units::fee_rate::FeeRate, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt::deserialize<'d, D: serde::de::Deserializer<'d>>(d: D) -> core::result::Result<core::option::Option<bitcoin_units::fee_rate::FeeRate>, <D as serde::de::Deserializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt::serialize<S: serde::ser::Serializer>(f: &core::option::Option<bitcoin_units::fee_rate::FeeRate>, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::serialize<S: serde::ser::Serializer>(f: &bitcoin_units::fee_rate::FeeRate, s: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error>
-pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::ConversionError
-pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
-pub fn bitcoin_units::locktime::absolute::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::ConversionError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::locktime::absolute::Height::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
-pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::absolute::Height::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
-pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
-pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseHeightError>
-pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::absolute::Height::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
-pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::ParseHeightError
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseHeightError) -> bool
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::ParseTimeError
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseTimeError) -> bool
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::locktime::absolute::Time::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::locktime::absolute::Time::clone(&self) -> bitcoin_units::locktime::absolute::Time
-pub fn bitcoin_units::locktime::absolute::Time::cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::absolute::Time::deserialize<D>(deserializer: D) -> core::result::Result<Self, <D as serde::de::Deserializer>::Error> where D: serde::de::Deserializer<'de>
-pub fn bitcoin_units::locktime::absolute::Time::eq(&self, other: &bitcoin_units::locktime::absolute::Time) -> bool
-pub fn bitcoin_units::locktime::absolute::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Time::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseTimeError>
-pub fn bitcoin_units::locktime::absolute::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::absolute::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::absolute::Time::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::absolute::Time::serialize<S>(&self, serializer: S) -> core::result::Result<<S as serde::ser::Serializer>::Ok, <S as serde::ser::Serializer>::Error> where S: serde::ser::Serializer
-pub fn bitcoin_units::locktime::absolute::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::locktime::relative::Height::clone(&self) -> bitcoin_units::locktime::relative::Height
-pub fn bitcoin_units::locktime::relative::Height::cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::relative::Height::default() -> bitcoin_units::locktime::relative::Height
-pub fn bitcoin_units::locktime::relative::Height::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_units::locktime::relative::Height::eq(&self, other: &bitcoin_units::locktime::relative::Height) -> bool
-pub fn bitcoin_units::locktime::relative::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::Height::from(value: u16) -> Self
-pub fn bitcoin_units::locktime::relative::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::relative::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::relative::Height::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::relative::Height::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_units::locktime::relative::Height::try_from(h: bitcoin_units::block::BlockInterval) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Time::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::locktime::relative::Time::clone(&self) -> bitcoin_units::locktime::relative::Time
-pub fn bitcoin_units::locktime::relative::Time::cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::relative::Time::default() -> bitcoin_units::locktime::relative::Time
-pub fn bitcoin_units::locktime::relative::Time::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_units::locktime::relative::Time::eq(&self, other: &bitcoin_units::locktime::relative::Time) -> bool
-pub fn bitcoin_units::locktime::relative::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::relative::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::relative::Time::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::relative::Time::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_units::locktime::relative::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::TimeOverflowError
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::TimeOverflowError) -> bool
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::new(seconds: u32) -> Self
-pub fn bitcoin_units::parse::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
-pub fn bitcoin_units::parse::ParseIntError::clone(&self) -> bitcoin_units::parse::ParseIntError
-pub fn bitcoin_units::parse::ParseIntError::eq(&self, other: &bitcoin_units::parse::ParseIntError) -> bool
-pub fn bitcoin_units::parse::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::ParseIntError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::parse::PrefixedHexError::clone(&self) -> bitcoin_units::parse::PrefixedHexError
-pub fn bitcoin_units::parse::PrefixedHexError::eq(&self, other: &bitcoin_units::parse::PrefixedHexError) -> bool
-pub fn bitcoin_units::parse::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::PrefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
-pub fn bitcoin_units::parse::PrefixedHexError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::parse::PrefixedHexError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::parse::UnprefixedHexError::clone(&self) -> bitcoin_units::parse::UnprefixedHexError
-pub fn bitcoin_units::parse::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse::UnprefixedHexError) -> bool
-pub fn bitcoin_units::parse::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::UnprefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
-pub fn bitcoin_units::parse::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::parse::UnprefixedHexError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)>
-pub fn bitcoin_units::parse::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::int_from_box<T: bitcoin_units::parse::Integer>(s: alloc::boxed::Box<str>) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::int_from_str<T: bitcoin_units::parse::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::int_from_string<T: bitcoin_units::parse::Integer>(s: alloc::string::String) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::arbitrary(u: &mut arbitrary::unstructured::Unstructured<'a>) -> arbitrary::error::Result<Self>
-pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
-pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
-pub fn bitcoin_units::weight::Weight::deserialize<__D>(__deserializer: __D) -> core::result::Result<Self, <__D as serde::de::Deserializer>::Error> where __D: serde::de::Deserializer<'de>
-pub fn bitcoin_units::weight::Weight::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::div(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::weight::Weight::div_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::weight::Weight::eq(&self, other: &bitcoin_units::weight::Weight) -> bool
-pub fn bitcoin_units::weight::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::weight::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
-pub fn bitcoin_units::weight::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::weight::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::weight::Weight::mul(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::weight::Weight::serialize<__S>(&self, __serializer: __S) -> core::result::Result<<__S as serde::ser::Serializer>::Ok, <__S as serde::ser::Serializer>::Error> where __S: serde::ser::Serializer
-pub fn bitcoin_units::weight::Weight::sub(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
-pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
-pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::weight::Weight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::weight::Weight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse::ParseIntError) -> Self
-pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
-pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
-pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
-pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
-pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub mod bitcoin_units
-pub mod bitcoin_units::amount
-pub mod bitcoin_units::amount::serde
-pub mod bitcoin_units::amount::serde::as_btc
-pub mod bitcoin_units::amount::serde::as_btc::opt
-pub mod bitcoin_units::amount::serde::as_sat
-pub mod bitcoin_units::amount::serde::as_sat::opt
-pub mod bitcoin_units::amount::serde::as_str
-pub mod bitcoin_units::amount::serde::as_str::opt
-pub mod bitcoin_units::block
-pub mod bitcoin_units::fee_rate
-pub mod bitcoin_units::fee_rate::serde
-pub mod bitcoin_units::fee_rate::serde::as_sat_per_kwu
-pub mod bitcoin_units::fee_rate::serde::as_sat_per_kwu::opt
-pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil
-pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_ceil::opt
-pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_floor
-pub mod bitcoin_units::fee_rate::serde::as_sat_per_vb_floor::opt
-pub mod bitcoin_units::locktime
-pub mod bitcoin_units::locktime::absolute
-pub mod bitcoin_units::locktime::relative
-pub mod bitcoin_units::parse
-pub mod bitcoin_units::weight
-pub struct bitcoin_units::Amount(_)
-pub struct bitcoin_units::BlockHeight(pub u32)
-pub struct bitcoin_units::BlockInterval(pub u32)
-pub struct bitcoin_units::FeeRate(_)
-pub struct bitcoin_units::SignedAmount(_)
-pub struct bitcoin_units::Weight(_)
-pub struct bitcoin_units::amount::Amount(_)
-pub struct bitcoin_units::amount::Display
-pub struct bitcoin_units::amount::InputTooLargeError
-pub struct bitcoin_units::amount::InvalidCharacterError
-pub struct bitcoin_units::amount::MissingDigitsError
-pub struct bitcoin_units::amount::OutOfRangeError
-pub struct bitcoin_units::amount::ParseAmountError(_)
-pub struct bitcoin_units::amount::ParseError(_)
-pub struct bitcoin_units::amount::SignedAmount(_)
-pub struct bitcoin_units::amount::TooPreciseError
-pub struct bitcoin_units::block::BlockHeight(pub u32)
-pub struct bitcoin_units::block::BlockInterval(pub u32)
-pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
-pub struct bitcoin_units::fee_rate::FeeRate(_)
-pub struct bitcoin_units::locktime::absolute::Height(_)
-pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
-pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
-pub struct bitcoin_units::locktime::absolute::Time(_)
-pub struct bitcoin_units::locktime::relative::Height(_)
-pub struct bitcoin_units::locktime::relative::Time(_)
-pub struct bitcoin_units::locktime::relative::TimeOverflowError
-pub struct bitcoin_units::parse::PrefixedHexError(_)
-pub struct bitcoin_units::parse::UnprefixedHexError(_)
-pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: bitcoin_units::amount::sealed::Sealed<R>
-pub trait bitcoin_units::amount::serde::SerdeAmount: core::marker::Copy + core::marker::Sized
-pub trait bitcoin_units::amount::serde::SerdeAmountForOpt: core::marker::Copy + core::marker::Sized + bitcoin_units::amount::serde::SerdeAmount
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse::sealed::Sealed
-pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
-pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
-pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
-pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
-pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::Amount::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
-pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
-pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockInterval
-pub type bitcoin_units::block::BlockInterval::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockInterval::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockInterval::Output = bitcoin_units::block::BlockInterval
-pub type bitcoin_units::fee_rate::FeeRate::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::fee_rate::FeeRate::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::Amount
-pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::ParseHeightError
-pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ConversionError
-pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ParseHeightError
-pub type bitcoin_units::locktime::absolute::Time::Err = bitcoin_units::locktime::absolute::ParseTimeError
-pub type bitcoin_units::locktime::absolute::Time::Error = bitcoin_units::locktime::absolute::ParseTimeError
-pub type bitcoin_units::locktime::relative::Height::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::block::TooBigForRelativeBlockHeightError
-pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Time::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Time::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Output = bitcoin_units::Amount
-pub type bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::weight::Weight::Output = u64
-pub type u64::Output = bitcoin_units::weight::Weight
diff --git a/api/units/alloc-only.txt b/api/units/alloc-only.txt
deleted file mode 100644
index 37c97385c3..0000000000
--- a/api/units/alloc-only.txt
+++ /dev/null
@@ -1,1156 +0,0 @@
-#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
-#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
-#[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
-impl bitcoin_units::Amount
-impl bitcoin_units::SignedAmount
-impl bitcoin_units::amount::Denomination
-impl bitcoin_units::amount::Display
-impl bitcoin_units::amount::OutOfRangeError
-impl bitcoin_units::block::BlockHeight
-impl bitcoin_units::block::BlockInterval
-impl bitcoin_units::fee_rate::FeeRate
-impl bitcoin_units::locktime::absolute::Height
-impl bitcoin_units::locktime::absolute::Time
-impl bitcoin_units::locktime::relative::Height
-impl bitcoin_units::locktime::relative::Time
-impl bitcoin_units::locktime::relative::TimeOverflowError
-impl bitcoin_units::parse::Integer for i128
-impl bitcoin_units::parse::Integer for i16
-impl bitcoin_units::parse::Integer for i32
-impl bitcoin_units::parse::Integer for i64
-impl bitcoin_units::parse::Integer for i8
-impl bitcoin_units::parse::Integer for u128
-impl bitcoin_units::parse::Integer for u16
-impl bitcoin_units::parse::Integer for u32
-impl bitcoin_units::parse::Integer for u64
-impl bitcoin_units::parse::Integer for u8
-impl bitcoin_units::weight::Weight
-impl core::clone::Clone for bitcoin_units::Amount
-impl core::clone::Clone for bitcoin_units::SignedAmount
-impl core::clone::Clone for bitcoin_units::amount::Denomination
-impl core::clone::Clone for bitcoin_units::amount::Display
-impl core::clone::Clone for bitcoin_units::amount::InputTooLargeError
-impl core::clone::Clone for bitcoin_units::amount::InvalidCharacterError
-impl core::clone::Clone for bitcoin_units::amount::MissingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::MissingDigitsError
-impl core::clone::Clone for bitcoin_units::amount::OutOfRangeError
-impl core::clone::Clone for bitcoin_units::amount::ParseAmountError
-impl core::clone::Clone for bitcoin_units::amount::ParseDenominationError
-impl core::clone::Clone for bitcoin_units::amount::ParseError
-impl core::clone::Clone for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::TooPreciseError
-impl core::clone::Clone for bitcoin_units::amount::UnknownDenominationError
-impl core::clone::Clone for bitcoin_units::block::BlockHeight
-impl core::clone::Clone for bitcoin_units::block::BlockInterval
-impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::clone::Clone for bitcoin_units::fee_rate::FeeRate
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ConversionError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::Time
-impl core::clone::Clone for bitcoin_units::locktime::relative::Height
-impl core::clone::Clone for bitcoin_units::locktime::relative::Time
-impl core::clone::Clone for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::clone::Clone for bitcoin_units::parse::ParseIntError
-impl core::clone::Clone for bitcoin_units::parse::PrefixedHexError
-impl core::clone::Clone for bitcoin_units::parse::UnprefixedHexError
-impl core::clone::Clone for bitcoin_units::weight::Weight
-impl core::cmp::Eq for bitcoin_units::Amount
-impl core::cmp::Eq for bitcoin_units::SignedAmount
-impl core::cmp::Eq for bitcoin_units::amount::Denomination
-impl core::cmp::Eq for bitcoin_units::amount::InputTooLargeError
-impl core::cmp::Eq for bitcoin_units::amount::InvalidCharacterError
-impl core::cmp::Eq for bitcoin_units::amount::MissingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::MissingDigitsError
-impl core::cmp::Eq for bitcoin_units::amount::OutOfRangeError
-impl core::cmp::Eq for bitcoin_units::amount::ParseAmountError
-impl core::cmp::Eq for bitcoin_units::amount::ParseDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::ParseError
-impl core::cmp::Eq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::TooPreciseError
-impl core::cmp::Eq for bitcoin_units::amount::UnknownDenominationError
-impl core::cmp::Eq for bitcoin_units::block::BlockHeight
-impl core::cmp::Eq for bitcoin_units::block::BlockInterval
-impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::cmp::Eq for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ConversionError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::Time
-impl core::cmp::Eq for bitcoin_units::locktime::relative::Height
-impl core::cmp::Eq for bitcoin_units::locktime::relative::Time
-impl core::cmp::Eq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::cmp::Eq for bitcoin_units::parse::ParseIntError
-impl core::cmp::Eq for bitcoin_units::parse::PrefixedHexError
-impl core::cmp::Eq for bitcoin_units::parse::UnprefixedHexError
-impl core::cmp::Eq for bitcoin_units::weight::Weight
-impl core::cmp::Ord for bitcoin_units::Amount
-impl core::cmp::Ord for bitcoin_units::SignedAmount
-impl core::cmp::Ord for bitcoin_units::block::BlockHeight
-impl core::cmp::Ord for bitcoin_units::block::BlockInterval
-impl core::cmp::Ord for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
-impl core::cmp::Ord for bitcoin_units::locktime::absolute::Time
-impl core::cmp::Ord for bitcoin_units::locktime::relative::Height
-impl core::cmp::Ord for bitcoin_units::locktime::relative::Time
-impl core::cmp::Ord for bitcoin_units::weight::Weight
-impl core::cmp::PartialEq for bitcoin_units::Amount
-impl core::cmp::PartialEq for bitcoin_units::SignedAmount
-impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
-impl core::cmp::PartialEq for bitcoin_units::amount::InputTooLargeError
-impl core::cmp::PartialEq for bitcoin_units::amount::InvalidCharacterError
-impl core::cmp::PartialEq for bitcoin_units::amount::MissingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::MissingDigitsError
-impl core::cmp::PartialEq for bitcoin_units::amount::OutOfRangeError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseAmountError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseError
-impl core::cmp::PartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::TooPreciseError
-impl core::cmp::PartialEq for bitcoin_units::amount::UnknownDenominationError
-impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
-impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
-impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::cmp::PartialEq for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ConversionError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Time
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Height
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Time
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::cmp::PartialEq for bitcoin_units::parse::ParseIntError
-impl core::cmp::PartialEq for bitcoin_units::parse::PrefixedHexError
-impl core::cmp::PartialEq for bitcoin_units::parse::UnprefixedHexError
-impl core::cmp::PartialEq for bitcoin_units::weight::Weight
-impl core::cmp::PartialOrd for bitcoin_units::Amount
-impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
-impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
-impl core::cmp::PartialOrd for bitcoin_units::block::BlockInterval
-impl core::cmp::PartialOrd for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
-impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Time
-impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
-impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
-impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
-impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
-impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
-impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::ParseAmountError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::ParseDenominationError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
-impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
-impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
-impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
-impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_units::block::BlockInterval
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::PrefixedHexError
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
-impl core::convert::From<bitcoin_units::weight::Weight> for u64
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseDenominationError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
-impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
-impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
-impl core::convert::From<u32> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
-impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<&str> for bitcoin_units::fee_rate::FeeRate
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Time
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Height
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Time
-impl core::convert::TryFrom<&str> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockHeight
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::fee_rate::FeeRate
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::absolute::Time
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::Height
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::locktime::relative::Time
-impl core::convert::TryFrom<alloc::boxed::Box<str>> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockHeight
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::fee_rate::FeeRate
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::absolute::Time
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Height
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::locktime::relative::Time
-impl core::convert::TryFrom<alloc::string::String> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
-impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
-impl core::default::Default for bitcoin_units::Amount
-impl core::default::Default for bitcoin_units::SignedAmount
-impl core::default::Default for bitcoin_units::block::BlockInterval
-impl core::default::Default for bitcoin_units::locktime::relative::Height
-impl core::default::Default for bitcoin_units::locktime::relative::Time
-impl core::fmt::Debug for bitcoin_units::Amount
-impl core::fmt::Debug for bitcoin_units::SignedAmount
-impl core::fmt::Debug for bitcoin_units::amount::Denomination
-impl core::fmt::Debug for bitcoin_units::amount::Display
-impl core::fmt::Debug for bitcoin_units::amount::InputTooLargeError
-impl core::fmt::Debug for bitcoin_units::amount::InvalidCharacterError
-impl core::fmt::Debug for bitcoin_units::amount::MissingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::MissingDigitsError
-impl core::fmt::Debug for bitcoin_units::amount::OutOfRangeError
-impl core::fmt::Debug for bitcoin_units::amount::ParseAmountError
-impl core::fmt::Debug for bitcoin_units::amount::ParseDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::ParseError
-impl core::fmt::Debug for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::TooPreciseError
-impl core::fmt::Debug for bitcoin_units::amount::UnknownDenominationError
-impl core::fmt::Debug for bitcoin_units::block::BlockHeight
-impl core::fmt::Debug for bitcoin_units::block::BlockInterval
-impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::fmt::Debug for bitcoin_units::fee_rate::FeeRate
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ConversionError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::Time
-impl core::fmt::Debug for bitcoin_units::locktime::relative::Height
-impl core::fmt::Debug for bitcoin_units::locktime::relative::Time
-impl core::fmt::Debug for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::fmt::Debug for bitcoin_units::parse::ParseIntError
-impl core::fmt::Debug for bitcoin_units::parse::PrefixedHexError
-impl core::fmt::Debug for bitcoin_units::parse::UnprefixedHexError
-impl core::fmt::Debug for bitcoin_units::weight::Weight
-impl core::fmt::Display for bitcoin_units::Amount
-impl core::fmt::Display for bitcoin_units::SignedAmount
-impl core::fmt::Display for bitcoin_units::amount::Denomination
-impl core::fmt::Display for bitcoin_units::amount::Display
-impl core::fmt::Display for bitcoin_units::amount::InputTooLargeError
-impl core::fmt::Display for bitcoin_units::amount::InvalidCharacterError
-impl core::fmt::Display for bitcoin_units::amount::MissingDigitsError
-impl core::fmt::Display for bitcoin_units::amount::OutOfRangeError
-impl core::fmt::Display for bitcoin_units::amount::ParseAmountError
-impl core::fmt::Display for bitcoin_units::amount::ParseDenominationError
-impl core::fmt::Display for bitcoin_units::amount::ParseError
-impl core::fmt::Display for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::fmt::Display for bitcoin_units::amount::TooPreciseError
-impl core::fmt::Display for bitcoin_units::amount::UnknownDenominationError
-impl core::fmt::Display for bitcoin_units::block::BlockHeight
-impl core::fmt::Display for bitcoin_units::block::BlockInterval
-impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::fmt::Display for bitcoin_units::fee_rate::FeeRate
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ConversionError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::Time
-impl core::fmt::Display for bitcoin_units::locktime::relative::Height
-impl core::fmt::Display for bitcoin_units::locktime::relative::Time
-impl core::fmt::Display for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::fmt::Display for bitcoin_units::parse::ParseIntError
-impl core::fmt::Display for bitcoin_units::parse::PrefixedHexError
-impl core::fmt::Display for bitcoin_units::parse::UnprefixedHexError
-impl core::fmt::Display for bitcoin_units::weight::Weight
-impl core::hash::Hash for bitcoin_units::Amount
-impl core::hash::Hash for bitcoin_units::SignedAmount
-impl core::hash::Hash for bitcoin_units::amount::Denomination
-impl core::hash::Hash for bitcoin_units::block::BlockHeight
-impl core::hash::Hash for bitcoin_units::block::BlockInterval
-impl core::hash::Hash for bitcoin_units::fee_rate::FeeRate
-impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
-impl core::hash::Hash for bitcoin_units::locktime::absolute::Time
-impl core::hash::Hash for bitcoin_units::locktime::relative::Height
-impl core::hash::Hash for bitcoin_units::locktime::relative::Time
-impl core::hash::Hash for bitcoin_units::weight::Weight
-impl core::iter::traits::accum::Sum for bitcoin_units::Amount
-impl core::iter::traits::accum::Sum for bitcoin_units::SignedAmount
-impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockInterval
-impl core::iter::traits::accum::Sum for bitcoin_units::fee_rate::FeeRate
-impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
-impl core::marker::Copy for bitcoin_units::Amount
-impl core::marker::Copy for bitcoin_units::SignedAmount
-impl core::marker::Copy for bitcoin_units::amount::Denomination
-impl core::marker::Copy for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Copy for bitcoin_units::block::BlockHeight
-impl core::marker::Copy for bitcoin_units::block::BlockInterval
-impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
-impl core::marker::Copy for bitcoin_units::locktime::absolute::Time
-impl core::marker::Copy for bitcoin_units::locktime::relative::Height
-impl core::marker::Copy for bitcoin_units::locktime::relative::Time
-impl core::marker::Copy for bitcoin_units::weight::Weight
-impl core::marker::Freeze for bitcoin_units::Amount
-impl core::marker::Freeze for bitcoin_units::SignedAmount
-impl core::marker::Freeze for bitcoin_units::amount::Denomination
-impl core::marker::Freeze for bitcoin_units::amount::Display
-impl core::marker::Freeze for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Freeze for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Freeze for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Freeze for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Freeze for bitcoin_units::amount::ParseAmountError
-impl core::marker::Freeze for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::ParseError
-impl core::marker::Freeze for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::TooPreciseError
-impl core::marker::Freeze for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Freeze for bitcoin_units::block::BlockHeight
-impl core::marker::Freeze for bitcoin_units::block::BlockInterval
-impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Freeze for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::Time
-impl core::marker::Freeze for bitcoin_units::locktime::relative::Height
-impl core::marker::Freeze for bitcoin_units::locktime::relative::Time
-impl core::marker::Freeze for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Freeze for bitcoin_units::parse::ParseIntError
-impl core::marker::Freeze for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Freeze for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Freeze for bitcoin_units::weight::Weight
-impl core::marker::Send for bitcoin_units::Amount
-impl core::marker::Send for bitcoin_units::SignedAmount
-impl core::marker::Send for bitcoin_units::amount::Denomination
-impl core::marker::Send for bitcoin_units::amount::Display
-impl core::marker::Send for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Send for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Send for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Send for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Send for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Send for bitcoin_units::amount::ParseAmountError
-impl core::marker::Send for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Send for bitcoin_units::amount::ParseError
-impl core::marker::Send for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Send for bitcoin_units::amount::TooPreciseError
-impl core::marker::Send for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Send for bitcoin_units::block::BlockHeight
-impl core::marker::Send for bitcoin_units::block::BlockInterval
-impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Send for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Send for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Send for bitcoin_units::locktime::absolute::Height
-impl core::marker::Send for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Send for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Send for bitcoin_units::locktime::absolute::Time
-impl core::marker::Send for bitcoin_units::locktime::relative::Height
-impl core::marker::Send for bitcoin_units::locktime::relative::Time
-impl core::marker::Send for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Send for bitcoin_units::parse::ParseIntError
-impl core::marker::Send for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Send for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Send for bitcoin_units::weight::Weight
-impl core::marker::StructuralPartialEq for bitcoin_units::Amount
-impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::InputTooLargeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDigitsError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::OutOfRangeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseAmountError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::TooPreciseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
-impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
-impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::FeeRate
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Time
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Height
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Time
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::ParseIntError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::PrefixedHexError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::StructuralPartialEq for bitcoin_units::weight::Weight
-impl core::marker::Sync for bitcoin_units::Amount
-impl core::marker::Sync for bitcoin_units::SignedAmount
-impl core::marker::Sync for bitcoin_units::amount::Denomination
-impl core::marker::Sync for bitcoin_units::amount::Display
-impl core::marker::Sync for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Sync for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Sync for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Sync for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Sync for bitcoin_units::amount::ParseAmountError
-impl core::marker::Sync for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Sync for bitcoin_units::amount::ParseError
-impl core::marker::Sync for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::TooPreciseError
-impl core::marker::Sync for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Sync for bitcoin_units::block::BlockHeight
-impl core::marker::Sync for bitcoin_units::block::BlockInterval
-impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Sync for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::Time
-impl core::marker::Sync for bitcoin_units::locktime::relative::Height
-impl core::marker::Sync for bitcoin_units::locktime::relative::Time
-impl core::marker::Sync for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Sync for bitcoin_units::parse::ParseIntError
-impl core::marker::Sync for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Sync for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Sync for bitcoin_units::weight::Weight
-impl core::marker::Unpin for bitcoin_units::Amount
-impl core::marker::Unpin for bitcoin_units::SignedAmount
-impl core::marker::Unpin for bitcoin_units::amount::Denomination
-impl core::marker::Unpin for bitcoin_units::amount::Display
-impl core::marker::Unpin for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Unpin for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Unpin for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Unpin for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Unpin for bitcoin_units::amount::ParseAmountError
-impl core::marker::Unpin for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::ParseError
-impl core::marker::Unpin for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::TooPreciseError
-impl core::marker::Unpin for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Unpin for bitcoin_units::block::BlockHeight
-impl core::marker::Unpin for bitcoin_units::block::BlockInterval
-impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Unpin for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::Time
-impl core::marker::Unpin for bitcoin_units::locktime::relative::Height
-impl core::marker::Unpin for bitcoin_units::locktime::relative::Time
-impl core::marker::Unpin for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Unpin for bitcoin_units::parse::ParseIntError
-impl core::marker::Unpin for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Unpin for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Unpin for bitcoin_units::weight::Weight
-impl core::ops::arith::Add for bitcoin_units::Amount
-impl core::ops::arith::Add for bitcoin_units::SignedAmount
-impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
-impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add for bitcoin_units::weight::Weight
-impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
-impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl core::ops::arith::AddAssign for bitcoin_units::Amount
-impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
-impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
-impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
-impl core::ops::arith::AddAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Div for bitcoin_units::weight::Weight
-impl core::ops::arith::Div<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::Amount
-impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
-impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Div<u64> for bitcoin_units::Amount
-impl core::ops::arith::Div<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::DivAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::DivAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::DivAssign<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::Mul<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::weight::Weight
-impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for u64
-impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
-impl core::ops::arith::Mul<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::MulAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::MulAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::MulAssign<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::Neg for bitcoin_units::SignedAmount
-impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
-impl core::ops::arith::RemAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::RemAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::Sub for bitcoin_units::Amount
-impl core::ops::arith::Sub for bitcoin_units::SignedAmount
-impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
-impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub for bitcoin_units::weight::Weight
-impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
-impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl core::ops::arith::SubAssign for bitcoin_units::Amount
-impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
-impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
-impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
-impl core::ops::arith::SubAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::SubAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::SubAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InputTooLargeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InvalidCharacterError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDigitsError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::OutOfRangeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseAmountError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::TooPreciseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::UnknownDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::FeeRate
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ConversionError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Time
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Height
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Time
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::ParseIntError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::PrefixedHexError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::UnprefixedHexError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::weight::Weight
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InputTooLargeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InvalidCharacterError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDigitsError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::OutOfRangeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseAmountError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::TooPreciseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::UnknownDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::FeeRate
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ConversionError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Time
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Height
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Time
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::ParseIntError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::PrefixedHexError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::UnprefixedHexError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::weight::Weight
-impl core::str::traits::FromStr for bitcoin_units::Amount
-impl core::str::traits::FromStr for bitcoin_units::SignedAmount
-impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
-impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
-impl core::str::traits::FromStr for bitcoin_units::block::BlockInterval
-impl core::str::traits::FromStr for bitcoin_units::fee_rate::FeeRate
-impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
-impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Time
-impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Height
-impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Time
-impl core::str::traits::FromStr for bitcoin_units::weight::Weight
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Amount> for bitcoin_units::Amount
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::Amount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::Amount>
-impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::SignedAmount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::SignedAmount>
-pub bitcoin_units::amount::Denomination::Bit
-pub bitcoin_units::amount::Denomination::Bitcoin
-pub bitcoin_units::amount::Denomination::CentiBitcoin
-pub bitcoin_units::amount::Denomination::MicroBitcoin
-pub bitcoin_units::amount::Denomination::MilliBitcoin
-pub bitcoin_units::amount::Denomination::Satoshi
-pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
-pub const bitcoin_units::Amount::FIFTY_BTC: Self
-pub const bitcoin_units::Amount::MAX: Self
-pub const bitcoin_units::Amount::MAX_MONEY: Self
-pub const bitcoin_units::Amount::MIN: Self
-pub const bitcoin_units::Amount::ONE_BTC: Self
-pub const bitcoin_units::Amount::ONE_SAT: Self
-pub const bitcoin_units::Amount::SIZE: usize
-pub const bitcoin_units::Amount::ZERO: Self
-pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
-pub const bitcoin_units::SignedAmount::MAX: Self
-pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
-pub const bitcoin_units::SignedAmount::MIN: Self
-pub const bitcoin_units::SignedAmount::ONE_BTC: Self
-pub const bitcoin_units::SignedAmount::ONE_SAT: Self
-pub const bitcoin_units::SignedAmount::ZERO: Self
-pub const bitcoin_units::amount::Denomination::BTC: Self
-pub const bitcoin_units::amount::Denomination::SAT: Self
-pub const bitcoin_units::block::BlockHeight::MAX: Self
-pub const bitcoin_units::block::BlockHeight::MIN: Self
-pub const bitcoin_units::block::BlockHeight::ZERO: Self
-pub const bitcoin_units::block::BlockInterval::MAX: Self
-pub const bitcoin_units::block::BlockInterval::MIN: Self
-pub const bitcoin_units::block::BlockInterval::ZERO: Self
-pub const bitcoin_units::fee_rate::FeeRate::BROADCAST_MIN: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::DUST: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::MAX: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::MIN: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::ZERO: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::locktime::absolute::Height::MAX: Self
-pub const bitcoin_units::locktime::absolute::Height::MIN: Self
-pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
-pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
-pub const bitcoin_units::locktime::absolute::Time::MAX: Self
-pub const bitcoin_units::locktime::absolute::Time::MIN: Self
-pub const bitcoin_units::locktime::relative::Height::MAX: Self
-pub const bitcoin_units::locktime::relative::Height::MIN: Self
-pub const bitcoin_units::locktime::relative::Height::ZERO: Self
-pub const bitcoin_units::locktime::relative::Time::MAX: Self
-pub const bitcoin_units::locktime::relative::Time::MIN: Self
-pub const bitcoin_units::locktime::relative::Time::ZERO: Self
-pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
-pub const bitcoin_units::weight::Weight::MAX: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MAX_BLOCK: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MIN: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MIN_TRANSACTION: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
-pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
-pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
-pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_floor(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
-pub const fn bitcoin_units::Amount::checked_div_by_weight_ceil(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
-pub const fn bitcoin_units::Amount::checked_div_by_weight_floor(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::fee_rate::FeeRate>
-pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::from_sat_unchecked(satoshi: u64) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::to_sat(self) -> u64
-pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::from_sat_unchecked(satoshi: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
-pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
-pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb_unchecked(sat_vb: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_kwu(self) -> u64
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_ceil(self) -> u64
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_floor(self) -> u64
-pub const fn bitcoin_units::locktime::absolute::Height::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Height, bitcoin_units::locktime::absolute::ConversionError>
-pub const fn bitcoin_units::locktime::absolute::Height::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::absolute::Time::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Time, bitcoin_units::locktime::absolute::ConversionError>
-pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
-pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
-pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
-pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
-pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_mul_by_fee_rate(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
-pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::to_kwu_ceil(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
-pub fn &bitcoin_units::Amount::add(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::sub(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::add(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::add(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::sub(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
-pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
-pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: &bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
-pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
-pub fn bitcoin_units::Amount::default() -> Self
-pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
-pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::Amount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::Amount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseError>
-pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
-pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
-pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
-pub fn bitcoin_units::Amount::to_btc(self) -> f64
-pub fn bitcoin_units::Amount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
-pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::Amount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::Amount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
-pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
-pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
-pub fn bitcoin_units::SignedAmount::default() -> Self
-pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
-pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
-pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
-pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
-pub fn bitcoin_units::SignedAmount::from_btc(btc: f64) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_float_in(value: f64, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseError>
-pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
-pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
-pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
-pub fn bitcoin_units::SignedAmount::mul_assign(&mut self, rhs: i64)
-pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
-pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
-pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
-pub fn bitcoin_units::SignedAmount::signum(self) -> i64
-pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
-pub fn bitcoin_units::SignedAmount::to_btc(self) -> f64
-pub fn bitcoin_units::SignedAmount::to_float_in(self, denom: bitcoin_units::amount::Denomination) -> f64
-pub fn bitcoin_units::SignedAmount::to_string_in(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::SignedAmount::to_string_with_denomination(self, denom: bitcoin_units::amount::Denomination) -> alloc::string::String
-pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
-pub fn bitcoin_units::amount::CheckedSum::checked_sum(self) -> core::option::Option<R>
-pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
-pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
-pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
-pub fn bitcoin_units::amount::InputTooLargeError::clone(&self) -> bitcoin_units::amount::InputTooLargeError
-pub fn bitcoin_units::amount::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::InputTooLargeError) -> bool
-pub fn bitcoin_units::amount::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::InvalidCharacterError
-pub fn bitcoin_units::amount::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::InvalidCharacterError) -> bool
-pub fn bitcoin_units::amount::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::MissingDenominationError::clone(&self) -> bitcoin_units::amount::MissingDenominationError
-pub fn bitcoin_units::amount::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::MissingDenominationError) -> bool
-pub fn bitcoin_units::amount::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::MissingDigitsError::clone(&self) -> bitcoin_units::amount::MissingDigitsError
-pub fn bitcoin_units::amount::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::MissingDigitsError) -> bool
-pub fn bitcoin_units::amount::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::OutOfRangeError::clone(&self) -> bitcoin_units::amount::OutOfRangeError
-pub fn bitcoin_units::amount::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::OutOfRangeError) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::OutOfRangeError::is_above_max(self) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::is_below_min(self) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::valid_range(self) -> (i64, u64)
-pub fn bitcoin_units::amount::ParseAmountError::clone(&self) -> bitcoin_units::amount::ParseAmountError
-pub fn bitcoin_units::amount::ParseAmountError::eq(&self, other: &bitcoin_units::amount::ParseAmountError) -> bool
-pub fn bitcoin_units::amount::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseAmountError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::ParseDenominationError::clone(&self) -> bitcoin_units::amount::ParseDenominationError
-pub fn bitcoin_units::amount::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::ParseDenominationError) -> bool
-pub fn bitcoin_units::amount::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseDenominationError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::ParseError::clone(&self) -> bitcoin_units::amount::ParseError
-pub fn bitcoin_units::amount::ParseError::eq(&self, other: &bitcoin_units::amount::ParseError) -> bool
-pub fn bitcoin_units::amount::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseAmountError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseDenominationError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::PossiblyConfusingDenominationError
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::PossiblyConfusingDenominationError) -> bool
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::TooPreciseError::clone(&self) -> bitcoin_units::amount::TooPreciseError
-pub fn bitcoin_units::amount::TooPreciseError::eq(&self, other: &bitcoin_units::amount::TooPreciseError) -> bool
-pub fn bitcoin_units::amount::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::UnknownDenominationError
-pub fn bitcoin_units::amount::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::UnknownDenominationError) -> bool
-pub fn bitcoin_units::amount::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
-pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
-pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
-pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
-pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
-pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockHeight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
-pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
-pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
-pub fn bitcoin_units::block::BlockInterval::default() -> bitcoin_units::block::BlockInterval
-pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
-pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::block::BlockInterval::from(h: bitcoin_units::locktime::relative::Height) -> Self
-pub fn bitcoin_units::block::BlockInterval::from(inner: u32) -> Self
-pub fn bitcoin_units::block::BlockInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::block::BlockInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::block::BlockInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::block::BlockInterval::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
-pub fn bitcoin_units::block::BlockInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::block::BlockInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::block::BlockInterval>
-pub fn bitcoin_units::block::BlockInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockInterval::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
-pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
-pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
-pub fn bitcoin_units::fee_rate::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::fee_wu(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb(sat_vb: u64) -> core::option::Option<Self>
-pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
-pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
-pub fn bitcoin_units::fee_rate::FeeRate::to_fee(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::ConversionError
-pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
-pub fn bitcoin_units::locktime::absolute::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
-pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
-pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseHeightError>
-pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::ParseHeightError
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseHeightError) -> bool
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::ParseTimeError
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseTimeError) -> bool
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Time::clone(&self) -> bitcoin_units::locktime::absolute::Time
-pub fn bitcoin_units::locktime::absolute::Time::cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::absolute::Time::eq(&self, other: &bitcoin_units::locktime::absolute::Time) -> bool
-pub fn bitcoin_units::locktime::absolute::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Time::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseTimeError>
-pub fn bitcoin_units::locktime::absolute::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::absolute::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::absolute::Time::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::absolute::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::clone(&self) -> bitcoin_units::locktime::relative::Height
-pub fn bitcoin_units::locktime::relative::Height::cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::relative::Height::default() -> bitcoin_units::locktime::relative::Height
-pub fn bitcoin_units::locktime::relative::Height::eq(&self, other: &bitcoin_units::locktime::relative::Height) -> bool
-pub fn bitcoin_units::locktime::relative::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::Height::from(value: u16) -> Self
-pub fn bitcoin_units::locktime::relative::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::relative::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::relative::Height::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::relative::Height::try_from(h: bitcoin_units::block::BlockInterval) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Time::clone(&self) -> bitcoin_units::locktime::relative::Time
-pub fn bitcoin_units::locktime::relative::Time::cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::relative::Time::default() -> bitcoin_units::locktime::relative::Time
-pub fn bitcoin_units::locktime::relative::Time::eq(&self, other: &bitcoin_units::locktime::relative::Time) -> bool
-pub fn bitcoin_units::locktime::relative::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::relative::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::relative::Time::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::relative::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Time::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Time::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::TimeOverflowError
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::TimeOverflowError) -> bool
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::new(seconds: u32) -> Self
-pub fn bitcoin_units::parse::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
-pub fn bitcoin_units::parse::ParseIntError::clone(&self) -> bitcoin_units::parse::ParseIntError
-pub fn bitcoin_units::parse::ParseIntError::eq(&self, other: &bitcoin_units::parse::ParseIntError) -> bool
-pub fn bitcoin_units::parse::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::PrefixedHexError::clone(&self) -> bitcoin_units::parse::PrefixedHexError
-pub fn bitcoin_units::parse::PrefixedHexError::eq(&self, other: &bitcoin_units::parse::PrefixedHexError) -> bool
-pub fn bitcoin_units::parse::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::PrefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
-pub fn bitcoin_units::parse::PrefixedHexError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::parse::UnprefixedHexError::clone(&self) -> bitcoin_units::parse::UnprefixedHexError
-pub fn bitcoin_units::parse::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse::UnprefixedHexError) -> bool
-pub fn bitcoin_units::parse::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::UnprefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
-pub fn bitcoin_units::parse::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::parse::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::int_from_box<T: bitcoin_units::parse::Integer>(s: alloc::boxed::Box<str>) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::int_from_str<T: bitcoin_units::parse::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::int_from_string<T: bitcoin_units::parse::Integer>(s: alloc::string::String) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
-pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
-pub fn bitcoin_units::weight::Weight::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::div(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::weight::Weight::div_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::weight::Weight::eq(&self, other: &bitcoin_units::weight::Weight) -> bool
-pub fn bitcoin_units::weight::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::weight::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
-pub fn bitcoin_units::weight::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::weight::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::weight::Weight::mul(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::weight::Weight::sub(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
-pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
-pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::weight::Weight::try_from(s: alloc::boxed::Box<str>) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::weight::Weight::try_from(s: alloc::string::String) -> core::result::Result<Self, Self::Error>
-pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse::ParseIntError) -> Self
-pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
-pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
-pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
-pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
-pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub mod bitcoin_units
-pub mod bitcoin_units::amount
-pub mod bitcoin_units::block
-pub mod bitcoin_units::fee_rate
-pub mod bitcoin_units::locktime
-pub mod bitcoin_units::locktime::absolute
-pub mod bitcoin_units::locktime::relative
-pub mod bitcoin_units::parse
-pub mod bitcoin_units::weight
-pub struct bitcoin_units::Amount(_)
-pub struct bitcoin_units::BlockHeight(pub u32)
-pub struct bitcoin_units::BlockInterval(pub u32)
-pub struct bitcoin_units::FeeRate(_)
-pub struct bitcoin_units::SignedAmount(_)
-pub struct bitcoin_units::Weight(_)
-pub struct bitcoin_units::amount::Amount(_)
-pub struct bitcoin_units::amount::Display
-pub struct bitcoin_units::amount::InputTooLargeError
-pub struct bitcoin_units::amount::InvalidCharacterError
-pub struct bitcoin_units::amount::MissingDigitsError
-pub struct bitcoin_units::amount::OutOfRangeError
-pub struct bitcoin_units::amount::ParseAmountError(_)
-pub struct bitcoin_units::amount::ParseError(_)
-pub struct bitcoin_units::amount::SignedAmount(_)
-pub struct bitcoin_units::amount::TooPreciseError
-pub struct bitcoin_units::block::BlockHeight(pub u32)
-pub struct bitcoin_units::block::BlockInterval(pub u32)
-pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
-pub struct bitcoin_units::fee_rate::FeeRate(_)
-pub struct bitcoin_units::locktime::absolute::Height(_)
-pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
-pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
-pub struct bitcoin_units::locktime::absolute::Time(_)
-pub struct bitcoin_units::locktime::relative::Height(_)
-pub struct bitcoin_units::locktime::relative::Time(_)
-pub struct bitcoin_units::locktime::relative::TimeOverflowError
-pub struct bitcoin_units::parse::PrefixedHexError(_)
-pub struct bitcoin_units::parse::UnprefixedHexError(_)
-pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: bitcoin_units::amount::sealed::Sealed<R>
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse::sealed::Sealed
-pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
-pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
-pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
-pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
-pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::Amount::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
-pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
-pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockInterval
-pub type bitcoin_units::block::BlockInterval::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockInterval::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockInterval::Output = bitcoin_units::block::BlockInterval
-pub type bitcoin_units::fee_rate::FeeRate::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::fee_rate::FeeRate::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::Amount
-pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::ParseHeightError
-pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ConversionError
-pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ParseHeightError
-pub type bitcoin_units::locktime::absolute::Time::Err = bitcoin_units::locktime::absolute::ParseTimeError
-pub type bitcoin_units::locktime::absolute::Time::Error = bitcoin_units::locktime::absolute::ParseTimeError
-pub type bitcoin_units::locktime::relative::Height::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::block::TooBigForRelativeBlockHeightError
-pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Time::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Time::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Output = bitcoin_units::Amount
-pub type bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::weight::Weight::Output = u64
-pub type u64::Output = bitcoin_units::weight::Weight
diff --git a/api/units/no-features.txt b/api/units/no-features.txt
deleted file mode 100644
index 1464a2aa30..0000000000
--- a/api/units/no-features.txt
+++ /dev/null
@@ -1,1108 +0,0 @@
-#[non_exhaustive] pub enum bitcoin_units::amount::Denomination
-#[non_exhaustive] pub enum bitcoin_units::amount::ParseDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::MissingDenominationError
-#[non_exhaustive] pub struct bitcoin_units::amount::PossiblyConfusingDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::amount::UnknownDenominationError(_)
-#[non_exhaustive] pub struct bitcoin_units::locktime::absolute::ConversionError
-#[non_exhaustive] pub struct bitcoin_units::parse::ParseIntError
-impl bitcoin_units::Amount
-impl bitcoin_units::SignedAmount
-impl bitcoin_units::amount::Denomination
-impl bitcoin_units::amount::Display
-impl bitcoin_units::amount::OutOfRangeError
-impl bitcoin_units::block::BlockHeight
-impl bitcoin_units::block::BlockInterval
-impl bitcoin_units::fee_rate::FeeRate
-impl bitcoin_units::locktime::absolute::Height
-impl bitcoin_units::locktime::absolute::Time
-impl bitcoin_units::locktime::relative::Height
-impl bitcoin_units::locktime::relative::Time
-impl bitcoin_units::locktime::relative::TimeOverflowError
-impl bitcoin_units::parse::Integer for i128
-impl bitcoin_units::parse::Integer for i16
-impl bitcoin_units::parse::Integer for i32
-impl bitcoin_units::parse::Integer for i64
-impl bitcoin_units::parse::Integer for i8
-impl bitcoin_units::parse::Integer for u128
-impl bitcoin_units::parse::Integer for u16
-impl bitcoin_units::parse::Integer for u32
-impl bitcoin_units::parse::Integer for u64
-impl bitcoin_units::parse::Integer for u8
-impl bitcoin_units::weight::Weight
-impl core::clone::Clone for bitcoin_units::Amount
-impl core::clone::Clone for bitcoin_units::SignedAmount
-impl core::clone::Clone for bitcoin_units::amount::Denomination
-impl core::clone::Clone for bitcoin_units::amount::Display
-impl core::clone::Clone for bitcoin_units::amount::InputTooLargeError
-impl core::clone::Clone for bitcoin_units::amount::InvalidCharacterError
-impl core::clone::Clone for bitcoin_units::amount::MissingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::MissingDigitsError
-impl core::clone::Clone for bitcoin_units::amount::OutOfRangeError
-impl core::clone::Clone for bitcoin_units::amount::ParseAmountError
-impl core::clone::Clone for bitcoin_units::amount::ParseDenominationError
-impl core::clone::Clone for bitcoin_units::amount::ParseError
-impl core::clone::Clone for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::clone::Clone for bitcoin_units::amount::TooPreciseError
-impl core::clone::Clone for bitcoin_units::amount::UnknownDenominationError
-impl core::clone::Clone for bitcoin_units::block::BlockHeight
-impl core::clone::Clone for bitcoin_units::block::BlockInterval
-impl core::clone::Clone for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::clone::Clone for bitcoin_units::fee_rate::FeeRate
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ConversionError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::Height
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::clone::Clone for bitcoin_units::locktime::absolute::Time
-impl core::clone::Clone for bitcoin_units::locktime::relative::Height
-impl core::clone::Clone for bitcoin_units::locktime::relative::Time
-impl core::clone::Clone for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::clone::Clone for bitcoin_units::parse::ParseIntError
-impl core::clone::Clone for bitcoin_units::parse::PrefixedHexError
-impl core::clone::Clone for bitcoin_units::parse::UnprefixedHexError
-impl core::clone::Clone for bitcoin_units::weight::Weight
-impl core::cmp::Eq for bitcoin_units::Amount
-impl core::cmp::Eq for bitcoin_units::SignedAmount
-impl core::cmp::Eq for bitcoin_units::amount::Denomination
-impl core::cmp::Eq for bitcoin_units::amount::InputTooLargeError
-impl core::cmp::Eq for bitcoin_units::amount::InvalidCharacterError
-impl core::cmp::Eq for bitcoin_units::amount::MissingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::MissingDigitsError
-impl core::cmp::Eq for bitcoin_units::amount::OutOfRangeError
-impl core::cmp::Eq for bitcoin_units::amount::ParseAmountError
-impl core::cmp::Eq for bitcoin_units::amount::ParseDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::ParseError
-impl core::cmp::Eq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::cmp::Eq for bitcoin_units::amount::TooPreciseError
-impl core::cmp::Eq for bitcoin_units::amount::UnknownDenominationError
-impl core::cmp::Eq for bitcoin_units::block::BlockHeight
-impl core::cmp::Eq for bitcoin_units::block::BlockInterval
-impl core::cmp::Eq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::cmp::Eq for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ConversionError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::Height
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::cmp::Eq for bitcoin_units::locktime::absolute::Time
-impl core::cmp::Eq for bitcoin_units::locktime::relative::Height
-impl core::cmp::Eq for bitcoin_units::locktime::relative::Time
-impl core::cmp::Eq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::cmp::Eq for bitcoin_units::parse::ParseIntError
-impl core::cmp::Eq for bitcoin_units::parse::PrefixedHexError
-impl core::cmp::Eq for bitcoin_units::parse::UnprefixedHexError
-impl core::cmp::Eq for bitcoin_units::weight::Weight
-impl core::cmp::Ord for bitcoin_units::Amount
-impl core::cmp::Ord for bitcoin_units::SignedAmount
-impl core::cmp::Ord for bitcoin_units::block::BlockHeight
-impl core::cmp::Ord for bitcoin_units::block::BlockInterval
-impl core::cmp::Ord for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::Ord for bitcoin_units::locktime::absolute::Height
-impl core::cmp::Ord for bitcoin_units::locktime::absolute::Time
-impl core::cmp::Ord for bitcoin_units::locktime::relative::Height
-impl core::cmp::Ord for bitcoin_units::locktime::relative::Time
-impl core::cmp::Ord for bitcoin_units::weight::Weight
-impl core::cmp::PartialEq for bitcoin_units::Amount
-impl core::cmp::PartialEq for bitcoin_units::SignedAmount
-impl core::cmp::PartialEq for bitcoin_units::amount::Denomination
-impl core::cmp::PartialEq for bitcoin_units::amount::InputTooLargeError
-impl core::cmp::PartialEq for bitcoin_units::amount::InvalidCharacterError
-impl core::cmp::PartialEq for bitcoin_units::amount::MissingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::MissingDigitsError
-impl core::cmp::PartialEq for bitcoin_units::amount::OutOfRangeError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseAmountError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::ParseError
-impl core::cmp::PartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::cmp::PartialEq for bitcoin_units::amount::TooPreciseError
-impl core::cmp::PartialEq for bitcoin_units::amount::UnknownDenominationError
-impl core::cmp::PartialEq for bitcoin_units::block::BlockHeight
-impl core::cmp::PartialEq for bitcoin_units::block::BlockInterval
-impl core::cmp::PartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::cmp::PartialEq for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ConversionError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Height
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::cmp::PartialEq for bitcoin_units::locktime::absolute::Time
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Height
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::Time
-impl core::cmp::PartialEq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::cmp::PartialEq for bitcoin_units::parse::ParseIntError
-impl core::cmp::PartialEq for bitcoin_units::parse::PrefixedHexError
-impl core::cmp::PartialEq for bitcoin_units::parse::UnprefixedHexError
-impl core::cmp::PartialEq for bitcoin_units::weight::Weight
-impl core::cmp::PartialOrd for bitcoin_units::Amount
-impl core::cmp::PartialOrd for bitcoin_units::SignedAmount
-impl core::cmp::PartialOrd for bitcoin_units::block::BlockHeight
-impl core::cmp::PartialOrd for bitcoin_units::block::BlockInterval
-impl core::cmp::PartialOrd for bitcoin_units::fee_rate::FeeRate
-impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Height
-impl core::cmp::PartialOrd for bitcoin_units::locktime::absolute::Time
-impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Height
-impl core::cmp::PartialOrd for bitcoin_units::locktime::relative::Time
-impl core::cmp::PartialOrd for bitcoin_units::weight::Weight
-impl core::convert::AsRef<core::num::error::ParseIntError> for bitcoin_units::parse::ParseIntError
-impl core::convert::From<bitcoin_units::Amount> for bitcoin_units::SignedAmount
-impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::InputTooLargeError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::InvalidCharacterError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::MissingDigitsError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::OutOfRangeError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::ParseAmountError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::ParseDenominationError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<bitcoin_units::amount::TooPreciseError> for bitcoin_units::amount::ParseError
-impl core::convert::From<bitcoin_units::block::BlockHeight> for u32
-impl core::convert::From<bitcoin_units::block::BlockInterval> for u32
-impl core::convert::From<bitcoin_units::fee_rate::FeeRate> for u64
-impl core::convert::From<bitcoin_units::locktime::absolute::Height> for bitcoin_units::block::BlockHeight
-impl core::convert::From<bitcoin_units::locktime::relative::Height> for bitcoin_units::block::BlockInterval
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::PrefixedHexError
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for bitcoin_units::parse::UnprefixedHexError
-impl core::convert::From<bitcoin_units::parse::ParseIntError> for core::num::error::ParseIntError
-impl core::convert::From<bitcoin_units::weight::Weight> for u64
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseAmountError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseDenominationError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::amount::ParseError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::PrefixedHexError
-impl core::convert::From<core::convert::Infallible> for bitcoin_units::parse::UnprefixedHexError
-impl core::convert::From<u16> for bitcoin_units::locktime::relative::Height
-impl core::convert::From<u32> for bitcoin_units::block::BlockHeight
-impl core::convert::From<u32> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockHeight
-impl core::convert::TryFrom<&str> for bitcoin_units::block::BlockInterval
-impl core::convert::TryFrom<&str> for bitcoin_units::fee_rate::FeeRate
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::absolute::Time
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Height
-impl core::convert::TryFrom<&str> for bitcoin_units::locktime::relative::Time
-impl core::convert::TryFrom<&str> for bitcoin_units::weight::Weight
-impl core::convert::TryFrom<bitcoin_units::SignedAmount> for bitcoin_units::Amount
-impl core::convert::TryFrom<bitcoin_units::block::BlockHeight> for bitcoin_units::locktime::absolute::Height
-impl core::convert::TryFrom<bitcoin_units::block::BlockInterval> for bitcoin_units::locktime::relative::Height
-impl core::default::Default for bitcoin_units::Amount
-impl core::default::Default for bitcoin_units::SignedAmount
-impl core::default::Default for bitcoin_units::block::BlockInterval
-impl core::default::Default for bitcoin_units::locktime::relative::Height
-impl core::default::Default for bitcoin_units::locktime::relative::Time
-impl core::fmt::Debug for bitcoin_units::Amount
-impl core::fmt::Debug for bitcoin_units::SignedAmount
-impl core::fmt::Debug for bitcoin_units::amount::Denomination
-impl core::fmt::Debug for bitcoin_units::amount::Display
-impl core::fmt::Debug for bitcoin_units::amount::InputTooLargeError
-impl core::fmt::Debug for bitcoin_units::amount::InvalidCharacterError
-impl core::fmt::Debug for bitcoin_units::amount::MissingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::MissingDigitsError
-impl core::fmt::Debug for bitcoin_units::amount::OutOfRangeError
-impl core::fmt::Debug for bitcoin_units::amount::ParseAmountError
-impl core::fmt::Debug for bitcoin_units::amount::ParseDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::ParseError
-impl core::fmt::Debug for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::fmt::Debug for bitcoin_units::amount::TooPreciseError
-impl core::fmt::Debug for bitcoin_units::amount::UnknownDenominationError
-impl core::fmt::Debug for bitcoin_units::block::BlockHeight
-impl core::fmt::Debug for bitcoin_units::block::BlockInterval
-impl core::fmt::Debug for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::fmt::Debug for bitcoin_units::fee_rate::FeeRate
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ConversionError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::Height
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::fmt::Debug for bitcoin_units::locktime::absolute::Time
-impl core::fmt::Debug for bitcoin_units::locktime::relative::Height
-impl core::fmt::Debug for bitcoin_units::locktime::relative::Time
-impl core::fmt::Debug for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::fmt::Debug for bitcoin_units::parse::ParseIntError
-impl core::fmt::Debug for bitcoin_units::parse::PrefixedHexError
-impl core::fmt::Debug for bitcoin_units::parse::UnprefixedHexError
-impl core::fmt::Debug for bitcoin_units::weight::Weight
-impl core::fmt::Display for bitcoin_units::Amount
-impl core::fmt::Display for bitcoin_units::SignedAmount
-impl core::fmt::Display for bitcoin_units::amount::Denomination
-impl core::fmt::Display for bitcoin_units::amount::Display
-impl core::fmt::Display for bitcoin_units::amount::InputTooLargeError
-impl core::fmt::Display for bitcoin_units::amount::InvalidCharacterError
-impl core::fmt::Display for bitcoin_units::amount::MissingDigitsError
-impl core::fmt::Display for bitcoin_units::amount::OutOfRangeError
-impl core::fmt::Display for bitcoin_units::amount::ParseAmountError
-impl core::fmt::Display for bitcoin_units::amount::ParseDenominationError
-impl core::fmt::Display for bitcoin_units::amount::ParseError
-impl core::fmt::Display for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::fmt::Display for bitcoin_units::amount::TooPreciseError
-impl core::fmt::Display for bitcoin_units::amount::UnknownDenominationError
-impl core::fmt::Display for bitcoin_units::block::BlockHeight
-impl core::fmt::Display for bitcoin_units::block::BlockInterval
-impl core::fmt::Display for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::fmt::Display for bitcoin_units::fee_rate::FeeRate
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ConversionError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::Height
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::fmt::Display for bitcoin_units::locktime::absolute::Time
-impl core::fmt::Display for bitcoin_units::locktime::relative::Height
-impl core::fmt::Display for bitcoin_units::locktime::relative::Time
-impl core::fmt::Display for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::fmt::Display for bitcoin_units::parse::ParseIntError
-impl core::fmt::Display for bitcoin_units::parse::PrefixedHexError
-impl core::fmt::Display for bitcoin_units::parse::UnprefixedHexError
-impl core::fmt::Display for bitcoin_units::weight::Weight
-impl core::hash::Hash for bitcoin_units::Amount
-impl core::hash::Hash for bitcoin_units::SignedAmount
-impl core::hash::Hash for bitcoin_units::amount::Denomination
-impl core::hash::Hash for bitcoin_units::block::BlockHeight
-impl core::hash::Hash for bitcoin_units::block::BlockInterval
-impl core::hash::Hash for bitcoin_units::fee_rate::FeeRate
-impl core::hash::Hash for bitcoin_units::locktime::absolute::Height
-impl core::hash::Hash for bitcoin_units::locktime::absolute::Time
-impl core::hash::Hash for bitcoin_units::locktime::relative::Height
-impl core::hash::Hash for bitcoin_units::locktime::relative::Time
-impl core::hash::Hash for bitcoin_units::weight::Weight
-impl core::iter::traits::accum::Sum for bitcoin_units::Amount
-impl core::iter::traits::accum::Sum for bitcoin_units::SignedAmount
-impl core::iter::traits::accum::Sum for bitcoin_units::block::BlockInterval
-impl core::iter::traits::accum::Sum for bitcoin_units::fee_rate::FeeRate
-impl core::iter::traits::accum::Sum for bitcoin_units::weight::Weight
-impl core::marker::Copy for bitcoin_units::Amount
-impl core::marker::Copy for bitcoin_units::SignedAmount
-impl core::marker::Copy for bitcoin_units::amount::Denomination
-impl core::marker::Copy for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Copy for bitcoin_units::block::BlockHeight
-impl core::marker::Copy for bitcoin_units::block::BlockInterval
-impl core::marker::Copy for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Copy for bitcoin_units::locktime::absolute::Height
-impl core::marker::Copy for bitcoin_units::locktime::absolute::Time
-impl core::marker::Copy for bitcoin_units::locktime::relative::Height
-impl core::marker::Copy for bitcoin_units::locktime::relative::Time
-impl core::marker::Copy for bitcoin_units::weight::Weight
-impl core::marker::Freeze for bitcoin_units::Amount
-impl core::marker::Freeze for bitcoin_units::SignedAmount
-impl core::marker::Freeze for bitcoin_units::amount::Denomination
-impl core::marker::Freeze for bitcoin_units::amount::Display
-impl core::marker::Freeze for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Freeze for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Freeze for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Freeze for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Freeze for bitcoin_units::amount::ParseAmountError
-impl core::marker::Freeze for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::ParseError
-impl core::marker::Freeze for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Freeze for bitcoin_units::amount::TooPreciseError
-impl core::marker::Freeze for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Freeze for bitcoin_units::block::BlockHeight
-impl core::marker::Freeze for bitcoin_units::block::BlockInterval
-impl core::marker::Freeze for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Freeze for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::Height
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Freeze for bitcoin_units::locktime::absolute::Time
-impl core::marker::Freeze for bitcoin_units::locktime::relative::Height
-impl core::marker::Freeze for bitcoin_units::locktime::relative::Time
-impl core::marker::Freeze for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Freeze for bitcoin_units::parse::ParseIntError
-impl core::marker::Freeze for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Freeze for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Freeze for bitcoin_units::weight::Weight
-impl core::marker::Send for bitcoin_units::Amount
-impl core::marker::Send for bitcoin_units::SignedAmount
-impl core::marker::Send for bitcoin_units::amount::Denomination
-impl core::marker::Send for bitcoin_units::amount::Display
-impl core::marker::Send for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Send for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Send for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Send for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Send for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Send for bitcoin_units::amount::ParseAmountError
-impl core::marker::Send for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Send for bitcoin_units::amount::ParseError
-impl core::marker::Send for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Send for bitcoin_units::amount::TooPreciseError
-impl core::marker::Send for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Send for bitcoin_units::block::BlockHeight
-impl core::marker::Send for bitcoin_units::block::BlockInterval
-impl core::marker::Send for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Send for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Send for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Send for bitcoin_units::locktime::absolute::Height
-impl core::marker::Send for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Send for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Send for bitcoin_units::locktime::absolute::Time
-impl core::marker::Send for bitcoin_units::locktime::relative::Height
-impl core::marker::Send for bitcoin_units::locktime::relative::Time
-impl core::marker::Send for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Send for bitcoin_units::parse::ParseIntError
-impl core::marker::Send for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Send for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Send for bitcoin_units::weight::Weight
-impl core::marker::StructuralPartialEq for bitcoin_units::Amount
-impl core::marker::StructuralPartialEq for bitcoin_units::SignedAmount
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::Denomination
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::InputTooLargeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::MissingDigitsError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::OutOfRangeError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseAmountError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::ParseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::TooPreciseError
-impl core::marker::StructuralPartialEq for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockHeight
-impl core::marker::StructuralPartialEq for bitcoin_units::block::BlockInterval
-impl core::marker::StructuralPartialEq for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::StructuralPartialEq for bitcoin_units::fee_rate::FeeRate
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Height
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::absolute::Time
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Height
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::Time
-impl core::marker::StructuralPartialEq for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::ParseIntError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::PrefixedHexError
-impl core::marker::StructuralPartialEq for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::StructuralPartialEq for bitcoin_units::weight::Weight
-impl core::marker::Sync for bitcoin_units::Amount
-impl core::marker::Sync for bitcoin_units::SignedAmount
-impl core::marker::Sync for bitcoin_units::amount::Denomination
-impl core::marker::Sync for bitcoin_units::amount::Display
-impl core::marker::Sync for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Sync for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Sync for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Sync for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Sync for bitcoin_units::amount::ParseAmountError
-impl core::marker::Sync for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Sync for bitcoin_units::amount::ParseError
-impl core::marker::Sync for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Sync for bitcoin_units::amount::TooPreciseError
-impl core::marker::Sync for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Sync for bitcoin_units::block::BlockHeight
-impl core::marker::Sync for bitcoin_units::block::BlockInterval
-impl core::marker::Sync for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Sync for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::Height
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Sync for bitcoin_units::locktime::absolute::Time
-impl core::marker::Sync for bitcoin_units::locktime::relative::Height
-impl core::marker::Sync for bitcoin_units::locktime::relative::Time
-impl core::marker::Sync for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Sync for bitcoin_units::parse::ParseIntError
-impl core::marker::Sync for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Sync for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Sync for bitcoin_units::weight::Weight
-impl core::marker::Unpin for bitcoin_units::Amount
-impl core::marker::Unpin for bitcoin_units::SignedAmount
-impl core::marker::Unpin for bitcoin_units::amount::Denomination
-impl core::marker::Unpin for bitcoin_units::amount::Display
-impl core::marker::Unpin for bitcoin_units::amount::InputTooLargeError
-impl core::marker::Unpin for bitcoin_units::amount::InvalidCharacterError
-impl core::marker::Unpin for bitcoin_units::amount::MissingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::MissingDigitsError
-impl core::marker::Unpin for bitcoin_units::amount::OutOfRangeError
-impl core::marker::Unpin for bitcoin_units::amount::ParseAmountError
-impl core::marker::Unpin for bitcoin_units::amount::ParseDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::ParseError
-impl core::marker::Unpin for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::marker::Unpin for bitcoin_units::amount::TooPreciseError
-impl core::marker::Unpin for bitcoin_units::amount::UnknownDenominationError
-impl core::marker::Unpin for bitcoin_units::block::BlockHeight
-impl core::marker::Unpin for bitcoin_units::block::BlockInterval
-impl core::marker::Unpin for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::marker::Unpin for bitcoin_units::fee_rate::FeeRate
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ConversionError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::Height
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::marker::Unpin for bitcoin_units::locktime::absolute::Time
-impl core::marker::Unpin for bitcoin_units::locktime::relative::Height
-impl core::marker::Unpin for bitcoin_units::locktime::relative::Time
-impl core::marker::Unpin for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::marker::Unpin for bitcoin_units::parse::ParseIntError
-impl core::marker::Unpin for bitcoin_units::parse::PrefixedHexError
-impl core::marker::Unpin for bitcoin_units::parse::UnprefixedHexError
-impl core::marker::Unpin for bitcoin_units::weight::Weight
-impl core::ops::arith::Add for bitcoin_units::Amount
-impl core::ops::arith::Add for bitcoin_units::SignedAmount
-impl core::ops::arith::Add for bitcoin_units::block::BlockInterval
-impl core::ops::arith::Add for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add for bitcoin_units::weight::Weight
-impl core::ops::arith::Add<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::Add<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::Add<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Add<bitcoin_units::Amount> for &bitcoin_units::Amount
-impl core::ops::arith::Add<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl core::ops::arith::Add<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Add<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Add<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl core::ops::arith::AddAssign for bitcoin_units::Amount
-impl core::ops::arith::AddAssign for bitcoin_units::SignedAmount
-impl core::ops::arith::AddAssign for bitcoin_units::block::BlockInterval
-impl core::ops::arith::AddAssign for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::AddAssign for bitcoin_units::weight::Weight
-impl core::ops::arith::AddAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::AddAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::AddAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::AddAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Div for bitcoin_units::weight::Weight
-impl core::ops::arith::Div<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::Amount
-impl core::ops::arith::Div<bitcoin_units::weight::Weight> for bitcoin_units::Amount
-impl core::ops::arith::Div<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Div<u64> for bitcoin_units::Amount
-impl core::ops::arith::Div<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::DivAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::DivAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::DivAssign<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::Mul<bitcoin_units::fee_rate::FeeRate> for bitcoin_units::weight::Weight
-impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Mul<bitcoin_units::weight::Weight> for u64
-impl core::ops::arith::Mul<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Mul<u64> for bitcoin_units::Amount
-impl core::ops::arith::Mul<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::MulAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::MulAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::MulAssign<u64> for bitcoin_units::weight::Weight
-impl core::ops::arith::Neg for bitcoin_units::SignedAmount
-impl core::ops::arith::Rem<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::Rem<u64> for bitcoin_units::Amount
-impl core::ops::arith::RemAssign<i64> for bitcoin_units::SignedAmount
-impl core::ops::arith::RemAssign<u64> for bitcoin_units::Amount
-impl core::ops::arith::Sub for bitcoin_units::Amount
-impl core::ops::arith::Sub for bitcoin_units::SignedAmount
-impl core::ops::arith::Sub for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Sub for bitcoin_units::block::BlockInterval
-impl core::ops::arith::Sub for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub for bitcoin_units::weight::Weight
-impl core::ops::arith::Sub<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::Sub<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::Sub<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::ops::arith::Sub<bitcoin_units::Amount> for &bitcoin_units::Amount
-impl core::ops::arith::Sub<bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl core::ops::arith::Sub<bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockHeight
-impl core::ops::arith::Sub<bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::Sub<bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl core::ops::arith::SubAssign for bitcoin_units::Amount
-impl core::ops::arith::SubAssign for bitcoin_units::SignedAmount
-impl core::ops::arith::SubAssign for bitcoin_units::block::BlockInterval
-impl core::ops::arith::SubAssign for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::SubAssign for bitcoin_units::weight::Weight
-impl core::ops::arith::SubAssign<&bitcoin_units::Amount> for bitcoin_units::Amount
-impl core::ops::arith::SubAssign<&bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl core::ops::arith::SubAssign<&bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl core::ops::arith::SubAssign<&bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::Amount
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::SignedAmount
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Denomination
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InputTooLargeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::InvalidCharacterError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::MissingDigitsError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::OutOfRangeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseAmountError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::ParseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::TooPreciseError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::amount::UnknownDenominationError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockHeight
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::BlockInterval
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::fee_rate::FeeRate
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ConversionError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Height
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::absolute::Time
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Height
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::Time
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::ParseIntError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::PrefixedHexError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::parse::UnprefixedHexError
-impl core::panic::unwind_safe::RefUnwindSafe for bitcoin_units::weight::Weight
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::Amount
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::SignedAmount
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Denomination
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::Display
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InputTooLargeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::InvalidCharacterError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::MissingDigitsError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::OutOfRangeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseAmountError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::ParseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::PossiblyConfusingDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::TooPreciseError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::amount::UnknownDenominationError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockHeight
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::BlockInterval
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::block::TooBigForRelativeBlockHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::fee_rate::FeeRate
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ConversionError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Height
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseHeightError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::ParseTimeError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::absolute::Time
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Height
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::Time
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::locktime::relative::TimeOverflowError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::ParseIntError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::PrefixedHexError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::parse::UnprefixedHexError
-impl core::panic::unwind_safe::UnwindSafe for bitcoin_units::weight::Weight
-impl core::str::traits::FromStr for bitcoin_units::Amount
-impl core::str::traits::FromStr for bitcoin_units::SignedAmount
-impl core::str::traits::FromStr for bitcoin_units::amount::Denomination
-impl core::str::traits::FromStr for bitcoin_units::block::BlockHeight
-impl core::str::traits::FromStr for bitcoin_units::block::BlockInterval
-impl core::str::traits::FromStr for bitcoin_units::fee_rate::FeeRate
-impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Height
-impl core::str::traits::FromStr for bitcoin_units::locktime::absolute::Time
-impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Height
-impl core::str::traits::FromStr for bitcoin_units::locktime::relative::Time
-impl core::str::traits::FromStr for bitcoin_units::weight::Weight
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::Amount> for bitcoin_units::Amount
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::SignedAmount> for bitcoin_units::SignedAmount
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::block::BlockInterval> for bitcoin_units::block::BlockInterval
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::fee_rate::FeeRate> for bitcoin_units::fee_rate::FeeRate
-impl<'a> core::iter::traits::accum::Sum<&'a bitcoin_units::weight::Weight> for bitcoin_units::weight::Weight
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl<'a> core::ops::arith::Add<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::Amount> for &bitcoin_units::Amount
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::SignedAmount> for &bitcoin_units::SignedAmount
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::fee_rate::FeeRate> for &bitcoin_units::fee_rate::FeeRate
-impl<'a> core::ops::arith::Sub<&'a bitcoin_units::weight::Weight> for &bitcoin_units::weight::Weight
-impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::Amount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::Amount>
-impl<T> bitcoin_units::amount::CheckedSum<bitcoin_units::SignedAmount> for T where T: core::iter::traits::iterator::Iterator<Item = bitcoin_units::SignedAmount>
-pub bitcoin_units::amount::Denomination::Bit
-pub bitcoin_units::amount::Denomination::Bitcoin
-pub bitcoin_units::amount::Denomination::CentiBitcoin
-pub bitcoin_units::amount::Denomination::MicroBitcoin
-pub bitcoin_units::amount::Denomination::MilliBitcoin
-pub bitcoin_units::amount::Denomination::Satoshi
-pub bitcoin_units::amount::ParseDenominationError::PossiblyConfusing(bitcoin_units::amount::PossiblyConfusingDenominationError)
-pub bitcoin_units::amount::ParseDenominationError::Unknown(bitcoin_units::amount::UnknownDenominationError)
-pub const bitcoin_units::Amount::FIFTY_BTC: Self
-pub const bitcoin_units::Amount::MAX: Self
-pub const bitcoin_units::Amount::MAX_MONEY: Self
-pub const bitcoin_units::Amount::MIN: Self
-pub const bitcoin_units::Amount::ONE_BTC: Self
-pub const bitcoin_units::Amount::ONE_SAT: Self
-pub const bitcoin_units::Amount::SIZE: usize
-pub const bitcoin_units::Amount::ZERO: Self
-pub const bitcoin_units::SignedAmount::FIFTY_BTC: Self
-pub const bitcoin_units::SignedAmount::MAX: Self
-pub const bitcoin_units::SignedAmount::MAX_MONEY: Self
-pub const bitcoin_units::SignedAmount::MIN: Self
-pub const bitcoin_units::SignedAmount::ONE_BTC: Self
-pub const bitcoin_units::SignedAmount::ONE_SAT: Self
-pub const bitcoin_units::SignedAmount::ZERO: Self
-pub const bitcoin_units::amount::Denomination::BTC: Self
-pub const bitcoin_units::amount::Denomination::SAT: Self
-pub const bitcoin_units::block::BlockHeight::MAX: Self
-pub const bitcoin_units::block::BlockHeight::MIN: Self
-pub const bitcoin_units::block::BlockHeight::ZERO: Self
-pub const bitcoin_units::block::BlockInterval::MAX: Self
-pub const bitcoin_units::block::BlockInterval::MIN: Self
-pub const bitcoin_units::block::BlockInterval::ZERO: Self
-pub const bitcoin_units::fee_rate::FeeRate::BROADCAST_MIN: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::DUST: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::MAX: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::MIN: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::fee_rate::FeeRate::ZERO: bitcoin_units::fee_rate::FeeRate
-pub const bitcoin_units::locktime::absolute::Height::MAX: Self
-pub const bitcoin_units::locktime::absolute::Height::MIN: Self
-pub const bitcoin_units::locktime::absolute::Height::ZERO: Self
-pub const bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD: u32
-pub const bitcoin_units::locktime::absolute::Time::MAX: Self
-pub const bitcoin_units::locktime::absolute::Time::MIN: Self
-pub const bitcoin_units::locktime::relative::Height::MAX: Self
-pub const bitcoin_units::locktime::relative::Height::MIN: Self
-pub const bitcoin_units::locktime::relative::Height::ZERO: Self
-pub const bitcoin_units::locktime::relative::Time::MAX: Self
-pub const bitcoin_units::locktime::relative::Time::MIN: Self
-pub const bitcoin_units::locktime::relative::Time::ZERO: Self
-pub const bitcoin_units::weight::WITNESS_SCALE_FACTOR: usize
-pub const bitcoin_units::weight::Weight::MAX: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MAX_BLOCK: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MIN: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::MIN_TRANSACTION: bitcoin_units::weight::Weight
-pub const bitcoin_units::weight::Weight::WITNESS_SCALE_FACTOR: u64
-pub const bitcoin_units::weight::Weight::ZERO: bitcoin_units::weight::Weight
-pub const fn bitcoin_units::Amount::checked_add(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_div(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_ceil(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
-pub const fn bitcoin_units::Amount::checked_div_by_fee_rate_floor(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::weight::Weight>
-pub const fn bitcoin_units::Amount::checked_mul(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_rem(self, rhs: u64) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::checked_sub(self, rhs: bitcoin_units::Amount) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::Amount::from_int_btc_const(whole_bitcoin: u32) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::from_sat(satoshi: u64) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::from_sat_unchecked(satoshi: u64) -> bitcoin_units::Amount
-pub const fn bitcoin_units::Amount::to_sat(self) -> u64
-pub const fn bitcoin_units::SignedAmount::checked_abs(self) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_add(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_div(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_mul(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_rem(self, rhs: i64) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::checked_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub const fn bitcoin_units::SignedAmount::from_int_btc_const(whole_bitcoin: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::from_sat(satoshi: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::from_sat_unchecked(satoshi: i64) -> bitcoin_units::SignedAmount
-pub const fn bitcoin_units::SignedAmount::to_sat(self) -> i64
-pub const fn bitcoin_units::block::BlockHeight::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockHeight::to_u32(self) -> u32
-pub const fn bitcoin_units::block::BlockInterval::from_u32(inner: u32) -> Self
-pub const fn bitcoin_units::block::BlockInterval::to_u32(self) -> u32
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_add(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_div(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_mul_by_weight(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::fee_rate::FeeRate::checked_sub(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kvb(sat_kvb: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_kwu(sat_kwu: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb_unchecked(sat_vb: u64) -> Self
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_kwu(self) -> u64
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_ceil(self) -> u64
-pub const fn bitcoin_units::fee_rate::FeeRate::to_sat_per_vb_floor(self) -> u64
-pub const fn bitcoin_units::locktime::absolute::Height::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Height, bitcoin_units::locktime::absolute::ConversionError>
-pub const fn bitcoin_units::locktime::absolute::Height::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::absolute::Time::from_consensus(n: u32) -> core::result::Result<bitcoin_units::locktime::absolute::Time, bitcoin_units::locktime::absolute::ConversionError>
-pub const fn bitcoin_units::locktime::absolute::Time::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::absolute::is_block_height(n: u32) -> bool
-pub const fn bitcoin_units::locktime::absolute::is_block_time(n: u32) -> bool
-pub const fn bitcoin_units::locktime::relative::Height::from_height(blocks: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Height::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::relative::Height::value(self) -> u16
-pub const fn bitcoin_units::locktime::relative::Time::from_512_second_intervals(intervals: u16) -> Self
-pub const fn bitcoin_units::locktime::relative::Time::from_seconds_ceil(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::from_seconds_floor(seconds: u32) -> core::result::Result<Self, bitcoin_units::locktime::relative::TimeOverflowError>
-pub const fn bitcoin_units::locktime::relative::Time::to_consensus_u32(self) -> u32
-pub const fn bitcoin_units::locktime::relative::Time::value(self) -> u16
-pub const fn bitcoin_units::weight::Weight::checked_add(self, rhs: Self) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_div(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_mul(self, rhs: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::checked_mul_by_fee_rate(self, fee_rate: bitcoin_units::fee_rate::FeeRate) -> core::option::Option<bitcoin_units::Amount>
-pub const fn bitcoin_units::weight::Weight::checked_sub(self, rhs: Self) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::from_non_witness_data_size(non_witness_size: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_vb(vb: u64) -> core::option::Option<Self>
-pub const fn bitcoin_units::weight::Weight::from_vb_unchecked(vb: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_vb_unwrap(vb: u64) -> bitcoin_units::weight::Weight
-pub const fn bitcoin_units::weight::Weight::from_witness_data_size(witness_size: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::from_wu(wu: u64) -> Self
-pub const fn bitcoin_units::weight::Weight::to_kwu_ceil(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_kwu_floor(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_vbytes_ceil(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_vbytes_floor(self) -> u64
-pub const fn bitcoin_units::weight::Weight::to_wu(self) -> u64
-pub fn &bitcoin_units::Amount::add(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::sub(self, rhs: &'a bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::add(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::sub(self, rhs: &'a bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &'a bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::add(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::sub(self, rhs: &'a bitcoin_units::weight::Weight) -> Self::Output
-pub fn &bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::Amount>
-pub fn T::checked_sum(self) -> core::option::Option<bitcoin_units::SignedAmount>
-pub fn bitcoin_units::Amount::add(self, rhs: &bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: &bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::add_assign(&mut self, rhs: bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::clone(&self) -> bitcoin_units::Amount
-pub fn bitcoin_units::Amount::cmp(&self, other: &bitcoin_units::Amount) -> core::cmp::Ordering
-pub fn bitcoin_units::Amount::default() -> Self
-pub fn bitcoin_units::Amount::display_dynamic(self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::Amount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::Amount::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::Amount::div(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::Amount::div_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::Amount::eq(&self, other: &bitcoin_units::Amount) -> bool
-pub fn bitcoin_units::Amount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::Amount::from_int_btc<T: core::convert::Into<u64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::Amount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::Amount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::Amount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::ParseError>
-pub fn bitcoin_units::Amount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::Amount::mul(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::Amount::mul_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::Amount::partial_cmp(&self, other: &bitcoin_units::Amount) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::Amount::rem(self, modulus: u64) -> Self
-pub fn bitcoin_units::Amount::rem_assign(&mut self, modulus: u64)
-pub fn bitcoin_units::Amount::sub(self, rhs: &bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub(self, rhs: bitcoin_units::Amount) -> Self::Output
-pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: &bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::sub_assign(&mut self, rhs: bitcoin_units::Amount)
-pub fn bitcoin_units::Amount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::Amount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::Amount>
-pub fn bitcoin_units::Amount::to_signed(self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::Amount::try_from(value: bitcoin_units::SignedAmount) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::Amount::unchecked_add(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
-pub fn bitcoin_units::Amount::unchecked_sub(self, rhs: bitcoin_units::Amount) -> bitcoin_units::Amount
-pub fn bitcoin_units::SignedAmount::abs(self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::add(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::add_assign(&mut self, rhs: bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::clone(&self) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::cmp(&self, other: &bitcoin_units::SignedAmount) -> core::cmp::Ordering
-pub fn bitcoin_units::SignedAmount::default() -> Self
-pub fn bitcoin_units::SignedAmount::display_dynamic(self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::SignedAmount::display_in(self, denomination: bitcoin_units::amount::Denomination) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::SignedAmount::div(self, rhs: i64) -> Self::Output
-pub fn bitcoin_units::SignedAmount::div_assign(&mut self, rhs: i64)
-pub fn bitcoin_units::SignedAmount::eq(&self, other: &bitcoin_units::SignedAmount) -> bool
-pub fn bitcoin_units::SignedAmount::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::SignedAmount::from(value: bitcoin_units::Amount) -> Self
-pub fn bitcoin_units::SignedAmount::from_int_btc<T: core::convert::Into<i64>>(whole_bitcoin: T) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::SignedAmount::from_str_in(s: &str, denom: bitcoin_units::amount::Denomination) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseAmountError>
-pub fn bitcoin_units::SignedAmount::from_str_with_denomination(s: &str) -> core::result::Result<bitcoin_units::SignedAmount, bitcoin_units::amount::ParseError>
-pub fn bitcoin_units::SignedAmount::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::SignedAmount::is_negative(self) -> bool
-pub fn bitcoin_units::SignedAmount::is_positive(self) -> bool
-pub fn bitcoin_units::SignedAmount::mul(self, rhs: i64) -> Self::Output
-pub fn bitcoin_units::SignedAmount::mul_assign(&mut self, rhs: i64)
-pub fn bitcoin_units::SignedAmount::neg(self) -> Self::Output
-pub fn bitcoin_units::SignedAmount::partial_cmp(&self, other: &bitcoin_units::SignedAmount) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::SignedAmount::positive_sub(self, rhs: bitcoin_units::SignedAmount) -> core::option::Option<bitcoin_units::SignedAmount>
-pub fn bitcoin_units::SignedAmount::rem(self, modulus: i64) -> Self
-pub fn bitcoin_units::SignedAmount::rem_assign(&mut self, modulus: i64)
-pub fn bitcoin_units::SignedAmount::signum(self) -> i64
-pub fn bitcoin_units::SignedAmount::sub(self, rhs: &bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub(self, rhs: bitcoin_units::SignedAmount) -> Self::Output
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: &bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::sub_assign(&mut self, rhs: bitcoin_units::SignedAmount)
-pub fn bitcoin_units::SignedAmount::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::SignedAmount::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::SignedAmount>
-pub fn bitcoin_units::SignedAmount::to_unsigned(self) -> core::result::Result<bitcoin_units::Amount, bitcoin_units::amount::OutOfRangeError>
-pub fn bitcoin_units::SignedAmount::unchecked_add(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::unchecked_sub(self, rhs: bitcoin_units::SignedAmount) -> bitcoin_units::SignedAmount
-pub fn bitcoin_units::SignedAmount::unsigned_abs(self) -> bitcoin_units::Amount
-pub fn bitcoin_units::amount::CheckedSum::checked_sum(self) -> core::option::Option<R>
-pub fn bitcoin_units::amount::Denomination::clone(&self) -> bitcoin_units::amount::Denomination
-pub fn bitcoin_units::amount::Denomination::eq(&self, other: &bitcoin_units::amount::Denomination) -> bool
-pub fn bitcoin_units::amount::Denomination::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::Denomination::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::amount::Denomination::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::amount::Display::clone(&self) -> bitcoin_units::amount::Display
-pub fn bitcoin_units::amount::Display::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::Display::show_denomination(self) -> Self
-pub fn bitcoin_units::amount::InputTooLargeError::clone(&self) -> bitcoin_units::amount::InputTooLargeError
-pub fn bitcoin_units::amount::InputTooLargeError::eq(&self, other: &bitcoin_units::amount::InputTooLargeError) -> bool
-pub fn bitcoin_units::amount::InputTooLargeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::InvalidCharacterError::clone(&self) -> bitcoin_units::amount::InvalidCharacterError
-pub fn bitcoin_units::amount::InvalidCharacterError::eq(&self, other: &bitcoin_units::amount::InvalidCharacterError) -> bool
-pub fn bitcoin_units::amount::InvalidCharacterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::MissingDenominationError::clone(&self) -> bitcoin_units::amount::MissingDenominationError
-pub fn bitcoin_units::amount::MissingDenominationError::eq(&self, other: &bitcoin_units::amount::MissingDenominationError) -> bool
-pub fn bitcoin_units::amount::MissingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::MissingDigitsError::clone(&self) -> bitcoin_units::amount::MissingDigitsError
-pub fn bitcoin_units::amount::MissingDigitsError::eq(&self, other: &bitcoin_units::amount::MissingDigitsError) -> bool
-pub fn bitcoin_units::amount::MissingDigitsError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::OutOfRangeError::clone(&self) -> bitcoin_units::amount::OutOfRangeError
-pub fn bitcoin_units::amount::OutOfRangeError::eq(&self, other: &bitcoin_units::amount::OutOfRangeError) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::OutOfRangeError::is_above_max(self) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::is_below_min(self) -> bool
-pub fn bitcoin_units::amount::OutOfRangeError::valid_range(self) -> (i64, u64)
-pub fn bitcoin_units::amount::ParseAmountError::clone(&self) -> bitcoin_units::amount::ParseAmountError
-pub fn bitcoin_units::amount::ParseAmountError::eq(&self, other: &bitcoin_units::amount::ParseAmountError) -> bool
-pub fn bitcoin_units::amount::ParseAmountError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseAmountError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::ParseAmountError::from(value: bitcoin_units::amount::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::ParseDenominationError::clone(&self) -> bitcoin_units::amount::ParseDenominationError
-pub fn bitcoin_units::amount::ParseDenominationError::eq(&self, other: &bitcoin_units::amount::ParseDenominationError) -> bool
-pub fn bitcoin_units::amount::ParseDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseDenominationError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::ParseError::clone(&self) -> bitcoin_units::amount::ParseError
-pub fn bitcoin_units::amount::ParseError::eq(&self, other: &bitcoin_units::amount::ParseError) -> bool
-pub fn bitcoin_units::amount::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InputTooLargeError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::InvalidCharacterError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::MissingDigitsError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::OutOfRangeError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseAmountError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::ParseDenominationError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(e: bitcoin_units::amount::TooPreciseError) -> Self
-pub fn bitcoin_units::amount::ParseError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::clone(&self) -> bitcoin_units::amount::PossiblyConfusingDenominationError
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::eq(&self, other: &bitcoin_units::amount::PossiblyConfusingDenominationError) -> bool
-pub fn bitcoin_units::amount::PossiblyConfusingDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::TooPreciseError::clone(&self) -> bitcoin_units::amount::TooPreciseError
-pub fn bitcoin_units::amount::TooPreciseError::eq(&self, other: &bitcoin_units::amount::TooPreciseError) -> bool
-pub fn bitcoin_units::amount::TooPreciseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::amount::UnknownDenominationError::clone(&self) -> bitcoin_units::amount::UnknownDenominationError
-pub fn bitcoin_units::amount::UnknownDenominationError::eq(&self, other: &bitcoin_units::amount::UnknownDenominationError) -> bool
-pub fn bitcoin_units::amount::UnknownDenominationError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::block::BlockHeight::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::clone(&self) -> bitcoin_units::block::BlockHeight
-pub fn bitcoin_units::block::BlockHeight::cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::cmp::Ordering
-pub fn bitcoin_units::block::BlockHeight::eq(&self, other: &bitcoin_units::block::BlockHeight) -> bool
-pub fn bitcoin_units::block::BlockHeight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::block::BlockHeight::from(h: bitcoin_units::locktime::absolute::Height) -> Self
-pub fn bitcoin_units::block::BlockHeight::from(inner: u32) -> Self
-pub fn bitcoin_units::block::BlockHeight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::block::BlockHeight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::block::BlockHeight::partial_cmp(&self, other: &bitcoin_units::block::BlockHeight) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockHeight) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockHeight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::BlockInterval::add(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockInterval::add_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
-pub fn bitcoin_units::block::BlockInterval::clone(&self) -> bitcoin_units::block::BlockInterval
-pub fn bitcoin_units::block::BlockInterval::cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::cmp::Ordering
-pub fn bitcoin_units::block::BlockInterval::default() -> bitcoin_units::block::BlockInterval
-pub fn bitcoin_units::block::BlockInterval::eq(&self, other: &bitcoin_units::block::BlockInterval) -> bool
-pub fn bitcoin_units::block::BlockInterval::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::block::BlockInterval::from(h: bitcoin_units::locktime::relative::Height) -> Self
-pub fn bitcoin_units::block::BlockInterval::from(inner: u32) -> Self
-pub fn bitcoin_units::block::BlockInterval::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::block::BlockInterval::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::block::BlockInterval::partial_cmp(&self, other: &bitcoin_units::block::BlockInterval) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::block::BlockInterval::sub(self, rhs: bitcoin_units::block::BlockInterval) -> Self::Output
-pub fn bitcoin_units::block::BlockInterval::sub_assign(&mut self, rhs: bitcoin_units::block::BlockInterval)
-pub fn bitcoin_units::block::BlockInterval::sum<I: core::iter::traits::iterator::Iterator<Item = Self>>(iter: I) -> Self
-pub fn bitcoin_units::block::BlockInterval::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::block::BlockInterval>
-pub fn bitcoin_units::block::BlockInterval::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::clone(&self) -> bitcoin_units::block::TooBigForRelativeBlockHeightError
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::eq(&self, other: &bitcoin_units::block::TooBigForRelativeBlockHeightError) -> bool
-pub fn bitcoin_units::block::TooBigForRelativeBlockHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::add(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::add_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::clone(&self) -> bitcoin_units::fee_rate::FeeRate
-pub fn bitcoin_units::fee_rate::FeeRate::cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::cmp::Ordering
-pub fn bitcoin_units::fee_rate::FeeRate::eq(&self, other: &bitcoin_units::fee_rate::FeeRate) -> bool
-pub fn bitcoin_units::fee_rate::FeeRate::fee_vb(self, vb: u64) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::fee_wu(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::fee_rate::FeeRate::from_sat_per_vb(sat_vb: u64) -> core::option::Option<Self>
-pub fn bitcoin_units::fee_rate::FeeRate::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::fee_rate::FeeRate::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::fee_rate::FeeRate::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::partial_cmp(&self, other: &bitcoin_units::fee_rate::FeeRate) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: &bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::sub(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: &bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sub_assign(&mut self, rhs: bitcoin_units::fee_rate::FeeRate)
-pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::fee_rate::FeeRate>
-pub fn bitcoin_units::fee_rate::FeeRate::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
-pub fn bitcoin_units::fee_rate::FeeRate::to_fee(self, weight: bitcoin_units::weight::Weight) -> core::option::Option<bitcoin_units::Amount>
-pub fn bitcoin_units::fee_rate::FeeRate::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::ConversionError::clone(&self) -> bitcoin_units::locktime::absolute::ConversionError
-pub fn bitcoin_units::locktime::absolute::ConversionError::eq(&self, other: &bitcoin_units::locktime::absolute::ConversionError) -> bool
-pub fn bitcoin_units::locktime::absolute::ConversionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Height::clone(&self) -> bitcoin_units::locktime::absolute::Height
-pub fn bitcoin_units::locktime::absolute::Height::cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::absolute::Height::eq(&self, other: &bitcoin_units::locktime::absolute::Height) -> bool
-pub fn bitcoin_units::locktime::absolute::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Height::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseHeightError>
-pub fn bitcoin_units::locktime::absolute::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::absolute::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::absolute::Height::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Height) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(h: bitcoin_units::block::BlockHeight) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::clone(&self) -> bitcoin_units::locktime::absolute::ParseHeightError
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseHeightError) -> bool
-pub fn bitcoin_units::locktime::absolute::ParseHeightError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::clone(&self) -> bitcoin_units::locktime::absolute::ParseTimeError
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::eq(&self, other: &bitcoin_units::locktime::absolute::ParseTimeError) -> bool
-pub fn bitcoin_units::locktime::absolute::ParseTimeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Time::clone(&self) -> bitcoin_units::locktime::absolute::Time
-pub fn bitcoin_units::locktime::absolute::Time::cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::absolute::Time::eq(&self, other: &bitcoin_units::locktime::absolute::Time) -> bool
-pub fn bitcoin_units::locktime::absolute::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::absolute::Time::from_hex(s: &str) -> core::result::Result<Self, bitcoin_units::locktime::absolute::ParseTimeError>
-pub fn bitcoin_units::locktime::absolute::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::absolute::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::absolute::Time::partial_cmp(&self, other: &bitcoin_units::locktime::absolute::Time) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::absolute::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::clone(&self) -> bitcoin_units::locktime::relative::Height
-pub fn bitcoin_units::locktime::relative::Height::cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::relative::Height::default() -> bitcoin_units::locktime::relative::Height
-pub fn bitcoin_units::locktime::relative::Height::eq(&self, other: &bitcoin_units::locktime::relative::Height) -> bool
-pub fn bitcoin_units::locktime::relative::Height::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::Height::from(value: u16) -> Self
-pub fn bitcoin_units::locktime::relative::Height::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::relative::Height::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::relative::Height::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Height) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::relative::Height::try_from(h: bitcoin_units::block::BlockInterval) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Height::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::Time::clone(&self) -> bitcoin_units::locktime::relative::Time
-pub fn bitcoin_units::locktime::relative::Time::cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::cmp::Ordering
-pub fn bitcoin_units::locktime::relative::Time::default() -> bitcoin_units::locktime::relative::Time
-pub fn bitcoin_units::locktime::relative::Time::eq(&self, other: &bitcoin_units::locktime::relative::Time) -> bool
-pub fn bitcoin_units::locktime::relative::Time::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::Time::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::locktime::relative::Time::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::locktime::relative::Time::partial_cmp(&self, other: &bitcoin_units::locktime::relative::Time) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::locktime::relative::Time::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::clone(&self) -> bitcoin_units::locktime::relative::TimeOverflowError
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::eq(&self, other: &bitcoin_units::locktime::relative::TimeOverflowError) -> bool
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::locktime::relative::TimeOverflowError::new(seconds: u32) -> Self
-pub fn bitcoin_units::parse::ParseIntError::as_ref(&self) -> &core::num::error::ParseIntError
-pub fn bitcoin_units::parse::ParseIntError::clone(&self) -> bitcoin_units::parse::ParseIntError
-pub fn bitcoin_units::parse::ParseIntError::eq(&self, other: &bitcoin_units::parse::ParseIntError) -> bool
-pub fn bitcoin_units::parse::ParseIntError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::PrefixedHexError::clone(&self) -> bitcoin_units::parse::PrefixedHexError
-pub fn bitcoin_units::parse::PrefixedHexError::eq(&self, other: &bitcoin_units::parse::PrefixedHexError) -> bool
-pub fn bitcoin_units::parse::PrefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::PrefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
-pub fn bitcoin_units::parse::PrefixedHexError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::parse::UnprefixedHexError::clone(&self) -> bitcoin_units::parse::UnprefixedHexError
-pub fn bitcoin_units::parse::UnprefixedHexError::eq(&self, other: &bitcoin_units::parse::UnprefixedHexError) -> bool
-pub fn bitcoin_units::parse::UnprefixedHexError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::parse::UnprefixedHexError::from(e: bitcoin_units::parse::ParseIntError) -> Self
-pub fn bitcoin_units::parse::UnprefixedHexError::from(never: core::convert::Infallible) -> Self
-pub fn bitcoin_units::parse::hex_check_unprefixed(s: &str) -> core::result::Result<&str, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::hex_remove_prefix(s: &str) -> core::result::Result<&str, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u128(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u128_prefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u128_unchecked(s: &str) -> core::result::Result<u128, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u128_unprefixed(s: &str) -> core::result::Result<u128, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::hex_u32(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u32_prefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::PrefixedHexError>
-pub fn bitcoin_units::parse::hex_u32_unchecked(s: &str) -> core::result::Result<u32, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::parse::hex_u32_unprefixed(s: &str) -> core::result::Result<u32, bitcoin_units::parse::UnprefixedHexError>
-pub fn bitcoin_units::parse::int_from_str<T: bitcoin_units::parse::Integer>(s: &str) -> core::result::Result<T, bitcoin_units::parse::ParseIntError>
-pub fn bitcoin_units::weight::Weight::add(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::add_assign(&mut self, rhs: bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::clone(&self) -> bitcoin_units::weight::Weight
-pub fn bitcoin_units::weight::Weight::cmp(&self, other: &bitcoin_units::weight::Weight) -> core::cmp::Ordering
-pub fn bitcoin_units::weight::Weight::div(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::div(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::weight::Weight::div_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::weight::Weight::eq(&self, other: &bitcoin_units::weight::Weight) -> bool
-pub fn bitcoin_units::weight::Weight::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
-pub fn bitcoin_units::weight::Weight::from_kwu(wu: u64) -> core::option::Option<Self>
-pub fn bitcoin_units::weight::Weight::from_str(s: &str) -> core::result::Result<Self, Self::Err>
-pub fn bitcoin_units::weight::Weight::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
-pub fn bitcoin_units::weight::Weight::mul(self, rhs: bitcoin_units::fee_rate::FeeRate) -> Self::Output
-pub fn bitcoin_units::weight::Weight::mul(self, rhs: u64) -> Self::Output
-pub fn bitcoin_units::weight::Weight::mul_assign(&mut self, rhs: u64)
-pub fn bitcoin_units::weight::Weight::partial_cmp(&self, other: &bitcoin_units::weight::Weight) -> core::option::Option<core::cmp::Ordering>
-pub fn bitcoin_units::weight::Weight::sub(self, rhs: &bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: &bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::sub_assign(&mut self, rhs: bitcoin_units::weight::Weight)
-pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = &'a bitcoin_units::weight::Weight>
-pub fn bitcoin_units::weight::Weight::sum<I>(iter: I) -> Self where I: core::iter::traits::iterator::Iterator<Item = Self>
-pub fn bitcoin_units::weight::Weight::try_from(s: &str) -> core::result::Result<Self, Self::Error>
-pub fn core::num::error::ParseIntError::from(value: bitcoin_units::parse::ParseIntError) -> Self
-pub fn u32::from(height: bitcoin_units::block::BlockHeight) -> Self
-pub fn u32::from(height: bitcoin_units::block::BlockInterval) -> Self
-pub fn u64::from(value: bitcoin_units::fee_rate::FeeRate) -> Self
-pub fn u64::from(value: bitcoin_units::weight::Weight) -> Self
-pub fn u64::mul(self, rhs: bitcoin_units::weight::Weight) -> Self::Output
-pub mod bitcoin_units
-pub mod bitcoin_units::amount
-pub mod bitcoin_units::block
-pub mod bitcoin_units::fee_rate
-pub mod bitcoin_units::locktime
-pub mod bitcoin_units::locktime::absolute
-pub mod bitcoin_units::locktime::relative
-pub mod bitcoin_units::parse
-pub mod bitcoin_units::weight
-pub struct bitcoin_units::Amount(_)
-pub struct bitcoin_units::BlockHeight(pub u32)
-pub struct bitcoin_units::BlockInterval(pub u32)
-pub struct bitcoin_units::FeeRate(_)
-pub struct bitcoin_units::SignedAmount(_)
-pub struct bitcoin_units::Weight(_)
-pub struct bitcoin_units::amount::Amount(_)
-pub struct bitcoin_units::amount::Display
-pub struct bitcoin_units::amount::InputTooLargeError
-pub struct bitcoin_units::amount::InvalidCharacterError
-pub struct bitcoin_units::amount::MissingDigitsError
-pub struct bitcoin_units::amount::OutOfRangeError
-pub struct bitcoin_units::amount::ParseAmountError(_)
-pub struct bitcoin_units::amount::ParseError(_)
-pub struct bitcoin_units::amount::SignedAmount(_)
-pub struct bitcoin_units::amount::TooPreciseError
-pub struct bitcoin_units::block::BlockHeight(pub u32)
-pub struct bitcoin_units::block::BlockInterval(pub u32)
-pub struct bitcoin_units::block::TooBigForRelativeBlockHeightError(_)
-pub struct bitcoin_units::fee_rate::FeeRate(_)
-pub struct bitcoin_units::locktime::absolute::Height(_)
-pub struct bitcoin_units::locktime::absolute::ParseHeightError(_)
-pub struct bitcoin_units::locktime::absolute::ParseTimeError(_)
-pub struct bitcoin_units::locktime::absolute::Time(_)
-pub struct bitcoin_units::locktime::relative::Height(_)
-pub struct bitcoin_units::locktime::relative::Time(_)
-pub struct bitcoin_units::locktime::relative::TimeOverflowError
-pub struct bitcoin_units::parse::PrefixedHexError(_)
-pub struct bitcoin_units::parse::UnprefixedHexError(_)
-pub struct bitcoin_units::weight::Weight(_)
-pub trait bitcoin_units::amount::CheckedSum<R>: bitcoin_units::amount::sealed::Sealed<R>
-pub trait bitcoin_units::parse::Integer: core::str::traits::FromStr<Err = core::num::error::ParseIntError> + core::convert::TryFrom<i8> + core::marker::Sized + bitcoin_units::parse::sealed::Sealed
-pub type &bitcoin_units::Amount::Output = bitcoin_units::Amount
-pub type &bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type &bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
-pub type &bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::Amount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::Amount::Error = bitcoin_units::amount::OutOfRangeError
-pub type bitcoin_units::Amount::Output = bitcoin_units::Amount
-pub type bitcoin_units::Amount::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::Amount::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::SignedAmount::Err = bitcoin_units::amount::ParseError
-pub type bitcoin_units::SignedAmount::Output = bitcoin_units::SignedAmount
-pub type bitcoin_units::amount::Denomination::Err = bitcoin_units::amount::ParseDenominationError
-pub type bitcoin_units::block::BlockHeight::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockHeight::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockHeight
-pub type bitcoin_units::block::BlockHeight::Output = bitcoin_units::block::BlockInterval
-pub type bitcoin_units::block::BlockInterval::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockInterval::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::block::BlockInterval::Output = bitcoin_units::block::BlockInterval
-pub type bitcoin_units::fee_rate::FeeRate::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::fee_rate::FeeRate::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::Amount
-pub type bitcoin_units::fee_rate::FeeRate::Output = bitcoin_units::fee_rate::FeeRate
-pub type bitcoin_units::locktime::absolute::Height::Err = bitcoin_units::locktime::absolute::ParseHeightError
-pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ConversionError
-pub type bitcoin_units::locktime::absolute::Height::Error = bitcoin_units::locktime::absolute::ParseHeightError
-pub type bitcoin_units::locktime::absolute::Time::Err = bitcoin_units::locktime::absolute::ParseTimeError
-pub type bitcoin_units::locktime::absolute::Time::Error = bitcoin_units::locktime::absolute::ParseTimeError
-pub type bitcoin_units::locktime::relative::Height::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::block::TooBigForRelativeBlockHeightError
-pub type bitcoin_units::locktime::relative::Height::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Time::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::locktime::relative::Time::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Err = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Error = bitcoin_units::parse::ParseIntError
-pub type bitcoin_units::weight::Weight::Output = bitcoin_units::Amount
-pub type bitcoin_units::weight::Weight::Output = bitcoin_units::weight::Weight
-pub type bitcoin_units::weight::Weight::Output = u64
-pub type u64::Output = bitcoin_units::weight::Weight

From 927251ef8e8d158a0f93c23f9c40d95ec719b520 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 5 Feb 2025 16:33:15 +0000
Subject: [PATCH 320/554] Expand version signalling test

Add a check for max soft fork signalling bit 28
---
 primitives/src/block.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index cfc322c15f..12a24eae5c 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -365,6 +365,8 @@ mod tests {
     fn version_is_signalling() {
         let version = Version::from_consensus(0b00100000000000000000000000000010);
         assert!(Version::is_signalling_soft_fork(&version, 1));
+        let version = Version::from_consensus(0b00110000000000000000000000000000);
+        assert!(Version::is_signalling_soft_fork(&version, 28));
     }
 
     #[test]

From 0df15d5cfd1813dc7124a346dfbf34b566f152e9 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 5 Feb 2025 16:45:08 +0000
Subject: [PATCH 321/554] Add version test

Mutant found in Version.

Add a round trip test for version::from_consensus to kill the mutant.
---
 primitives/src/block.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index 12a24eae5c..faa37f2184 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -374,4 +374,10 @@ mod tests {
         let version = Version::from_consensus(0b00100000000000000000000000000010);
         assert!(!Version::is_signalling_soft_fork(&version, 0));
     }
+
+    #[test]
+    fn version_to_consensus() {
+        let version = Version::from_consensus(1234567890);
+        assert_eq!(version.to_consensus(), 1234567890);
+    }
 }

From ff3b3ddb675446fd21f3f7488749fc7fb26c7ef2 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Wed, 5 Feb 2025 21:37:31 +0000
Subject: [PATCH 322/554] Add a test for Header size

Calculate the header size and test it is equal to `Header::SIZE`
---
 primitives/src/block.rs | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index faa37f2184..b30a2c6c96 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -380,4 +380,28 @@ mod tests {
         let version = Version::from_consensus(1234567890);
         assert_eq!(version.to_consensus(), 1234567890);
     }
+
+    // Check that the size of the header consensus serialization matches the const SIZE value
+    #[test]
+    fn header_size() {
+        let header = Header {
+            version: Version::ONE,
+            prev_blockhash: BlockHash::from_byte_array([0x99; 32]),
+            merkle_root: TxMerkleNode::from_byte_array([0x77; 32]),
+            time: 2,
+            bits: CompactTarget::from_consensus(3),
+            nonce: 4,
+        };
+
+        // Calculate the size of the block header in bytes from the sum of the serialized lengths
+        // it's fields: version, prev_blockhash, merkle_root, time, bits, nonce.
+        let header_size = header.version.to_consensus().to_le_bytes().len()
+            + header.prev_blockhash.as_byte_array().len()
+            + header.merkle_root.as_byte_array().len()
+            + header.time.to_le_bytes().len()
+            + header.bits.to_consensus().to_le_bytes().len()
+            + header.nonce.to_le_bytes().len();
+
+        assert_eq!(header_size, Header::SIZE);
+    }
 }

From 486d55f0421a05c0aaa8f883bc15cacd212dcc19 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 6 Feb 2025 16:07:25 +0000
Subject: [PATCH 323/554] Add test to opcodes

Cargo mutant found a mutant in opcodes.

Add a test to kill it.
---
 primitives/src/opcodes.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index bd9e8ce862..5da0295d39 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -565,6 +565,12 @@ mod tests {
         assert_eq!(s, "    OP_NOP");
     }
 
+    #[test]
+    fn ordinary_op_code() {
+        let ordinary_op = Ordinary::from_opcode(OP_PUSHDATA1).expect("0x4C");
+        assert_eq!(ordinary_op.to_u8(), 0x4C_u8);
+    }
+
     #[test]
     fn decode_pushnum() {
         // Test all possible opcodes

From b2d0737accb998071e0f19cda6f988956b6c097a Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 6 Feb 2025 17:05:06 +0000
Subject: [PATCH 324/554] Add tests to CompactTarget

Add tests to pow.rs to kill the mutants found in CompactTarget.
---
 primitives/src/pow.rs | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/primitives/src/pow.rs b/primitives/src/pow.rs
index b4a25f3409..95743c7a28 100644
--- a/primitives/src/pow.rs
+++ b/primitives/src/pow.rs
@@ -43,3 +43,26 @@ impl fmt::UpperHex for CompactTarget {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::UpperHex::fmt(&self.0, f) }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn compact_target_ordering() {
+        let lower = CompactTarget::from_consensus(0x1d00fffe);
+        let lower_copy = CompactTarget::from_consensus(0x1d00fffe);
+        let higher = CompactTarget::from_consensus(0x1d00ffff);
+
+        assert!(lower < higher);
+        assert!(lower == lower_copy);
+    }
+
+    #[test]
+    fn compact_target_formatting() {
+        let compact_target = CompactTarget::from_consensus(0x1d00ffff);
+        assert_eq!(format!("{:x}", compact_target), "1d00ffff");
+        assert_eq!(format!("{:X}", compact_target), "1D00FFFF");
+        assert_eq!(compact_target.to_consensus(), 0x1d00ffff);
+    }
+}

From a4fe67645ac2ac130de5509b84c142b0a0f63179 Mon Sep 17 00:00:00 2001
From: ndungudedan <dnkibere@gmail.com>
Date: Thu, 6 Feb 2025 22:23:45 +0300
Subject: [PATCH 325/554] Use relative::* or absolute::* in locktime example

Users should be encouraged to explicitly use relative::* or

absolute::* instead of just LockTime, Time, or Height so that

it is clear when looking at the code if it is a relative or

absolute locktime.
---
 primitives/src/locktime/absolute.rs | 58 ++++++++++++++---------------
 primitives/src/locktime/relative.rs | 38 +++++++++----------
 2 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 976f56143c..ae924e26bc 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -42,9 +42,9 @@ pub use units::locktime::absolute::{ConversionError, Height, ParseHeightError, P
 /// # Examples
 ///
 /// ```
-/// # use bitcoin_primitives::absolute::{LockTime, LockTime::*};
-/// # let n = LockTime::from_consensus(741521);          // n OP_CHECKLOCKTIMEVERIFY
-/// # let lock_time = LockTime::from_consensus(741521);  // nLockTime
+/// # use bitcoin_primitives::absolute::{self, LockTime::*};
+/// # let n = absolute::LockTime::from_consensus(741521);          // n OP_CHECKLOCKTIMEVERIFY
+/// # let lock_time = absolute::LockTime::from_consensus(741521);  // nLockTime
 /// // To compare absolute lock times there are various `is_satisfied_*` methods, you may also use:
 /// let _is_satisfied = match (n, lock_time) {
 ///     (Blocks(n), Blocks(lock_time)) => n <= lock_time,
@@ -59,10 +59,10 @@ pub enum LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// use bitcoin_primitives::absolute::LockTime;
+    /// use bitcoin_primitives::absolute;
     ///
     /// let block: u32 = 741521;
-    /// let n = LockTime::from_height(block).expect("valid height");
+    /// let n = absolute::LockTime::from_height(block).expect("valid height");
     /// assert!(n.is_block_height());
     /// assert_eq!(n.to_consensus_u32(), block);
     /// ```
@@ -72,10 +72,10 @@ pub enum LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// use bitcoin_primitives::absolute::LockTime;
+    /// use bitcoin_primitives::absolute;
     ///
     /// let seconds: u32 = 1653195600; // May 22nd, 5am UTC.
-    /// let n = LockTime::from_time(seconds).expect("valid time");
+    /// let n = absolute::LockTime::from_time(seconds).expect("valid time");
     /// assert!(n.is_block_time());
     /// assert_eq!(n.to_consensus_u32(), seconds);
     /// ```
@@ -95,9 +95,9 @@ impl LockTime {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_primitives::absolute::LockTime;
+    /// # use bitcoin_primitives::absolute;
     /// let hex_str = "0x61cf9980"; // Unix timestamp for January 1, 2022
-    /// let lock_time = LockTime::from_hex(hex_str)?;
+    /// let lock_time = absolute::LockTime::from_hex(hex_str)?;
     /// assert_eq!(lock_time.to_consensus_u32(), 0x61cf9980);
     ///
     /// # Ok::<_, units::parse::PrefixedHexError>(())
@@ -112,9 +112,9 @@ impl LockTime {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_primitives::absolute::LockTime;
+    /// # use bitcoin_primitives::absolute;
     /// let hex_str = "61cf9980"; // Unix timestamp for January 1, 2022
-    /// let lock_time = LockTime::from_unprefixed_hex(hex_str)?;
+    /// let lock_time = absolute::LockTime::from_unprefixed_hex(hex_str)?;
     /// assert_eq!(lock_time.to_consensus_u32(), 0x61cf9980);
     ///
     /// # Ok::<_, units::parse::UnprefixedHexError>(())
@@ -129,11 +129,11 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin_primitives::absolute::LockTime;
+    /// # use bitcoin_primitives::absolute;
     ///
     /// // `from_consensus` roundtrips as expected with `to_consensus_u32`.
     /// let n_lock_time: u32 = 741521;
-    /// let lock_time = LockTime::from_consensus(n_lock_time);
+    /// let lock_time = absolute::LockTime::from_consensus(n_lock_time);
     /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
     #[inline]
     pub fn from_consensus(n: u32) -> Self {
@@ -157,9 +157,9 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin_primitives::absolute::LockTime;
-    /// assert!(LockTime::from_height(741521).is_ok());
-    /// assert!(LockTime::from_height(1653195600).is_err());
+    /// # use bitcoin_primitives::absolute;
+    /// assert!(absolute::LockTime::from_height(741521).is_ok());
+    /// assert!(absolute::LockTime::from_height(1653195600).is_err());
     /// ```
     #[inline]
     pub fn from_height(n: u32) -> Result<Self, ConversionError> {
@@ -183,9 +183,9 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin_primitives::absolute::LockTime;
-    /// assert!(LockTime::from_time(1653195600).is_ok());
-    /// assert!(LockTime::from_time(741521).is_err());
+    /// # use bitcoin_primitives::absolute;
+    /// assert!(absolute::LockTime::from_time(1653195600).is_ok());
+    /// assert!(absolute::LockTime::from_time(741521).is_err());
     /// ```
     #[inline]
     pub fn from_time(n: u32) -> Result<Self, ConversionError> {
@@ -223,12 +223,12 @@ impl LockTime {
     /// # Examples
     ///
     /// ```no_run
-    /// # use bitcoin_primitives::absolute::{LockTime, Height, Time};
+    /// # use bitcoin_primitives::absolute;
     /// // 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") }
+    /// fn get_height() -> absolute::Height { todo!("return the current block height") }
+    /// fn get_time() -> absolute::Time { todo!("return the current block time") }
     ///
-    /// let n = LockTime::from_consensus(741521); // `n OP_CHEKCLOCKTIMEVERIFY`.
+    /// let n = absolute::LockTime::from_consensus(741521); // `n OP_CHEKCLOCKTIMEVERIFY`.
     /// if n.is_satisfied_by(get_height(), get_time()) {
     ///     // Can create and mine a transaction that satisfies the OP_CLTV timelock constraint.
     /// }
@@ -257,9 +257,9 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin_primitives::absolute::LockTime;
-    /// let lock_time = LockTime::from_consensus(741521);
-    /// let check = LockTime::from_consensus(741521 + 1);
+    /// # use bitcoin_primitives::absolute;
+    /// let lock_time = absolute::LockTime::from_consensus(741521);
+    /// let check = absolute::LockTime::from_consensus(741521 + 1);
     /// assert!(lock_time.is_implied_by(check));
     /// ```
     #[inline]
@@ -285,9 +285,9 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin_primitives::absolute::{LockTime, LockTime::*};
-    /// # let n = LockTime::from_consensus(741521);              // n OP_CHECKLOCKTIMEVERIFY
-    /// # let lock_time = LockTime::from_consensus(741521 + 1);  // nLockTime
+    /// # use bitcoin_primitives::absolute::{self, LockTime::*};
+    /// # let n = absolute::LockTime::from_consensus(741521);  // n OP_CHECKLOCKTIMEVERIFY
+    /// # let lock_time = absolute::LockTime::from_consensus(741521 + 1);  // nLockTime
     ///
     /// let _is_satisfied = match (n, lock_time) {
     ///     (Blocks(n), Blocks(lock_time)) => n <= lock_time,
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 85aeeaeaa9..0874225b22 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -36,16 +36,16 @@ pub use units::locktime::relative::{Height, Time, TimeOverflowError};
 /// # Examples
 ///
 /// ```
-/// use bitcoin_primitives::relative::{LockTime, Height, Time};
-/// let lock_by_height = LockTime::from_height(144); // 144 blocks, approx 24h.
+/// use bitcoin_primitives::relative;
+/// let lock_by_height = relative::LockTime::from_height(144); // 144 blocks, approx 24h.
 /// assert!(lock_by_height.is_block_height());
 ///
-/// let lock_by_time = LockTime::from_512_second_intervals(168); // 168 time intervals, approx 24h.
+/// let lock_by_time = relative::LockTime::from_512_second_intervals(168); // 168 time intervals, approx 24h.
 /// assert!(lock_by_time.is_block_time());
 ///
 /// // Check if a lock time is satisfied by a given height or time.
-/// let height = Height::from(150);
-/// let time = Time::from_512_second_intervals(200);
+/// let height = relative::Height::from(150);
+/// let time = relative::Time::from_512_second_intervals(200);
 /// assert!(lock_by_height.is_satisfied_by(height, time));
 /// assert!(lock_by_time.is_satisfied_by(height, time));
 /// ```
@@ -75,17 +75,17 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin_primitives::relative::LockTime;
+    /// # use bitcoin_primitives::relative;
     ///
     /// // Values with bit 22 set to 0 will be interpreted as height-based lock times.
     /// let height: u32 = 144; // 144 blocks, approx 24h.
-    /// let lock_time = LockTime::from_consensus(height)?;
+    /// let lock_time = relative::LockTime::from_consensus(height)?;
     /// assert!(lock_time.is_block_height());
     /// assert_eq!(lock_time.to_consensus_u32(), height);
     ///
     /// // Values with bit 22 set to 1 will be interpreted as time-based lock times.
     /// let time: u32 = 168 | (1 << 22) ; // Bit 22 is 1 with time approx 24h.
-    /// let lock_time = LockTime::from_consensus(time)?;
+    /// let lock_time = relative::LockTime::from_consensus(time)?;
     /// assert!(lock_time.is_block_time());
     /// assert_eq!(lock_time.to_consensus_u32(), time);
     ///
@@ -118,11 +118,11 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin_primitives::{Sequence, relative::LockTime};
+    /// # use bitcoin_primitives::{Sequence, relative};
     ///
     /// // Interpret a sequence number from a Bitcoin transaction input as a relative lock time
     /// let sequence_number = Sequence::from_consensus(144); // 144 blocks, approx 24h.
-    /// let lock_time = LockTime::from_sequence(sequence_number)?;
+    /// let lock_time = relative::LockTime::from_sequence(sequence_number)?;
     /// assert!(lock_time.is_block_height());
     ///
     /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
@@ -200,12 +200,12 @@ impl LockTime {
     ///
     /// ```rust
     /// # use bitcoin_primitives::Sequence;
-    /// # use bitcoin_primitives::locktime::relative::{Height, Time};
+    /// # use bitcoin_primitives::relative;
     ///
     /// # let required_height = 100;       // 100 blocks.
     /// # let intervals = 70;     // Approx 10 hours.
-    /// # let current_height = || Height::from(required_height + 10);
-    /// # let current_time = || Time::from_512_second_intervals(intervals + 10);
+    /// # let current_height = || relative::Height::from(required_height + 10);
+    /// # let current_time = || relative::Time::from_512_second_intervals(intervals + 10);
     /// # let lock = Sequence::from_height(required_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.
@@ -269,10 +269,10 @@ impl LockTime {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_primitives::{Sequence, relative::LockTime};
+    /// # use bitcoin_primitives::{Sequence, relative};
     ///
     /// let sequence = Sequence::from_consensus(1 << 22 | 168); // Bit 22 is 1 with time approx 24h.
-    /// let lock_time = LockTime::from_sequence(sequence)?;
+    /// let lock_time = relative::LockTime::from_sequence(sequence)?;
     /// let input_sequence = Sequence::from_consensus(1 << 22 | 336); // Approx 48h.
     /// assert!(lock_time.is_block_time());
     ///
@@ -299,11 +299,11 @@ impl LockTime {
     ///
     /// ```rust
     /// # use bitcoin_primitives::Sequence;
-    /// # use bitcoin_primitives::locktime::relative::Height;
+    /// # use bitcoin_primitives::relative;
     ///
     /// let required_height: u16 = 100;
     /// let lock = Sequence::from_height(required_height).to_relative_lock_time().expect("valid height");
-    /// assert!(lock.is_satisfied_by_height(Height::from(required_height + 1)).expect("a height"));
+    /// assert!(lock.is_satisfied_by_height(relative::Height::from(required_height + 1)).expect("a height"));
     /// ```
     #[inline]
     pub fn is_satisfied_by_height(&self, height: Height) -> Result<bool, IncompatibleHeightError> {
@@ -325,11 +325,11 @@ impl LockTime {
     ///
     /// ```rust
     /// # use bitcoin_primitives::Sequence;
-    /// # use bitcoin_primitives::locktime::relative::Time;
+    /// # use bitcoin_primitives::relative;
     ///
     /// let intervals: u16 = 70; // approx 10 hours;
     /// let lock = Sequence::from_512_second_intervals(intervals).to_relative_lock_time().expect("valid time");
-    /// assert!(lock.is_satisfied_by_time(Time::from_512_second_intervals(intervals + 10)).expect("a time"));
+    /// assert!(lock.is_satisfied_by_time(relative::Time::from_512_second_intervals(intervals + 10)).expect("a time"));
     /// ```
     #[inline]
     pub fn is_satisfied_by_time(&self, time: Time) -> Result<bool, IncompatibleTimeError> {

From ee0486a43f33a6068f13fb1a82244ecb60b94740 Mon Sep 17 00:00:00 2001
From: yancy <yancy@yancy.lol>
Date: Tue, 14 Jan 2025 12:29:46 -0600
Subject: [PATCH 326/554] refactor: use convenience method to calculate fee

The FeeRate module provides a convenience method to calculate the fee.
---
 bitcoin/src/blockdata/transaction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 7d7bf76993..d9ec07c808 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -790,7 +790,7 @@ pub fn effective_value(
     value: Amount,
 ) -> Option<SignedAmount> {
     let weight = satisfaction_weight.checked_add(TX_IN_BASE_WEIGHT)?;
-    let signed_input_fee = fee_rate.checked_mul_by_weight(weight)?.to_signed();
+    let signed_input_fee = fee_rate.to_fee(weight)?.to_signed();
     value.to_signed().checked_sub(signed_input_fee)
 }
 

From 94f9bac6aadec17bbda66f7ad23a970fccdd840e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 4 Feb 2025 09:17:59 +1100
Subject: [PATCH 327/554] Return Self::Output from ops::Rem

The ops traits return `Self::Output` not `Self`. The current code builds
because `Self` and `Self::Output` are both the same type.

Use `Self::Output` as the return value of `ops::Rem`.
---
 units/src/amount/signed.rs   | 2 +-
 units/src/amount/unsigned.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index aece125bd0..99602eca98 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -502,7 +502,7 @@ crate::internal_macros::impl_sub_assign!(SignedAmount);
 impl ops::Rem<i64> for SignedAmount {
     type Output = SignedAmount;
 
-    fn rem(self, modulus: i64) -> Self {
+    fn rem(self, modulus: i64) -> Self::Output {
         self.checked_rem(modulus).expect("SignedAmount remainder error")
     }
 }
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index e80f5c6b72..645dbe9d8c 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -445,7 +445,7 @@ crate::internal_macros::impl_sub_assign!(Amount);
 impl ops::Rem<u64> for Amount {
     type Output = Amount;
 
-    fn rem(self, modulus: u64) -> Self {
+    fn rem(self, modulus: u64) -> Self::Output {
         self.checked_rem(modulus).expect("Amount remainder error")
     }
 }

From 6263b9c6afc377822d0cefb1303e98ea51f1a5b6 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 7 Feb 2025 06:56:17 +1100
Subject: [PATCH 328/554] hashes: Derive Debug for all hash engines

Public types typically should implement `Debug`.

Derive `Debug` for all the hash engines
---
 hashes/src/hash160/mod.rs    | 2 +-
 hashes/src/hmac/mod.rs       | 2 +-
 hashes/src/ripemd160/mod.rs  | 2 +-
 hashes/src/sha1/mod.rs       | 2 +-
 hashes/src/sha256/mod.rs     | 2 +-
 hashes/src/sha256d/mod.rs    | 2 +-
 hashes/src/sha384/mod.rs     | 2 +-
 hashes/src/sha512/mod.rs     | 2 +-
 hashes/src/sha512_256/mod.rs | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/hashes/src/hash160/mod.rs b/hashes/src/hash160/mod.rs
index b984960c9b..fd2e366c20 100644
--- a/hashes/src/hash160/mod.rs
+++ b/hashes/src/hash160/mod.rs
@@ -25,7 +25,7 @@ fn from_engine(e: HashEngine) -> Hash {
 }
 
 /// Engine to compute HASH160 hash function.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HashEngine(sha256::HashEngine);
 
 impl HashEngine {
diff --git a/hashes/src/hmac/mod.rs b/hashes/src/hmac/mod.rs
index a661f64e32..5cddfdc53a 100644
--- a/hashes/src/hmac/mod.rs
+++ b/hashes/src/hmac/mod.rs
@@ -35,7 +35,7 @@ impl<T: GeneralHash + str::FromStr> str::FromStr for Hmac<T> {
 }
 
 /// Pair of underlying hash engines, used for the inner and outer hash of HMAC.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HmacEngine<T: GeneralHash> {
     iengine: T::Engine,
     oengine: T::Engine,
diff --git a/hashes/src/ripemd160/mod.rs b/hashes/src/ripemd160/mod.rs
index 759900ce28..e6be175370 100644
--- a/hashes/src/ripemd160/mod.rs
+++ b/hashes/src/ripemd160/mod.rs
@@ -48,7 +48,7 @@ fn from_engine(e: HashEngine) -> Hash {
 const BLOCK_SIZE: usize = 64;
 
 /// Engine to compute RIPEMD160 hash function.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HashEngine {
     buffer: [u8; BLOCK_SIZE],
     h: [u32; 5],
diff --git a/hashes/src/sha1/mod.rs b/hashes/src/sha1/mod.rs
index 6c198d1859..dc32d31dd1 100644
--- a/hashes/src/sha1/mod.rs
+++ b/hashes/src/sha1/mod.rs
@@ -40,7 +40,7 @@ fn from_engine(mut e: HashEngine) -> Hash {
 const BLOCK_SIZE: usize = 64;
 
 /// Engine to compute SHA1 hash function.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HashEngine {
     buffer: [u8; BLOCK_SIZE],
     h: [u32; 5],
diff --git a/hashes/src/sha256/mod.rs b/hashes/src/sha256/mod.rs
index 70bf9121bb..6ae83b879b 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -54,7 +54,7 @@ fn from_engine(e: HashEngine) -> Hash {
 const BLOCK_SIZE: usize = 64;
 
 /// Engine to compute SHA256 hash function.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HashEngine {
     buffer: [u8; BLOCK_SIZE],
     h: [u32; 8],
diff --git a/hashes/src/sha256d/mod.rs b/hashes/src/sha256d/mod.rs
index 165bee52e6..003801d998 100644
--- a/hashes/src/sha256d/mod.rs
+++ b/hashes/src/sha256d/mod.rs
@@ -20,7 +20,7 @@ fn from_engine(e: HashEngine) -> Hash {
 }
 
 /// Engine to compute SHA256d hash function.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HashEngine(sha256::HashEngine);
 
 impl HashEngine {
diff --git a/hashes/src/sha384/mod.rs b/hashes/src/sha384/mod.rs
index 18f23b40a9..200bf9f6ea 100644
--- a/hashes/src/sha384/mod.rs
+++ b/hashes/src/sha384/mod.rs
@@ -17,7 +17,7 @@ fn from_engine(e: HashEngine) -> Hash {
 }
 
 /// Engine to compute SHA384 hash function.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HashEngine(sha512::HashEngine);
 
 impl HashEngine {
diff --git a/hashes/src/sha512/mod.rs b/hashes/src/sha512/mod.rs
index f72f62e563..65bf75c18e 100644
--- a/hashes/src/sha512/mod.rs
+++ b/hashes/src/sha512/mod.rs
@@ -49,7 +49,7 @@ pub(crate) fn from_engine(e: HashEngine) -> Hash {
 pub(crate) const BLOCK_SIZE: usize = 128;
 
 /// Engine to compute SHA512 hash function.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct HashEngine {
     h: [u64; 8],
     bytes_hashed: u64,
diff --git a/hashes/src/sha512_256/mod.rs b/hashes/src/sha512_256/mod.rs
index cb1d5d372f..3452508f03 100644
--- a/hashes/src/sha512_256/mod.rs
+++ b/hashes/src/sha512_256/mod.rs
@@ -27,7 +27,7 @@ fn from_engine(e: HashEngine) -> Hash {
 /// 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)]
+#[derive(Debug, Clone)]
 pub struct HashEngine(sha512::HashEngine);
 
 impl HashEngine {

From e5c74c38a20e153f0919b43755d58dff8f2c8da2 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 6 Feb 2025 14:01:39 +0000
Subject: [PATCH 329/554] Add missing re-exports to primitives crate root

There are re-exports in the bitcoin root from primitives that were not
re-exported in the primitives crate root.

Add the missing re-exports to primitives crate root.
---
 primitives/src/lib.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index a25d422e71..5cd7150637 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -68,6 +68,7 @@ pub use self::{
     block::{
         Block, Checked as BlockChecked, Unchecked as BlockUnchecked, Validation as BlockValidation,
     },
+    script::{Script, ScriptBuf},
     transaction::{Transaction, TxIn, TxOut},
     witness::Witness,
 };
@@ -76,10 +77,11 @@ pub use self::{
     block::{BlockHash, Header as BlockHeader, WitnessCommitment},
     locktime::{absolute, relative},
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
+    opcodes::Opcode,
     pow::CompactTarget,
     sequence::Sequence,
     taproot::{TapBranchTag, TapLeafHash, TapLeafTag, TapNodeHash, TapTweakHash, TapTweakTag},
-    transaction::{Txid, Wtxid},
+    transaction::{OutPoint, Txid, Wtxid},
 };
 
 #[rustfmt::skip]

From 6c3d7f6443833ea687bdad8fb41775c107407034 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 7 Feb 2025 17:02:50 +0000
Subject: [PATCH 330/554] Test Sequence properties

Cargo mutants found multiple mutants in the functions that return true
or false for various Sequence properties.

Add a test to kill the mutants.
---
 primitives/src/sequence.rs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/primitives/src/sequence.rs b/primitives/src/sequence.rs
index 163f70a05e..5e13575987 100644
--- a/primitives/src/sequence.rs
+++ b/primitives/src/sequence.rs
@@ -307,4 +307,31 @@ mod tests {
     fn from_seconds_ceil_causes_overflow_error() {
         assert!(Sequence::from_seconds_ceil(MAXIMUM_ENCODABLE_SECONDS + 1).is_err());
     }
+
+    #[test]
+    fn sequence_properties() {
+        let seq_max = Sequence(0xFFFFFFFF);
+        let seq_no_rbf = Sequence(0xFFFFFFFE);
+        let seq_rbf = Sequence(0xFFFFFFFD);
+
+        assert!(seq_max.is_final());
+        assert!(!seq_no_rbf.is_final());
+
+        assert!(seq_no_rbf.enables_absolute_lock_time());
+        assert!(!seq_max.enables_absolute_lock_time());
+
+        assert!(seq_rbf.is_rbf());
+        assert!(!seq_no_rbf.is_rbf());
+
+        let seq_relative = Sequence(0x7FFFFFFF);
+        assert!(seq_relative.is_relative_lock_time());
+        assert!(!seq_max.is_relative_lock_time());
+
+        let seq_height_locked = Sequence(0x00399999);
+        let seq_time_locked = Sequence(0x00400000);
+        assert!(seq_height_locked.is_height_locked());
+        assert!(seq_time_locked.is_time_locked());
+        assert!(!seq_time_locked.is_height_locked());
+        assert!(!seq_height_locked.is_time_locked());
+    }
 }

From 963dba2bdf102b2015393014d06cc56b8473520a Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 7 Feb 2025 17:50:45 +0000
Subject: [PATCH 331/554] Test sequence formatting

Add a test to kill the mutants in Sequence formatting.
---
 primitives/src/sequence.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/primitives/src/sequence.rs b/primitives/src/sequence.rs
index 5e13575987..e225739f8e 100644
--- a/primitives/src/sequence.rs
+++ b/primitives/src/sequence.rs
@@ -334,4 +334,15 @@ mod tests {
         assert!(!seq_time_locked.is_height_locked());
         assert!(!seq_height_locked.is_time_locked());
     }
+
+    #[test]
+    fn sequence_formatting() {
+        let sequence = Sequence(0x7FFFFFFF);
+        assert_eq!(format!("{:x}", sequence), "7fffffff");
+        assert_eq!(format!("{:X}", sequence), "7FFFFFFF");
+
+        // Test From<Sequence> for u32
+        let sequence_u32: u32 = sequence.into();
+        assert_eq!(sequence_u32, 0x7FFFFFFF);
+    }
 }

From c9a86dcf58fa7818634a9a1dbb29d16e38b4ccd6 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 8 Feb 2025 01:37:36 +0000
Subject: [PATCH 332/554] Automated update to Github CI to rustc
 nightly-2025-02-07

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 609e36af3f..36da8033ee 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-01-31
+nightly-2025-02-07

From 613fddc82be3b17696eaf4589d30995ba29f529b Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 7 Feb 2025 07:00:01 +1100
Subject: [PATCH 333/554] Delete deprecated sha256t_hash_newtype macro

This macro is a maintenance burden. We would like to put a tag on the
hash engine but doing so would require breaking this macro anyway so
lets just delete it.
---
 hashes/src/sha256t/mod.rs | 99 ---------------------------------------
 1 file changed, 99 deletions(-)

diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 6c62846c87..2e7ddf89d3 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -140,105 +140,6 @@ where
     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:
-///
-/// ```
-/// # #[allow(deprecated)] {
-/// # use bitcoin_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 the hash_newtype! macro.
-///     #[hash_newtype(backward)]
-///     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_LENGTH)` 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.
-///
-/// [`hash_newtype`]: crate::hash_newtype
-#[macro_export]
-#[deprecated(since = "0.15.0", note = "use `sha256_tag!` combined with `hash_newtype!` instead")]
-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_tag_struct!($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 = $crate::sha256t_tag_constructor!($constructor, $($tag_value)+);
-                $crate::sha256::HashEngine::from_midstate(MIDSTATE)
-            }
-        }
-
-        $crate::hash_newtype! {
-            $(#[$($hash_attr)*])*
-            $hash_vis struct $hash_name($(#[$($field_attr)*])* $crate::sha256t::Hash<$tag>);
-        }
-
-        impl $hash_name {
-            /// Constructs a new engine.
-            #[allow(unused)] // the user of macro may not need this
-            pub fn engine() -> <$hash_name as $crate::GeneralHash>::Engine {
-                <$hash_name as $crate::GeneralHash>::engine()
-            }
-
-            /// Produces a hash from the current state of a given engine.
-            #[allow(unused)] // the user of macro may not need this
-            pub fn from_engine(e: <$hash_name as $crate::GeneralHash>::Engine) -> Self {
-                <$hash_name as $crate::GeneralHash>::from_engine(e)
-            }
-
-            /// Hashes some bytes.
-            #[allow(unused)] // the user of macro may not need this
-            pub fn hash(data: &[u8]) -> Self {
-                <$hash_name as $crate::GeneralHash>::hash(data)
-            }
-
-            /// Hashes all the byte slices retrieved from the iterator together.
-            #[allow(unused)] // the user of macro may not need this
-            pub fn hash_byte_chunks<B, I>(byte_slices: I) -> Self
-            where
-                B: AsRef<[u8]>,
-                I: IntoIterator<Item = B>,
-            {
-                <$hash_name as $crate::GeneralHash>::hash_byte_chunks(byte_slices)
-            }
-        }
-
-        impl $crate::GeneralHash for $hash_name {
-            type Engine = <$crate::sha256t::Hash<$tag> as $crate::GeneralHash>::Engine;
-
-            fn engine() -> Self::Engine {
-                <$crate::sha256t::Hash<$tag> as $crate::GeneralHash>::engine()
-            }
-
-            fn from_engine(e: Self::Engine) -> $hash_name {
-                Self::from(<$crate::sha256t::Hash<$tag> as $crate::GeneralHash>::from_engine(e))
-            }
-        }
-    }
-}
-
 // Workaround macros being unavailable in attributes.
 #[doc(hidden)]
 #[macro_export]

From ba6425947fa9b9a4f43c4977cb3b4bf477d4ce1e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 7 Feb 2025 07:05:30 +1100
Subject: [PATCH 334/554] hashes: Use associated cost for pre-tagging

Instead of requiring users of the `Tag` trait to implement the `engine`
method we can have an associated const and provide an `engine` method
with a default implementation.

Use an associated const for the pre-tagged hash engine. Fro now keep the
`engine` trait method but have a default impl that returns the const. We
will remove it as a separate patch to assist review.
---
 hashes/src/macros.rs       |  6 +-----
 hashes/src/sha256t/mod.rs  | 13 +++++++------
 hashes/tests/regression.rs |  5 +----
 3 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/hashes/src/macros.rs b/hashes/src/macros.rs
index dc134577a2..12ca01520c 100644
--- a/hashes/src/macros.rs
+++ b/hashes/src/macros.rs
@@ -33,11 +33,7 @@ macro_rules! sha256t_tag {
         $crate::sha256t_tag_struct!($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 = $crate::sha256t_tag_constructor!($constructor, $($tag_value)+);
-                $crate::sha256::HashEngine::from_midstate(MIDSTATE)
-            }
+            const MIDSTATE: $crate::sha256::Midstate = $crate::sha256t_tag_constructor!($constructor, $($tag_value)+);
         }
     }
 }
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 2e7ddf89d3..4a4ce84ee4 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -11,8 +11,13 @@ type HashEngine = sha256::HashEngine;
 
 /// Trait representing a tag that can be used as a context for SHA256t hashes.
 pub trait Tag {
+    /// The [`Midstate`] after pre-tagging the hash engine.
+    const MIDSTATE: sha256::Midstate;
+
     /// Returns a hash engine that is pre-tagged and is ready to be used for the data.
-    fn engine() -> sha256::HashEngine;
+    fn engine() -> sha256::HashEngine {
+        sha256::HashEngine::from_midstate(Self::MIDSTATE)
+    }
 }
 
 /// Output of the SHA256t hash function.
@@ -190,11 +195,7 @@ mod tests {
     pub struct TestHashTag;
 
     impl sha256t::Tag for TestHashTag {
-        fn engine() -> sha256::HashEngine {
-            // The TapRoot TapLeaf midstate.
-            let midstate = sha256::Midstate::new(TEST_MIDSTATE, 64);
-            sha256::HashEngine::from_midstate(midstate)
-        }
+        const MIDSTATE: sha256::Midstate = sha256::Midstate::new(TEST_MIDSTATE, 64);
     }
 
     // We support manually implementing `Tag` and creating a tagged hash from it.
diff --git a/hashes/tests/regression.rs b/hashes/tests/regression.rs
index 0b68567945..a4ffddc2f1 100644
--- a/hashes/tests/regression.rs
+++ b/hashes/tests/regression.rs
@@ -40,10 +40,7 @@ impl_regression_test! {
 pub struct RegHashTag;
 
 impl sha256t::Tag for RegHashTag {
-    fn engine() -> sha256::HashEngine {
-        let midstate = sha256::Midstate::new([0xab; 32], 64);
-        sha256::HashEngine::from_midstate(midstate)
-    }
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::new([0xab; 32], 64);
 }
 
 type RegHash = sha256t::Hash<RegHashTag>;

From 5ce8781162cdf75515a26ceab4209cd0c89c0001 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 7 Feb 2025 07:14:04 +1100
Subject: [PATCH 335/554] Remove the Tag::engine method

Now we have an associated const we can do away with the `engine` trait
method all together. Users can call `Hash<FooTag>::engine` instead. This
is better because its an API more similar to the other hash types and
therefor easier to discover and remember.
---
 bitcoin/src/taproot/mod.rs | 19 +++++++++----------
 hashes/src/sha256t/mod.rs  |  9 +++------
 2 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 50ea6c257a..d9842ec28e 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -1564,7 +1564,6 @@ mod sealed {
 #[cfg(test)]
 mod test {
     use hashes::sha256;
-    use hashes::sha256t::Tag;
     use hex::{DisplayHex, FromHex};
     use secp256k1::VerifyOnly;
 
@@ -1590,12 +1589,12 @@ mod test {
 
     #[test]
     fn midstates() {
-        use sha256t::Hash;
+        use sha256t::{Hash, Tag};
         // 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());
+        assert_eq!(tag_engine("TapLeaf").midstate().unwrap(), TapLeafTag::MIDSTATE);
+        assert_eq!(tag_engine("TapBranch").midstate().unwrap(), TapBranchTag::MIDSTATE);
+        assert_eq!(tag_engine("TapTweak").midstate().unwrap(), TapTweakTag::MIDSTATE);
+        assert_eq!(tag_engine("TapSighash").midstate().unwrap(), TapSighashTag::MIDSTATE);
 
         // check that hash creation is the same as building into the same engine
         fn empty_hash(tag_name: &str) -> [u8; 32] {
@@ -1618,19 +1617,19 @@ mod test {
         //   CHashWriter writer = HasherTapLeaf;
         //   writer.GetSHA256().GetHex()
         assert_eq!(
-            Hash::<TapLeafTag>::from_engine(TapLeafTag::engine()).to_string(),
+            Hash::<TapLeafTag>::from_engine(Hash::<TapLeafTag>::engine()).to_string(),
             "5212c288a377d1f8164962a5a13429f9ba6a7b84e59776a52c6637df2106facb"
         );
         assert_eq!(
-            Hash::<TapBranchTag>::from_engine(TapBranchTag::engine()).to_string(),
+            Hash::<TapBranchTag>::from_engine(Hash::<TapBranchTag>::engine()).to_string(),
             "53c373ec4d6f3c53c1f5fb2ff506dcefe1a0ed74874f93fa93c8214cbe9ffddf"
         );
         assert_eq!(
-            Hash::<TapTweakTag>::from_engine(TapTweakTag::engine()).to_string(),
+            Hash::<TapTweakTag>::from_engine(Hash::<TapTweakTag>::engine()).to_string(),
             "8aa4229474ab0100b2d6f0687f031d1fc9d8eef92a042ad97d279bff456b15e4"
         );
         assert_eq!(
-            Hash::<TapSighashTag>::from_engine(TapSighashTag::engine()).to_string(),
+            Hash::<TapSighashTag>::from_engine(Hash::<TapSighashTag>::engine()).to_string(),
             "dabc11914abcd8072900042a2681e52f8dba99ce82e224f97b5fdb7cd4b9c803"
         );
 
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 4a4ce84ee4..cb91f6ab07 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -13,11 +13,6 @@ type HashEngine = sha256::HashEngine;
 pub trait Tag {
     /// The [`Midstate`] after pre-tagging the hash engine.
     const MIDSTATE: sha256::Midstate;
-
-    /// Returns a hash engine that is pre-tagged and is ready to be used for the data.
-    fn engine() -> sha256::HashEngine {
-        sha256::HashEngine::from_midstate(Self::MIDSTATE)
-    }
 }
 
 /// Output of the SHA256t hash function.
@@ -65,7 +60,9 @@ where
     pub fn from_engine(e: HashEngine) -> Hash<T> { from_engine(e) }
 
     /// Constructs a new engine.
-    pub fn engine() -> HashEngine { T::engine() }
+    pub fn engine() -> HashEngine {
+        sha256::HashEngine::from_midstate(T::MIDSTATE)
+    }
 
     /// Hashes some bytes.
     #[allow(clippy::self_named_constructors)] // Hash is a noun and a verb.

From a0211906fe265eb848823c8fdbd407a3ea372770 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 7 Feb 2025 07:22:00 +1100
Subject: [PATCH 336/554] sha256t: Remove standalone from_engine function

This function is meant to be used in conjunction with the
`general_hash_type` macro but the `sha256t` module does not use that
macro.

Inline the function. Internal change only.
---
 hashes/src/sha256t/mod.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index cb91f6ab07..f355ac82ea 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -57,7 +57,9 @@ where
     }
 
     /// Produces a hash from the current state of a given engine.
-    pub fn from_engine(e: HashEngine) -> Hash<T> { from_engine(e) }
+    pub fn from_engine(e: HashEngine) -> Hash<T> {
+        Hash::from_byte_array(sha256::Hash::from_engine(e).to_byte_array())
+    }
 
     /// Constructs a new engine.
     pub fn engine() -> HashEngine {
@@ -135,13 +137,6 @@ impl<T: Tag> core::hash::Hash for Hash<T> {
 
 crate::internal_macros::hash_trait_impls!(256, false, T: Tag);
 
-fn from_engine<T>(e: sha256::HashEngine) -> Hash<T>
-where
-    T: Tag,
-{
-    Hash::from_byte_array(sha256::Hash::from_engine(e).to_byte_array())
-}
-
 // Workaround macros being unavailable in attributes.
 #[doc(hidden)]
 #[macro_export]

From 3e8e2e46bf7a2c093b832047aaadacf93d40a4ec Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 7 Feb 2025 07:25:45 +1100
Subject: [PATCH 337/554] Use Self::Engine in GeneralHash impl

Match the trait method signature. Internal change only.
---
 hashes/src/internal_macros.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index 959ccdb471..3c6818bd46 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -29,7 +29,7 @@ macro_rules! hash_trait_impls {
         impl<$($gen: $gent),*> $crate::GeneralHash for Hash<$($gen),*> {
             type Engine = HashEngine;
 
-            fn from_engine(e: HashEngine) -> Hash<$($gen),*> { Self::from_engine(e) }
+            fn from_engine(e: Self::Engine) -> Hash<$($gen),*> { Self::from_engine(e) }
         }
 
         #[cfg(feature = "serde")]

From 6002ccdc567b26c69f6b55173f5d11b95b4d6966 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 7 Feb 2025 07:27:29 +1100
Subject: [PATCH 338/554] Add a tagged sha256t hash engine

We would like it if two different pre-tagged engines were considered
different types so it is not possible to mix them up.

Add a new `sha256t::HashEngine<T>` where `T` is a tag the same as on
`sha256t::Hash<T>`.
---
 bitcoin/src/taproot/mod.rs    |  2 +-
 hashes/src/internal_macros.rs |  2 +-
 hashes/src/sha256t/mod.rs     | 41 ++++++++++++++++++++++++++++-------
 3 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index d9842ec28e..775357f07f 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -1600,7 +1600,7 @@ mod test {
         fn empty_hash(tag_name: &str) -> [u8; 32] {
             let mut e = tag_engine(tag_name);
             e.input(&[]);
-            Hash::<TapBranchTag>::from_engine(e).to_byte_array()
+            sha256::Hash::from_engine(e).to_byte_array()
         }
         assert_eq!(empty_hash("TapLeaf"), Hash::<TapLeafTag>::hash(&[]).to_byte_array());
         assert_eq!(empty_hash("TapBranch"), Hash::<TapBranchTag>::hash(&[]).to_byte_array());
diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index 3c6818bd46..5ae79f119f 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -27,7 +27,7 @@ macro_rules! hash_trait_impls {
         $crate::impl_debug_only!(Hash, { $bits / 8 }, $reverse $(, $gen: $gent)*);
 
         impl<$($gen: $gent),*> $crate::GeneralHash for Hash<$($gen),*> {
-            type Engine = HashEngine;
+            type Engine = HashEngine<$($gen),*>;
 
             fn from_engine(e: Self::Engine) -> Hash<$($gen),*> { Self::from_engine(e) }
         }
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index f355ac82ea..5d28b9d93c 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -5,12 +5,12 @@
 use core::cmp;
 use core::marker::PhantomData;
 
+#[cfg(doc)]
+use crate::sha256::Midstate;
 use crate::{sha256, FromSliceError, HashEngine as _};
 
-type HashEngine = sha256::HashEngine;
-
 /// Trait representing a tag that can be used as a context for SHA256t hashes.
-pub trait Tag {
+pub trait Tag: Clone {
     /// The [`Midstate`] after pre-tagging the hash engine.
     const MIDSTATE: sha256::Midstate;
 }
@@ -57,14 +57,12 @@ where
     }
 
     /// Produces a hash from the current state of a given engine.
-    pub fn from_engine(e: HashEngine) -> Hash<T> {
-        Hash::from_byte_array(sha256::Hash::from_engine(e).to_byte_array())
+    pub fn from_engine(e: HashEngine<T>) -> Hash<T> {
+        Hash::from_byte_array(sha256::Hash::from_engine(e.0).to_byte_array())
     }
 
     /// Constructs a new engine.
-    pub fn engine() -> HashEngine {
-        sha256::HashEngine::from_midstate(T::MIDSTATE)
-    }
+    pub fn engine() -> HashEngine<T> { HashEngine::default() }
 
     /// Hashes some bytes.
     #[allow(clippy::self_named_constructors)] // Hash is a noun and a verb.
@@ -137,6 +135,33 @@ impl<T: Tag> core::hash::Hash for Hash<T> {
 
 crate::internal_macros::hash_trait_impls!(256, false, T: Tag);
 
+/// Engine to compute SHA256t hash function.
+#[derive(Debug, Clone)]
+pub struct HashEngine<T>(sha256::HashEngine, PhantomData<T>);
+
+impl<T: Tag> Default for HashEngine<T> {
+    fn default() -> Self {
+        let tagged = sha256::HashEngine::from_midstate(T::MIDSTATE);
+        HashEngine(tagged, PhantomData)
+    }
+}
+
+impl<T: Tag> crate::HashEngine for HashEngine<T> {
+    const BLOCK_SIZE: usize = 64; // Same as sha256::HashEngine::BLOCK_SIZE;
+    fn input(&mut self, data: &[u8]) { self.0.input(data) }
+    fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
+}
+
+crate::internal_macros::impl_io_write!(
+    HashEngine<T>,
+    |us: &mut HashEngine<T>, buf| {
+        us.input(buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) },
+    T: crate::sha256t::Tag
+);
+
 // Workaround macros being unavailable in attributes.
 #[doc(hidden)]
 #[macro_export]

From 6244cb75faf62aed4b47d63a59d14cb766e4e7a8 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 6 Feb 2025 10:37:48 +1100
Subject: [PATCH 339/554] Introduce monadic AmountOpResult

We would like to return an error when doing math ops on amount types.
We cannot however use the stdlib `Result` or `Option` because we want to
implement ops on the result type.

Add an `AmountOpResult` type. Return this type from all math operations
on `Amount` and `SignedAmount`.

Implement `core::iter::Sum` for the new type to allow summing iterators
of amounts - somewhat ugly to use, see tests for example usage.
---
 bitcoin/examples/taproot-psbt.rs     |   8 +-
 bitcoin/src/blockdata/transaction.rs |   2 +-
 bitcoin/src/psbt/mod.rs              |   2 +-
 units/src/amount/mod.rs              |   2 +
 units/src/amount/result.rs           | 588 +++++++++++++++++++++++++++
 units/src/amount/signed.rs           |  81 +---
 units/src/amount/tests.rs            | 358 +++++++++++-----
 units/src/amount/unsigned.rs         |  73 +---
 units/src/amount/verification.rs     |  23 +-
 units/src/internal_macros.rs         |  60 +++
 10 files changed, 921 insertions(+), 276 deletions(-)
 create mode 100644 units/src/amount/result.rs

diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index 1d712ed1b1..c312cf3d7a 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -412,7 +412,8 @@ impl BenefactorWallet {
             taproot_spend_info.internal_key(),
             taproot_spend_info.merkle_root(),
         );
-        let value = input_utxo.amount - ABSOLUTE_FEES;
+        let value = (input_utxo.amount - ABSOLUTE_FEES)
+            .expect("ABSOLUTE_FEES must be set below input amount");
 
         // Spend a normal BIP86-like output as an input in our inheritance funding transaction
         let tx = generate_bip86_key_spend_tx(
@@ -476,7 +477,7 @@ impl BenefactorWallet {
             let mut psbt = self.next_psbt.clone().expect("should have next_psbt");
             let input = &mut psbt.inputs[0];
             let input_value = input.witness_utxo.as_ref().unwrap().value;
-            let output_value = input_value - ABSOLUTE_FEES;
+            let output_value = (input_value - ABSOLUTE_FEES).into_result()?;
 
             // We use some other derivation path in this example for our inheritance protocol. The important thing is to ensure
             // that we use an unhardened path so we can make use of xpubs.
@@ -649,7 +650,8 @@ impl BeneficiaryWallet {
         psbt.unsigned_tx.lock_time = lock_time;
         psbt.unsigned_tx.output = vec![TxOut {
             script_pubkey: to_address.script_pubkey(),
-            value: input_value - ABSOLUTE_FEES,
+            value: (input_value - ABSOLUTE_FEES)
+                .expect("ABSOLUTE_FEES must be set below input amount"),
         }];
         psbt.outputs = vec![Output::default()];
         let unsigned_tx = psbt.unsigned_tx.clone();
diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 7d7bf76993..56094aa7c8 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -1673,7 +1673,7 @@ mod tests {
 
         // 10 sat/kwu * (204wu + BASE_WEIGHT) = 4 sats
         let expected_fee = "4 sats".parse::<SignedAmount>().unwrap();
-        let expected_effective_value = value.to_signed() - expected_fee;
+        let expected_effective_value = (value.to_signed() - expected_fee).unwrap();
         assert_eq!(effective_value, expected_effective_value);
     }
 
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 96e36786a9..2471fc41d5 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -2249,7 +2249,7 @@ mod tests {
         };
         assert_eq!(
             t.fee().expect("fee calculation"),
-            prev_output_val - (output_0_val + output_1_val)
+            (prev_output_val - (output_0_val + output_1_val)).unwrap()
         );
         // no previous output
         let mut t2 = t.clone();
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index b290c625fd..e5e23417c8 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -6,6 +6,7 @@
 //! We refer to the documentation on the types for more information.
 
 mod error;
+mod result;
 #[cfg(feature = "serde")]
 pub mod serde;
 
@@ -34,6 +35,7 @@ pub use self::{
         OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError,
         PossiblyConfusingDenominationError, TooPreciseError, UnknownDenominationError,
     },
+    result::{NumOpError, NumOpResult},
     signed::SignedAmount,
     unsigned::Amount,
 };
diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
new file mode 100644
index 0000000000..c0e84f6e77
--- /dev/null
+++ b/units/src/amount/result.rs
@@ -0,0 +1,588 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Provides a monodic numeric result type that is used to return the result of
+//! doing mathematical operations (`core::ops`) on amount types.
+
+use core::{fmt, ops};
+
+use NumOpResult as R;
+
+use super::{Amount, SignedAmount};
+
+/// Result of an operation on [`Amount`] or [`SignedAmount`].
+///
+/// The type parameter `T` should be normally `Amout` or `SignedAmount`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[must_use]
+pub enum NumOpResult<T> {
+    /// Result of a successful mathematical operation.
+    Valid(T),
+    /// Result of an unsuccessful mathematical operation.
+    Error(NumOpError),
+}
+
+impl<T: fmt::Debug> NumOpResult<T> {
+    /// Returns the contained valid amount, consuming `self`.
+    ///
+    /// # Panics
+    ///
+    /// Panics with `msg` if the numeric result is an `Error`.
+    #[track_caller]
+    pub fn expect(self, msg: &str) -> T {
+        match self {
+            R::Valid(amount) => amount,
+            R::Error(_) => panic!("{}", msg),
+        }
+    }
+
+    /// Returns the contained valid amount, consuming `self`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the numeric result is an `Error`.
+    #[track_caller]
+    pub fn unwrap(self) -> T {
+        match self {
+            R::Valid(amount) => amount,
+            R::Error(e) => panic!("tried to unwrap an invalid numeric result: {:?}", e),
+        }
+    }
+
+    /// Returns the contained error, consuming `self`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the numeric result is a valid amount.
+    #[track_caller]
+    pub fn unwrap_err(self) -> NumOpError {
+        match self {
+            R::Error(e) => e,
+            R::Valid(a) => panic!("tried to unwrap a valid numeric result: {:?}", a),
+        }
+    }
+
+    /// Converts this `NumOpResult` to an `Option<T>`.
+    pub fn ok(self) -> Option<T> {
+        match self {
+            R::Valid(amount) => Some(amount),
+            R::Error(_) => None,
+        }
+    }
+
+    /// Converts this `NumOpResult` to a `Result<T, NumOpError>`.
+    #[allow(clippy::missing_errors_doc)]
+    pub fn into_result(self) -> Result<T, NumOpError> {
+        match self {
+            R::Valid(amount) => Ok(amount),
+            R::Error(e) => Err(e),
+        }
+    }
+
+    /// Calls `op` if the numeric result is `Valid`, otherwise returns the `Error` value of `self`.
+    pub fn and_then<F>(self, op: F) -> NumOpResult<T>
+    where
+        F: FnOnce(T) -> NumOpResult<T>,
+    {
+        match self {
+            R::Valid(amount) => op(amount),
+            R::Error(e) => R::Error(e),
+        }
+    }
+
+    /// Returns `true` if the numeric result is a valid amount.
+    pub fn is_valid(&self) -> bool {
+        match self {
+            R::Valid(_) => true,
+            R::Error(_) => false,
+        }
+    }
+
+    /// Returns `true` if the numeric result is an invalid amount.
+    pub fn is_error(&self) -> bool { !self.is_valid() }
+}
+
+impl From<Amount> for NumOpResult<Amount> {
+    fn from(a: Amount) -> Self { Self::Valid(a) }
+}
+impl From<&Amount> for NumOpResult<Amount> {
+    fn from(a: &Amount) -> Self { Self::Valid(*a) }
+}
+
+impl From<SignedAmount> for NumOpResult<SignedAmount> {
+    fn from(a: SignedAmount) -> Self { Self::Valid(a) }
+}
+impl From<&SignedAmount> for NumOpResult<SignedAmount> {
+    fn from(a: &SignedAmount) -> Self { Self::Valid(*a) }
+}
+
+impl ops::Add for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn add(self, rhs: Amount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
+}
+crate::internal_macros::impl_add_for_amount_references!(Amount);
+
+impl ops::Add<NumOpResult<Amount>> for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn add(self, rhs: NumOpResult<Amount>) -> Self::Output { rhs.and_then(|a| a + self) }
+}
+impl ops::Add<NumOpResult<Amount>> for &Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn add(self, rhs: NumOpResult<Amount>) -> Self::Output { rhs.and_then(|a| a + self) }
+}
+impl ops::Add<Amount> for NumOpResult<Amount> {
+    type Output = NumOpResult<Amount>;
+
+    fn add(self, rhs: Amount) -> Self::Output { rhs + self }
+}
+impl ops::Add<&Amount> for NumOpResult<Amount> {
+    type Output = NumOpResult<Amount>;
+
+    fn add(self, rhs: &Amount) -> Self::Output { rhs + self }
+}
+
+impl ops::Sub for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn sub(self, rhs: Amount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
+}
+crate::internal_macros::impl_sub_for_amount_references!(Amount);
+
+impl ops::Sub<NumOpResult<Amount>> for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn sub(self, rhs: NumOpResult<Amount>) -> Self::Output {
+        match rhs {
+            R::Valid(amount) => self - amount,
+            R::Error(_) => rhs,
+        }
+    }
+}
+impl ops::Sub<NumOpResult<Amount>> for &Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn sub(self, rhs: NumOpResult<Amount>) -> Self::Output {
+        match rhs {
+            R::Valid(amount) => self - amount,
+            R::Error(_) => rhs,
+        }
+    }
+}
+impl ops::Sub<Amount> for NumOpResult<Amount> {
+    type Output = NumOpResult<Amount>;
+
+    fn sub(self, rhs: Amount) -> Self::Output {
+        match self {
+            R::Valid(amount) => amount - rhs,
+            R::Error(_) => self,
+        }
+    }
+}
+impl ops::Sub<&Amount> for NumOpResult<Amount> {
+    type Output = NumOpResult<Amount>;
+
+    fn sub(self, rhs: &Amount) -> Self::Output {
+        match self {
+            R::Valid(amount) => amount - (*rhs),
+            R::Error(_) => self,
+        }
+    }
+}
+
+impl ops::Mul<u64> for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn mul(self, rhs: u64) -> Self::Output { self.checked_mul(rhs).valid_or_error() }
+}
+impl ops::Mul<&u64> for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn mul(self, rhs: &u64) -> Self::Output { self.mul(*rhs) }
+}
+impl ops::Mul<u64> for &Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn mul(self, rhs: u64) -> Self::Output { (*self).mul(rhs) }
+}
+impl ops::Mul<&u64> for &Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn mul(self, rhs: &u64) -> Self::Output { self.mul(*rhs) }
+}
+
+impl ops::Div<u64> for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn div(self, rhs: u64) -> Self::Output { self.checked_div(rhs).valid_or_error() }
+}
+impl ops::Div<&u64> for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn div(self, rhs: &u64) -> Self::Output { self.div(*rhs) }
+}
+impl ops::Div<u64> for &Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn div(self, rhs: u64) -> Self::Output { (*self).div(rhs) }
+}
+impl ops::Div<&u64> for &Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn div(self, rhs: &u64) -> Self::Output { (*self).div(*rhs) }
+}
+
+impl ops::Rem<u64> for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn rem(self, modulus: u64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
+}
+impl ops::Rem<&u64> for Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn rem(self, modulus: &u64) -> Self::Output { self.rem(*modulus) }
+}
+impl ops::Rem<u64> for &Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn rem(self, modulus: u64) -> Self::Output { (*self).rem(modulus) }
+}
+impl ops::Rem<&u64> for &Amount {
+    type Output = NumOpResult<Amount>;
+
+    fn rem(self, modulus: &u64) -> Self::Output { (*self).rem(*modulus) }
+}
+
+impl ops::Add for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn add(self, rhs: SignedAmount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
+}
+crate::internal_macros::impl_add_for_amount_references!(SignedAmount);
+
+impl ops::Add<NumOpResult<SignedAmount>> for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn add(self, rhs: NumOpResult<SignedAmount>) -> Self::Output { rhs.and_then(|a| a + self) }
+}
+impl ops::Add<NumOpResult<SignedAmount>> for &SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn add(self, rhs: NumOpResult<SignedAmount>) -> Self::Output { rhs.and_then(|a| a + self) }
+}
+impl ops::Add<SignedAmount> for NumOpResult<SignedAmount> {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn add(self, rhs: SignedAmount) -> Self::Output { rhs + self }
+}
+impl ops::Add<&SignedAmount> for NumOpResult<SignedAmount> {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn add(self, rhs: &SignedAmount) -> Self::Output { rhs + self }
+}
+
+impl ops::Sub for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn sub(self, rhs: SignedAmount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
+}
+crate::internal_macros::impl_sub_for_amount_references!(SignedAmount);
+
+impl ops::Sub<NumOpResult<SignedAmount>> for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn sub(self, rhs: NumOpResult<SignedAmount>) -> Self::Output {
+        match rhs {
+            R::Valid(amount) => amount - rhs,
+            R::Error(_) => rhs,
+        }
+    }
+}
+impl ops::Sub<NumOpResult<SignedAmount>> for &SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn sub(self, rhs: NumOpResult<SignedAmount>) -> Self::Output {
+        match rhs {
+            R::Valid(amount) => amount - rhs,
+            R::Error(_) => rhs,
+        }
+    }
+}
+impl ops::Sub<SignedAmount> for NumOpResult<SignedAmount> {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn sub(self, rhs: SignedAmount) -> Self::Output {
+        match self {
+            R::Valid(amount) => amount - rhs,
+            R::Error(_) => self,
+        }
+    }
+}
+impl ops::Sub<&SignedAmount> for NumOpResult<SignedAmount> {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn sub(self, rhs: &SignedAmount) -> Self::Output {
+        match self {
+            R::Valid(amount) => amount - *rhs,
+            R::Error(_) => self,
+        }
+    }
+}
+
+impl ops::Mul<i64> for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn mul(self, rhs: i64) -> Self::Output { self.checked_mul(rhs).valid_or_error() }
+}
+impl ops::Mul<&i64> for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn mul(self, rhs: &i64) -> Self::Output { self.mul(*rhs) }
+}
+impl ops::Mul<i64> for &SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn mul(self, rhs: i64) -> Self::Output { (*self).mul(rhs) }
+}
+impl ops::Mul<&i64> for &SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn mul(self, rhs: &i64) -> Self::Output { self.mul(*rhs) }
+}
+
+impl ops::Div<i64> for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn div(self, rhs: i64) -> Self::Output { self.checked_div(rhs).valid_or_error() }
+}
+impl ops::Div<&i64> for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn div(self, rhs: &i64) -> Self::Output { self.div(*rhs) }
+}
+impl ops::Div<i64> for &SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn div(self, rhs: i64) -> Self::Output { (*self).div(rhs) }
+}
+impl ops::Div<&i64> for &SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn div(self, rhs: &i64) -> Self::Output { (*self).div(*rhs) }
+}
+
+impl ops::Rem<i64> for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn rem(self, modulus: i64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
+}
+impl ops::Rem<&i64> for SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn rem(self, modulus: &i64) -> Self::Output { self.rem(*modulus) }
+}
+impl ops::Rem<i64> for &SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn rem(self, modulus: i64) -> Self::Output { (*self).rem(modulus) }
+}
+impl ops::Rem<&i64> for &SignedAmount {
+    type Output = NumOpResult<SignedAmount>;
+
+    fn rem(self, modulus: &i64) -> Self::Output { (*self).rem(*modulus) }
+}
+
+impl ops::Neg for SignedAmount {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output { Self::from_sat(self.to_sat().neg()) }
+}
+
+impl<T> ops::Add for NumOpResult<T>
+where
+    T: ops::Add<Output = NumOpResult<T>>,
+{
+    type Output = NumOpResult<T>;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
+            (_, _) => R::Error(NumOpError {}),
+        }
+    }
+}
+impl<T> ops::Add<NumOpResult<T>> for &NumOpResult<T>
+where
+    T: ops::Add<Output = NumOpResult<T>> + Copy,
+{
+    type Output = NumOpResult<T>;
+
+    fn add(self, rhs: NumOpResult<T>) -> Self::Output {
+        match (self, rhs) {
+            (R::Valid(lhs), R::Valid(rhs)) => *lhs + rhs,
+            (_, _) => R::Error(NumOpError {}),
+        }
+    }
+}
+impl<T> ops::Add<&NumOpResult<T>> for NumOpResult<T>
+where
+    T: ops::Add<Output = NumOpResult<T>> + Copy,
+{
+    type Output = NumOpResult<T>;
+
+    fn add(self, rhs: &NumOpResult<T>) -> Self::Output {
+        match (self, rhs) {
+            (R::Valid(lhs), R::Valid(rhs)) => lhs + *rhs,
+            (_, _) => R::Error(NumOpError {}),
+        }
+    }
+}
+impl<T> ops::Add for &NumOpResult<T>
+where
+    T: ops::Add<Output = NumOpResult<T>> + Copy,
+{
+    type Output = NumOpResult<T>;
+
+    fn add(self, rhs: &NumOpResult<T>) -> Self::Output {
+        match (self, rhs) {
+            (R::Valid(lhs), R::Valid(rhs)) => *lhs + *rhs,
+            (_, _) => R::Error(NumOpError {}),
+        }
+    }
+}
+
+impl<T> ops::Sub for NumOpResult<T>
+where
+    T: ops::Sub<Output = NumOpResult<T>>,
+{
+    type Output = NumOpResult<T>;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (R::Valid(lhs), R::Valid(rhs)) => lhs - rhs,
+            (_, _) => R::Error(NumOpError {}),
+        }
+    }
+}
+impl<T> ops::Sub<NumOpResult<T>> for &NumOpResult<T>
+where
+    T: ops::Sub<Output = NumOpResult<T>> + Copy,
+{
+    type Output = NumOpResult<T>;
+
+    fn sub(self, rhs: NumOpResult<T>) -> Self::Output {
+        match (self, rhs) {
+            (R::Valid(lhs), R::Valid(rhs)) => *lhs - rhs,
+            (_, _) => R::Error(NumOpError {}),
+        }
+    }
+}
+impl<T> ops::Sub<&NumOpResult<T>> for NumOpResult<T>
+where
+    T: ops::Sub<Output = NumOpResult<T>> + Copy,
+{
+    type Output = NumOpResult<T>;
+
+    fn sub(self, rhs: &NumOpResult<T>) -> Self::Output {
+        match (self, rhs) {
+            (R::Valid(lhs), R::Valid(rhs)) => lhs - *rhs,
+            (_, _) => R::Error(NumOpError {}),
+        }
+    }
+}
+impl<T> ops::Sub for &NumOpResult<T>
+where
+    T: ops::Sub<Output = NumOpResult<T>> + Copy,
+{
+    type Output = NumOpResult<T>;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (R::Valid(lhs), R::Valid(rhs)) => *lhs - *rhs,
+            (_, _) => R::Error(NumOpError {}),
+        }
+    }
+}
+
+impl core::iter::Sum<NumOpResult<Amount>> for NumOpResult<Amount> {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = NumOpResult<Amount>>,
+    {
+        iter.fold(R::Valid(Amount::ZERO), |acc, amount| match (acc, amount) {
+            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
+            (_, _) => R::Error(NumOpError {}),
+        })
+    }
+}
+impl<'a> core::iter::Sum<&'a NumOpResult<Amount>> for NumOpResult<Amount> {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = &'a NumOpResult<Amount>>,
+    {
+        iter.fold(R::Valid(Amount::ZERO), |acc, amount| match (acc, amount) {
+            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
+            (_, _) => R::Error(NumOpError {}),
+        })
+    }
+}
+
+impl core::iter::Sum<NumOpResult<SignedAmount>> for NumOpResult<SignedAmount> {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = NumOpResult<SignedAmount>>,
+    {
+        iter.fold(R::Valid(SignedAmount::ZERO), |acc, amount| match (acc, amount) {
+            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
+            (_, _) => R::Error(NumOpError {}),
+        })
+    }
+}
+impl<'a> core::iter::Sum<&'a NumOpResult<SignedAmount>> for NumOpResult<SignedAmount> {
+    fn sum<I>(iter: I) -> Self
+    where
+        I: Iterator<Item = &'a NumOpResult<SignedAmount>>,
+    {
+        iter.fold(R::Valid(SignedAmount::ZERO), |acc, amount| match (acc, amount) {
+            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
+            (_, _) => R::Error(NumOpError {}),
+        })
+    }
+}
+
+pub(in crate::amount) trait OptionExt<T> {
+    fn valid_or_error(self) -> NumOpResult<T>;
+}
+
+impl OptionExt<Amount> for Option<Amount> {
+    fn valid_or_error(self) -> NumOpResult<Amount> {
+        match self {
+            Some(amount) => R::Valid(amount),
+            None => R::Error(NumOpError {}),
+        }
+    }
+}
+
+impl OptionExt<SignedAmount> for Option<SignedAmount> {
+    fn valid_or_error(self) -> NumOpResult<SignedAmount> {
+        match self {
+            Some(amount) => R::Valid(amount),
+            None => R::Error(NumOpError {}),
+        }
+    }
+}
+
+/// An error occurred while doing a mathematical operation.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct NumOpError;
+
+impl fmt::Display for NumOpError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "a math operation on amounts gave an invalid numeric result")
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for NumOpError {}
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 99602eca98..f51be5570f 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -5,7 +5,7 @@
 #[cfg(feature = "alloc")]
 use alloc::string::{String, ToString};
 use core::str::FromStr;
-use core::{default, fmt, ops};
+use core::{default, fmt};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
@@ -479,68 +479,6 @@ impl fmt::Display for SignedAmount {
     }
 }
 
-impl ops::Add for SignedAmount {
-    type Output = SignedAmount;
-
-    fn add(self, rhs: SignedAmount) -> Self::Output {
-        self.checked_add(rhs).expect("SignedAmount addition error")
-    }
-}
-crate::internal_macros::impl_add_for_references!(SignedAmount);
-crate::internal_macros::impl_add_assign!(SignedAmount);
-
-impl ops::Sub for SignedAmount {
-    type Output = SignedAmount;
-
-    fn sub(self, rhs: SignedAmount) -> Self::Output {
-        self.checked_sub(rhs).expect("SignedAmount subtraction error")
-    }
-}
-crate::internal_macros::impl_sub_for_references!(SignedAmount);
-crate::internal_macros::impl_sub_assign!(SignedAmount);
-
-impl ops::Rem<i64> for SignedAmount {
-    type Output = SignedAmount;
-
-    fn rem(self, modulus: i64) -> Self::Output {
-        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 ops::Neg for SignedAmount {
-    type Output = Self;
-
-    fn neg(self) -> Self::Output { Self(self.0.neg()) }
-}
-
 impl FromStr for SignedAmount {
     type Err = ParseError;
 
@@ -572,23 +510,6 @@ impl From<Amount> for SignedAmount {
     }
 }
 
-impl core::iter::Sum for SignedAmount {
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        let sats: i64 = iter.map(|amt| amt.0).sum();
-        Self::from_sat(sats)
-    }
-}
-
-impl<'a> core::iter::Sum<&'a SignedAmount> for SignedAmount {
-    fn sum<I>(iter: I) -> Self
-    where
-        I: Iterator<Item = &'a SignedAmount>,
-    {
-        let sats: i64 = iter.map(|amt| amt.0).sum();
-        Self::from_sat(sats)
-    }
-}
-
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for SignedAmount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index a733e30422..f5b450fdb8 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -116,28 +116,15 @@ fn mul_div() {
     let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
-    assert_eq!(sat(14) * 3, sat(42));
-    assert_eq!(sat(14) / 2, sat(7));
-    assert_eq!(sat(14) % 3, sat(2));
-    assert_eq!(ssat(-14) * 3, ssat(-42));
-    assert_eq!(ssat(-14) / 2, ssat(-7));
-    assert_eq!(ssat(-14) % 3, ssat(-2));
-
-    let mut a = sat(30);
-    a /= 3;
-    assert_eq!(a, sat(10));
-    a %= 3;
-    assert_eq!(a, sat(1));
-    a *= 3;
-    assert_eq!(a, sat(3));
-
-    let mut b = ssat(30);
-    b /= 3;
-    assert_eq!(b, ssat(10));
-    b %= 3;
-    assert_eq!(b, ssat(1));
-    b *= 3;
-    assert_eq!(b, ssat(3));
+    let op_result_sat = |sat| NumOpResult::Valid(Amount::from_sat(sat));
+    let op_result_ssat = |sat| NumOpResult::Valid(SignedAmount::from_sat(sat));
+
+    assert_eq!(sat(14) * 3, op_result_sat(42));
+    assert_eq!(sat(14) / 2, op_result_sat(7));
+    assert_eq!(sat(14) % 3, op_result_sat(2));
+    assert_eq!(ssat(-14) * 3, op_result_ssat(-42));
+    assert_eq!(ssat(-14) / 2, op_result_ssat(-7));
+    assert_eq!(ssat(-14) % 3, op_result_ssat(-2));
 }
 
 #[test]
@@ -149,11 +136,41 @@ fn neg() {
 #[cfg(feature = "std")]
 #[test]
 fn overflows() {
-    // panic on overflow
-    let result = panic::catch_unwind(|| Amount::MAX + Amount::from_sat_unchecked(1));
-    assert!(result.is_err());
-    let result = panic::catch_unwind(|| Amount::from_sat_unchecked(8_446_744_073_709_551_615) * 3);
-    assert!(result.is_err());
+    let result = Amount::MAX + Amount::from_sat_unchecked(1);
+    assert!(result.is_error());
+    let result = Amount::from_sat_unchecked(8_446_744_073_709_551_615) * 3;
+    assert!(result.is_error());
+}
+
+#[test]
+fn add() {
+    let sat = Amount::from_sat;
+    let ssat = SignedAmount::from_sat;
+
+    assert!(sat(0) + sat(0) == sat(0).into());
+    assert!(sat(127) + sat(179) == sat(306).into());
+
+    assert!(ssat(0) + ssat(0) == ssat(0).into());
+    assert!(ssat(127) + ssat(179) == ssat(306).into());
+    assert!(ssat(-127) + ssat(179) == ssat(52).into());
+    assert!(ssat(127) + ssat(-179) == ssat(-52).into());
+    assert!(ssat(-127) + ssat(-179) == ssat(-306).into());
+}
+
+#[test]
+fn sub() {
+    let sat = Amount::from_sat;
+    let ssat = SignedAmount::from_sat;
+
+    assert!(sat(0) - sat(0) == sat(0).into());
+    assert!(sat(179) - sat(127) == sat(52).into());
+    assert!((sat(127) - sat(179)).is_error());
+
+    assert!(ssat(0) - ssat(0) == ssat(0).into());
+    assert!(ssat(127) - ssat(179) == ssat(-52).into());
+    assert!(ssat(-127) - ssat(179) == ssat(-306).into());
+    assert!(ssat(127) - ssat(-179) == ssat(306).into());
+    assert!(ssat(-127) - ssat(-179) == ssat(52).into());
 }
 
 #[test]
@@ -990,18 +1007,28 @@ fn sum_amounts() {
     let sat = Amount::from_sat;
     let ssat = SignedAmount::from_sat;
 
-    assert_eq!([].iter().sum::<Amount>(), Amount::ZERO);
-    assert_eq!([].iter().sum::<SignedAmount>(), SignedAmount::ZERO);
+    assert_eq!([].iter().sum::<NumOpResult<Amount>>(), Amount::ZERO.into());
+    assert_eq!([].iter().sum::<NumOpResult<SignedAmount>>(), SignedAmount::ZERO.into());
 
     let amounts = [sat(42), sat(1337), sat(21)];
-    assert_eq!(amounts.iter().sum::<Amount>(), sat(1400));
-    let sum = amounts.into_iter().sum::<Amount>();
-    assert_eq!(sum, sat(1400));
+    assert_eq!(
+        amounts.iter().map(|a| NumOpResult::Valid(*a)).sum::<NumOpResult<Amount>>(),
+        sat(1400).into(),
+    );
+    assert_eq!(
+        amounts.into_iter().map(NumOpResult::Valid).sum::<NumOpResult<Amount>>(),
+        sat(1400).into(),
+    );
 
     let amounts = [ssat(-42), ssat(1337), ssat(21)];
-    assert_eq!(amounts.iter().sum::<SignedAmount>(), ssat(1316));
-    let sum = amounts.into_iter().sum::<SignedAmount>();
-    assert_eq!(sum, ssat(1316));
+    assert_eq!(
+        amounts.iter().map(NumOpResult::from).sum::<NumOpResult<SignedAmount>>(),
+        ssat(1316).into(),
+    );
+    assert_eq!(
+        amounts.into_iter().map(NumOpResult::from).sum::<NumOpResult<SignedAmount>>(),
+        ssat(1316).into()
+    );
 }
 
 #[test]
@@ -1108,10 +1135,11 @@ fn unsigned_addition() {
     let two = sat(2);
     let three = sat(3);
 
-    assert!(one + two == three);
-    assert!(&one + two == three);
-    assert!(one + &two == three);
-    assert!(&one + &two == three);
+    assert!((one + two) == three.into());
+    assert!((one + two) == three.into());
+    assert!((&one + two) == three.into());
+    assert!((one + &two) == three.into());
+    assert!((&one + &two) == three.into());
 }
 
 #[test]
@@ -1123,36 +1151,10 @@ fn unsigned_subtract() {
     let two = sat(2);
     let three = sat(3);
 
-    assert!(three - two == one);
-    assert!(&three - two == one);
-    assert!(three - &two == one);
-    assert!(&three - &two == one);
-}
-
-#[test]
-fn unsigned_add_assign() {
-    let sat = Amount::from_sat;
-
-    let mut f = sat(1);
-    f += sat(2);
-    assert_eq!(f, sat(3));
-
-    let mut f = sat(1);
-    f += &sat(2);
-    assert_eq!(f, sat(3));
-}
-
-#[test]
-fn unsigned_sub_assign() {
-    let sat = Amount::from_sat;
-
-    let mut f = sat(3);
-    f -= sat(2);
-    assert_eq!(f, sat(1));
-
-    let mut f = sat(3);
-    f -= &sat(2);
-    assert_eq!(f, sat(1));
+    assert!(three - two == one.into());
+    assert!(&three - two == one.into());
+    assert!(three - &two == one.into());
+    assert!(&three - &two == one.into());
 }
 
 #[test]
@@ -1164,10 +1166,10 @@ fn signed_addition() {
     let two = ssat(2);
     let three = ssat(3);
 
-    assert!(one + two == three);
-    assert!(&one + two == three);
-    assert!(one + &two == three);
-    assert!(&one + &two == three);
+    assert!(one + two == three.into());
+    assert!(&one + two == three.into());
+    assert!(one + &two == three.into());
+    assert!(&one + &two == three.into());
 }
 
 #[test]
@@ -1179,43 +1181,199 @@ fn signed_subtract() {
     let two = ssat(2);
     let three = ssat(3);
 
-    assert!(three - two == one);
-    assert!(&three - two == one);
-    assert!(three - &two == one);
-    assert!(&three - &two == one);
+    assert!(three - two == one.into());
+    assert!(&three - two == one.into());
+    assert!(three - &two == one.into());
+    assert!(&three - &two == one.into());
 }
 
 #[test]
-fn signed_add_assign() {
-    let ssat = SignedAmount::from_sat;
+fn check_const() {
+    assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);
+    assert_eq!(Amount::ONE_BTC.to_sat(), 100_000_000);
+    assert_eq!(SignedAmount::FIFTY_BTC.to_sat(), SignedAmount::ONE_BTC.to_sat() * 50);
+    assert_eq!(Amount::FIFTY_BTC.to_sat(), Amount::ONE_BTC.to_sat() * 50);
+    assert_eq!(Amount::MAX_MONEY.to_sat() as i64, SignedAmount::MAX_MONEY.to_sat());
+}
 
-    let mut f = ssat(1);
-    f += ssat(2);
-    assert_eq!(f, ssat(3));
+// Verify we have implemented all combinations of ops for `Amount` and `SignedAmount`.
+// It's easier to read this test that check the code.
+#[test]
+#[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
+fn amount_tyes_all_ops() {
+    // Sanity check than stdlib supports the set of reference combinations for the ops we want.
+    {
+        let x = 127;
 
-    let mut f = ssat(1);
-    f += &ssat(2);
-    assert_eq!(f, ssat(3));
+        let _ = x + x;
+        let _ = &x + x;
+        let _ = x + &x;
+        let _ = &x + &x;
+
+        let _ = x - x;
+        let _ = &x - x;
+        let _ = x - &x;
+        let _ = &x - &x;
+
+        let _ = -x;
+    }
+
+    let sat = Amount::from_sat(1);
+    let ssat = SignedAmount::from_sat(1);
+
+    // Add
+    let _ = sat + sat;
+    let _ = &sat + sat;
+    let _ = sat + &sat;
+    let _ = &sat + &sat;
+
+    // let _ = ssat + sat;
+    // let _ = &ssat + sat;
+    // let _ = ssat + &sat;
+    // let _ = &ssat + &sat;
+
+    // let _ = sat + ssat;
+    // let _ = &sat + ssat;
+    // let _ = sat + &ssat;
+    // let _ = &sat + &ssat;
+
+    let _ = ssat + ssat;
+    let _ = &ssat + ssat;
+    let _ = ssat + &ssat;
+    let _ = &ssat + &ssat;
+
+    // Sub
+    let _ = sat - sat;
+    let _ = &sat - sat;
+    let _ = sat - &sat;
+    let _ = &sat - &sat;
+
+    // let _ = ssat - sat;
+    // let _ = &ssat - sat;
+    // let _ = ssat - &sat;
+    // let _ = &ssat - &sat;
+
+    // let _ = sat - ssat;
+    // let _ = &sat - ssat;
+    // let _ = sat - &ssat;
+    // let _ = &sat - &ssat;
+
+    let _ = ssat - ssat;
+    let _ = &ssat - ssat;
+    let _ = ssat - &ssat;
+    let _ = &ssat - &ssat;
+
+    // let _ = sat * sat;  // Intentionally not supported.
+
+    // Mul
+    let _ = sat * 3;
+    let _ = sat * &3;
+    let _ = &sat * 3;
+    let _ = &sat * &3;
+
+    let _ = ssat * 3_i64; // Explicit type for the benefit of the reader.
+    let _ = ssat * &3;
+    let _ = &ssat * 3;
+    let _ = &ssat * &3;
+
+    // Div
+    let _ = sat / 3;
+    let _ = &sat / 3;
+    let _ = sat / &3;
+    let _ = &sat / &3;
+
+    let _ = ssat / 3_i64; // Explicit type for the benefit of the reader.
+    let _ = &ssat / 3;
+    let _ = ssat / &3;
+    let _ = &ssat / &3;
+
+    // Rem
+    let _ = sat % 3;
+    let _ = &sat % 3;
+    let _ = sat % &3;
+    let _ = &sat % &3;
+
+    let _ = ssat % 3;
+    let _ = &ssat % 3;
+    let _ = ssat % &3;
+    let _ = &ssat % &3;
+
+    // FIXME: Do we want to support this?
+    // let _ = sat / sat;
+    //
+    // "How many times does this amount go into that amount?" - seems
+    // like a reasonable question to ask.
+
+    // FIXME: Do we want to support these?
+    // let _ = -sat;
+    // let _ = -ssat;
 }
 
+// FIXME: Should we support this sort of thing?
+// It will be a lot more code for possibly not that much benefit.
 #[test]
-fn signed_sub_assign() {
-    let ssat = SignedAmount::from_sat;
-
-    let mut f = ssat(3);
-    f -= ssat(2);
-    assert_eq!(f, ssat(1));
+fn can_ops_on_amount_and_signed_amount() {
+    // let res: NumOpResult<SignedAmount> = sat + ssat;
+}
 
-    let mut f = ssat(3);
-    f -= &ssat(2);
-    assert_eq!(f, ssat(1));
+// Verify we have implemented all combinations of ops for the `NumOpResult` type.
+// It's easier to read this test that check the code.
+#[test]
+#[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
+fn amount_op_result_all_ops() {
+    let sat = Amount::from_sat(1);
+    // let ssat = SignedAmount::from_sat(1);
+
+    // Explicit type as sanity check.
+    let res: NumOpResult<Amount> = sat + sat;
+    // let sres: NumOpResult<SignedAmount> = ssat + ssat;
+
+    // Operations that where RHS is the result of another operation.
+    let _ = sat + res.clone();
+    let _ = &sat + res.clone();
+    // let _ = sat + &res.clone();
+    // let _ = &sat + &res.clone();
+
+    let _ = sat - res.clone();
+    let _ = &sat - res.clone();
+    // let _ = sat - &res.clone();
+    // let _ = &sat - &res.clone();
+
+    // Operations that where LHS is the result of another operation.
+    let _ = res.clone() + sat;
+    // let _ = &res.clone() + sat;
+    let _ = res.clone() + &sat;
+    // let _ = &res.clone() + &sat;
+
+    let _ = res.clone() - sat;
+    // let _ = &res.clone() - sat;
+    let _ = res.clone() - &sat;
+    // let _ = &res.clone() - &sat;
+
+    // Operations that where both sides are the result of another operation.
+    let _ = res.clone() + res.clone();
+    // let _ = &res.clone() + res.clone();
+    // let _ = res.clone() + &res.clone();
+    // let _ = &res.clone() + &res.clone();
+
+    let _ = res.clone() - res.clone();
+    // let _ = &res.clone() - res.clone();
+    // let _ = res.clone() - &res.clone();
+    // let _ = &res.clone() - &res.clone();
 }
 
+// Verify we have implemented all `Sum` for the `NumOpResult` type.
 #[test]
-fn check_const() {
-    assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);
-    assert_eq!(Amount::ONE_BTC.to_sat(), 100_000_000);
-    assert_eq!(SignedAmount::FIFTY_BTC.to_sat(), SignedAmount::ONE_BTC.to_sat() * 50);
-    assert_eq!(Amount::FIFTY_BTC.to_sat(), Amount::ONE_BTC.to_sat() * 50);
-    assert_eq!(Amount::MAX_MONEY.to_sat() as i64, SignedAmount::MAX_MONEY.to_sat());
+fn amount_op_result_sum() {
+    let res = Amount::from_sat(1) + Amount::from_sat(1);
+    let amounts = [res.clone(), res.clone()];
+    let amount_refs = [&res, &res];
+
+    // Sum iterators.
+    let _ = amounts.iter().sum::<NumOpResult<Amount>>();
+    let _ = amount_refs.iter().copied().sum::<NumOpResult<Amount>>();
+    let _ = amount_refs.into_iter().sum::<NumOpResult<Amount>>();
+
+    // FIXME: Should we support this? I don't think so (Tobin).
+    // let _ = amount_refs.iter().sum::<NumOpResult<&Amount>>();
 }
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 645dbe9d8c..c52a8f2c54 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -5,7 +5,7 @@
 #[cfg(feature = "alloc")]
 use alloc::string::{String, ToString};
 use core::str::FromStr;
-use core::{default, fmt, ops};
+use core::{default, fmt};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
@@ -422,60 +422,6 @@ impl fmt::Display for Amount {
     }
 }
 
-impl ops::Add for Amount {
-    type Output = Amount;
-
-    fn add(self, rhs: Amount) -> Self::Output {
-        self.checked_add(rhs).expect("Amount addition error")
-    }
-}
-crate::internal_macros::impl_add_for_references!(Amount);
-crate::internal_macros::impl_add_assign!(Amount);
-
-impl ops::Sub for Amount {
-    type Output = Amount;
-
-    fn sub(self, rhs: Amount) -> Self::Output {
-        self.checked_sub(rhs).expect("Amount subtraction error")
-    }
-}
-crate::internal_macros::impl_sub_for_references!(Amount);
-crate::internal_macros::impl_sub_assign!(Amount);
-
-impl ops::Rem<u64> for Amount {
-    type Output = Amount;
-
-    fn rem(self, modulus: u64) -> Self::Output {
-        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 = ParseError;
 
@@ -506,23 +452,6 @@ impl TryFrom<SignedAmount> for Amount {
     fn try_from(value: SignedAmount) -> Result<Self, Self::Error> { value.to_unsigned() }
 }
 
-impl core::iter::Sum for Amount {
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        let sats: u64 = iter.map(|amt| amt.0).sum();
-        Self::from_sat(sats)
-    }
-}
-
-impl<'a> core::iter::Sum<&'a Amount> for Amount {
-    fn sum<I>(iter: I) -> Self
-    where
-        I: Iterator<Item = &'a Amount>,
-    {
-        let sats: u64 = iter.map(|amt| amt.0).sum();
-        Self::from_sat(sats)
-    }
-}
-
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Amount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
diff --git a/units/src/amount/verification.rs b/units/src/amount/verification.rs
index f0d7b47eb2..ecf35d2173 100644
--- a/units/src/amount/verification.rs
+++ b/units/src/amount/verification.rs
@@ -29,19 +29,11 @@ fn u_amount_homomorphic() {
     let a2 = Amount::from_sat(n2);
     kani::assume(a1.checked_add(a2).is_some()); // Adding amounts doesn't overflow.
 
-    assert_eq!(Amount::from_sat(n1) + Amount::from_sat(n2), Amount::from_sat(n1 + n2));
-
-    let mut amt = Amount::from_sat(n1);
-    amt += Amount::from_sat(n2);
-    assert_eq!(amt, Amount::from_sat(n1 + n2));
+    assert_eq!(Amount::from_sat(n1) + Amount::from_sat(n2), Amount::from_sat(n1 + n2).into());
 
     let max = cmp::max(n1, n2);
     let min = cmp::min(n1, n2);
-    assert_eq!(Amount::from_sat(max) - Amount::from_sat(min), Amount::from_sat(max - min));
-
-    let mut amt = Amount::from_sat(max);
-    amt -= Amount::from_sat(min);
-    assert_eq!(amt, Amount::from_sat(max - min));
+    assert_eq!(Amount::from_sat(max) - Amount::from_sat(min), Amount::from_sat(max - min).into());
 }
 
 #[kani::unwind(4)]
@@ -59,17 +51,10 @@ fn s_amount_homomorphic() {
 
     assert_eq!(
         SignedAmount::from_sat(n1) + SignedAmount::from_sat(n2),
-        SignedAmount::from_sat(n1 + n2)
+        SignedAmount::from_sat(n1 + n2).into()
     );
     assert_eq!(
         SignedAmount::from_sat(n1) - SignedAmount::from_sat(n2),
-        SignedAmount::from_sat(n1 - n2)
+        SignedAmount::from_sat(n1 - n2).into()
     );
-
-    let mut amt = SignedAmount::from_sat(n1);
-    amt += SignedAmount::from_sat(n2);
-    assert_eq!(amt, SignedAmount::from_sat(n1 + n2));
-    let mut amt = SignedAmount::from_sat(n1);
-    amt -= SignedAmount::from_sat(n2);
-    assert_eq!(amt, SignedAmount::from_sat(n1 - n2));
 }
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
index 475f9374e6..1bae689861 100644
--- a/units/src/internal_macros.rs
+++ b/units/src/internal_macros.rs
@@ -34,6 +34,36 @@ macro_rules! impl_add_for_references {
 }
 pub(crate) use impl_add_for_references;
 
+/// Implements `ops::Add` for various amount references.
+///
+/// Requires `$ty` it implement `Add` e.g. 'impl Add<T> for T'. Adds impls of:
+///
+/// - Add<T> for &T
+/// - Add<&T> for T
+/// - Add<&T> for &T
+macro_rules! impl_add_for_amount_references {
+    ($ty:ident) => {
+        impl core::ops::Add<$ty> for &$ty {
+            type Output = NumOpResult<$ty>;
+
+            fn add(self, rhs: $ty) -> Self::Output { *self + rhs }
+        }
+
+        impl core::ops::Add<&$ty> for $ty {
+            type Output = NumOpResult<$ty>;
+
+            fn add(self, rhs: &$ty) -> Self::Output { self + *rhs }
+        }
+
+        impl<'a> core::ops::Add<&'a $ty> for &$ty {
+            type Output = NumOpResult<$ty>;
+
+            fn add(self, rhs: &'a $ty) -> Self::Output { *self + *rhs }
+        }
+    };
+}
+pub(crate) use impl_add_for_amount_references;
+
 /// Implement `ops::AddAssign` for `$ty` and `&$ty`.
 macro_rules! impl_add_assign {
     ($ty:ident) => {
@@ -78,6 +108,36 @@ macro_rules! impl_sub_for_references {
 }
 pub(crate) use impl_sub_for_references;
 
+/// Implement `ops::Sub` for various amount references.
+///
+/// Requires `$ty` it implement `Sub` e.g. 'impl Sub<T> for T'. Adds impls of:
+///
+/// - Sub<T> for &T
+/// - Sub<&T> for T
+/// - Sub<&T> for &T
+macro_rules! impl_sub_for_amount_references {
+    ($ty:ident) => {
+        impl core::ops::Sub<$ty> for &$ty {
+            type Output = NumOpResult<$ty>;
+
+            fn sub(self, rhs: $ty) -> Self::Output { *self - rhs }
+        }
+
+        impl core::ops::Sub<&$ty> for $ty {
+            type Output = NumOpResult<$ty>;
+
+            fn sub(self, rhs: &$ty) -> Self::Output { self - *rhs }
+        }
+
+        impl<'a> core::ops::Sub<&'a $ty> for &$ty {
+            type Output = NumOpResult<$ty>;
+
+            fn sub(self, rhs: &'a $ty) -> Self::Output { *self - *rhs }
+        }
+    };
+}
+pub(crate) use impl_sub_for_amount_references;
+
 /// Implement `ops::SubAssign` for `$ty` and `&$ty`.
 macro_rules! impl_sub_assign {
     ($ty:ident) => {

From 9833ca32ce6948069fff92846022cdbd0f91b7dd Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 10 Feb 2025 10:50:59 +1100
Subject: [PATCH 340/554] primitives: Do not depend on bitcoin_io

Currently the `primitives` crate does not use the `io` dependency. I
don't know if this is just a mistake of if it used to and the manifest
is just stale.
---
 Cargo-minimal.lock    | 1 -
 Cargo-recent.lock     | 1 -
 primitives/Cargo.toml | 5 ++---
 3 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 5e47891e01..ecd87a1775 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -107,7 +107,6 @@ dependencies = [
  "arbitrary",
  "bincode",
  "bitcoin-internals",
- "bitcoin-io",
  "bitcoin-units",
  "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index 47641c992a..16d558d3d6 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -106,7 +106,6 @@ dependencies = [
  "arbitrary",
  "bincode",
  "bitcoin-internals",
- "bitcoin-io",
  "bitcoin-units",
  "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index a44c42c6e5..48074486c8 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -16,8 +16,8 @@ exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["alloc", "hashes/std", "hex/std", "internals/std", "io/std", "units/std"]
-alloc = ["hashes/alloc", "hex/alloc", "internals/alloc", "io/alloc", "units/alloc"]
+std = ["alloc", "hashes/std", "hex/std", "internals/std", "units/std"]
+alloc = ["hashes/alloc", "hex/alloc", "internals/alloc", "units/alloc"]
 serde = ["dep:serde", "hashes/serde", "internals/serde", "units/serde", "alloc"]
 arbitrary = ["dep:arbitrary", "units/arbitrary"]
 
@@ -25,7 +25,6 @@ arbitrary = ["dep:arbitrary", "units/arbitrary"]
 hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["bitcoin-io", "hex"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false }
 internals = { package = "bitcoin-internals", version = "0.4.0" }
-io = { package = "bitcoin-io", version = "0.2.0", default-features = false }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false }
 
 arbitrary = { version = "1.4", optional = true }

From fd4586eaae22cafb5a04cdc55919a4ec4aa6151a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 27 Jan 2025 10:45:01 +1100
Subject: [PATCH 341/554] Invert dependency between io and hashes

Currently in order to release `hashes v1.0` we need to 1.0 `io` as well.
For multiple reasons, many out of our control, the `io` crate may not
stabalise any time soon.

Instead we can invert the dependency between the two crates.

This is an ingenious idea, props to Kixunil for coming up with it.

Notes

- `io` does not currently re-export the `hashes` crate.
- This work highlights that we cannot call `hash_reader` on a siphash.
- The `Hmac::hash_reader` uses the default key which may not be obvious.

Signed-off-by: Tobin C. Harding <me@tobin.cc>
---
 Cargo-minimal.lock            |   2 +-
 Cargo-recent.lock             |   2 +-
 bitcoin/Cargo.toml            |   4 +-
 hashes/Cargo.toml             |   5 +-
 hashes/contrib/sanitizer.sh   |   2 +-
 hashes/contrib/test_vars.sh   |   4 +-
 hashes/embedded/Cargo.toml    |   7 +-
 hashes/src/hmac/mod.rs        |   3 +-
 hashes/src/internal_macros.rs |  29 +--
 hashes/src/lib.rs             |  34 ---
 hashes/src/sha256t/mod.rs     |  21 +-
 hashes/tests/io.rs            | 129 ------------
 hashes/tests/regression.rs    |   2 +
 io/Cargo.toml                 |   6 +-
 io/contrib/test_vars.sh       |   4 +-
 io/src/hash.rs                | 378 ++++++++++++++++++++++++++++++++++
 io/src/lib.rs                 |   8 +
 primitives/Cargo.toml         |   2 +-
 18 files changed, 417 insertions(+), 225 deletions(-)
 delete mode 100644 hashes/tests/io.rs
 create mode 100644 io/src/hash.rs

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index ecd87a1775..f90f321d54 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -98,6 +98,7 @@ name = "bitcoin-io"
 version = "0.2.0"
 dependencies = [
  "bitcoin-internals",
+ "bitcoin_hashes 0.16.0",
 ]
 
 [[package]]
@@ -140,7 +141,6 @@ dependencies = [
 name = "bitcoin_hashes"
 version = "0.16.0"
 dependencies = [
- "bitcoin-io",
  "hex-conservative 0.3.0",
  "serde",
  "serde_json",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index 16d558d3d6..8b590d8acd 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -97,6 +97,7 @@ name = "bitcoin-io"
 version = "0.2.0"
 dependencies = [
  "bitcoin-internals",
+ "bitcoin_hashes 0.16.0",
 ]
 
 [[package]]
@@ -139,7 +140,6 @@ dependencies = [
 name = "bitcoin_hashes"
 version = "0.16.0"
 dependencies = [
- "bitcoin-io",
  "hex-conservative 0.3.0",
  "serde",
  "serde_json",
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index cf0575029d..9713bf2001 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -27,10 +27,10 @@ arbitrary = ["dep:arbitrary", "units/arbitrary", "primitives/arbitrary"]
 [dependencies]
 base58 = { package = "base58ck", version = "0.2.0", default-features = false, features = ["alloc"] }
 bech32 = { version = "0.11.0", default-features = false, features = ["alloc"] }
-hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["alloc", "bitcoin-io", "hex"] }
+hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["alloc", "hex"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, features = ["alloc"] }
 internals = { package = "bitcoin-internals", version = "0.4.0", features = ["alloc"] }
-io = { package = "bitcoin-io", version = "0.2.0", default-features = false, features = ["alloc"] }
+io = { package = "bitcoin-io", version = "0.2.0", default-features = false, features = ["alloc", "hashes"] }
 primitives = { package = "bitcoin-primitives", version = "0.101.0", default-features = false, features = ["alloc"] }
 secp256k1 = { version = "0.29.0", default-features = false, features = ["hashes", "alloc"] }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false, features = ["alloc"] }
diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
index c34f2f04e3..35760c87e1 100644
--- a/hashes/Cargo.toml
+++ b/hashes/Cargo.toml
@@ -15,8 +15,8 @@ exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["alloc", "bitcoin-io?/std", "hex/std"]
-alloc = ["bitcoin-io?/alloc", "hex/alloc"]
+std = ["alloc", "hex/std"]
+alloc = ["hex/alloc"]
 serde = ["dep:serde", "hex"]
 # Smaller (but slower) implementation of sha256, sha512 and ripemd160
 small-hash = []
@@ -24,7 +24,6 @@ small-hash = []
 [dependencies]
 
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, optional = true }
-bitcoin-io = { version = "0.2.0", default-features = false, optional = true }
 serde = { version = "1.0", default-features = false, optional = true }
 
 [dev-dependencies]
diff --git a/hashes/contrib/sanitizer.sh b/hashes/contrib/sanitizer.sh
index e3d1e81521..495e404c18 100755
--- a/hashes/contrib/sanitizer.sh
+++ b/hashes/contrib/sanitizer.sh
@@ -5,7 +5,7 @@
 set -euox pipefail
 
 # Run the sanitizer with these features.
-FEATURES="std bitcoin-io serde"
+FEATURES="std serde"
 
 cargo clean
 CC='clang -fsanitize=address -fno-omit-frame-pointer'                                        \
diff --git a/hashes/contrib/test_vars.sh b/hashes/contrib/test_vars.sh
index 35360740a3..efcd3dcfc6 100644
--- a/hashes/contrib/test_vars.sh
+++ b/hashes/contrib/test_vars.sh
@@ -5,10 +5,10 @@
 # shellcheck disable=SC2034
 
 # Test all these features with "std" enabled.
-FEATURES_WITH_STD="bitcoin-io serde small-hash"
+FEATURES_WITH_STD="serde small-hash"
 
 # Test all these features without "std" enabled.
-FEATURES_WITHOUT_STD="alloc bitcoin-io serde small-hash"
+FEATURES_WITHOUT_STD="alloc serde small-hash"
 
 # Run these examples.
 EXAMPLES=""
diff --git a/hashes/embedded/Cargo.toml b/hashes/embedded/Cargo.toml
index be73fe563d..dcf5a7ecbc 100644
--- a/hashes/embedded/Cargo.toml
+++ b/hashes/embedded/Cargo.toml
@@ -19,8 +19,8 @@ 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 }
-bitcoin_hashes = { path="../", default-features = false, features = ["bitcoin-io"] }
-bitcoin-io = { path = "../../io", default_features = false }
+bitcoin_hashes = { path="../", default-features = false, features = [] }
+bitcoin-io = { path = "../../io", default_features = false, features = ["hashes"] }
 
 [[bin]]
 name = "embedded"
@@ -32,6 +32,9 @@ 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.bitcoin_hashes]
+path = "../../hashes"
+
 [patch.crates-io.bitcoin-internals]
 path = "../../internals"
 
diff --git a/hashes/src/hmac/mod.rs b/hashes/src/hmac/mod.rs
index 5cddfdc53a..eace7f951e 100644
--- a/hashes/src/hmac/mod.rs
+++ b/hashes/src/hmac/mod.rs
@@ -155,7 +155,8 @@ impl<'de, T: GeneralHash + Deserialize<'de>> Deserialize<'de> for Hmac<T> {
     }
 }
 
-crate::internal_macros::impl_io_write!(
+#[cfg(feature = "std")]
+crate::internal_macros::impl_write!(
     HmacEngine<T>,
     |us: &mut HmacEngine<T>, buf| {
         us.input(buf);
diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index 5ae79f119f..67b9f6170e 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -91,12 +91,6 @@ macro_rules! general_hash_type {
             {
                 <Self as $crate::GeneralHash>::hash_byte_chunks(byte_slices)
             }
-
-            /// Hashes the entire contents of the `reader`.
-            #[cfg(feature = "bitcoin-io")]
-            pub fn hash_reader<R: io::BufRead>(reader: &mut R) -> Result<Self, io::Error> {
-                <Self as $crate::GeneralHash>::hash_reader(reader)
-            }
         }
     };
 }
@@ -156,7 +150,7 @@ macro_rules! hash_type_no_default {
 
         $crate::internal_macros::hash_trait_impls!($bits, $reverse);
 
-        $crate::internal_macros::impl_io_write!(
+        $crate::internal_macros::impl_write!(
             HashEngine,
             |us: &mut HashEngine, buf| {
                 crate::HashEngine::input(us, buf);
@@ -168,29 +162,16 @@ macro_rules! hash_type_no_default {
 }
 pub(crate) use hash_type_no_default;
 
-// We do not use the `bitcoin_io::impl_write` macro because we don't have an unconditional
-// dependency on `bitcoin-io` and we want to implement `std:io::Write` even when we don't depend on
-// `bitcoin-io`.
-macro_rules! impl_io_write {
+macro_rules! impl_write {
     ($ty: ty, $write_fn: expr, $flush_fn: expr $(, $bounded_ty: ident : $bounds: path),*) => {
-        #[cfg(feature = "bitcoin-io")]
-        impl<$($bounded_ty: $bounds),*> bitcoin_io::Write for $ty {
-            #[inline]
-            fn write(&mut self, buf: &[u8]) -> bitcoin_io::Result<usize> {
-                $write_fn(self, buf)
-            }
-            #[inline]
-            fn flush(&mut self) -> bitcoin_io::Result<()> {
-                $flush_fn(self)
-            }
-        }
-
+        // `bitcoin_io::Write` is implemented in `bitcoin_io`.
         #[cfg(feature = "std")]
         impl<$($bounded_ty: $bounds),*> std::io::Write for $ty {
             #[inline]
             fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
                 $write_fn(self, buf)
             }
+
             #[inline]
             fn flush(&mut self) -> std::io::Result<()> {
                 $flush_fn(self)
@@ -198,7 +179,7 @@ macro_rules! impl_io_write {
         }
     }
 }
-pub(crate) use impl_io_write;
+pub(crate) use impl_write;
 
 macro_rules! engine_input_impl(
     () => (
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 9f0067aafd..0324da01a5 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -75,9 +75,6 @@ extern crate core;
 #[cfg(feature = "std")]
 extern crate std;
 
-#[cfg(feature = "bitcoin-io")]
-extern crate bitcoin_io as io;
-
 /// A generic serialization/deserialization framework.
 #[cfg(feature = "serde")]
 pub extern crate serde;
@@ -239,28 +236,6 @@ pub trait GeneralHash: Hash {
         }
         Self::from_engine(engine)
     }
-
-    /// Hashes the entire contents of the `reader`.
-    #[cfg(feature = "bitcoin-io")]
-    fn hash_reader<R: io::BufRead>(reader: &mut R) -> Result<Self, io::Error>
-    where
-        Self::Engine: Default,
-    {
-        let mut engine = Self::engine();
-        loop {
-            let bytes = reader.fill_buf()?;
-
-            let read = bytes.len();
-            // Empty slice means EOF.
-            if read == 0 {
-                break;
-            }
-
-            engine.input(bytes);
-            reader.consume(read);
-        }
-        Ok(Self::from_engine(engine))
-    }
 }
 
 /// Trait which applies to hashes of all types.
@@ -367,13 +342,4 @@ mod tests {
         let rinsed = hex.parse::<TestNewtype>().expect("failed to parse hex");
         assert_eq!(rinsed, orig)
     }
-
-    #[test]
-    #[cfg(feature = "bitcoin-io")]
-    fn hash_reader() {
-        use crate::sha256;
-
-        let mut reader: &[u8] = b"hello";
-        assert_eq!(sha256::Hash::hash_reader(&mut reader).unwrap(), sha256::Hash::hash(b"hello"),)
-    }
 }
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 5d28b9d93c..e2461eebff 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -87,25 +87,6 @@ where
         Self::from_engine(engine)
     }
 
-    /// Hashes the entire contents of the `reader`.
-    #[cfg(feature = "bitcoin-io")]
-    pub fn hash_reader<R: io::BufRead>(reader: &mut R) -> Result<Self, io::Error> {
-        let mut engine = Self::engine();
-        loop {
-            let bytes = reader.fill_buf()?;
-
-            let read = bytes.len();
-            // Empty slice means EOF.
-            if read == 0 {
-                break;
-            }
-
-            engine.input(bytes);
-            reader.consume(read);
-        }
-        Ok(Self::from_engine(engine))
-    }
-
     /// Returns the underlying byte array.
     pub const fn to_byte_array(self) -> [u8; 32] { self.0 }
 
@@ -152,7 +133,7 @@ impl<T: Tag> crate::HashEngine for HashEngine<T> {
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
 }
 
-crate::internal_macros::impl_io_write!(
+crate::internal_macros::impl_write!(
     HashEngine<T>,
     |us: &mut HashEngine<T>, buf| {
         us.input(buf);
diff --git a/hashes/tests/io.rs b/hashes/tests/io.rs
deleted file mode 100644
index 9151bba30a..0000000000
--- a/hashes/tests/io.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Test the `bitcoin-io` implementations.
-
-#![cfg(feature = "bitcoin-io")]
-#![cfg(feature = "hex")]
-
-use bitcoin_hashes::{
-    hash160, hmac, ripemd160, sha1, sha256, sha256d, sha384, sha512, sha512_256, siphash24,
-    GeneralHash as _,
-};
-use bitcoin_io::Write;
-
-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!(
-    sha384,
-    "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b",
-    "82135637ef6d6dd31a20e2bc9998681a3eecaf8f8c76d45e545214de38439d9a533848ec75f53e4b1a8805709c5124d0",
-    "fb7511d9a98c5686f9c2f55e242397815c9229d8759451e1710b8da6861e08d52f0357176f4b74f8cad9e23ab65411c7",
-);
-
-write_test!(
-    sha512,
-    "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce\
-     47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
-    "57ecf739d3a7ca647639adae80a05f4f361304bfcbfa1ceba93296b096e74287\
-     45fc10c142cecdd3bb587a3dba598c072f6f78b31cc0a06a3da0105ee51f75d6",
-    "dd28f78c53f3bc9bd0c2dca9642a1ad402a70412f985c1f6e54fadb98ce9c458\
-     4761df8d04ed04bb734ba48dd2106bb9ea54524f1394cdd18e6da3166e71c3ee",
-);
-
-write_test!(
-    sha512_256,
-    "c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a",
-    "8d4bb96e7956cf5f08bf5c45f7982630c46b0b022f25cbaf722ae97c06a6e7a2",
-    "3367646f3e264653f7dd664ac2cb6d3b96329e86ffb7a29a1082e2a4ddc9ee7a",
-);
-
-write_test!(
-    ripemd160,
-    "9c1185a5c5e9fc54612808977ee8f548b2258d31",
-    "e571a1ca5b780aa52bafdb9ec852544ffca418ba",
-    "ddd2ecce739e823629c7d46ab18918e9c4a51c75",
-);
-
-write_test!(
-    hash160,
-    "b472a266d0bd89c13706a4132ccfb16f7c3b9fcb",
-    "671356a1a874695ad3bc20cae440f4360835bd5a",
-    "a9608c952c8dbcc20c53803d2ca5ad31d64d9313",
-);
-
-#[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"
-    );
-}
-
-#[test]
-fn siphash24() {
-    let mut engine = siphash24::HashEngine::with_keys(0, 0);
-    engine.write_all(&[]).unwrap();
-    assert_eq!(format!("{}", siphash24::Hash::from_engine(engine)), "d70077739d4b921e");
-
-    let mut engine = siphash24::HashEngine::with_keys(0, 0);
-    engine.write_all(&[1; 256]).unwrap();
-    assert_eq!(format!("{}", siphash24::Hash::from_engine(engine)), "3a3ccefde9b5b1e3");
-
-    let mut engine = siphash24::HashEngine::with_keys(0, 0);
-    engine.write_all(&[99; 64000]).unwrap();
-    assert_eq!(format!("{}", siphash24::Hash::from_engine(engine)), "ce456e4e4ecbc5bf");
-}
diff --git a/hashes/tests/regression.rs b/hashes/tests/regression.rs
index a4ffddc2f1..319d6ecf37 100644
--- a/hashes/tests/regression.rs
+++ b/hashes/tests/regression.rs
@@ -1,6 +1,8 @@
 //! Regression tests for each hash type.
 //!
 //! Note that if `bitcoin-io` is enabled then we get more regression-like testing from `./io.rs`.
+//!
+//! Test input data and expected hashes is the same as in `io/src/hash.rs`.
 
 #![cfg(feature = "hex")]
 
diff --git a/io/Cargo.toml b/io/Cargo.toml
index 224d37804b..d245121da6 100644
--- a/io/Cargo.toml
+++ b/io/Cargo.toml
@@ -15,12 +15,14 @@ exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["alloc"]
-alloc = []
+std = ["alloc", "hashes?/std"]
+alloc = ["hashes?/alloc"]
 
 [dependencies]
 internals = { package = "bitcoin-internals", version = "0.4.0" }
 
+hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, optional = true }
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
diff --git a/io/contrib/test_vars.sh b/io/contrib/test_vars.sh
index 92dc094064..279c2507c4 100644
--- a/io/contrib/test_vars.sh
+++ b/io/contrib/test_vars.sh
@@ -5,10 +5,10 @@
 # shellcheck disable=SC2034
 
 # Test all these features with "std" enabled.
-FEATURES_WITH_STD=""
+FEATURES_WITH_STD="hashes"
 
 # Test all these features without "std" enabled.
-FEATURES_WITHOUT_STD="alloc"
+FEATURES_WITHOUT_STD="alloc hashes"
 
 # Run these examples.
 EXAMPLES=""
diff --git a/io/src/hash.rs b/io/src/hash.rs
new file mode 100644
index 0000000000..a6a364e945
--- /dev/null
+++ b/io/src/hash.rs
@@ -0,0 +1,378 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! I/O hashing support.
+//!
+//! Support for various hashing related things e.g.
+//!
+//! - Hashing to a writer.
+//! - Implement I/O traits for hash engines.
+
+use hashes::hmac::HmacEngine;
+use hashes::{
+    hash160, ripemd160, sha1, sha256, sha256d, sha256t, sha384, sha512, sha512_256, siphash24,
+    GeneralHash, HashEngine as _,
+};
+
+macro_rules! impl_write {
+    ($ty: ty, $write_fn: expr, $flush_fn: expr $(, $bounded_ty: ident : $bounds: path),*) => {
+        // `std::io::Write` is implemented in `bitcoin_hashes` because of the orphan rule.
+        impl<$($bounded_ty: $bounds),*> crate::Write for $ty {
+            #[inline]
+            fn write(&mut self, buf: &[u8]) -> crate::Result<usize> {
+                $write_fn(self, buf)}
+
+            #[inline]
+            fn flush(&mut self) -> crate::Result<()> {
+                $flush_fn(self)
+            }
+        }
+    }
+}
+pub(crate) use impl_write;
+
+impl_write!(
+    hash160::HashEngine,
+    |us: &mut hash160::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    ripemd160::HashEngine,
+    |us: &mut ripemd160::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    sha1::HashEngine,
+    |us: &mut sha1::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    sha256::HashEngine,
+    |us: &mut sha256::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    sha256d::HashEngine,
+    |us: &mut sha256d::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    sha256t::HashEngine<T>,
+    |us: &mut sha256t::HashEngine<T>, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) },
+    T: sha256t::Tag
+);
+
+impl_write!(
+    sha384::HashEngine,
+    |us: &mut sha384::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    sha512::HashEngine,
+    |us: &mut sha512::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    sha512_256::HashEngine,
+    |us: &mut sha512_256::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    siphash24::HashEngine,
+    |us: &mut siphash24::HashEngine, buf| {
+        hashes::HashEngine::input(us, buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) }
+);
+
+impl_write!(
+    HmacEngine<T>,
+    |us: &mut HmacEngine<T>, buf| {
+        us.input(buf);
+        Ok(buf.len())
+    },
+    |_us| { Ok(()) },
+    T: hashes::GeneralHash
+);
+
+/// Hashes data from a reader.
+///
+/// Adds functionality to a [`hashes::GeneralHash`] type to support hashing data read from a
+/// buffered reader.
+pub trait GeneralHashExt: GeneralHash + sealed::Sealed {
+    /// Hashes the entire contents of the `reader`.
+    fn hash_reader<R: crate::BufRead>(reader: &mut R) -> Result<Self, crate::Error>
+    where
+        Self::Engine: Default,
+    {
+        let mut engine = Self::engine(); // This calls `Self::Engine::default()`.
+        loop {
+            let bytes = reader.fill_buf()?;
+
+            let read = bytes.len();
+            // Empty slice means EOF.
+            if read == 0 {
+                break;
+            }
+
+            engine.input(bytes);
+            reader.consume(read);
+        }
+        Ok(Self::from_engine(engine))
+    }
+}
+
+impl<T: GeneralHash> GeneralHashExt for T {}
+
+mod sealed {
+    /// Used to seal the `GeneralHashExt` trait.
+    pub trait Sealed {}
+
+    impl<T: hashes::GeneralHash> Sealed for T {}
+}
+
+#[cfg(test)]
+#[cfg(feature = "alloc")]
+mod tests {
+    use alloc::format;
+
+    use hashes::{hmac, Hmac};
+
+    use super::*;
+    use crate::{Cursor, Write as _};
+
+    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!(
+        sha384,
+        "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b",
+        "82135637ef6d6dd31a20e2bc9998681a3eecaf8f8c76d45e545214de38439d9a533848ec75f53e4b1a8805709c5124d0",
+        "fb7511d9a98c5686f9c2f55e242397815c9229d8759451e1710b8da6861e08d52f0357176f4b74f8cad9e23ab65411c7",
+    );
+
+    write_test!(
+        sha512,
+        "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce\
+         47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
+        "57ecf739d3a7ca647639adae80a05f4f361304bfcbfa1ceba93296b096e74287\
+         45fc10c142cecdd3bb587a3dba598c072f6f78b31cc0a06a3da0105ee51f75d6",
+        "dd28f78c53f3bc9bd0c2dca9642a1ad402a70412f985c1f6e54fadb98ce9c458\
+         4761df8d04ed04bb734ba48dd2106bb9ea54524f1394cdd18e6da3166e71c3ee",
+    );
+
+    write_test!(
+        sha512_256,
+        "c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a",
+        "8d4bb96e7956cf5f08bf5c45f7982630c46b0b022f25cbaf722ae97c06a6e7a2",
+        "3367646f3e264653f7dd664ac2cb6d3b96329e86ffb7a29a1082e2a4ddc9ee7a",
+    );
+
+    write_test!(
+        ripemd160,
+        "9c1185a5c5e9fc54612808977ee8f548b2258d31",
+        "e571a1ca5b780aa52bafdb9ec852544ffca418ba",
+        "ddd2ecce739e823629c7d46ab18918e9c4a51c75",
+    );
+
+    write_test!(
+        hash160,
+        "b472a266d0bd89c13706a4132ccfb16f7c3b9fcb",
+        "671356a1a874695ad3bc20cae440f4360835bd5a",
+        "a9608c952c8dbcc20c53803d2ca5ad31d64d9313",
+    );
+
+    #[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"
+        );
+    }
+
+    #[test]
+    fn siphash24() {
+        let mut engine = siphash24::HashEngine::with_keys(0, 0);
+        engine.write_all(&[]).unwrap();
+        assert_eq!(format!("{}", siphash24::Hash::from_engine(engine)), "d70077739d4b921e");
+
+        let mut engine = siphash24::HashEngine::with_keys(0, 0);
+        engine.write_all(&[1; 256]).unwrap();
+        assert_eq!(format!("{}", siphash24::Hash::from_engine(engine)), "3a3ccefde9b5b1e3");
+
+        let mut engine = siphash24::HashEngine::with_keys(0, 0);
+        engine.write_all(&[99; 64000]).unwrap();
+        assert_eq!(format!("{}", siphash24::Hash::from_engine(engine)), "ce456e4e4ecbc5bf");
+    }
+
+    // Data and expected hashes taken from `bitcoin_hashes/tests/regression.rs`.
+    const DATA: &str = "arbitrary data to hash as a regression test";
+    const HMAC_KEY: &[u8] = b"some key";
+
+    macro_rules! impl_hash_reader_test {
+        ($($test_name:ident, $module:ident, $want:literal);* $(;)?) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    let hash = $module::Hash::hash(DATA.as_bytes());
+                    let got = format!("{}", hash);
+                    assert_eq!(got, $want);
+
+                    let mut reader = Cursor::new(DATA);
+                    let hash_from_reader = $module::Hash::hash_reader(&mut reader).unwrap();
+                    assert_eq!(hash_from_reader, hash)
+                }
+            )*
+        }
+    }
+
+    impl_hash_reader_test! {
+        hash_from_reader_hash160, hash160, "a17909f6d5373b0085c4180ba207126e5040f74d";
+        hash_from_reader_ripemd160, ripemd160, "e6801701c77a1cd85662335258c7869631b4a9a8";
+        hash_from_reader_sha1, sha1, "e1e81eeabadafa3d5d41cc3f405385426b0f47fd";
+        hash_from_reader_sha256, sha256, "d291c6c5a07fa1d9315cdae090ebe14169fbe0a219cd55a48d0d2104eab6ec51";
+        hash_from_reader_sha256d, sha256d, "93a743b022290bde3233a619b21aaebe06c5cf5cc959464c41be35711e37731b";
+        hash_from_reader_sha384, sha384, "f545bd83d297978d47a7f26b858a54188499dfb4d7d570a6a2362c765031d57a29d7e002df5e34d184e70b65a4f47153";
+        hash_from_reader_sha512, sha512, "057d0a37e9e0ac9a93acde0752748da059a27bcf946c7af00692ac1a95db8d21f965f40af22efc4710f100f8d3e43f79f77b1f48e1e400a95b7344b7bc0dfd10";
+        hash_from_reader_sha512_256, sha512_256, "e204244c429b5bca037a2a8a6e7ed8a42b808ceaff182560840bb8c5c8e9a2ec";
+    }
+
+    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
+    pub struct RegHashTag; // Name comes from regression tests in `bitcoin_hashes`.
+
+    impl sha256t::Tag for RegHashTag {
+        const MIDSTATE: sha256::Midstate = sha256::Midstate::new([0xab; 32], 64);
+    }
+
+    type RegHash = sha256t::Hash<RegHashTag>;
+
+    #[test]
+    fn regression_sha256t() {
+        let hash = RegHash::hash(DATA.as_bytes());
+        let got = format!("{}", hash);
+        let want = "17db326d7c13867376ccca1f8a211377be3cbeaeb372f167822284866ddf14ca";
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn regression_hmac_sha256_with_key() {
+        let mut engine = HmacEngine::<sha256::Hash>::new(HMAC_KEY);
+        engine.input(DATA.as_bytes());
+        let hash = Hmac::from_engine(engine);
+
+        let got = format!("{}", hash);
+        let want = "d159cecaf4adf90b6a641bab767e4817d3a51c414acea3682686c35ec0b37b52";
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn regression_hmac_sha512_with_key() {
+        let mut engine = HmacEngine::<sha512::Hash>::new(HMAC_KEY);
+        engine.input(DATA.as_bytes());
+        let hash = Hmac::from_engine(engine);
+
+        let got = format!("{}", hash);
+        let want = "8511773748f89ba22c07fb3a2981a12c1823695119de41f4a62aead6b848bd34939acf16475c35ed7956114fead3e794cc162ecd35e447a4dabc3227d55f757b";
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn regression_siphash24_with_key() {
+        let mut engine = siphash24::HashEngine::with_keys(0, 0);
+        engine.input(DATA.as_bytes());
+        let hash = siphash24::Hash::from_engine(engine);
+
+        let got = format!("{}", hash);
+        let want = "e823ed82311d601a";
+        assert_eq!(got, want);
+    }
+}
diff --git a/io/src/lib.rs b/io/src/lib.rs
index 0e1d331268..3c020d0b4d 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -25,11 +25,17 @@
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
+#[cfg(feature = "hashes")]
+pub extern crate hashes;
+
 #[cfg(feature = "std")]
 mod bridge;
 mod error;
 mod macros;
 
+#[cfg(feature = "hashes")]
+mod hash;
+
 #[cfg(all(not(feature = "std"), feature = "alloc"))]
 use alloc::vec::Vec;
 use core::cmp;
@@ -39,6 +45,8 @@ pub use bridge::{FromStd, ToStd};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 pub use self::error::{Error, ErrorKind};
+#[cfg(feature = "hashes")]
+pub use self::hash::GeneralHashExt;
 
 /// Result type returned by functions in this crate.
 pub type Result<T> = core::result::Result<T, Error>;
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 48074486c8..241be623a6 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -22,7 +22,7 @@ serde = ["dep:serde", "hashes/serde", "internals/serde", "units/serde", "alloc"]
 arbitrary = ["dep:arbitrary", "units/arbitrary"]
 
 [dependencies]
-hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["bitcoin-io", "hex"] }
+hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["hex"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false }
 internals = { package = "bitcoin-internals", version = "0.4.0" }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false }

From a4ef027134980a3eaa6808aa4c0e3882e6fa29f2 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 10 Feb 2025 14:13:13 +0000
Subject: [PATCH 342/554] Add tests of transaction functions

Cargo mutants found mutants in Transaction.

Add a test to kill them.
---
 primitives/src/transaction.rs | 46 +++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index e91540e557..9744a5ee02 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -598,3 +598,49 @@ impl<'a> Arbitrary<'a> for Txid {
         Ok(Txid(t))
     }
 }
+
+#[cfg(feature = "alloc")]
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn transaction_functions() {
+        let txin = TxIn {
+            previous_output: OutPoint {
+                txid: Txid::from_byte_array([0xAA; 32]), // Arbitrary invalid dummy value.
+                vout: 0,
+            },
+            script_sig: ScriptBuf::new(),
+            sequence: Sequence::MAX,
+            witness: Witness::new(),
+        };
+
+        let txout = TxOut {
+            value: Amount::from_sat(123456789),
+            script_pubkey: ScriptBuf::new(),
+        };
+
+        let tx_orig = Transaction {
+            version: Version::ONE,
+            lock_time: absolute::LockTime::from_consensus(1738968231), // The time this was written
+            input: vec![txin.clone()],
+            output: vec![txout.clone()],
+        };
+
+        // Test changing the transaction
+        let mut tx = tx_orig.clone();
+        tx.inputs_mut()[0].previous_output.txid = Txid::from_byte_array([0xFF; 32]);
+        tx.outputs_mut()[0].value = Amount::from_sat(987654321);
+        assert_eq!(tx.inputs()[0].previous_output.txid.to_byte_array(), [0xFF; 32]);
+        assert_eq!(tx.outputs()[0].value.to_sat(), 987654321);
+
+        // Test uses_segwit_serialization
+        assert!(!tx.uses_segwit_serialization());
+        tx.input[0].witness.push(vec![0xAB, 0xCD, 0xEF]);
+        assert!(tx.uses_segwit_serialization());
+
+        // Test partial ord
+        assert!(tx > tx_orig);
+    }
+}

From 957be3c978368218508f424e21c5fa2c0714d7e1 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 10 Feb 2025 14:16:44 +0000
Subject: [PATCH 343/554] Add OutPoint test

Cargo mutant found mutants in OutPoint.

Add a test to kill them.
---
 primitives/src/transaction.rs | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 9744a5ee02..b8d4bbcb6b 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -643,4 +643,30 @@ mod tests {
         // Test partial ord
         assert!(tx > tx_orig);
     }
+
+    #[test]
+    fn outpoint_from_str() {
+        // Check format errors
+        let mut outpoint_str = "0".repeat(64); // No ":"
+        let outpoint: Result<OutPoint, ParseOutPointError> = outpoint_str.parse();
+        assert_eq!(outpoint, Err(ParseOutPointError::Format));
+
+        outpoint_str.push(':'); // Empty vout
+        let outpoint: Result<OutPoint, ParseOutPointError> = outpoint_str.parse();
+        assert_eq!(outpoint, Err(ParseOutPointError::Format));
+
+        outpoint_str.push('0'); // Correct format
+        let outpoint: OutPoint = outpoint_str.parse().unwrap();
+        assert_eq!(outpoint.txid, Txid::from_byte_array([0; 32]));
+        assert_eq!(outpoint.vout, 0);
+
+        // Check the number of bytes OutPoint contributes to the transaction is equal to SIZE
+        let outpoint_size = outpoint.txid.as_byte_array().len() + outpoint.vout.to_le_bytes().len();
+        assert_eq!(outpoint_size, OutPoint::SIZE);
+
+        // Check TooLong error
+        outpoint_str.push_str("0000000000");
+        let outpoint: Result<OutPoint, ParseOutPointError> = outpoint_str.parse();
+        assert_eq!(outpoint, Err(ParseOutPointError::TooLong));
+    }
 }

From 435750f2922abc3093dc4386cd75f852dfb7190d Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 10 Feb 2025 14:17:51 +0000
Subject: [PATCH 344/554] Add a parse_vout test

Add a test to kill the mutants in parse_vout().
---
 primitives/src/transaction.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index b8d4bbcb6b..3a3682f6a4 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -669,4 +669,12 @@ mod tests {
         let outpoint: Result<OutPoint, ParseOutPointError> = outpoint_str.parse();
         assert_eq!(outpoint, Err(ParseOutPointError::TooLong));
     }
+
+    #[test]
+    fn canonical_vout() {
+        assert_eq!(parse_vout("0").unwrap(), 0);
+        assert_eq!(parse_vout("1").unwrap(), 1);
+        assert!(parse_vout("01").is_err()); // Leading zero not allowed
+        assert!(parse_vout("+1").is_err()); // Non digits not allowed
+    }
 }

From 43a7c66f50b663aee503c958c5158127fa0b8d5c Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Tue, 11 Feb 2025 19:00:46 +0300
Subject: [PATCH 345/554] units: Remove alloc from fee module

The fee module methods behind alloc perform only arithmetic operations, so they don't require heap allocation
---
 units/src/fee.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/units/src/fee.rs b/units/src/fee.rs
index 94601db87a..472eb93700 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -33,7 +33,6 @@ impl Amount {
     /// let fee_rate = amount.checked_div_by_weight_ceil(weight).expect("Division by weight failed");
     /// assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(34));
     /// ```
-    #[cfg(feature = "alloc")]
     #[must_use]
     pub const fn checked_div_by_weight_ceil(self, weight: Weight) -> Option<FeeRate> {
         let wu = weight.to_wu();
@@ -56,7 +55,6 @@ impl Amount {
     /// can be made. See also [`Self::checked_div_by_weight_ceil`].
     ///
     /// Returns [`None`] if overflow occurred.
-    #[cfg(feature = "alloc")]
     #[must_use]
     pub const fn checked_div_by_weight_floor(self, weight: Weight) -> Option<FeeRate> {
         // No `?` operator in const context.

From 3ee66c5bb882893cc75d92643ad315da51a19c03 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Feb 2025 16:37:31 +0000
Subject: [PATCH 346/554] Modify push test

Cargo mutants found mutants in witness.

Add to the existing test `push` to kill the mutants from `is_empty` and
`third_to_last`.

Change the dummy values to make the progression of `elements` down the
test easier to follow.
---
 primitives/src/witness.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index abec3e1fb2..d0c9553936 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -497,6 +497,7 @@ mod test {
     fn push() {
         // Sanity check default.
         let mut witness = Witness::default();
+        assert!(witness.is_empty());
         assert_eq!(witness.last(), None);
         assert_eq!(witness.second_to_last(), None);
 
@@ -506,10 +507,11 @@ mod test {
         assert_eq!(witness.nth(3), None);
 
         // Push a single byte element onto the witness stack.
-        let push = [0_u8];
+        let push = [11_u8];
         witness.push(push);
+        assert!(!witness.is_empty());
 
-        let elements = [1u8, 0];
+        let elements = [1u8, 11];
         let expected = Witness {
             witness_elements: 1,
             content: append_u32_vec(&elements, &[0]), // Start at index 0.
@@ -529,10 +531,10 @@ mod test {
         assert_eq!(witness.nth(3), None);
 
         // Now push 2 byte element onto the witness stack.
-        let push = [2u8, 3u8];
+        let push = [21u8, 22u8];
         witness.push(push);
 
-        let elements = [1u8, 0, 2, 2, 3];
+        let elements = [1u8, 11, 2, 21, 22];
         let expected = Witness {
             witness_elements: 2,
             content: append_u32_vec(&elements, &[0, 2]),
@@ -552,10 +554,10 @@ mod test {
         assert_eq!(witness.last(), Some(element_1));
 
         // Now push another 2 byte element onto the witness stack.
-        let push = [4u8, 5u8];
+        let push = [31u8, 32u8];
         witness.push(push);
 
-        let elements = [1u8, 0, 2, 2, 3, 2, 4, 5];
+        let elements = [1u8, 11, 2, 21, 22, 2, 31, 32];
         let expected = Witness {
             witness_elements: 3,
             content: append_u32_vec(&elements, &[0, 2, 5]),
@@ -571,6 +573,7 @@ mod test {
         assert_eq!(witness.nth(2), Some(element_2));
         assert_eq!(witness.nth(3), None);
 
+        assert_eq!(witness.third_to_last(), Some(element_0));
         assert_eq!(witness.second_to_last(), Some(element_1));
         assert_eq!(witness.last(), Some(element_2));
     }

From 2f95064cfd0ce07d002f6e0d027e99f6dcef5d22 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Feb 2025 17:08:30 +0000
Subject: [PATCH 347/554] Add from_parts test

Add a test to kill the mutant in `from_parts__unstable`
---
 primitives/src/witness.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index d0c9553936..af8e0c0acf 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -597,6 +597,18 @@ mod test {
         }
     }
 
+    #[test]
+    fn witness_from_parts() {
+        let elements = [1u8, 11, 2, 21, 22];
+        let witness_elements = 2;
+        let content = append_u32_vec(&elements, &[0, 2]);
+        let indices_start = elements.len();
+        let witness = Witness::from_parts__unstable(content.clone(), witness_elements, indices_start);
+        assert_eq!(witness.nth(0).unwrap(), [11_u8]);
+        assert_eq!(witness.nth(1).unwrap(), [21_u8, 22]);
+        assert_eq!(witness.size(), 6);
+    }
+
     #[test]
     #[cfg(feature = "serde")]
     fn serde_bincode_backward_compatibility() {

From 7e66091e1e8b6cdd3e40d001ea1824125f7175e7 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Feb 2025 17:31:24 +0000
Subject: [PATCH 348/554] Add from impl tests

Add tests for the witness from implementations to kill all the mutants
found by cargo mutants.
---
 primitives/src/witness.rs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index af8e0c0acf..d48755992d 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -609,6 +609,33 @@ mod test {
         assert_eq!(witness.size(), 6);
     }
 
+    #[test]
+    fn witness_from_impl() {
+        // Test From implementations with the same 2 elements
+        let vec = vec![vec![11], vec![21, 22]];
+        let slice_vec: &[Vec<u8>] = &vec;
+        let slice_slice: &[&[u8]] = &[&[11u8], &[21, 22]];
+        let vec_slice: Vec<&[u8]> = vec![&[11u8], &[21, 22]];
+
+        let witness_vec_vec = Witness::from(vec.clone());
+        let witness_slice_vec = Witness::from(slice_vec);
+        let witness_slice_slice = Witness::from(slice_slice);
+        let witness_vec_slice = Witness::from(vec_slice);
+
+        let mut expected = Witness::from_slice(&vec);
+        assert_eq!(expected.len(), 2);
+        assert_eq!(expected.to_vec(), vec);
+
+        assert_eq!(witness_vec_vec, expected);
+        assert_eq!(witness_slice_vec, expected);
+        assert_eq!(witness_slice_slice, expected);
+        assert_eq!(witness_vec_slice, expected);
+
+        // Test clear method
+        expected.clear();
+        assert!(expected.is_empty());
+    }
+
     #[test]
     #[cfg(feature = "serde")]
     fn serde_bincode_backward_compatibility() {

From 6cecc40ae4d52b711f58998315155bc8c6b19d7b Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 10 Feb 2025 14:59:35 +0000
Subject: [PATCH 349/554] Test LockTime PartialOrd

Add tests to kill the mutants in both relative and absolute PartialOrd.
---
 primitives/src/locktime/absolute.rs | 6 ++++++
 primitives/src/locktime/relative.rs | 3 +++
 2 files changed, 9 insertions(+)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index ae924e26bc..da8ef86b7a 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -501,6 +501,9 @@ mod tests {
         assert!(lock_by_height.is_satisfied_by(height_same, time));
         assert!(lock_by_height.is_satisfied_by(height_above, time));
         assert!(!lock_by_height.is_satisfied_by(height_below, time));
+
+        let lock_by_height_above = LockTime::from_consensus(800_000);
+        assert!(lock_by_height < lock_by_height_above)
     }
 
     #[test]
@@ -516,6 +519,9 @@ mod tests {
         assert!(lock_by_time.is_satisfied_by(height, time_same));
         assert!(lock_by_time.is_satisfied_by(height, time_after));
         assert!(!lock_by_time.is_satisfied_by(height, time_before));
+
+        let lock_by_time_after = LockTime::from_consensus(1653282000);
+        assert!(lock_by_time < lock_by_time_after);
     }
 
     #[test]
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 0874225b22..2cca3889be 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -501,6 +501,9 @@ mod tests {
         assert!(!lock_by_height1.is_same_unit(lock_by_time1));
         assert!(lock_by_time1.is_same_unit(lock_by_time2));
         assert!(!lock_by_time1.is_same_unit(lock_by_height1));
+
+        assert!(lock_by_height1 < lock_by_height2);
+        assert!(lock_by_time1 < lock_by_time2);
     }
 
     #[test]

From 32b05132b542a657911feb5f8477d17c84334502 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Feb 2025 17:45:14 +0000
Subject: [PATCH 350/554] Reorganize mutants.toml

Generalize `deserialize` as an exception for everywhere.

Reword comment to make clearer
---
 .cargo/mutants.toml | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/.cargo/mutants.toml b/.cargo/mutants.toml
index b6ed18c553..9247476897 100644
--- a/.cargo/mutants.toml
+++ b/.cargo/mutants.toml
@@ -8,20 +8,14 @@ exclude_re = [
     "impl Arbitrary",
     "impl Display",
     ".*Error",
-    # --------------------------------------------Crate-specific exclusions--------------------------------------------
+    "deserialize", # Skip serde mutation tests
+
+    # ----------------------------------Crate-specific exclusions----------------------------------
     # Units
     # src/amount/mod.rs
     "parse_signed_to_satoshi", # Can't kill all mutants since there is no denomination smaller than Satoshi
     "fmt_satoshi_in", # Related to formatting/display
     "dec_width", # Replacing num /= 10 with num %=10 in a loop causes a timeout due to infinite loop
-    # src/fee_rate/serde.rs
-    "as_sat_per_kwu::opt::deserialize::<impl Visitor for VisitOpt>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
-    "as_sat_per_vb_floor::opt::deserialize::<impl Visitor for VisitOpt>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
-    "as_sat_per_vb_ceil::opt::deserialize::<impl Visitor for VisitOpt>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
-    # src/amount/serde.rs
-    "as_sat::opt::deserialize::<impl Visitor for VisitOptAmt<X>>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
-    "as_btc::opt::deserialize::<impl Visitor for VisitOptAmt<X>>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
-    "as_str::opt::deserialize::<impl Visitor for VisitOptAmt<X>>.*", # Replaces return value with Ok(Default::default()), which is the same as Ok(None)
     # src/locktime/relative.rs
-    "Time::to_consensus_u32" # It will replace | with ^, which will return the same value since the XOR is always taken against the u16 and an all-zero bitmask
+    "Time::to_consensus_u32", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask
 ]

From 3c12d4eb1fcdfc8d7569ef3f4024811017abd15c Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Feb 2025 17:52:32 +0000
Subject: [PATCH 351/554] Add primitives to mutants.toml

Add exceptions for `primitives` to `mutants.toml`.

Add `primitives` to the list of paths to run cargo mutants on.
---
 .cargo/mutants.toml | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/.cargo/mutants.toml b/.cargo/mutants.toml
index 9247476897..6477f498ed 100644
--- a/.cargo/mutants.toml
+++ b/.cargo/mutants.toml
@@ -1,5 +1,5 @@
 additional_cargo_args = ["--all-features"]
-examine_globs = ["units/src/**/*.rs"]
+examine_globs = ["units/src/**/*.rs", "primitives/src/**/*.rs"]
 exclude_globs = [
     "units/src/amount/verification.rs" # kani tests
 ]
@@ -9,6 +9,7 @@ exclude_re = [
     "impl Display",
     ".*Error",
     "deserialize", # Skip serde mutation tests
+    "Iterator", # Mutating operations in an iterator can result in an infinite loop
 
     # ----------------------------------Crate-specific exclusions----------------------------------
     # Units
@@ -18,4 +19,14 @@ exclude_re = [
     "dec_width", # Replacing num /= 10 with num %=10 in a loop causes a timeout due to infinite loop
     # src/locktime/relative.rs
     "Time::to_consensus_u32", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask
+
+    # primitives
+    "Sequence::from_512_second_intervals", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask
+    "Opcode::classify", # Not possible to kill all mutants without individually checking every opcode classification
+    "Block<Checked>::cached_witness_root", # Skip getters
+    "Block<Checked>::transactions", # Skip getters
+    "Script::to_bytes", # Deprecated
+    "decode_cursor", # Mutating operations in decode_cursor can result in an infinite loop
+    "fmt_debug", # Mutants from formatting/display changes
+    "fmt_debug_pretty", # Mutants from formatting/display changes
 ]

From 0acd2b5e894246d0b0cf7f78bb820a8940c41c26 Mon Sep 17 00:00:00 2001
From: Andrew Toth <andrewstoth@gmail.com>
Date: Wed, 12 Feb 2025 09:55:33 -0500
Subject: [PATCH 352/554] primitives: store transaction::Version as u32 instead
 of i32

---
 bitcoin/src/blockdata/transaction.rs | 12 +++---------
 primitives/src/transaction.rs        |  4 ++--
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index d9ec07c808..0a99677e03 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -631,7 +631,7 @@ crate::internal_macros::define_extension_trait! {
     /// Extension functionality for the [`Version`] type.
     pub trait VersionExt impl for Version {
         /// Constructs a new non-standard transaction version.
-        fn non_standard(version: i32) -> Version { Self(version) }
+        fn non_standard(version: u32) -> Version { Self(version) }
 
         /// Returns true if this transaction version number is considered standard.
         fn is_standard(&self) -> bool { *self == Version::ONE || *self == Version::TWO || *self == Version::THREE }
@@ -1369,17 +1369,11 @@ mod tests {
 
     #[test]
     fn transaction_version() {
-        let tx_bytes = hex!("ffffff7f0100000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
+        let tx_bytes = hex!("ffffffff0100000000000000000000000000000000000000000000000000000000000000000000000000ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000");
         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));
+        assert_eq!(realtx.version, Version::non_standard(u32::MAX));
     }
 
     #[test]
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index e91540e557..df1bef8a84 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -510,7 +510,7 @@ impl Wtxid {
 ///
 /// Currently, as specified by [BIP-68] and [BIP-431], version 1, 2, and 3 are considered standard.
 ///
-/// Standardness of the inner `i32` is not an invariant because you are free to create transactions
+/// Standardness of the inner `u32` is not an invariant because you are free to create transactions
 /// of any version, transactions with non-standard version numbers will not be relayed by the
 /// Bitcoin network.
 ///
@@ -518,7 +518,7 @@ impl Wtxid {
 /// [BIP-431]: https://github.com/bitcoin/bips/blob/master/bip-0431.mediawiki
 #[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Version(pub i32);
+pub struct Version(pub u32);
 
 impl Version {
     /// The original Bitcoin transaction version (pre-BIP-68).

From ab2f7091814333b20669d41f1f78e0e52795df08 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Thu, 13 Feb 2025 03:00:40 +0530
Subject: [PATCH 353/554] Implement Default for Script

Add Default implementation for Script that returns an empty script.

ScriptBuf already has #[derive(Default)] in the code so it's already handled
---
 primitives/src/script/borrowed.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index af5c48ebc8..6e68a6ef69 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -56,6 +56,11 @@ use crate::prelude::{Box, ToOwned, Vec};
 #[repr(transparent)]
 pub struct Script(pub(in crate::script) [u8]);
 
+impl Default for &Script {
+    #[inline]
+    fn default() -> Self { Script::new() }
+}
+
 impl ToOwned for Script {
     type Owned = ScriptBuf;
 

From 00cd247bc49451fe8c2cbf537ed042b0bb5c3340 Mon Sep 17 00:00:00 2001
From: ndungudedan <dnkibere@gmail.com>
Date: Thu, 13 Feb 2025 11:45:25 +0300
Subject: [PATCH 354/554] Validate compressed WIF keys

For private WIF keys corresponding to a compressed address,
the last byte of the key needs to be 0x01, but the API
doesn't enforce this when using PrivateKey::from_wif(). So,
invalid keys can be accepted.

Thus we check if the last byte is equivalent to 0x01
if the key's length is 34 (which indicates it's
compressed).
---
 bitcoin/src/crypto/key.rs | 44 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 9e9f1aa8c7..9ba23615a9 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -497,7 +497,12 @@ impl PrivateKey {
 
         let compressed = match data.len() {
             33 => false,
-            34 => true,
+            34 => {
+                if data[33] != 1 {
+                    return Err(InvalidWifCompressionFlagError{ invalid: data[33] }.into());
+                }
+                true
+            },
             length => {
                 return Err(InvalidBase58PayloadLengthError { length }.into());
             }
@@ -963,6 +968,8 @@ pub enum FromWifError {
     InvalidAddressVersion(InvalidAddressVersionError),
     /// A secp256k1 error.
     Secp256k1(secp256k1::Error),
+    /// Invalid WIF compression flag.
+    InvalidWifCompressionFlag(InvalidWifCompressionFlagError),
 }
 
 impl From<Infallible> for FromWifError {
@@ -980,6 +987,8 @@ impl fmt::Display for FromWifError {
             InvalidAddressVersion(ref e) =>
                 write_err!(f, "decoded base58 data contained an invalid address version btye"; e),
             Secp256k1(ref e) => write_err!(f, "private key validation failed"; e),
+            InvalidWifCompressionFlag(ref e) => 
+                write_err!(f, "invalid WIF compression flag";e),
         }
     }
 }
@@ -994,6 +1003,7 @@ impl std::error::Error for FromWifError {
             InvalidBase58PayloadLength(ref e) => Some(e),
             InvalidAddressVersion(ref e) => Some(e),
             Secp256k1(ref e) => Some(e),
+            InvalidWifCompressionFlag(ref e) => Some(e),
         }
     }
 }
@@ -1016,6 +1026,12 @@ impl From<InvalidAddressVersionError> for FromWifError {
     fn from(e: InvalidAddressVersionError) -> FromWifError { Self::InvalidAddressVersion(e) }
 }
 
+impl From<InvalidWifCompressionFlagError> for FromWifError {
+    fn from(e: InvalidWifCompressionFlagError) -> FromWifError {
+        Self::InvalidWifCompressionFlag(e)
+    }
+}
+
 /// Error returned while constructing public key from string.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ParsePublicKeyError {
@@ -1161,6 +1177,27 @@ impl fmt::Display for InvalidAddressVersionError {
 #[cfg(feature = "std")]
 impl std::error::Error for InvalidAddressVersionError {}
 
+/// Invalid compression flag for a WIF key
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct InvalidWifCompressionFlagError{
+    /// The invalid compression flag.
+    pub(crate) invalid: u8,
+}
+
+impl InvalidWifCompressionFlagError {
+    /// Returns the invalid compression flag.
+    pub fn invalid_compression_flag(&self) -> u8 { self.invalid }
+}
+
+impl fmt::Display for InvalidWifCompressionFlagError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "invalid WIF compression flag. Expected a 0x01 byte at the end of the key but found: {}", self.invalid)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for InvalidWifCompressionFlagError {}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1168,6 +1205,11 @@ mod tests {
 
     #[test]
     fn key_derivation() {
+        // mainnet compressed WIF with invalid compression flag.
+        let sk =
+        PrivateKey::from_wif("L2x4uC2YgfFWZm9tF4pjDnVR6nJkheizFhEr2KvDNnTEmEqVzPJY");
+        assert!(matches!(sk, Err(FromWifError::InvalidWifCompressionFlag(InvalidWifCompressionFlagError { invalid: 49 }))));
+
         // testnet compressed
         let sk =
             PrivateKey::from_wif("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap();

From 44df39e72cf57f13a6e788a443167ff959a73d4e Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 13 Feb 2025 18:03:56 +0000
Subject: [PATCH 355/554] Skip deprecated functions in mutants.toml

Cargo mutants found mutants in `fee_vb` and `fee_wu`.

Both functions are deprecated.  Skip them in mutant testing.
---
 .cargo/mutants.toml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.cargo/mutants.toml b/.cargo/mutants.toml
index 6477f498ed..96f3735504 100644
--- a/.cargo/mutants.toml
+++ b/.cargo/mutants.toml
@@ -19,6 +19,8 @@ exclude_re = [
     "dec_width", # Replacing num /= 10 with num %=10 in a loop causes a timeout due to infinite loop
     # src/locktime/relative.rs
     "Time::to_consensus_u32", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask
+    "FeeRate::fee_vb", # Deprecated
+    "FeeRate::fee_wu", # Deprecated
 
     # primitives
     "Sequence::from_512_second_intervals", # Mutant from replacing | with ^, this returns the same value since the XOR is taken against the u16 with an all-zero bitmask

From 854a4cf51189b4be596c4f048420fc9b1212d714 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 13 Feb 2025 18:05:03 +0000
Subject: [PATCH 356/554] Kill mutant in checked_mul_by_fee_rate

Use `checked_mul_by_fee_rate` in existing test to kill the mutant.
---
 units/src/fee.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/src/fee.rs b/units/src/fee.rs
index 94601db87a..84c0899b89 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -254,7 +254,7 @@ mod tests {
 
         let weight = Weight::from_wu(381);
         let fee_rate = FeeRate::from_sat_per_kwu(864);
-        let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
+        let fee = weight.checked_mul_by_fee_rate(fee_rate).unwrap();
         // 381 * 0.864 yields 329.18.
         // The result is then rounded up to 330.
         assert_eq!(fee, Amount::from_sat_unchecked(330));

From e7c6564d38346a8100be08a43554bfc95cdbb34d Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 13 Feb 2025 19:03:28 +0000
Subject: [PATCH 357/554] Add missing hex feature gate

`hex` was previously enabled by `alloc`, now it is optional add the
missing feature gate to tests.
---
 hashes/src/cmp.rs             | 1 +
 hashes/src/hash160/mod.rs     | 1 +
 hashes/src/hkdf/mod.rs        | 1 +
 hashes/src/lib.rs             | 1 +
 hashes/src/ripemd160/tests.rs | 1 +
 hashes/src/sha1/tests.rs      | 1 +
 hashes/src/sha256/tests.rs    | 2 ++
 hashes/src/sha256d/mod.rs     | 2 ++
 hashes/src/sha256t/mod.rs     | 4 ++++
 hashes/src/sha384/mod.rs      | 1 +
 hashes/src/sha512/tests.rs    | 1 +
 hashes/src/sha512_256/mod.rs  | 1 +
 12 files changed, 17 insertions(+)

diff --git a/hashes/src/cmp.rs b/hashes/src/cmp.rs
index b19aeb4003..3a72b389ff 100644
--- a/hashes/src/cmp.rs
+++ b/hashes/src/cmp.rs
@@ -95,6 +95,7 @@ mod tests {
 }
 
 #[cfg(bench)]
+#[cfg(feature = "hex")]
 mod benches {
     use test::Bencher;
 
diff --git a/hashes/src/hash160/mod.rs b/hashes/src/hash160/mod.rs
index fd2e366c20..d70ec275d3 100644
--- a/hashes/src/hash160/mod.rs
+++ b/hashes/src/hash160/mod.rs
@@ -47,6 +47,7 @@ impl crate::HashEngine for HashEngine {
 mod tests {
     #[test]
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     fn test() {
         use alloc::string::ToString;
 
diff --git a/hashes/src/hkdf/mod.rs b/hashes/src/hkdf/mod.rs
index f9f027857c..5df8722d1a 100644
--- a/hashes/src/hkdf/mod.rs
+++ b/hashes/src/hkdf/mod.rs
@@ -107,6 +107,7 @@ where
 
 #[cfg(test)]
 #[cfg(feature = "alloc")]
+#[cfg(feature = "hex")]
 mod tests {
     use hex::prelude::{DisplayHex, FromHex};
 
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 0324da01a5..f4fb6fd446 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -326,6 +326,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     fn newtype_fmt_roundtrip() {
         use alloc::format;
 
diff --git a/hashes/src/ripemd160/tests.rs b/hashes/src/ripemd160/tests.rs
index d6340591cc..3b9a324b68 100644
--- a/hashes/src/ripemd160/tests.rs
+++ b/hashes/src/ripemd160/tests.rs
@@ -1,5 +1,6 @@
 #[test]
 #[cfg(feature = "alloc")]
+#[cfg(feature = "hex")]
 fn test() {
     use alloc::string::ToString;
 
diff --git a/hashes/src/sha1/tests.rs b/hashes/src/sha1/tests.rs
index 2bfe37b1cf..ce30cd3342 100644
--- a/hashes/src/sha1/tests.rs
+++ b/hashes/src/sha1/tests.rs
@@ -1,5 +1,6 @@
 #[test]
 #[cfg(feature = "alloc")]
+#[cfg(feature = "hex")]
 fn test() {
     use alloc::string::ToString;
 
diff --git a/hashes/src/sha256/tests.rs b/hashes/src/sha256/tests.rs
index 65f166e17e..4e45ae6545 100644
--- a/hashes/src/sha256/tests.rs
+++ b/hashes/src/sha256/tests.rs
@@ -5,6 +5,7 @@ use crate::{sha256, HashEngine};
 
 #[test]
 #[cfg(feature = "alloc")]
+#[cfg(feature = "hex")]
 fn test() {
     use alloc::string::ToString;
 
@@ -70,6 +71,7 @@ fn test() {
 
 #[test]
 #[cfg(feature = "alloc")]
+#[cfg(feature = "hex")]
 fn fmt_roundtrips() {
     use alloc::format;
 
diff --git a/hashes/src/sha256d/mod.rs b/hashes/src/sha256d/mod.rs
index 003801d998..54943db517 100644
--- a/hashes/src/sha256d/mod.rs
+++ b/hashes/src/sha256d/mod.rs
@@ -45,6 +45,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     fn test() {
         use alloc::string::ToString;
 
@@ -98,6 +99,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     fn fmt_roundtrips() {
         use alloc::format;
 
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index e2461eebff..5f4ce2fe1b 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -182,10 +182,12 @@ mod tests {
 
     // The digest created by sha256 hashing `&[0]` starting with `TEST_MIDSTATE`.
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     const HASH_ZERO_BACKWARD: &str =
         "29589d5122ec666ab5b4695070b6debc63881a4f85d88d93ddc90078038213ed";
     // And the same thing, forward.
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     const HASH_ZERO_FORWARD: &str =
         "ed1382037800c9dd938dd8854f1a8863bcdeb6705069b4b56a66ec22519d5829";
 
@@ -198,10 +200,12 @@ mod tests {
 
     // We support manually implementing `Tag` and creating a tagged hash from it.
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     pub type TestHash = sha256t::Hash<TestHashTag>;
 
     #[test]
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     fn manually_created_sha256t_hash_type() {
         use alloc::string::ToString;
 
diff --git a/hashes/src/sha384/mod.rs b/hashes/src/sha384/mod.rs
index 200bf9f6ea..c20b356dcd 100644
--- a/hashes/src/sha384/mod.rs
+++ b/hashes/src/sha384/mod.rs
@@ -41,6 +41,7 @@ impl crate::HashEngine for HashEngine {
 mod tests {
     #[test]
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     fn test() {
         use alloc::string::ToString;
 
diff --git a/hashes/src/sha512/tests.rs b/hashes/src/sha512/tests.rs
index 4b46f01760..ecf78582b2 100644
--- a/hashes/src/sha512/tests.rs
+++ b/hashes/src/sha512/tests.rs
@@ -1,5 +1,6 @@
 #[test]
 #[cfg(feature = "alloc")]
+#[cfg(feature = "hex")]
 fn test() {
     use alloc::string::ToString;
 
diff --git a/hashes/src/sha512_256/mod.rs b/hashes/src/sha512_256/mod.rs
index 3452508f03..40b4ca6517 100644
--- a/hashes/src/sha512_256/mod.rs
+++ b/hashes/src/sha512_256/mod.rs
@@ -51,6 +51,7 @@ impl crate::HashEngine for HashEngine {
 mod tests {
     #[test]
     #[cfg(feature = "alloc")]
+    #[cfg(feature = "hex")]
     fn test() {
         use alloc::string::ToString;
 

From f99847d6eca0977d6f987baa7846c62a0613ba35 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Fri, 14 Feb 2025 13:54:37 +0100
Subject: [PATCH 358/554] Do not enable `soft-float` when running `miri`

To ensure that all target features are tested we simply enable all of
them. However some of them are problematic. We already have an exception
to not enable `crt-static`. This change also adds `soft-float` to the
list because `miri` was warning about it being UB.
---
 contrib/test-miri.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/test-miri.sh b/contrib/test-miri.sh
index 6ca2dab512..5e979a6f46 100755
--- a/contrib/test-miri.sh
+++ b/contrib/test-miri.sh
@@ -6,7 +6,7 @@ cd "$(dirname "$0")/.."
 
 . contrib/test_vars.sh
 
-target_features="$(rustc --print target-features | awk '{ if ($1 == "") { exit 0 } if (NR != 1 && $1 != "crt-static") { if (NR == 2) { printf "+%s", $1 } else { printf ",+%s", $1 } } }')"
+target_features="$(rustc --print target-features | awk '{ if ($1 == "") { exit 0 } if (NR != 1 && $1 != "crt-static" && $1 != "soft-float") { if (NR == 2) { printf "+%s", $1 } else { printf ",+%s", $1 } } }')"
 
 for crate in $CRATES;
 do

From 11770cac1c6efbe03c4dded93b22426832ff87cd Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 14 Feb 2025 12:28:35 +0000
Subject: [PATCH 359/554] Add hashes to io dev-depencies and require hex

The tests in `hash` require hex.  Previously this was enabled when
`alloc` was enabled.  Now `alloc` doesn't enable `hex` add `hashes` to
`dev-dependecies` and set it to require `hex`
---
 io/Cargo.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/io/Cargo.toml b/io/Cargo.toml
index d245121da6..f59c35e00c 100644
--- a/io/Cargo.toml
+++ b/io/Cargo.toml
@@ -23,6 +23,9 @@ internals = { package = "bitcoin-internals", version = "0.4.0" }
 
 hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, optional = true }
 
+[dev-dependencies]
+hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["hex"] }
+
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

From 7c12d92bc3011e1305238f0f5d3b155a01875814 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 14 Feb 2025 12:30:16 +0000
Subject: [PATCH 360/554] Only enable hex/std, alloc when hex is

`hex/std` and `hex/alloc` should only be included if optional
dependency `hex` is enabled`.

Add `?` so it is only included if the optional feature `hex` is enabled.
---
 hashes/Cargo.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
index 35760c87e1..25e213790d 100644
--- a/hashes/Cargo.toml
+++ b/hashes/Cargo.toml
@@ -15,8 +15,8 @@ exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["alloc", "hex/std"]
-alloc = ["hex/alloc"]
+std = ["alloc", "hex?/std"]
+alloc = ["hex?/alloc"]
 serde = ["dep:serde", "hex"]
 # Smaller (but slower) implementation of sha256, sha512 and ripemd160
 small-hash = []

From f433b36ee116990edbee33f444b0b1d902e46321 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 15 Feb 2025 01:39:44 +0000
Subject: [PATCH 361/554] Automated update to Github CI to rustc
 nightly-2025-02-14

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 36da8033ee..952e0e57c6 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-02-07
+nightly-2025-02-14

From 0fbfe68c72496c3135108914cdb2c2b45e496e99 Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 16 Feb 2025 01:21:38 +0000
Subject: [PATCH 362/554] 2025-02-16 automated rustfmt nightly

---
 bitcoin/src/crypto/key.rs     | 19 +++++++++++--------
 primitives/src/transaction.rs |  5 +----
 primitives/src/witness.rs     |  3 ++-
 3 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 9ba23615a9..1b3c3a4843 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -499,10 +499,10 @@ impl PrivateKey {
             33 => false,
             34 => {
                 if data[33] != 1 {
-                    return Err(InvalidWifCompressionFlagError{ invalid: data[33] }.into());
+                    return Err(InvalidWifCompressionFlagError { invalid: data[33] }.into());
                 }
                 true
-            },
+            }
             length => {
                 return Err(InvalidBase58PayloadLengthError { length }.into());
             }
@@ -987,8 +987,7 @@ impl fmt::Display for FromWifError {
             InvalidAddressVersion(ref e) =>
                 write_err!(f, "decoded base58 data contained an invalid address version btye"; e),
             Secp256k1(ref e) => write_err!(f, "private key validation failed"; e),
-            InvalidWifCompressionFlag(ref e) => 
-                write_err!(f, "invalid WIF compression flag";e),
+            InvalidWifCompressionFlag(ref e) => write_err!(f, "invalid WIF compression flag";e),
         }
     }
 }
@@ -1179,7 +1178,7 @@ impl std::error::Error for InvalidAddressVersionError {}
 
 /// Invalid compression flag for a WIF key
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct InvalidWifCompressionFlagError{
+pub struct InvalidWifCompressionFlagError {
     /// The invalid compression flag.
     pub(crate) invalid: u8,
 }
@@ -1206,9 +1205,13 @@ mod tests {
     #[test]
     fn key_derivation() {
         // mainnet compressed WIF with invalid compression flag.
-        let sk =
-        PrivateKey::from_wif("L2x4uC2YgfFWZm9tF4pjDnVR6nJkheizFhEr2KvDNnTEmEqVzPJY");
-        assert!(matches!(sk, Err(FromWifError::InvalidWifCompressionFlag(InvalidWifCompressionFlagError { invalid: 49 }))));
+        let sk = PrivateKey::from_wif("L2x4uC2YgfFWZm9tF4pjDnVR6nJkheizFhEr2KvDNnTEmEqVzPJY");
+        assert!(matches!(
+            sk,
+            Err(FromWifError::InvalidWifCompressionFlag(InvalidWifCompressionFlagError {
+                invalid: 49
+            }))
+        ));
 
         // testnet compressed
         let sk =
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index ca7e635249..fa7b0e4301 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -616,10 +616,7 @@ mod tests {
             witness: Witness::new(),
         };
 
-        let txout = TxOut {
-            value: Amount::from_sat(123456789),
-            script_pubkey: ScriptBuf::new(),
-        };
+        let txout = TxOut { value: Amount::from_sat(123456789), script_pubkey: ScriptBuf::new() };
 
         let tx_orig = Transaction {
             version: Version::ONE,
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index d48755992d..62b6f2bc75 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -603,7 +603,8 @@ mod test {
         let witness_elements = 2;
         let content = append_u32_vec(&elements, &[0, 2]);
         let indices_start = elements.len();
-        let witness = Witness::from_parts__unstable(content.clone(), witness_elements, indices_start);
+        let witness =
+            Witness::from_parts__unstable(content.clone(), witness_elements, indices_start);
         assert_eq!(witness.nth(0).unwrap(), [11_u8]);
         assert_eq!(witness.nth(1).unwrap(), [21_u8, 22]);
         assert_eq!(witness.size(), 6);

From 8c2439550acdf3cb52c78d69eb55160f9d03a139 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 13 Feb 2025 15:02:25 +1100
Subject: [PATCH 363/554] hashes: Test macros in function scope

The two main public macros can be used in function scope - prove it.

While we are at it prove that additional attributes are supported by
them both as well as visability keywords.
---
 hashes/src/macros.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/hashes/src/macros.rs b/hashes/src/macros.rs
index 12ca01520c..1d35b53f81 100644
--- a/hashes/src/macros.rs
+++ b/hashes/src/macros.rs
@@ -576,6 +576,25 @@ mod test {
         fn all_zeros() -> Self { Self::from_byte_array([0; 32]) }
     }
 
+    #[test]
+    fn macros_work_in_function_scope() {
+        use crate::sha256t;
+
+        sha256t_tag! {
+            #[repr(align(2))] // This tests that we can add additional attributes.
+            pub struct FunctionScopeTag = hash_str("It works");
+        }
+
+        hash_newtype! {
+            /// Some docs.
+            #[repr(align(4))] // This tests that we can add additional attributes.
+            pub struct FunctionScopeHash(pub(crate) sha256t::Hash<FunctionScopeTag>);
+        }
+
+        assert_eq!(2, core::mem::align_of::<FunctionScopeTag>());
+        assert_eq!(4, core::mem::align_of::<FunctionScopeHash>());
+    }
+
     // NB: This runs with and without `hex` feature enabled, testing different code paths for each.
     #[test]
     #[cfg(feature = "alloc")]

From 85652359e89b4ead08fd8cb1a5e398cc2347e90d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 12 Feb 2025 03:30:31 +1100
Subject: [PATCH 364/554] hashes: Derive Copy and Clone for Hkdf

Currently the `Hkdf` type does not derive any traits.

We would like to derive the common set of traits but there are a bunch
reasons we can't;

- Don't want to leak secrets in `Debug`.
- Don't want to enable timing attacks with Eq/Ord and friends.

For now just derive `Copy` and `Clone`. We will then implement `Debug`
manually.
---
 hashes/src/hkdf/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/hashes/src/hkdf/mod.rs b/hashes/src/hkdf/mod.rs
index f9f027857c..b2cba08382 100644
--- a/hashes/src/hkdf/mod.rs
+++ b/hashes/src/hkdf/mod.rs
@@ -32,6 +32,7 @@ impl fmt::Display for MaxLengthError {
 impl std::error::Error for MaxLengthError {}
 
 /// HMAC-based Extract-and-Expand Key Derivation Function (HKDF).
+#[derive(Copy, Clone)]
 pub struct Hkdf<T: GeneralHash> {
     /// Pseudorandom key based on the extract step.
     prk: Hmac<T>,

From 50c0af7138bc90b621c6dd079de9c4c34d26c462 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 17 Feb 2025 12:37:13 +1100
Subject: [PATCH 365/554] Stop using Hash::from_slice

This function is deprecated, stop using it in favour of
`Hash::from_byte_array`.

Patch only touches test code, I'm guessing that is why lint warnings
were no showing up.
---
 bitcoin/src/blockdata/constants.rs | 2 +-
 bitcoin/src/p2p/message.rs         | 2 +-
 hashes/src/hash160/mod.rs          | 2 +-
 hashes/src/sha256d/mod.rs          | 2 +-
 hashes/src/siphash24/mod.rs        | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index ad8e96fdf2..4b7e51486c 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -373,7 +373,7 @@ mod test {
         // The genesis block hash is a double-sha256 and it is displayed backwards.
         let genesis_hash = genesis_block(network).block_hash();
         // 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 hash = sha256::Hash::from_byte_array(genesis_hash.to_byte_array());
         let want = format!("{:02x}", hash);
 
         let chain_hash = ChainHash::using_genesis_block_const(network);
diff --git a/bitcoin/src/p2p/message.rs b/bitcoin/src/p2p/message.rs
index e293801051..fda7cdd471 100644
--- a/bitcoin/src/p2p/message.rs
+++ b/bitcoin/src/p2p/message.rs
@@ -716,7 +716,7 @@ mod test {
     use crate::script::ScriptBuf;
     use crate::transaction::Transaction;
 
-    fn hash(slice: [u8; 32]) -> sha256d::Hash { sha256d::Hash::from_slice(&slice).unwrap() }
+    fn hash(array: [u8; 32]) -> sha256d::Hash { sha256d::Hash::from_byte_array(array) }
 
     #[test]
     fn full_round_ser_der_raw_network_message() {
diff --git a/hashes/src/hash160/mod.rs b/hashes/src/hash160/mod.rs
index d70ec275d3..282d653d76 100644
--- a/hashes/src/hash160/mod.rs
+++ b/hashes/src/hash160/mod.rs
@@ -118,7 +118,7 @@ mod tests {
             0xf1, 0x4a, 0xca, 0xd7,
         ];
 
-        let hash = hash160::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let hash = hash160::Hash::from_byte_array(HASH_BYTES);
         assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
         assert_tokens(&hash.readable(), &[Token::Str("132072df690933835eb8b6ad0b77e7b6f14acad7")]);
     }
diff --git a/hashes/src/sha256d/mod.rs b/hashes/src/sha256d/mod.rs
index 54943db517..adb2ffa715 100644
--- a/hashes/src/sha256d/mod.rs
+++ b/hashes/src/sha256d/mod.rs
@@ -122,7 +122,7 @@ mod tests {
             0xb7, 0x65, 0x44, 0x8c, 0x86, 0x35, 0xfb, 0x6c,
         ];
 
-        let hash = sha256d::Hash::from_slice(&HASH_BYTES).expect("right number of bytes");
+        let hash = sha256d::Hash::from_byte_array(HASH_BYTES);
         assert_tokens(&hash.compact(), &[Token::BorrowedBytes(&HASH_BYTES[..])]);
         assert_tokens(
             &hash.readable(),
diff --git a/hashes/src/siphash24/mod.rs b/hashes/src/siphash24/mod.rs
index a46fefe01f..1db7477332 100644
--- a/hashes/src/siphash24/mod.rs
+++ b/hashes/src/siphash24/mod.rs
@@ -321,7 +321,7 @@ mod tests {
 
         for i in 0..64 {
             vin[i] = i as u8;
-            let vec = Hash::from_slice(&vecs[i]).unwrap();
+            let vec = Hash::from_byte_array(vecs[i]);
             let out = Hash::hash_with_keys(k0, k1, &vin[0..i]);
             assert_eq!(vec, out, "vec #{}", i);
 

From 8d8edd2c77de9b0423533fc70802171803761fcd Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Sat, 15 Feb 2025 13:09:05 -0300
Subject: [PATCH 366/554] make Debug representation of Witness to be slice of
 hex-encoded bytes strings

---
 primitives/src/witness.rs | 84 +++++++++------------------------------
 1 file changed, 19 insertions(+), 65 deletions(-)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index d48755992d..e396da8fce 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -9,6 +9,7 @@ use core::ops::Index;
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+use hex::DisplayHex;
 use internals::compact_size;
 
 use crate::prelude::Vec;
@@ -231,76 +232,29 @@ fn decode_cursor(bytes: &[u8], start_of_indices: usize, index: usize) -> Option<
     }
 }
 
-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)
-        }
-    }
-}
+/// Debug implementation that displays the witness as a structured output containing hex-encoded witness elements.
+struct DebugElements<'a>(&'a Witness);
 
-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, "]")?;
-        }
+impl fmt::Debug for DebugElements<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.0.iter().map(|elem| elem.as_hex())).finish()
     }
-
-    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")?;
-    }
+/// Debug implementation that displays the witness as a structured output containing:
+/// - Number of witness elements
+/// - Total bytes across all elements
+/// - List of hex-encoded witness elements
+impl fmt::Debug for Witness {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let total_bytes: usize = self.iter().map(|elem| elem.len()).sum();
 
-    writeln!(f, "    ],")?;
-    writeln!(f, "}}")
+        f.debug_struct("Witness")
+            .field("num_elements", &self.witness_elements)
+            .field("total_bytes", &total_bytes)
+            .field("elements", &DebugElements(self))
+            .finish()
+    }
 }
 
 /// An iterator returning individual witness elements.

From 914730d7f1cb5e032cce155440bbe4f064a09533 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 17 Feb 2025 12:13:28 +0000
Subject: [PATCH 367/554] Add inline to small functions in result module

---
 units/src/amount/result.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index c0e84f6e77..645b3edde8 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -27,6 +27,7 @@ impl<T: fmt::Debug> NumOpResult<T> {
     /// # Panics
     ///
     /// Panics with `msg` if the numeric result is an `Error`.
+    #[inline]
     #[track_caller]
     pub fn expect(self, msg: &str) -> T {
         match self {
@@ -40,6 +41,7 @@ impl<T: fmt::Debug> NumOpResult<T> {
     /// # Panics
     ///
     /// Panics if the numeric result is an `Error`.
+    #[inline]
     #[track_caller]
     pub fn unwrap(self) -> T {
         match self {
@@ -53,6 +55,7 @@ impl<T: fmt::Debug> NumOpResult<T> {
     /// # Panics
     ///
     /// Panics if the numeric result is a valid amount.
+    #[inline]
     #[track_caller]
     pub fn unwrap_err(self) -> NumOpError {
         match self {
@@ -62,6 +65,7 @@ impl<T: fmt::Debug> NumOpResult<T> {
     }
 
     /// Converts this `NumOpResult` to an `Option<T>`.
+    #[inline]
     pub fn ok(self) -> Option<T> {
         match self {
             R::Valid(amount) => Some(amount),
@@ -70,6 +74,7 @@ impl<T: fmt::Debug> NumOpResult<T> {
     }
 
     /// Converts this `NumOpResult` to a `Result<T, NumOpError>`.
+    #[inline]
     #[allow(clippy::missing_errors_doc)]
     pub fn into_result(self) -> Result<T, NumOpError> {
         match self {
@@ -79,6 +84,7 @@ impl<T: fmt::Debug> NumOpResult<T> {
     }
 
     /// Calls `op` if the numeric result is `Valid`, otherwise returns the `Error` value of `self`.
+    #[inline]
     pub fn and_then<F>(self, op: F) -> NumOpResult<T>
     where
         F: FnOnce(T) -> NumOpResult<T>,
@@ -90,6 +96,7 @@ impl<T: fmt::Debug> NumOpResult<T> {
     }
 
     /// Returns `true` if the numeric result is a valid amount.
+    #[inline]
     pub fn is_valid(&self) -> bool {
         match self {
             R::Valid(_) => true,
@@ -98,6 +105,7 @@ impl<T: fmt::Debug> NumOpResult<T> {
     }
 
     /// Returns `true` if the numeric result is an invalid amount.
+    #[inline]
     pub fn is_error(&self) -> bool { !self.is_valid() }
 }
 
@@ -556,6 +564,7 @@ pub(in crate::amount) trait OptionExt<T> {
 }
 
 impl OptionExt<Amount> for Option<Amount> {
+    #[inline]
     fn valid_or_error(self) -> NumOpResult<Amount> {
         match self {
             Some(amount) => R::Valid(amount),
@@ -565,6 +574,7 @@ impl OptionExt<Amount> for Option<Amount> {
 }
 
 impl OptionExt<SignedAmount> for Option<SignedAmount> {
+    #[inline]
     fn valid_or_error(self) -> NumOpResult<SignedAmount> {
         match self {
             Some(amount) => R::Valid(amount),

From e41653d18838e0d6e157db475b7b034b2456c924 Mon Sep 17 00:00:00 2001
From: jeremiah <me@jeremiahrogers.com>
Date: Mon, 17 Feb 2025 21:00:40 -0500
Subject: [PATCH 368/554] add chacha20 benchmarks

---
 chacha20_poly1305/Cargo.toml     |  3 +++
 chacha20_poly1305/src/benches.rs | 45 ++++++++++++++++++++++++++++++++
 chacha20_poly1305/src/lib.rs     |  5 ++++
 3 files changed, 53 insertions(+)
 create mode 100644 chacha20_poly1305/src/benches.rs

diff --git a/chacha20_poly1305/Cargo.toml b/chacha20_poly1305/Cargo.toml
index 7e4e453588..da5242bf99 100644
--- a/chacha20_poly1305/Cargo.toml
+++ b/chacha20_poly1305/Cargo.toml
@@ -22,3 +22,6 @@ hex = { package = "hex-conservative", version = "0.3.0", default-features = fals
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
+
+[lints.rust]
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)'] }
diff --git a/chacha20_poly1305/src/benches.rs b/chacha20_poly1305/src/benches.rs
new file mode 100644
index 0000000000..5bfb6572ca
--- /dev/null
+++ b/chacha20_poly1305/src/benches.rs
@@ -0,0 +1,45 @@
+use test::Bencher;
+
+use crate::{ChaCha20, Key, Nonce};
+
+#[bench]
+pub fn chacha20_10(bh: &mut Bencher) {
+  let key =
+      Key::new([0u8; 32]);
+  let nonce = Nonce::new([0u8; 12]);
+  let count = 1;
+  let mut chacha = ChaCha20::new(key, nonce, count);
+  let mut bytes = [0u8; 10];
+  bh.iter(|| {
+    chacha.apply_keystream(&mut bytes[..]);
+  });
+  bh.bytes = bytes.len() as u64;
+}
+
+#[bench]
+pub fn chacha20_1k(bh: &mut Bencher) {
+  let key =
+      Key::new([0u8; 32]);
+  let nonce = Nonce::new([0u8; 12]);
+  let count = 1;
+  let mut chacha = ChaCha20::new(key, nonce, count);
+  let mut bytes = [0u8; 1024];
+  bh.iter(|| {
+    chacha.apply_keystream(&mut bytes[..]);
+  });
+  bh.bytes = bytes.len() as u64;
+}
+
+#[bench]
+pub fn chacha20_64k(bh: &mut Bencher) {
+  let key =
+      Key::new([0u8; 32]);
+  let nonce = Nonce::new([0u8; 12]);
+  let count = 1;
+  let mut chacha = ChaCha20::new(key, nonce, count);
+  let mut bytes = [0u8; 65536];
+  bh.iter(|| {
+    chacha.apply_keystream(&mut bytes[..]);
+  });
+  bh.bytes = bytes.len() as u64;
+}
diff --git a/chacha20_poly1305/src/lib.rs b/chacha20_poly1305/src/lib.rs
index 3058913ae4..42b2df3afe 100644
--- a/chacha20_poly1305/src/lib.rs
+++ b/chacha20_poly1305/src/lib.rs
@@ -5,6 +5,7 @@
 #![no_std]
 // Experimental features we need.
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(bench, feature(test))]
 // Coding conventions.
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
@@ -18,6 +19,10 @@ extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std;
 
+#[cfg(bench)]
+mod benches;
+#[cfg(bench)]
+extern crate test;
 pub mod chacha20;
 pub mod poly1305;
 

From d392cdbd7d1ecc53f4ef26b5557ca3acdffeb1d3 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 18 Feb 2025 13:28:11 +1100
Subject: [PATCH 369/554] Remove PartialOrd from locktimes

Currently it is possible to write

```rust
if this_locktime < that_locktime {
   do_this();
}
```

with the hope that this code means if a locktime is satisfied by the
value in the other locktime. This is a footgun because locktimes are
incommensurate.

We provide the `is_satisfied_by` API to help users do locktime
comparisons.

Remove the `PartialOrd` implementation from both locktime types.
---
 primitives/src/locktime/absolute.rs | 23 +++--------------------
 primitives/src/locktime/relative.rs | 22 +++-------------------
 2 files changed, 6 insertions(+), 39 deletions(-)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index da8ef86b7a..6d88388db5 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -28,7 +28,9 @@ pub use units::locktime::absolute::{ConversionError, Height, ParseHeightError, P
 /// ### Note on ordering
 ///
 /// 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`].
+/// ordering on locktimes. In order to compare locktimes, instead of using `<` or `>` we provide the
+/// [`LockTime::is_satisfied_by`] API.
+///
 /// For [`Transaction`], which has a locktime field, we implement a total ordering to make
 /// it easy to store transactions in sorted data structures, and use the locktime's 32-bit integer
 /// consensus encoding to order it. We also implement [`ordered::ArbitraryOrd`] if the "ordered"
@@ -319,19 +321,6 @@ impl From<Time> for LockTime {
     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::*;
@@ -501,9 +490,6 @@ mod tests {
         assert!(lock_by_height.is_satisfied_by(height_same, time));
         assert!(lock_by_height.is_satisfied_by(height_above, time));
         assert!(!lock_by_height.is_satisfied_by(height_below, time));
-
-        let lock_by_height_above = LockTime::from_consensus(800_000);
-        assert!(lock_by_height < lock_by_height_above)
     }
 
     #[test]
@@ -519,9 +505,6 @@ mod tests {
         assert!(lock_by_time.is_satisfied_by(height, time_same));
         assert!(lock_by_time.is_satisfied_by(height, time_after));
         assert!(!lock_by_time.is_satisfied_by(height, time_before));
-
-        let lock_by_time_after = LockTime::from_consensus(1653282000);
-        assert!(lock_by_time < lock_by_time_after);
     }
 
     #[test]
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 2cca3889be..2f1bc60725 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -7,7 +7,7 @@
 
 #[cfg(feature = "ordered")]
 use core::cmp::Ordering;
-use core::{cmp, convert, fmt};
+use core::{convert, fmt};
 
 use crate::Sequence;
 #[cfg(all(doc, feature = "alloc"))]
@@ -25,8 +25,8 @@ pub use units::locktime::relative::{Height, Time, TimeOverflowError};
 /// ### Note on ordering
 ///
 /// 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`]. We also
-/// implement [`ordered::ArbitraryOrd`] if the "ordered" feature is enabled.
+/// ordering on locktimes. In order to compare locktimes, instead of using `<` or `>` we provide the
+/// [`LockTime::is_satisfied_by`] API.
 ///
 /// ### Relevant BIPs
 ///
@@ -352,19 +352,6 @@ impl From<Time> for LockTime {
     fn from(t: Time) -> Self { LockTime::Time(t) }
 }
 
-impl PartialOrd for LockTime {
-    #[inline]
-    fn partial_cmp(&self, other: &LockTime) -> Option<cmp::Ordering> {
-        use LockTime::*;
-
-        match (*self, *other) {
-            (Blocks(ref a), Blocks(ref b)) => a.partial_cmp(b),
-            (Time(ref a), Time(ref b)) => a.partial_cmp(b),
-            (_, _) => None,
-        }
-    }
-}
-
 impl fmt::Display for LockTime {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use LockTime::*;
@@ -501,9 +488,6 @@ mod tests {
         assert!(!lock_by_height1.is_same_unit(lock_by_time1));
         assert!(lock_by_time1.is_same_unit(lock_by_time2));
         assert!(!lock_by_time1.is_same_unit(lock_by_height1));
-
-        assert!(lock_by_height1 < lock_by_height2);
-        assert!(lock_by_time1 < lock_by_time2);
     }
 
     #[test]

From 4259dab93ab52795305db4b889b9151595bcee51 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 18 Feb 2025 13:31:24 +1100
Subject: [PATCH 370/554] Remove rust-ordered dependency

It has turned out that the `rust-ordered` crate and it's
`ArbitraryOrd` trait are only useful for locktimes and only marginally
useful for them at best.

Remove the `ArbitraryOrd` impls and the `rust-ordered` dependency.

This topic was discussed in various places including:

- #2500
- #4002
- #3881

Close: #4029
---
 Cargo-minimal.lock                  |  8 --------
 Cargo-recent.lock                   |  8 --------
 bitcoin/Cargo.toml                  |  1 -
 bitcoin/contrib/test_vars.sh        |  4 ++--
 bitcoin/src/lib.rs                  |  5 -----
 primitives/Cargo.toml               |  1 -
 primitives/contrib/test_vars.sh     |  4 ++--
 primitives/src/locktime/absolute.rs | 18 +-----------------
 primitives/src/locktime/relative.rs | 16 ----------------
 9 files changed, 5 insertions(+), 60 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index f90f321d54..228661483a 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -62,7 +62,6 @@ dependencies = [
  "bitcoinconsensus",
  "hex-conservative 0.3.0",
  "hex_lit",
- "ordered",
  "secp256k1",
  "serde",
  "serde_json",
@@ -111,7 +110,6 @@ dependencies = [
  "bitcoin-units",
  "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
- "ordered",
  "serde",
  "serde_json",
 ]
@@ -254,12 +252,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "ordered"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79c12388aac4f817eae0359011d67d4072ed84cfc63b0d9a7958ef476fb74bec"
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.8"
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index 8b590d8acd..2b4ef7378b 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -61,7 +61,6 @@ dependencies = [
  "bitcoinconsensus",
  "hex-conservative 0.3.0",
  "hex_lit",
- "ordered",
  "secp256k1",
  "serde",
  "serde_json",
@@ -110,7 +109,6 @@ dependencies = [
  "bitcoin-units",
  "bitcoin_hashes 0.16.0",
  "hex-conservative 0.3.0",
- "ordered",
  "serde",
  "serde_json",
 ]
@@ -262,12 +260,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "ordered"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79c12388aac4f817eae0359011d67d4072ed84cfc63b0d9a7958ef476fb74bec"
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.20"
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index 9713bf2001..ab765c7e2f 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -39,7 +39,6 @@ arbitrary = { version = "1.4", optional = true }
 base64 = { version = "0.22.0", optional = true }
 # `bitcoinconsensus` version includes metadata which indicates the version of Core. Use `cargo tree` to see it.
 bitcoinconsensus = { version = "0.106.0", default-features = false, optional = true }
-ordered = { version = "0.4.0", optional = true }
 serde = { version = "1.0.103", default-features = false, features = [ "derive", "alloc" ], optional = true }
 
 [dev-dependencies]
diff --git a/bitcoin/contrib/test_vars.sh b/bitcoin/contrib/test_vars.sh
index c65af099da..f28ecdb33a 100644
--- a/bitcoin/contrib/test_vars.sh
+++ b/bitcoin/contrib/test_vars.sh
@@ -5,10 +5,10 @@
 # shellcheck disable=SC2034
 
 # Test all these features with "std" enabled.
-FEATURES_WITH_STD="rand-std serde secp-recovery bitcoinconsensus base64 ordered arbitrary"
+FEATURES_WITH_STD="rand-std serde secp-recovery bitcoinconsensus base64 arbitrary"
 
 # Test all these features without "std" or "alloc" enabled.
-FEATURES_WITHOUT_STD="rand serde secp-recovery bitcoinconsensus base64 ordered arbitrary"
+FEATURES_WITHOUT_STD="rand serde secp-recovery bitcoinconsensus base64 arbitrary"
 
 # Run these examples.
 EXAMPLES="ecdsa-psbt:std,bitcoinconsensus sign-tx-segwit-v0:rand-std sign-tx-taproot:rand-std taproot-psbt:bitcoinconsensus,rand-std sighash:std"
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index da1a714aca..af6386a40c 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -16,7 +16,6 @@
 //! * `base64` (dependency) - enables encoding of PSBTs and message signatures.
 //! * `bitcoinconsensus` (dependency) - enables validating scripts and transactions.
 //! * `default` - enables `std` and `secp-recovery`.
-//! * `ordered` (dependency) - adds implementations of `ArbitraryOrd` to some structs.
 //! * `rand` (transitive dependency) - makes it more convenient to generate random values.
 //! * `rand-std` - same as `rand` but also enables `std` here and in `secp256k1`.
 //! * `serde` (dependency) - implements `serde`-based serialization and deserialization.
@@ -80,10 +79,6 @@ pub extern crate hex;
 /// Re-export the `bitcoin-io` crate.
 pub extern crate io;
 
-/// Re-export the `ordered` crate.
-#[cfg(feature = "ordered")]
-pub extern crate ordered;
-
 /// Re-export the `rust-secp256k1` crate.
 ///
 /// Rust wrapper library for Pieter Wuille's libsecp256k1. Implements ECDSA and BIP-340 signatures
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 241be623a6..afb74fd00e 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -28,7 +28,6 @@ internals = { package = "bitcoin-internals", version = "0.4.0" }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false }
 
 arbitrary = { version = "1.4", optional = true }
-ordered = { version = "0.4.0", optional = true }
 serde = { version = "1.0.103", default-features = false, features = ["derive", "alloc"], optional = true }
 
 [dev-dependencies]
diff --git a/primitives/contrib/test_vars.sh b/primitives/contrib/test_vars.sh
index ef4753dd18..159713bb9e 100644
--- a/primitives/contrib/test_vars.sh
+++ b/primitives/contrib/test_vars.sh
@@ -5,10 +5,10 @@
 # shellcheck disable=SC2034
 
 # Test these features with "std" enabled.
-FEATURES_WITH_STD="ordered serde arbitrary"
+FEATURES_WITH_STD="serde arbitrary"
 
 # Test these features without "std" enabled.
-FEATURES_WITHOUT_STD="alloc ordered serde arbitrary"
+FEATURES_WITHOUT_STD="alloc serde arbitrary"
 
 # Run these examples.
 EXAMPLES=""
diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 6d88388db5..b6321f772d 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -5,7 +5,6 @@
 //! There are two types of lock time: lock-by-blockheight and lock-by-blocktime, distinguished by
 //! whether `LockTime < LOCKTIME_THRESHOLD`.
 
-use core::cmp::Ordering;
 use core::fmt;
 
 #[cfg(feature = "arbitrary")]
@@ -33,8 +32,7 @@ pub use units::locktime::absolute::{ConversionError, Height, ParseHeightError, P
 ///
 /// For [`Transaction`], which has a locktime field, we implement a total ordering to make
 /// it easy to store transactions in sorted data structures, and use the locktime's 32-bit integer
-/// consensus encoding to order it. We also implement [`ordered::ArbitraryOrd`] if the "ordered"
-/// feature is enabled.
+/// consensus encoding to order it.
 ///
 /// ### Relevant BIPs
 ///
@@ -389,20 +387,6 @@ impl<'de> serde::Deserialize<'de> for LockTime {
     }
 }
 
-#[cfg(feature = "ordered")]
-impl ordered::ArbitraryOrd for LockTime {
-    fn arbitrary_cmp(&self, other: &Self) -> Ordering {
-        use LockTime::*;
-
-        match (self, other) {
-            (Blocks(_), Seconds(_)) => Ordering::Less,
-            (Seconds(_), Blocks(_)) => Ordering::Greater,
-            (Blocks(this), Blocks(that)) => this.cmp(that),
-            (Seconds(this), Seconds(that)) => this.cmp(that),
-        }
-    }
-}
-
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for LockTime {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 2f1bc60725..663223efed 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -5,8 +5,6 @@
 //! 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.
 
-#[cfg(feature = "ordered")]
-use core::cmp::Ordering;
 use core::{convert, fmt};
 
 use crate::Sequence;
@@ -370,20 +368,6 @@ impl fmt::Display for LockTime {
     }
 }
 
-#[cfg(feature = "ordered")]
-impl ordered::ArbitraryOrd for LockTime {
-    fn arbitrary_cmp(&self, other: &Self) -> Ordering {
-        use LockTime::*;
-
-        match (self, other) {
-            (Blocks(_), Time(_)) => Ordering::Less,
-            (Time(_), Blocks(_)) => Ordering::Greater,
-            (Blocks(this), Blocks(that)) => this.cmp(that),
-            (Time(this), Time(that)) => this.cmp(that),
-        }
-    }
-}
-
 impl convert::TryFrom<Sequence> for LockTime {
     type Error = DisabledLockTimeError;
     fn try_from(seq: Sequence) -> Result<LockTime, DisabledLockTimeError> {

From da8b85ed7cf34c0510c0b64c67477d3819bee369 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 17 Feb 2025 12:20:40 +1100
Subject: [PATCH 371/554] Implement Debug for Hkdf

We would like to implement `Debug` for `Hkdf` but the inner field is
secret so we cannot derive an impl.

Use a tagged hash engine to hash the secret.
---
 hashes/src/hkdf/mod.rs | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/hashes/src/hkdf/mod.rs b/hashes/src/hkdf/mod.rs
index b2cba08382..92085df766 100644
--- a/hashes/src/hkdf/mod.rs
+++ b/hashes/src/hkdf/mod.rs
@@ -106,6 +106,26 @@ where
     }
 }
 
+impl<T: GeneralHash> fmt::Debug for Hkdf<T> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use crate::{sha256t, sha256t_tag};
+
+        struct Fingerprint([u8; 8]); // Print 16 hex characters as a fingerprint.
+
+        impl fmt::Debug for Fingerprint {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { crate::debug_hex(&self.0, f) }
+        }
+
+        sha256t_tag! {
+            pub struct Tag = hash_str("bitcoin_hashes1DEBUG");
+        }
+
+        let hash = sha256t::Hash::<Tag>::hash(self.prk.as_ref());
+        let fingerprint = Fingerprint(core::array::from_fn(|i| hash.as_byte_array()[i]));
+        f.debug_tuple("Hkdf").field(&format_args!("#{:?}", fingerprint)).finish()
+    }
+}
+
 #[cfg(test)]
 #[cfg(feature = "alloc")]
 mod tests {
@@ -192,4 +212,15 @@ mod tests {
             "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865"
         );
     }
+
+    #[test]
+    fn debug() {
+        let salt = Vec::from_hex("000102030405060708090a0b0c").unwrap();
+        let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
+
+        let hkdf = Hkdf::<sha256::Hash>::new(&salt, &ikm);
+        let debug = alloc::format!("{:?}", hkdf);
+
+        assert_eq!(debug, "Hkdf(#ec7bd36ab2ed4045)");
+    }
 }

From cdece244d5b660c658461e58093090d982e4835e Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 18 Feb 2025 09:28:31 +1100
Subject: [PATCH 372/554] Update to latest maintainer-tools

We have made a couple of improvements to the `run_task` script
lately (*cough* actually test code with `--all-features`).

Lets update to use it.
---
 .github/workflows/rust.yml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index d4d4ca6059..37ad742a47 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -34,7 +34,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: 4f17a059a2f57c1b99b7c240a1467a5c0acebdc3
+          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
           path: maintainer-tools
       - name: "Select toolchain"
         uses: dtolnay/rust-toolchain@stable
@@ -58,7 +58,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: 4f17a059a2f57c1b99b7c240a1467a5c0acebdc3
+          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
           path: maintainer-tools
       - name: "Select toolchain"
         uses: dtolnay/rust-toolchain@v1
@@ -83,7 +83,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: 4f17a059a2f57c1b99b7c240a1467a5c0acebdc3
+          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
           path: maintainer-tools
       - name: "Select toolchain"
         uses: dtolnay/rust-toolchain@stable
@@ -109,7 +109,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: 4f17a059a2f57c1b99b7c240a1467a5c0acebdc3
+          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
           path: maintainer-tools
       - name: "Select toolchain"
         uses: dtolnay/rust-toolchain@v1
@@ -136,7 +136,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: 4f17a059a2f57c1b99b7c240a1467a5c0acebdc3
+          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
           path: maintainer-tools
       - name: "Select toolchain"
         uses: dtolnay/rust-toolchain@stable
@@ -160,7 +160,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: 4f17a059a2f57c1b99b7c240a1467a5c0acebdc3
+          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
           path: maintainer-tools
       - name: "Select toolchain"
         uses: dtolnay/rust-toolchain@v1
@@ -186,7 +186,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: rust-bitcoin/rust-bitcoin-maintainer-tools
-          ref: 4f17a059a2f57c1b99b7c240a1467a5c0acebdc3
+          ref: c3324024ced9bb1eb854397686919c3ff7d97e1e
           path: maintainer-tools
       - name: "Select toolchain"
         uses: dtolnay/rust-toolchain@v1

From f61e93ccf1db7e7e3c9604fdb09b4e25195d88b2 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 17 Feb 2025 12:47:40 +1100
Subject: [PATCH 373/554] Properly deprecate Hash::from_slice

The `hashes::error::FromSliceError` error is only returned from
`from_slice`. We attempted to deprecate this function but it seems we
only did half a job at it.

- deprecate _all_ instances of the method/function
- deprecate the error type
---
 hashes/src/hmac/mod.rs        |  8 +++++---
 hashes/src/internal_macros.rs |  7 +++++--
 hashes/src/lib.rs             | 13 +++++++++----
 hashes/src/macros.rs          |  6 ++++--
 hashes/src/sha256t/mod.rs     |  7 ++++---
 5 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/hashes/src/hmac/mod.rs b/hashes/src/hmac/mod.rs
index eace7f951e..8215e48a75 100644
--- a/hashes/src/hmac/mod.rs
+++ b/hashes/src/hmac/mod.rs
@@ -12,7 +12,7 @@ use core::{convert, fmt, str};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-use crate::{FromSliceError, GeneralHash, Hash, HashEngine};
+use crate::{GeneralHash, Hash, HashEngine};
 
 /// A hash computed from a RFC 2104 HMAC. Parameterized by the underlying hash function.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -132,8 +132,10 @@ impl<T: GeneralHash> Hash for Hmac<T> {
 
     fn from_byte_array(bytes: T::Bytes) -> Self { Hmac(T::from_byte_array(bytes)) }
 
-    #[allow(deprecated)]
-    fn from_slice(sl: &[u8]) -> Result<Hmac<T>, FromSliceError> { T::from_slice(sl).map(Hmac) }
+    #[allow(deprecated_in_future)] // Because of `FromSliceError`.
+    fn from_slice(sl: &[u8]) -> Result<Hmac<T>, crate::FromSliceError> {
+        T::from_slice(sl).map(Hmac)
+    }
 
     fn to_byte_array(self) -> Self::Bytes { self.0.to_byte_array() }
 
diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index 67b9f6170e..fe5d6aa713 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -42,7 +42,8 @@ macro_rules! hash_trait_impls {
 
             fn from_byte_array(bytes: Self::Bytes) -> Self { Self::from_byte_array(bytes) }
 
-            #[allow(deprecated)]
+            #[allow(deprecated_in_future)] // Because of `FromSliceError`.
+            #[allow(deprecated)]           // Because of `from_slice`.
             fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result<Hash<$($gen),*>, $crate::FromSliceError> {
                 Self::from_slice(sl)
             }
@@ -126,11 +127,13 @@ macro_rules! hash_type_no_default {
             }
 
             /// Copies a byte slice into a hash object.
+            #[deprecated(since = "0.15.0", note = "use `from_byte_array` instead")]
+            #[allow(deprecated_in_future)] // Because of `FromSliceError`.
             pub fn from_slice(
                 sl: &[u8],
             ) -> $crate::_export::_core::result::Result<Hash, $crate::FromSliceError> {
                 if sl.len() != $bits / 8 {
-                    Err($crate::FromSliceError($crate::error::FromSliceErrorInner {
+                    Err($crate::error::FromSliceError($crate::error::FromSliceErrorInner {
                         expected: $bits / 8,
                         got: sl.len(),
                     }))
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index f4fb6fd446..2b8d5924c2 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -96,10 +96,11 @@ pub mod _export {
     }
 }
 
+#[deprecated(since = "TBD", note = "unused now that `Hash::from_slice` is deprecated")]
+mod error;
 mod internal_macros;
 
 pub mod cmp;
-pub mod error;
 pub mod hash160;
 pub mod hkdf;
 pub mod hmac;
@@ -132,11 +133,9 @@ use core::{convert, hash};
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
 pub use self::{
-    error::FromSliceError,
     hkdf::Hkdf,
     hmac::{Hmac, HmacEngine},
 };
-
 /// HASH-160: Alias for the [`hash160::Hash`] hash type.
 #[doc(inline)]
 pub use hash160::Hash as Hash160;
@@ -165,6 +164,11 @@ pub use sha512_256::Hash as Sha512_256;
 #[doc(inline)]
 pub use siphash24::Hash as Siphash24;
 
+/// Attempted to create a hash from an invalid length slice.
+#[deprecated(since = "TBD", note = "unused now that `Hash::from_slice` is deprecated")]
+#[allow(deprecated_in_future)]
+pub type FromSliceError = crate::error::FromSliceError; // Alias instead of re-export so we can deprecate it.
+
 /// Tagged SHA-256: Type alias for the [`sha256t::Hash`] hash type.
 pub type Sha256t<T> = sha256t::Hash<T>;
 
@@ -257,7 +261,8 @@ pub trait Hash:
     fn from_byte_array(bytes: Self::Bytes) -> Self;
 
     /// Copies a byte slice into a hash object.
-    #[deprecated(since = "0.15.0", note = "use `from_byte_array` instead")]
+    #[allow(deprecated_in_future)] // Because of `FromSliceError`.
+    #[deprecated(since = "TBD", note = "use `from_byte_array` instead")]
     fn from_slice(sl: &[u8]) -> Result<Self, FromSliceError>;
 
     /// Returns the underlying byte array.
diff --git a/hashes/src/macros.rs b/hashes/src/macros.rs
index 12ca01520c..9371eb1155 100644
--- a/hashes/src/macros.rs
+++ b/hashes/src/macros.rs
@@ -141,7 +141,8 @@ macro_rules! hash_newtype {
 
             /// Copies a byte slice into a hash object.
             #[deprecated(since = "0.15.0", note = "use `from_byte_array` instead")]
-            #[allow(deprecated)]
+            #[allow(deprecated_in_future)] // Because of `FromSliceError`.
+            #[allow(deprecated)]           // Because of `from_slice`.
             pub fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result<$newtype, $crate::FromSliceError> {
                 Ok($newtype(<$hash as $crate::Hash>::from_slice(sl)?))
             }
@@ -178,7 +179,8 @@ macro_rules! hash_newtype {
             fn from_byte_array(bytes: Self::Bytes) -> Self { Self::from_byte_array(bytes) }
 
             #[inline]
-            #[allow(deprecated)]
+            #[allow(deprecated_in_future)] // Because of `FromSliceError`.
+            #[allow(deprecated)]           // Because of `from_slice`.
             fn from_slice(sl: &[u8]) -> $crate::_export::_core::result::Result<$newtype, $crate::FromSliceError> {
                 Self::from_slice(sl)
             }
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 5f4ce2fe1b..56592820e5 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -7,7 +7,7 @@ use core::marker::PhantomData;
 
 #[cfg(doc)]
 use crate::sha256::Midstate;
-use crate::{sha256, FromSliceError, HashEngine as _};
+use crate::{sha256, HashEngine as _};
 
 /// Trait representing a tag that can be used as a context for SHA256t hashes.
 pub trait Tag: Clone {
@@ -44,11 +44,12 @@ where
 
     /// Copies a byte slice into a hash object.
     #[deprecated(since = "0.15.0", note = "use `from_byte_array` instead")]
-    pub fn from_slice(sl: &[u8]) -> Result<Hash<T>, FromSliceError> {
+    #[allow(deprecated_in_future)] // Because of `FromSliceError`.
+    pub fn from_slice(sl: &[u8]) -> Result<Hash<T>, crate::FromSliceError> {
         use crate::error::FromSliceErrorInner;
 
         if sl.len() != 32 {
-            Err(FromSliceError(FromSliceErrorInner { expected: 32, got: sl.len() }))
+            Err(crate::error::FromSliceError(FromSliceErrorInner { expected: 32, got: sl.len() }))
         } else {
             let mut ret = [0; 32];
             ret.copy_from_slice(sl);

From 948647a9dd95bedbb8c34f0b9548e859bfc723b1 Mon Sep 17 00:00:00 2001
From: jeremiah <me@jeremiahrogers.com>
Date: Wed, 19 Feb 2025 18:26:12 -0500
Subject: [PATCH 374/554] update documentation for changing lockfiles; change
 script to support mac nanaive cp function

---
 CONTRIBUTING.md              | 9 +++------
 contrib/update-lock-files.sh | 4 ++--
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 451376049d..c759dfa3ee 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -209,12 +209,9 @@ in Bitcoin Core, with the following exceptions:
 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
+2. Run `just update-lock-files`, if necessary install `just` first with `cargo install just`.
+3. Test your change
+4. Commit both `Cargo-minimal.lock` and `Cargo-recent.lock` together with `Cargo.toml` and your code changes
 
 ### Unsafe code
 
diff --git a/contrib/update-lock-files.sh b/contrib/update-lock-files.sh
index 02ba1f7c82..90b1865068 100755
--- a/contrib/update-lock-files.sh
+++ b/contrib/update-lock-files.sh
@@ -5,7 +5,7 @@
 set -euo pipefail
 
 for file in Cargo-minimal.lock Cargo-recent.lock; do
-    cp --force "$file" Cargo.lock
+    cp -f "$file" Cargo.lock
     cargo check
-    cp --force Cargo.lock "$file"
+    cp -f Cargo.lock "$file"
 done

From 4eb3177fab0655457a8a6d1556fd7eba54459250 Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Thu, 20 Feb 2025 10:46:09 -0300
Subject: [PATCH 375/554] Abstract out "debug-print hex fields" using WrapDebug

This commit introduces `WrapDebug` in `internals` and updates `Witness`
debug implementation to use it. The previous `DebugElements` struct has
been removed in favor of an ad-hoc closure inside `WrapDebug`, which
formats witness elements as a debug list of hex-encoded values.

By abstracting out the "debug-print hex fields" pattern, we reduce
code duplication and improve maintainability.
---
 internals/src/lib.rs        |  1 +
 internals/src/wrap_debug.rs |  9 +++++++++
 primitives/src/witness.rs   | 17 +++++++----------
 3 files changed, 17 insertions(+), 10 deletions(-)
 create mode 100644 internals/src/wrap_debug.rs

diff --git a/internals/src/lib.rs b/internals/src/lib.rs
index 87bba85f41..34fa682ae6 100644
--- a/internals/src/lib.rs
+++ b/internals/src/lib.rs
@@ -42,6 +42,7 @@ pub mod error;
 pub mod macros;
 mod parse;
 pub mod script;
+pub mod wrap_debug;
 #[cfg(feature = "serde")]
 #[macro_use]
 pub mod serde;
diff --git a/internals/src/wrap_debug.rs b/internals/src/wrap_debug.rs
new file mode 100644
index 0000000000..9a3f63d9b2
--- /dev/null
+++ b/internals/src/wrap_debug.rs
@@ -0,0 +1,9 @@
+//! Contains a wrapper for a function that implements `Debug`.
+use core::fmt;
+
+/// A wrapper for a function that implements `Debug`.
+pub struct WrapDebug<F: Fn(&mut fmt::Formatter) -> fmt::Result>(pub F);
+
+impl<F: Fn(&mut fmt::Formatter) -> fmt::Result> fmt::Debug for WrapDebug<F> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { (self.0)(f) }
+}
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index b802f9a1c4..e892334f1a 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -11,6 +11,7 @@ use core::ops::Index;
 use arbitrary::{Arbitrary, Unstructured};
 use hex::DisplayHex;
 use internals::compact_size;
+use internals::wrap_debug::WrapDebug;
 
 use crate::prelude::Vec;
 
@@ -232,15 +233,6 @@ fn decode_cursor(bytes: &[u8], start_of_indices: usize, index: usize) -> Option<
     }
 }
 
-/// Debug implementation that displays the witness as a structured output containing hex-encoded witness elements.
-struct DebugElements<'a>(&'a Witness);
-
-impl fmt::Debug for DebugElements<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_list().entries(self.0.iter().map(|elem| elem.as_hex())).finish()
-    }
-}
-
 /// Debug implementation that displays the witness as a structured output containing:
 /// - Number of witness elements
 /// - Total bytes across all elements
@@ -252,7 +244,12 @@ impl fmt::Debug for Witness {
         f.debug_struct("Witness")
             .field("num_elements", &self.witness_elements)
             .field("total_bytes", &total_bytes)
-            .field("elements", &DebugElements(self))
+            .field(
+                "elements",
+                &WrapDebug(|f| {
+                    f.debug_list().entries(self.iter().map(|elem| elem.as_hex())).finish()
+                }),
+            )
             .finish()
     }
 }

From 277223da6a70149a27713b9de169c4f498a2bf83 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 15:35:17 +0100
Subject: [PATCH 376/554] Make `Script` and `ScriptBuf` obey sanity rules

The newtype sanity rules (a name I came up with):
* Newtypes should have at most one constructor that directly references
  the inner field.
* Newtypes should have at most three accessor methods that directly
  reference the ineer field: one for owned access, the second for
  borrowed and the third for mutably borrowed.
* All other methods should use the methods above to perform operations
  on the newtype and not directly access the fields.

This commit makes `Script` and `ScriptBuf` obey these except for
`reserve` and `reserve_exact` since we don't have `as_mut_vec` method.
As a side effect it also adds `const` to `ScriptBuf::from_bytes`.
---
 primitives/src/script/borrowed.rs | 14 +++++++-------
 primitives/src/script/mod.rs      | 12 ++++++------
 primitives/src/script/owned.rs    | 16 ++++++++--------
 3 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index 6e68a6ef69..b16d1c6132 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -54,7 +54,7 @@ use crate::prelude::{Box, ToOwned, Vec};
 ///
 #[derive(PartialOrd, Ord, PartialEq, Eq, Hash)]
 #[repr(transparent)]
-pub struct Script(pub(in crate::script) [u8]);
+pub struct Script([u8]);
 
 impl Default for &Script {
     #[inline]
@@ -64,7 +64,7 @@ impl Default for &Script {
 impl ToOwned for Script {
     type Owned = ScriptBuf;
 
-    fn to_owned(&self) -> Self::Owned { ScriptBuf(self.0.to_owned()) }
+    fn to_owned(&self) -> Self::Owned { ScriptBuf::from_bytes(self.to_vec()) }
 }
 
 impl Script {
@@ -104,7 +104,7 @@ impl Script {
 
     /// Returns a copy of the script data.
     #[inline]
-    pub fn to_vec(&self) -> Vec<u8> { self.0.to_owned() }
+    pub fn to_vec(&self) -> Vec<u8> { self.as_bytes().to_owned() }
 
     /// Returns a copy of the script data.
     #[inline]
@@ -113,11 +113,11 @@ impl Script {
 
     /// Returns the length in bytes of the script.
     #[inline]
-    pub fn len(&self) -> usize { self.0.len() }
+    pub fn len(&self) -> usize { self.as_bytes().len() }
 
     /// Returns whether the script is the empty script.
     #[inline]
-    pub fn is_empty(&self) -> bool { self.0.is_empty() }
+    pub fn is_empty(&self) -> bool { self.as_bytes().is_empty() }
 
     /// Converts a [`Box<Script>`](Box) into a [`ScriptBuf`] without copying or allocating.
     #[must_use]
@@ -128,7 +128,7 @@ impl Script {
         // 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))
+        ScriptBuf::from_bytes(Vec::from(inner))
     }
 }
 
@@ -141,7 +141,7 @@ macro_rules! delegate_index {
 
                 #[inline]
                 fn index(&self, index: $type) -> &Self::Output {
-                    Self::from_bytes(&self.0[index])
+                    Self::from_bytes(&self.as_bytes()[index])
                 }
             }
         )*
diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index dda2240225..d628de7963 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -236,7 +236,7 @@ impl<'a> From<&'a Script> for Cow<'a, Script> {
 #[cfg(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));
+        let rw: *const [u8] = Arc::into_raw(Arc::from(value.as_bytes()));
         // 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
@@ -247,7 +247,7 @@ impl<'a> From<&'a Script> for Arc<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));
+        let rw: *const [u8] = Rc::into_raw(Rc::from(value.as_bytes()));
         // 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
@@ -257,11 +257,11 @@ impl<'a> From<&'a Script> for Rc<Script> {
 }
 
 impl From<Vec<u8>> for ScriptBuf {
-    fn from(v: Vec<u8>) -> Self { ScriptBuf(v) }
+    fn from(v: Vec<u8>) -> Self { ScriptBuf::from_bytes(v) }
 }
 
 impl From<ScriptBuf> for Vec<u8> {
-    fn from(v: ScriptBuf) -> Self { v.0 }
+    fn from(v: ScriptBuf) -> Self { v.into_bytes() }
 }
 
 impl AsRef<Script> for Script {
@@ -418,11 +418,11 @@ impl fmt::UpperHex for ScriptBuf {
 impl Deref for ScriptBuf {
     type Target = Script;
 
-    fn deref(&self) -> &Self::Target { Script::from_bytes(&self.0) }
+    fn deref(&self) -> &Self::Target { self.as_script() }
 }
 
 impl DerefMut for ScriptBuf {
-    fn deref_mut(&mut self) -> &mut Self::Target { Script::from_bytes_mut(&mut self.0) }
+    fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut_script() }
 }
 
 impl Borrow<Script> for ScriptBuf {
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 29950cbfba..bf9e8bc711 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -19,17 +19,17 @@ use crate::prelude::{Box, Vec};
 ///
 /// [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::script) Vec<u8>);
+pub struct ScriptBuf(Vec<u8>);
 
 impl ScriptBuf {
     /// Constructs a new empty script.
     #[inline]
-    pub const fn new() -> Self { ScriptBuf(Vec::new()) }
+    pub const fn new() -> Self { ScriptBuf::from_bytes(Vec::new()) }
 
     /// Converts byte vector into script.
     ///
     /// This method doesn't (re)allocate.
-    pub fn from_bytes(bytes: Vec<u8>) -> Self { ScriptBuf(bytes) }
+    pub const fn from_bytes(bytes: Vec<u8>) -> Self { ScriptBuf(bytes) }
 
     /// Returns a reference to unsized script.
     pub fn as_script(&self) -> &Script { Script::from_bytes(&self.0) }
@@ -52,12 +52,12 @@ impl ScriptBuf {
     #[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;
+        let rw = Box::into_raw(self.into_bytes().into_boxed_slice()) as *mut Script;
         unsafe { Box::from_raw(rw) }
     }
 
     /// Constructs a new empty script with pre-allocated capacity.
-    pub fn with_capacity(capacity: usize) -> Self { ScriptBuf(Vec::with_capacity(capacity)) }
+    pub fn with_capacity(capacity: usize) -> Self { ScriptBuf::from_bytes(Vec::with_capacity(capacity)) }
 
     /// Pre-allocates at least `additional_len` bytes if needed.
     ///
@@ -91,7 +91,7 @@ impl ScriptBuf {
 impl<'a> Arbitrary<'a> for ScriptBuf {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let v = Vec::<u8>::arbitrary(u)?;
-        Ok(ScriptBuf(v))
+        Ok(ScriptBuf::from_bytes(v))
     }
 }
 
@@ -103,7 +103,7 @@ mod tests {
     fn script_buf_from_bytes() {
         let bytes = vec![1, 2, 3];
         let script = ScriptBuf::from_bytes(bytes.clone());
-        assert_eq!(script.0, bytes);
+        assert_eq!(script.as_bytes(), bytes);
     }
 
     #[test]
@@ -120,7 +120,7 @@ mod tests {
         let mut script = ScriptBuf::from_bytes(bytes.clone());
         let script_mut_ref = script.as_mut_script();
         script_mut_ref.as_mut_bytes()[0] = 4;
-        assert_eq!(script.0, vec![4, 2, 3]);
+        assert_eq!(script.as_mut_bytes(), vec![4, 2, 3]);
     }
 
     #[test]

From 3b15e900f050e90d39730e91a98fdf5b0efe0226 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 15:49:46 +0100
Subject: [PATCH 377/554] Add `const` to some `Script` methods

We're confident these methods will never perform syscalls, so it's fine
to add `const` to them.
---
 primitives/src/script/borrowed.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index b16d1c6132..295f1eeda9 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -70,11 +70,11 @@ impl ToOwned for Script {
 impl Script {
     /// Constructs a new empty script.
     #[inline]
-    pub fn new() -> &'static Script { Script::from_bytes(&[]) }
+    pub const fn new() -> &'static Script { Script::from_bytes(&[]) }
 
     /// Treat byte slice as `Script`
     #[inline]
-    pub fn from_bytes(bytes: &[u8]) -> &Script {
+    pub const 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
@@ -96,7 +96,7 @@ impl Script {
 
     /// Returns the script data as a byte slice.
     #[inline]
-    pub fn as_bytes(&self) -> &[u8] { &self.0 }
+    pub const fn as_bytes(&self) -> &[u8] { &self.0 }
 
     /// Returns the script data as a mutable byte slice.
     #[inline]
@@ -113,11 +113,11 @@ impl Script {
 
     /// Returns the length in bytes of the script.
     #[inline]
-    pub fn len(&self) -> usize { self.as_bytes().len() }
+    pub const fn len(&self) -> usize { self.as_bytes().len() }
 
     /// Returns whether the script is the empty script.
     #[inline]
-    pub fn is_empty(&self) -> bool { self.as_bytes().is_empty() }
+    pub const fn is_empty(&self) -> bool { self.as_bytes().is_empty() }
 
     /// Converts a [`Box<Script>`](Box) into a [`ScriptBuf`] without copying or allocating.
     #[must_use]

From bca28640842f02614272d284cc54f8debcfde91d Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 15:54:25 +0100
Subject: [PATCH 378/554] Move `Deref{Mut}` from common module to `owned`

We have several trait implementations for `Script` and `ScriptBuf` in a
common module so that it's easy to verify that they are same but `Deref`
and `DerefMut` should *not* be implemented for `Script` so having them
in the common module is not helpful. This moves them to the appropriate
`Owned` module.
---
 primitives/src/script/mod.rs   | 11 -----------
 primitives/src/script/owned.rs | 13 +++++++++++--
 2 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index d628de7963..7ea5b928a5 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -10,7 +10,6 @@ mod owned;
 use core::cmp::Ordering;
 use core::convert::Infallible;
 use core::fmt;
-use core::ops::{Deref, DerefMut};
 
 use hashes::{hash160, sha256};
 use hex::DisplayHex;
@@ -415,16 +414,6 @@ impl fmt::UpperHex for ScriptBuf {
     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 { self.as_script() }
-}
-
-impl DerefMut for ScriptBuf {
-    fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut_script() }
-}
-
 impl Borrow<Script> for ScriptBuf {
     fn borrow(&self) -> &Script { self }
 }
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index bf9e8bc711..3cbf9c21e9 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-#[cfg(doc)]
-use core::ops::Deref;
+use core::ops::{Deref, DerefMut};
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
@@ -87,6 +86,16 @@ impl ScriptBuf {
     pub fn reserve_exact(&mut self, additional_len: usize) { self.0.reserve_exact(additional_len); }
 }
 
+impl Deref for ScriptBuf {
+    type Target = Script;
+
+    fn deref(&self) -> &Self::Target { self.as_script() }
+}
+
+impl DerefMut for ScriptBuf {
+    fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut_script() }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for ScriptBuf {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {

From b7e2af1b6b2ccb46b5ef14755e8150c64199e39a Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 16:02:22 +0100
Subject: [PATCH 379/554] Implement `Arbitrary` for `&'a Script`

The `Arbitrary` trait allows zero-copy implementations for borrowed
types, so this adds the implementation for borrowed `Script`.
---
 primitives/src/script/borrowed.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index 295f1eeda9..a2ba0f84b5 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -4,6 +4,9 @@ use core::ops::{
     Bound, Index, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
 };
 
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+
 use super::ScriptBuf;
 use crate::prelude::{Box, ToOwned, Vec};
 
@@ -132,6 +135,14 @@ impl Script {
     }
 }
 
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for &'a Script {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let v = <&'a [u8]>::arbitrary(u)?;
+        Ok(Script::from_bytes(v))
+    }
+}
+
 macro_rules! delegate_index {
     ($($type:ty),* $(,)?) => {
         $(

From 0567e6fe1d55a3473e83a28670e99010b6537729 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 16:18:21 +0100
Subject: [PATCH 380/554] Put `#[inline]` on most `Script{Buf}` methods

These methods are either newtype casts that should compile to no-ops or
directly calling into some other function with at most some pointer
adjustments. As such making them `#[inline]` is definitely benefitial.
There are also methods that check length and then call some other
function. These are also worth inlining since the length could be known
at compile time and the check could be eliminated.
---
 primitives/src/script/borrowed.rs |  3 +++
 primitives/src/script/mod.rs      | 39 +++++++++++++++++++++++++++++++
 primitives/src/script/owned.rs    | 10 ++++++++
 3 files changed, 52 insertions(+)

diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index a2ba0f84b5..29453482b4 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -67,6 +67,7 @@ impl Default for &Script {
 impl ToOwned for Script {
     type Owned = ScriptBuf;
 
+    #[inline]
     fn to_owned(&self) -> Self::Owned { ScriptBuf::from_bytes(self.to_vec()) }
 }
 
@@ -124,6 +125,7 @@ impl Script {
 
     /// Converts a [`Box<Script>`](Box) into a [`ScriptBuf`] without copying or allocating.
     #[must_use]
+    #[inline]
     pub fn into_script_buf(self: Box<Self>) -> ScriptBuf {
         let rw = Box::into_raw(self) as *mut [u8];
         // SAFETY: copied from `std`
@@ -137,6 +139,7 @@ impl Script {
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for &'a Script {
+    #[inline]
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let v = <&'a [u8]>::arbitrary(u)?;
         Ok(Script::from_bytes(v))
diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index 7ea5b928a5..8777eeeefc 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -56,6 +56,7 @@ impl ScriptHash {
     /// > spend a P2SH output if the redemption script it refers to is >520 bytes in length.
     ///
     /// ref: [BIP-16](https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size)
+    #[inline]
     pub fn from_script(redeem_script: &Script) -> Result<Self, RedeemScriptSizeError> {
         if redeem_script.len() > MAX_REDEEM_SCRIPT_SIZE {
             return Err(RedeemScriptSizeError { size: redeem_script.len() });
@@ -70,6 +71,7 @@ impl ScriptHash {
     /// then the output will be unspendable (see [BIP-16]).
     ///
     /// [BIP-16]: <https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki#user-content-520byte_limitation_on_serialized_script_size>
+    #[inline]
     pub fn from_script_unchecked(script: &Script) -> Self {
         ScriptHash(hash160::Hash::hash(script.as_bytes()))
     }
@@ -84,6 +86,7 @@ impl WScriptHash {
     /// > witnessScript must match the 32-byte witness program.
     ///
     /// ref: [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    #[inline]
     pub fn from_script(witness_script: &Script) -> Result<Self, WitnessScriptSizeError> {
         if witness_script.len() > MAX_WITNESS_SCRIPT_SIZE {
             return Err(WitnessScriptSizeError { size: witness_script.len() });
@@ -98,6 +101,7 @@ impl WScriptHash {
     /// output then the output will be unspendable (see [BIP-141]).
     ///
     /// ref: [BIP-141](https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki)
+    #[inline]
     pub fn from_script_unchecked(script: &Script) -> Self {
         WScriptHash(sha256::Hash::hash(script.as_bytes()))
     }
@@ -106,6 +110,7 @@ impl WScriptHash {
 impl TryFrom<ScriptBuf> for ScriptHash {
     type Error = RedeemScriptSizeError;
 
+    #[inline]
     fn try_from(redeem_script: ScriptBuf) -> Result<Self, Self::Error> {
         Self::from_script(&redeem_script)
     }
@@ -114,6 +119,7 @@ impl TryFrom<ScriptBuf> for ScriptHash {
 impl TryFrom<&ScriptBuf> for ScriptHash {
     type Error = RedeemScriptSizeError;
 
+    #[inline]
     fn try_from(redeem_script: &ScriptBuf) -> Result<Self, Self::Error> {
         Self::from_script(redeem_script)
     }
@@ -122,6 +128,7 @@ impl TryFrom<&ScriptBuf> for ScriptHash {
 impl TryFrom<&Script> for ScriptHash {
     type Error = RedeemScriptSizeError;
 
+    #[inline]
     fn try_from(redeem_script: &Script) -> Result<Self, Self::Error> {
         Self::from_script(redeem_script)
     }
@@ -130,6 +137,7 @@ impl TryFrom<&Script> for ScriptHash {
 impl TryFrom<ScriptBuf> for WScriptHash {
     type Error = WitnessScriptSizeError;
 
+    #[inline]
     fn try_from(witness_script: ScriptBuf) -> Result<Self, Self::Error> {
         Self::from_script(&witness_script)
     }
@@ -138,6 +146,7 @@ impl TryFrom<ScriptBuf> for WScriptHash {
 impl TryFrom<&ScriptBuf> for WScriptHash {
     type Error = WitnessScriptSizeError;
 
+    #[inline]
     fn try_from(witness_script: &ScriptBuf) -> Result<Self, Self::Error> {
         Self::from_script(witness_script)
     }
@@ -146,6 +155,7 @@ impl TryFrom<&ScriptBuf> for WScriptHash {
 impl TryFrom<&Script> for WScriptHash {
     type Error = WitnessScriptSizeError;
 
+    #[inline]
     fn try_from(witness_script: &Script) -> Result<Self, Self::Error> {
         Self::from_script(witness_script)
     }
@@ -159,10 +169,12 @@ pub struct RedeemScriptSizeError {
 }
 
 impl From<Infallible> for RedeemScriptSizeError {
+    #[inline]
     fn from(never: Infallible) -> Self { match never {} }
 }
 
 impl fmt::Display for RedeemScriptSizeError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "redeem script size exceeds {} bytes: {}", MAX_REDEEM_SCRIPT_SIZE, self.size)
     }
@@ -179,10 +191,12 @@ pub struct WitnessScriptSizeError {
 }
 
 impl From<Infallible> for WitnessScriptSizeError {
+    #[inline]
     fn from(never: Infallible) -> Self { match never {} }
 }
 
 impl fmt::Display for WitnessScriptSizeError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "witness script size exceeds {} bytes: {}", MAX_WITNESS_SCRIPT_SIZE, self.size)
     }
@@ -194,14 +208,17 @@ impl std::error::Error for WitnessScriptSizeError {}
 // We keep all the `Script` and `ScriptBuf` impls together since its easier to see side-by-side.
 
 impl From<ScriptBuf> for Box<Script> {
+    #[inline]
     fn from(v: ScriptBuf) -> Self { v.into_boxed_script() }
 }
 
 impl From<ScriptBuf> for Cow<'_, Script> {
+    #[inline]
     fn from(value: ScriptBuf) -> Self { Cow::Owned(value) }
 }
 
 impl<'a> From<Cow<'a, Script>> for ScriptBuf {
+    #[inline]
     fn from(value: Cow<'a, Script>) -> Self {
         match value {
             Cow::Owned(owned) => owned,
@@ -211,6 +228,7 @@ impl<'a> From<Cow<'a, Script>> for ScriptBuf {
 }
 
 impl<'a> From<Cow<'a, Script>> for Box<Script> {
+    #[inline]
     fn from(value: Cow<'a, Script>) -> Self {
         match value {
             Cow::Owned(owned) => owned.into(),
@@ -220,20 +238,24 @@ impl<'a> From<Cow<'a, Script>> for Box<Script> {
 }
 
 impl<'a> From<&'a Script> for Box<Script> {
+    #[inline]
     fn from(value: &'a Script) -> Self { value.to_owned().into() }
 }
 
 impl<'a> From<&'a Script> for ScriptBuf {
+    #[inline]
     fn from(value: &'a Script) -> Self { value.to_owned() }
 }
 
 impl<'a> From<&'a Script> for Cow<'a, Script> {
+    #[inline]
     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(target_has_atomic = "ptr")]
 impl<'a> From<&'a Script> for Arc<Script> {
+    #[inline]
     fn from(value: &'a Script) -> Self {
         let rw: *const [u8] = Arc::into_raw(Arc::from(value.as_bytes()));
         // SAFETY: copied from `std`
@@ -245,6 +267,7 @@ impl<'a> From<&'a Script> for Arc<Script> {
 }
 
 impl<'a> From<&'a Script> for Rc<Script> {
+    #[inline]
     fn from(value: &'a Script) -> Self {
         let rw: *const [u8] = Rc::into_raw(Rc::from(value.as_bytes()));
         // SAFETY: copied from `std`
@@ -256,10 +279,12 @@ impl<'a> From<&'a Script> for Rc<Script> {
 }
 
 impl From<Vec<u8>> for ScriptBuf {
+    #[inline]
     fn from(v: Vec<u8>) -> Self { ScriptBuf::from_bytes(v) }
 }
 
 impl From<ScriptBuf> for Vec<u8> {
+    #[inline]
     fn from(v: ScriptBuf) -> Self { v.into_bytes() }
 }
 
@@ -269,6 +294,7 @@ impl AsRef<Script> for Script {
 }
 
 impl AsRef<Script> for ScriptBuf {
+    #[inline]
     fn as_ref(&self) -> &Script { self }
 }
 
@@ -278,14 +304,17 @@ impl AsRef<[u8]> for Script {
 }
 
 impl AsRef<[u8]> for ScriptBuf {
+    #[inline]
     fn as_ref(&self) -> &[u8] { self.as_bytes() }
 }
 
 impl AsMut<Script> for Script {
+    #[inline]
     fn as_mut(&mut self) -> &mut Script { self }
 }
 
 impl AsMut<Script> for ScriptBuf {
+    #[inline]
     fn as_mut(&mut self) -> &mut Script { self }
 }
 
@@ -295,6 +324,7 @@ impl AsMut<[u8]> for Script {
 }
 
 impl AsMut<[u8]> for ScriptBuf {
+    #[inline]
     fn as_mut(&mut self) -> &mut [u8] { self.as_mut_bytes() }
 }
 
@@ -307,6 +337,7 @@ impl fmt::Debug for Script {
 }
 
 impl fmt::Debug for ScriptBuf {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(self.as_script(), f) }
 }
 
@@ -389,6 +420,7 @@ impl fmt::Display for ScriptBuf {
 }
 
 impl fmt::LowerHex for Script {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::LowerHex::fmt(&self.as_bytes().as_hex(), f)
     }
@@ -404,6 +436,7 @@ impl fmt::LowerHex for ScriptBuf {
 internals::impl_to_hex_from_lower_hex!(ScriptBuf, |script_buf: &ScriptBuf| script_buf.len() * 2);
 
 impl fmt::UpperHex for Script {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::UpperHex::fmt(&self.as_bytes().as_hex(), f)
     }
@@ -415,28 +448,34 @@ impl fmt::UpperHex for ScriptBuf {
 }
 
 impl Borrow<Script> for ScriptBuf {
+    #[inline]
     fn borrow(&self) -> &Script { self }
 }
 
 impl BorrowMut<Script> for ScriptBuf {
+    #[inline]
     fn borrow_mut(&mut self) -> &mut Script { self }
 }
 
 impl PartialEq<ScriptBuf> for Script {
+    #[inline]
     fn eq(&self, other: &ScriptBuf) -> bool { self.eq(other.as_script()) }
 }
 
 impl PartialEq<Script> for ScriptBuf {
+    #[inline]
     fn eq(&self, other: &Script) -> bool { self.as_script().eq(other) }
 }
 
 impl PartialOrd<Script> for ScriptBuf {
+    #[inline]
     fn partial_cmp(&self, other: &Script) -> Option<Ordering> {
         self.as_script().partial_cmp(other)
     }
 }
 
 impl PartialOrd<ScriptBuf> for Script {
+    #[inline]
     fn partial_cmp(&self, other: &ScriptBuf) -> Option<Ordering> {
         self.partial_cmp(other.as_script())
     }
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 3cbf9c21e9..7d33bc7705 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -28,17 +28,21 @@ impl ScriptBuf {
     /// Converts byte vector into script.
     ///
     /// This method doesn't (re)allocate.
+    #[inline]
     pub const fn from_bytes(bytes: Vec<u8>) -> Self { ScriptBuf(bytes) }
 
     /// Returns a reference to unsized script.
+    #[inline]
     pub fn as_script(&self) -> &Script { Script::from_bytes(&self.0) }
 
     /// Returns a mutable reference to unsized script.
+    #[inline]
     pub fn as_mut_script(&mut self) -> &mut Script { Script::from_bytes_mut(&mut self.0) }
 
     /// Converts the script into a byte vector.
     ///
     /// This method doesn't (re)allocate.
+    #[inline]
     pub fn into_bytes(self) -> Vec<u8> { self.0 }
 
     /// Converts this `ScriptBuf` into a [boxed](Box) [`Script`].
@@ -56,6 +60,7 @@ impl ScriptBuf {
     }
 
     /// Constructs a new empty script with pre-allocated capacity.
+    #[inline]
     pub fn with_capacity(capacity: usize) -> Self { ScriptBuf::from_bytes(Vec::with_capacity(capacity)) }
 
     /// Pre-allocates at least `additional_len` bytes if needed.
@@ -68,6 +73,7 @@ impl ScriptBuf {
     /// # Panics
     ///
     /// Panics if the new capacity exceeds `isize::MAX bytes`.
+    #[inline]
     pub fn reserve(&mut self, additional_len: usize) { self.0.reserve(additional_len); }
 
     /// Pre-allocates exactly `additional_len` bytes if needed.
@@ -83,21 +89,25 @@ impl ScriptBuf {
     /// # Panics
     ///
     /// Panics if the new capacity exceeds `isize::MAX bytes`.
+    #[inline]
     pub fn reserve_exact(&mut self, additional_len: usize) { self.0.reserve_exact(additional_len); }
 }
 
 impl Deref for ScriptBuf {
     type Target = Script;
 
+    #[inline]
     fn deref(&self) -> &Self::Target { self.as_script() }
 }
 
 impl DerefMut for ScriptBuf {
+    #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut_script() }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for ScriptBuf {
+    #[inline]
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let v = Vec::<u8>::arbitrary(u)?;
         Ok(ScriptBuf::from_bytes(v))

From 6b9d439dc1cc05b8da31381a9f585d22e3847852 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 16:23:26 +0100
Subject: [PATCH 381/554] Remove stale FIXME comments

These comments said that the modules should be private but they already
are. Also, the internals of the newtypes became private a few commits
ago.
---
 primitives/src/script/mod.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index 8777eeeefc..6f90337a94 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -2,9 +2,7 @@
 
 //! Bitcoin scripts.
 
-/// FIXME: Make this private.
 mod borrowed;
-/// FIXME: Make this private.
 mod owned;
 
 use core::cmp::Ordering;

From 82f553aada5fd4cd3aa6522f7c8d2a2135cc21d6 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 16:30:31 +0100
Subject: [PATCH 382/554] Expose `ScriptBuf`'s `capacity`

There are already several methods referring to capacity but none to
retrieve it. Those methods also promise certain behavior that mandates
having *a* capacity field inside the struct, so no changes in layout
will ever remove it. Thus it's OK to expose the field.

Aside from exposing the field, this also fixes up the tests to obey the
sanity rules.
---
 primitives/src/script/owned.rs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 7d33bc7705..53dc6d78b8 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -91,6 +91,14 @@ impl ScriptBuf {
     /// Panics if the new capacity exceeds `isize::MAX bytes`.
     #[inline]
     pub fn reserve_exact(&mut self, additional_len: usize) { self.0.reserve_exact(additional_len); }
+
+    /// Returns the number of **bytes** available for writing without reallocation.
+    ///
+    /// It is guaranteed that `script.capacity() >= script.len()` always holds.
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.0.capacity()
+    }
 }
 
 impl Deref for ScriptBuf {
@@ -161,20 +169,20 @@ mod tests {
     #[test]
     fn script_buf_capacity() {
         let script = ScriptBuf::with_capacity(10);
-        assert!(script.0.capacity() >= 10);
+        assert!(script.capacity() >= 10);
     }
 
     #[test]
     fn script_buf_reserve() {
         let mut script = ScriptBuf::new();
         script.reserve(10);
-        assert!(script.0.capacity() >= 10);
+        assert!(script.capacity() >= 10);
     }
 
     #[test]
     fn script_buf_reserve_exact() {
         let mut script = ScriptBuf::new();
         script.reserve_exact(10);
-        assert!(script.0.capacity() >= 10);
+        assert!(script.capacity() >= 10);
     }
 }

From 9ec9adc71d3e292b08ec25e53597762796cbfde8 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 17:59:12 +0100
Subject: [PATCH 383/554] Add a note about Electrum's script hashes

The Electrum protocol uses hashes of `script_pubkey` that might look
similar to the ones we have in the crate and could be confused. This
change notes that to hopefully avoid the confusion.

Resolves https://github.com/rust-bitcoin/rust-bitcoin/discussions/3997
---
 primitives/src/script/mod.rs | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index 6f90337a94..6e784e1bb4 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -33,9 +33,18 @@ pub const MAX_REDEEM_SCRIPT_SIZE: usize = 520;
 pub const MAX_WITNESS_SCRIPT_SIZE: usize = 10_000;
 
 hashes::hash_newtype! {
-    /// A hash of Bitcoin Script bytecode.
+    /// A 160-bit hash of Bitcoin Script bytecode.
+    ///
+    /// Note: there is another "script hash" object in bitcoin ecosystem (Electrum protocol) that
+    /// uses 256-bit hash and hashes a semantically different script. Thus, this type cannot
+    /// represent it.
     pub struct ScriptHash(hash160::Hash);
-    /// SegWit version of a Bitcoin Script bytecode hash.
+
+    /// SegWit (256-bit) version of a Bitcoin Script bytecode hash.
+    ///
+    /// Note: there is another "script hash" object in bitcoin ecosystem (Electrum protocol) that
+    /// looks similar to this one also being SHA256, however, they hash semantically different
+    /// scripts and have reversed representations, so this type cannot be used for both.
     pub struct WScriptHash(sha256::Hash);
 }
 

From ce55dd5b700f906c56717ea5157e59822e2520ea Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 18:10:53 +0100
Subject: [PATCH 384/554] Make `ScriptHash` & `WScriptHash` obey sanity rule

These were re-implementing hashing after the check rather than calling
the `_unchecked` method, so this replaces the manual implementation with
the method.
---
 primitives/src/script/mod.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index 6e784e1bb4..4e698da255 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -69,7 +69,8 @@ impl ScriptHash {
             return Err(RedeemScriptSizeError { size: redeem_script.len() });
         }
 
-        Ok(ScriptHash(hash160::Hash::hash(redeem_script.as_bytes())))
+        // We've just checked the length
+        Ok(ScriptHash::from_script_unchecked(redeem_script))
     }
 
     /// Constructs a new `ScriptHash` from any script irrespective of script size.
@@ -99,7 +100,8 @@ impl WScriptHash {
             return Err(WitnessScriptSizeError { size: witness_script.len() });
         }
 
-        Ok(WScriptHash(sha256::Hash::hash(witness_script.as_bytes())))
+        // We've just checked the length
+        Ok(WScriptHash::from_script_unchecked(witness_script))
     }
 
     /// Constructs a new `WScriptHash` from any script irrespective of script size.

From 5680b4e870ba3b7340432256c24d37d2b6ead15a Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Thu, 20 Feb 2025 19:05:56 +0100
Subject: [PATCH 385/554] Refer to `Script{Buf}` as `Self` where relevant

Using `Self` instead of specific type name can make some refactorings
easier.
---
 primitives/src/script/borrowed.rs | 10 +++++-----
 primitives/src/script/mod.rs      |  8 ++++----
 primitives/src/script/owned.rs    |  4 ++--
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index 29453482b4..ece38f6ee6 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -74,28 +74,28 @@ impl ToOwned for Script {
 impl Script {
     /// Constructs a new empty script.
     #[inline]
-    pub const fn new() -> &'static Script { Script::from_bytes(&[]) }
+    pub const fn new() -> &'static Self { Self::from_bytes(&[]) }
 
     /// Treat byte slice as `Script`
     #[inline]
-    pub const fn from_bytes(bytes: &[u8]) -> &Script {
+    pub const fn from_bytes(bytes: &[u8]) -> &Self {
         // 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) }
+        unsafe { &*(bytes as *const [u8] as *const Self) }
     }
 
     /// Treat mutable byte slice as `Script`
     #[inline]
-    pub fn from_bytes_mut(bytes: &mut [u8]) -> &mut Script {
+    pub fn from_bytes_mut(bytes: &mut [u8]) -> &mut Self {
         // 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) }
+        unsafe { &mut *(bytes as *mut [u8] as *mut Self) }
     }
 
     /// Returns the script data as a byte slice.
diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index 4e698da255..7832ecfef4 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -299,7 +299,7 @@ impl From<ScriptBuf> for Vec<u8> {
 
 impl AsRef<Script> for Script {
     #[inline]
-    fn as_ref(&self) -> &Script { self }
+    fn as_ref(&self) -> &Self { self }
 }
 
 impl AsRef<Script> for ScriptBuf {
@@ -319,7 +319,7 @@ impl AsRef<[u8]> for ScriptBuf {
 
 impl AsMut<Script> for Script {
     #[inline]
-    fn as_mut(&mut self) -> &mut Script { self }
+    fn as_mut(&mut self) -> &mut Self { self }
 }
 
 impl AsMut<Script> for ScriptBuf {
@@ -435,14 +435,14 @@ impl fmt::LowerHex for Script {
     }
 }
 #[cfg(feature = "alloc")]
-internals::impl_to_hex_from_lower_hex!(Script, |script: &Script| script.len() * 2);
+internals::impl_to_hex_from_lower_hex!(Script, |script: &Self| script.len() * 2);
 
 impl fmt::LowerHex for ScriptBuf {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(self.as_script(), f) }
 }
 #[cfg(feature = "alloc")]
-internals::impl_to_hex_from_lower_hex!(ScriptBuf, |script_buf: &ScriptBuf| script_buf.len() * 2);
+internals::impl_to_hex_from_lower_hex!(ScriptBuf, |script_buf: &Self| script_buf.len() * 2);
 
 impl fmt::UpperHex for Script {
     #[inline]
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index 53dc6d78b8..f3c78516e3 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -23,13 +23,13 @@ pub struct ScriptBuf(Vec<u8>);
 impl ScriptBuf {
     /// Constructs a new empty script.
     #[inline]
-    pub const fn new() -> Self { ScriptBuf::from_bytes(Vec::new()) }
+    pub const fn new() -> Self { Self::from_bytes(Vec::new()) }
 
     /// Converts byte vector into script.
     ///
     /// This method doesn't (re)allocate.
     #[inline]
-    pub const fn from_bytes(bytes: Vec<u8>) -> Self { ScriptBuf(bytes) }
+    pub const fn from_bytes(bytes: Vec<u8>) -> Self { Self(bytes) }
 
     /// Returns a reference to unsized script.
     #[inline]

From 2349e5be7342e87b77a01ec8a391de2640897180 Mon Sep 17 00:00:00 2001
From: Update Stable Rustc Bot <bot@example.com>
Date: Fri, 21 Feb 2025 00:56:08 +0000
Subject: [PATCH 386/554] Automated update to Github CI to rustc stable-1.85.0

---
 .github/workflows/stable-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stable-version b/.github/workflows/stable-version
index 1a17bdc171..f288d11142 100644
--- a/.github/workflows/stable-version
+++ b/.github/workflows/stable-version
@@ -1 +1 @@
-1.84.1
+1.85.0

From ca8bd531d64336f5d8edeb5938c23431a745ec13 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 22 Feb 2025 01:38:55 +0000
Subject: [PATCH 387/554] Automated update to Github CI to rustc
 nightly-2025-02-21

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 952e0e57c6..48d0eb4ab6 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-02-14
+nightly-2025-02-21

From 6c69b66b0d496a66a4db2f22df8ac617ed807fb3 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Sun, 23 Feb 2025 04:18:04 +0700
Subject: [PATCH 388/554] Use Version constant

Replace Version(2) with predefined Version::TWO constant
---
 bitcoin/tests/psbt-sign-taproot.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bitcoin/tests/psbt-sign-taproot.rs b/bitcoin/tests/psbt-sign-taproot.rs
index 15ff88115a..89611e7995 100644
--- a/bitcoin/tests/psbt-sign-taproot.rs
+++ b/bitcoin/tests/psbt-sign-taproot.rs
@@ -211,7 +211,7 @@ fn create_psbt_for_taproot_key_path_spend(
     let prev_tx_id = "06980ca116f74c7845a897461dd0e1d15b114130176de5004957da516b4dee3a";
 
     let transaction = Transaction {
-        version: Version(2),
+        version: Version::TWO,
         lock_time: absolute::LockTime::ZERO,
         input: vec![TxIn {
             previous_output: OutPoint { txid: prev_tx_id.parse().unwrap(), vout: 0 },
@@ -288,7 +288,7 @@ fn create_psbt_for_taproot_script_path_spend(
     }];
     let prev_tx_id = "9d7c6770fca57285babab60c51834cfcfd10ad302119cae842d7216b4ac9a376";
     let transaction = Transaction {
-        version: Version(2),
+        version: Version::TWO,
         lock_time: absolute::LockTime::ZERO,
         input: vec![TxIn {
             previous_output: OutPoint { txid: prev_tx_id.parse().unwrap(), vout: 0 },

From 0596867048be131f3af26f5f8be4b36f1fe186b0 Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 23 Feb 2025 01:21:34 +0000
Subject: [PATCH 389/554] 2025-02-23 automated rustfmt nightly

---
 chacha20_poly1305/src/benches.rs | 57 +++++++++++++++-----------------
 1 file changed, 27 insertions(+), 30 deletions(-)

diff --git a/chacha20_poly1305/src/benches.rs b/chacha20_poly1305/src/benches.rs
index 5bfb6572ca..ebe086c3f0 100644
--- a/chacha20_poly1305/src/benches.rs
+++ b/chacha20_poly1305/src/benches.rs
@@ -4,42 +4,39 @@ use crate::{ChaCha20, Key, Nonce};
 
 #[bench]
 pub fn chacha20_10(bh: &mut Bencher) {
-  let key =
-      Key::new([0u8; 32]);
-  let nonce = Nonce::new([0u8; 12]);
-  let count = 1;
-  let mut chacha = ChaCha20::new(key, nonce, count);
-  let mut bytes = [0u8; 10];
-  bh.iter(|| {
-    chacha.apply_keystream(&mut bytes[..]);
-  });
-  bh.bytes = bytes.len() as u64;
+    let key = Key::new([0u8; 32]);
+    let nonce = Nonce::new([0u8; 12]);
+    let count = 1;
+    let mut chacha = ChaCha20::new(key, nonce, count);
+    let mut bytes = [0u8; 10];
+    bh.iter(|| {
+        chacha.apply_keystream(&mut bytes[..]);
+    });
+    bh.bytes = bytes.len() as u64;
 }
 
 #[bench]
 pub fn chacha20_1k(bh: &mut Bencher) {
-  let key =
-      Key::new([0u8; 32]);
-  let nonce = Nonce::new([0u8; 12]);
-  let count = 1;
-  let mut chacha = ChaCha20::new(key, nonce, count);
-  let mut bytes = [0u8; 1024];
-  bh.iter(|| {
-    chacha.apply_keystream(&mut bytes[..]);
-  });
-  bh.bytes = bytes.len() as u64;
+    let key = Key::new([0u8; 32]);
+    let nonce = Nonce::new([0u8; 12]);
+    let count = 1;
+    let mut chacha = ChaCha20::new(key, nonce, count);
+    let mut bytes = [0u8; 1024];
+    bh.iter(|| {
+        chacha.apply_keystream(&mut bytes[..]);
+    });
+    bh.bytes = bytes.len() as u64;
 }
 
 #[bench]
 pub fn chacha20_64k(bh: &mut Bencher) {
-  let key =
-      Key::new([0u8; 32]);
-  let nonce = Nonce::new([0u8; 12]);
-  let count = 1;
-  let mut chacha = ChaCha20::new(key, nonce, count);
-  let mut bytes = [0u8; 65536];
-  bh.iter(|| {
-    chacha.apply_keystream(&mut bytes[..]);
-  });
-  bh.bytes = bytes.len() as u64;
+    let key = Key::new([0u8; 32]);
+    let nonce = Nonce::new([0u8; 12]);
+    let count = 1;
+    let mut chacha = ChaCha20::new(key, nonce, count);
+    let mut bytes = [0u8; 65536];
+    bh.iter(|| {
+        chacha.apply_keystream(&mut bytes[..]);
+    });
+    bh.bytes = bytes.len() as u64;
 }

From cb270eae8e22e2121d4d6a73b34bc1919334a7ce Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Fri, 21 Feb 2025 20:22:24 +0700
Subject: [PATCH 390/554] Make transaction::Version field private

This commit addresses #4041 by making the transaction::Version field private

Changes:
- Make the `Version` field private with `pub(crate)`
- Rename `non_standard` to `maybe_non_standard` for clarity since it accepts both standard and non-standard versions
- Add `#[inline]` attributes to small, frequently used methods:
  - `as_u32`
  - `maybe_non_standard`

Users now must use either:
- Constants (`Version::ONE/TWO/THREE`) for standard versions
- `maybe_non_standard` method for any version (standard or non-standard)
---
 bitcoin/src/blockdata/transaction.rs | 17 +++--------------
 primitives/src/transaction.rs        | 25 ++++++++++++++++++++++++-
 2 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index e01a02db50..0979171ff3 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -627,26 +627,15 @@ impl std::error::Error for IndexOutOfBoundsError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { None }
 }
 
-crate::internal_macros::define_extension_trait! {
-    /// Extension functionality for the [`Version`] type.
-    pub trait VersionExt impl for Version {
-        /// Constructs a new non-standard transaction version.
-        fn non_standard(version: u32) -> Version { Self(version) }
-
-        /// Returns true if this transaction version number is considered standard.
-        fn is_standard(&self) -> bool { *self == Version::ONE || *self == Version::TWO || *self == Version::THREE }
-    }
-}
-
 impl Encodable for Version {
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
-        self.0.consensus_encode(w)
+        self.to_u32().consensus_encode(w)
     }
 }
 
 impl Decodable for Version {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Decodable::consensus_decode(r).map(Version)
+        Decodable::consensus_decode(r).map(Version::maybe_non_standard)
     }
 }
 
@@ -1373,7 +1362,7 @@ mod tests {
         let tx: Result<Transaction, _> = deserialize(&tx_bytes);
         assert!(tx.is_ok());
         let realtx = tx.unwrap();
-        assert_eq!(realtx.version, Version::non_standard(u32::MAX));
+        assert_eq!(realtx.version, Version::maybe_non_standard(u32::MAX));
     }
 
     #[test]
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index fa7b0e4301..cf24946fb9 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -518,7 +518,7 @@ impl Wtxid {
 /// [BIP-431]: https://github.com/bitcoin/bips/blob/master/bip-0431.mediawiki
 #[derive(Copy, PartialEq, Eq, Clone, Debug, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Version(pub u32);
+pub struct Version(u32);
 
 impl Version {
     /// The original Bitcoin transaction version (pre-BIP-68).
@@ -529,12 +529,35 @@ impl Version {
 
     /// The third Bitcoin transaction version (post-BIP-431).
     pub const THREE: Self = Self(3);
+
+    /// Constructs a potentially non-standard transaction version.
+    ///
+    /// This can accept both standard and non-standard versions.
+    #[inline]
+    pub fn maybe_non_standard(version: u32) -> Version { Self(version) }
+
+    /// Returns the inner `u32` value of this `Version`.
+    #[inline]
+    pub const fn to_u32(self) -> u32 { self.0 }
+
+    /// Returns true if this transaction version number is considered standard.
+    ///
+    /// The behavior of this method matches whatever Bitcoin Core considers standard at the time
+    /// of the release and may change in future versions to accommodate new standard versions.
+    /// As of Bitcoin Core 28.0 ([release notes](https://bitcoincore.org/en/releases/28.0/)),
+    /// versions 1, 2, and 3 are considered standard.
+    #[inline]
+    pub fn is_standard(&self) -> bool { *self == Version::ONE || *self == Version::TWO || *self == Version::THREE }
 }
 
 impl fmt::Display for Version {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
 
+impl From<Version> for u32 {
+    fn from(version: Version) -> Self { version.0 }
+}
+
 #[cfg(feature = "arbitrary")]
 #[cfg(feature = "alloc")]
 impl<'a> Arbitrary<'a> for Transaction {

From 82a8aefc5341d04d2707858afdfda0fba9816ebd Mon Sep 17 00:00:00 2001
From: Jose Storopoli <jose@storopoli.com>
Date: Sun, 23 Feb 2025 08:57:02 -0300
Subject: [PATCH 391/554] sighash: Document witness_script in p2wsh

---
 bitcoin/src/crypto/sighash.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 5498211a04..572db4a129 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -886,6 +886,9 @@ impl<R: Borrow<Transaction>> SighashCache<R> {
     }
 
     /// Computes the BIP143 sighash to spend a p2wsh transaction for any flag type.
+    ///
+    /// `witness_script` is the script that goes into the [`Witness`],
+    /// not the one that goes into `script_pubkey` of a [`TxOut`].
     pub fn p2wsh_signature_hash(
         &mut self,
         input_index: usize,

From e810ecff7cbaeef3007fe7abf98f0fe383bcd219 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Fri, 21 Feb 2025 14:59:55 +0100
Subject: [PATCH 392/554] Fix key/script spend detection in `Witness`

The `taproot_control_block` did not properly detect whether it deals
with script spend or key spend. As a result, if key spend with annex was
used it'd return the first element (the signature) as if it was a
control block.

Further, the conditions identifying which kind of spend it was were
repeated multiple times but behaved subtly differently making only
`taproot_control_block` buggy but the other places confusing.

To resolve these issues this change adds a `P2TrSpend` enum that
represents a parsed witness and has a single method doing all the
parsing. The other methods can then be trivially implemented by matching
on that type. This way only one place needs to be verified and the
parsing code is more readable since it uses one big `match` to handle
all possibilities.

The downside of this is a potential perf impact if the parsing code
doesn't get inlined since the common parsing code has to shuffle around
data that the caller is not intersted in. I don't think this will be a
problem but if it will I suppose it will be solvable (e.g. by using
`#[inline(always)]`).

The enum also looks somewhat nice and perhaps downstream consumers could
make use of it. This change does not expose it yet but is written such
that after exposing it the API would be (mostly) idiomatic.

Closes #4097
---
 bitcoin/src/blockdata/witness.rs | 119 ++++++++++++++++++++++++-------
 1 file changed, 92 insertions(+), 27 deletions(-)

diff --git a/bitcoin/src/blockdata/witness.rs b/bitcoin/src/blockdata/witness.rs
index d6b67a7381..d8fa1fa174 100644
--- a/bitcoin/src/blockdata/witness.rs
+++ b/bitcoin/src/blockdata/witness.rs
@@ -147,14 +147,12 @@ crate::internal_macros::define_extension_trait! {
         ///
         /// See [`Script::is_p2tr`] to check whether this is actually a Taproot witness.
         fn tapscript(&self) -> Option<&Script> {
-            if self.is_empty() {
-                return None;
-            }
-
-            if self.taproot_annex().is_some() {
-                self.third_to_last().map(Script::from_bytes)
-            } else {
-                self.second_to_last().map(Script::from_bytes)
+            match P2TrSpend::from_witness(self) {
+                // Note: the method is named "tapscript" but historically it was actually returning
+                // leaf script. This is broken but we now keep the behavior the same to not subtly
+                // break someone.
+                Some(P2TrSpend::Script { leaf_script, .. }) => Some(leaf_script),
+                _ => None,
             }
         }
 
@@ -166,14 +164,9 @@ crate::internal_macros::define_extension_trait! {
         ///
         /// See [`Script::is_p2tr`] to check whether this is actually a Taproot witness.
         fn taproot_control_block(&self) -> Option<&[u8]> {
-            if self.is_empty() {
-                return None;
-            }
-
-            if self.taproot_annex().is_some() {
-                self.second_to_last()
-            } else {
-                self.last()
+            match P2TrSpend::from_witness(self) {
+                Some(P2TrSpend::Script { control_block, .. }) => Some(control_block),
+                _ => None,
             }
         }
 
@@ -183,17 +176,7 @@ crate::internal_macros::define_extension_trait! {
         ///
         /// See [`Script::is_p2tr`] to check whether this is actually a Taproot witness.
         fn taproot_annex(&self) -> Option<&[u8]> {
-            self.last().and_then(|last| {
-                // 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 self.len() >= 2 && last.first() == Some(&TAPROOT_ANNEX_PREFIX) {
-                    Some(last)
-                } else {
-                    None
-                }
-            })
+            P2TrSpend::from_witness(self)?.annex()
         }
 
         /// Get the p2wsh witness script following BIP141 rules.
@@ -206,6 +189,88 @@ crate::internal_macros::define_extension_trait! {
     }
 }
 
+/// Represents a possible Taproot spend.
+///
+/// Taproot can be spent as key spend or script spend and, depending on which it is, different data
+/// is in the witness. This type helps representing that data more cleanly when parsing the witness
+/// because there are a lot of conditions that make reasoning hard. It's better to parse it at one
+/// place and pass it along.
+///
+/// This type is so far private but it could be published eventually. The design is geared towards
+/// it but it's not fully finished.
+enum P2TrSpend<'a> {
+    Key {
+        // This field is technically present in witness in case of key spend but none of our code
+        // uses it yet. Rather than deleting it, it's kept here commented as documentation and as
+        // an easy way to add it if anything needs it - by just uncommenting.
+        // signature: &'a [u8],
+        annex: Option<&'a [u8]>,
+    },
+    Script {
+        leaf_script: &'a Script,
+        control_block: &'a [u8],
+        annex: Option<&'a [u8]>,
+    },
+}
+
+impl<'a> P2TrSpend<'a> {
+    /// Parses `Witness` to determine what kind of taproot spend this is.
+    ///
+    /// Note: this assumes `witness` is a taproot spend. The function cannot figure it out for sure
+    /// (without knowing the output), so it doesn't attempt to check anything other than what is
+    /// required for the program to not crash.
+    ///
+    /// In other words, if the caller is certain that the witness is a valid p2tr spend (e.g.
+    /// obtained from Bitcoin Core) then it's OK to unwrap this but not vice versa - `Some` does
+    /// not imply correctness.
+    fn from_witness(witness: &'a Witness) -> Option<Self> {
+        // BIP341 says:
+        //   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.
+        //
+        // However here we're not removing anything, so we have to adjust the numbers to account
+        // for the fact that annex is still there.
+        match witness.len() {
+            0 => None,
+            1 => Some(P2TrSpend::Key { /* signature: witness.last().expect("len > 0") ,*/ annex: None }),
+            2 if witness.last().expect("len > 0").starts_with(&[TAPROOT_ANNEX_PREFIX]) => {
+                let spend = P2TrSpend::Key {
+                    // signature: witness.second_to_last().expect("len > 1"),
+                    annex: witness.last(),
+                };
+                Some(spend)
+            },
+            // 2 => this is script spend without annex - same as when there are 3+ elements and the
+            //   last one does NOT start with TAPROOT_ANNEX_PREFIX. This is handled in the catchall
+            //   arm.
+            3.. if witness.last().expect("len > 0").starts_with(&[TAPROOT_ANNEX_PREFIX]) => {
+                let spend = P2TrSpend::Script {
+                    leaf_script: Script::from_bytes(witness.third_to_last().expect("len > 2")),
+                    control_block: witness.second_to_last().expect("len > 1"),
+                    annex: witness.last(),
+                };
+                Some(spend)
+            },
+            _ => {
+                let spend = P2TrSpend::Script {
+                    leaf_script: Script::from_bytes(witness.second_to_last().expect("len > 1")),
+                    control_block: witness.last().expect("len > 0"),
+                    annex: None,
+                };
+                Some(spend)
+            },
+        }
+    }
+
+    fn annex(&self) -> Option<&'a [u8]> {
+        match self {
+            P2TrSpend::Key { annex, .. } => *annex,
+            P2TrSpend::Script { annex, .. } => *annex,
+        }
+    }
+}
+
 mod sealed {
     pub trait Sealed {}
     impl Sealed for super::Witness {}

From 59f21a291f08af0029691676f86ac95dad04d8c3 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Fri, 21 Feb 2025 15:34:39 +0100
Subject: [PATCH 393/554] Add a test case checking `taproot_control_block`

The previous commit fixed a bug when `taproot_control_block` returned
`Some` on key-spends. This adds a test case for it which succeeds when
applied after the previous commit and fails if applied before it.
---
 bitcoin/src/blockdata/witness.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/witness.rs b/bitcoin/src/blockdata/witness.rs
index d8fa1fa174..20efc0b5f6 100644
--- a/bitcoin/src/blockdata/witness.rs
+++ b/bitcoin/src/blockdata/witness.rs
@@ -397,19 +397,24 @@ mod test {
         let control_block = hex!("02");
         // annex starting with 0x50 causes the branching logic.
         let annex = hex!("50");
+        let signature = vec![0xff; 64];
 
         let witness_vec = vec![tapscript.clone(), control_block.clone()];
-        let witness_vec_annex = vec![tapscript.clone(), control_block.clone(), annex];
+        let witness_vec_annex = vec![tapscript.clone(), control_block.clone(), annex.clone()];
+        let witness_vec_key_spend_annex = vec![signature, annex];
 
         let witness_serialized: Vec<u8> = serialize(&witness_vec);
         let witness_serialized_annex: Vec<u8> = serialize(&witness_vec_annex);
+        let witness_serialized_key_spend_annex: Vec<u8> = serialize(&witness_vec_key_spend_annex);
 
         let witness = deserialize::<Witness>(&witness_serialized[..]).unwrap();
         let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
+        let witness_key_spend_annex = deserialize::<Witness>(&witness_serialized_key_spend_annex[..]).unwrap();
 
         // With or without annex, the tapscript should be returned.
         assert_eq!(witness.taproot_control_block(), Some(&control_block[..]));
         assert_eq!(witness_annex.taproot_control_block(), Some(&control_block[..]));
+        assert!(witness_key_spend_annex.taproot_control_block().is_none())
     }
 
     #[test]

From a8168c3f81a76165022af3f3aeec82317d8a6bf1 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Fri, 21 Feb 2025 16:33:00 +0100
Subject: [PATCH 394/554] Add `taproot_leaf_script` methood to `Witness`

We already have `tapscript` method on `Witness` which is broken because
it doesn't check that the leaf script is a tapscript, however that
behavior might have been intended by some consumers who want to inspect
the script independent of the version. To resolve the confusion, we're
going to add a new method that returns both the leaf script and, to
avoid forgetting version check, also the leaf version.

This doesn't touch the `tapscript` method yet to make backporting of
this commit easier. It's also worth noting that leaf script is often
used together with version. To make passing them around easier it'd be
helpful to use a separate type. Thus this also adds a public POD type
containing the script and the version. In anticipation of if being
usable in different APIs it's also generic over the script type.
Similarly to the `tapscript` method, this also only adds the type and
doesn't change other functions to use it yet. Only the newly added
`taproot_leaf_script` method uses it now.

This is a part of #4073
---
 bitcoin/src/blockdata/witness.rs | 44 +++++++++++++++++++++++++++++++-
 bitcoin/src/taproot/mod.rs       |  9 +++++++
 2 files changed, 52 insertions(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/witness.rs b/bitcoin/src/blockdata/witness.rs
index 20efc0b5f6..d0ac6f526d 100644
--- a/bitcoin/src/blockdata/witness.rs
+++ b/bitcoin/src/blockdata/witness.rs
@@ -13,7 +13,7 @@ use crate::crypto::ecdsa;
 use crate::prelude::Vec;
 #[cfg(doc)]
 use crate::script::ScriptExt as _;
-use crate::taproot::{self, TAPROOT_ANNEX_PREFIX};
+use crate::taproot::{self, LeafScript, LeafVersion, TAPROOT_ANNEX_PREFIX, TAPROOT_CONTROL_BASE_SIZE, TAPROOT_LEAF_MASK};
 use crate::Script;
 
 #[rustfmt::skip]                // Keep public re-exports separate.
@@ -156,6 +156,22 @@ crate::internal_macros::define_extension_trait! {
             }
         }
 
+        /// Returns the leaf script with its version but without the merkle proof.
+        ///
+        /// This does not guarantee that this represents a P2TR [`Witness`]. It
+        /// merely gets the second to last or third to last element depending on
+        /// the first byte of the last element being equal to 0x50 and the associated
+        /// version.
+        fn taproot_leaf_script(&self) -> Option<LeafScript<&Script>> {
+            match P2TrSpend::from_witness(self) {
+                Some(P2TrSpend::Script { leaf_script, control_block, .. }) if control_block.len() >= TAPROOT_CONTROL_BASE_SIZE => {
+                    let version = LeafVersion::from_consensus(control_block[0] & TAPROOT_LEAF_MASK).ok()?;
+                    Some(LeafScript { version, script: leaf_script, })
+                },
+                _ => None,
+            }
+        }
+
         /// Get the taproot control block following BIP341 rules.
         ///
         /// This does not guarantee that this represents a P2TR [`Witness`]. It
@@ -371,6 +387,32 @@ mod test {
         assert_eq!(witness_annex.tapscript(), Some(Script::from_bytes(&tapscript[..])));
     }
 
+    #[test]
+    fn get_taproot_leaf_script() {
+        let tapscript = hex!("deadbeef");
+        let control_block = hex!("c0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+        // 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 = deserialize::<Witness>(&witness_serialized[..]).unwrap();
+        let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
+
+        let expected_leaf_script = LeafScript {
+            version: LeafVersion::TapScript,
+            script: Script::from_bytes(&tapscript),
+        };
+
+        // With or without annex, the tapscript should be returned.
+        assert_eq!(witness.taproot_leaf_script().unwrap(), expected_leaf_script);
+        assert_eq!(witness_annex.taproot_leaf_script().unwrap(), expected_leaf_script);
+    }
+
     #[test]
     fn get_tapscript_from_keypath() {
         let signature = hex!("deadbeef");
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 775357f07f..69746a1a5f 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -142,6 +142,15 @@ pub const TAPROOT_CONTROL_BASE_SIZE: usize = 33;
 pub const TAPROOT_CONTROL_MAX_SIZE: usize =
     TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT;
 
+/// The leaf script with its version.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct LeafScript<S> {
+    /// The version of the script.
+    pub version: LeafVersion,
+    /// The script, usually `ScriptBuf` or `&Script`.
+    pub script: S,
+}
+
 // type alias for versioned tap script corresponding Merkle proof
 type ScriptMerkleProofMap = BTreeMap<(ScriptBuf, LeafVersion), BTreeSet<TaprootMerkleBranch>>;
 

From b3f122b3996c1a73479be2f95b7f2ae642c9c56f Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 21 Feb 2025 10:22:18 +1100
Subject: [PATCH 395/554] Add Timestamp newtype

Bitcoin block headers have a timestamp. Currently we are using a
`u32`. while this functions correctly it gives the compiler no chance
to enforce type safety.

Add a `Timestamp` newtype that is a thin wrapper around a `u32`.
Document it and test the API surface in `api.rs`.
---
 bitcoin/src/bip152.rs              |  6 ++--
 bitcoin/src/blockdata/block.rs     | 17 +++++++--
 bitcoin/src/blockdata/constants.rs | 18 +++++-----
 bitcoin/src/lib.rs                 |  1 +
 bitcoin/src/pow.rs                 | 11 +++---
 primitives/src/block.rs            |  9 ++---
 primitives/src/lib.rs              |  1 +
 units/src/lib.rs                   |  2 ++
 units/src/timestamp.rs             | 58 ++++++++++++++++++++++++++++++
 units/tests/api.rs                 | 19 ++++++++--
 10 files changed, 116 insertions(+), 26 deletions(-)
 create mode 100644 units/src/timestamp.rs

diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs
index f57fe3e1ce..c7b69526bf 100644
--- a/bitcoin/src/bip152.rs
+++ b/bitcoin/src/bip152.rs
@@ -413,8 +413,8 @@ mod test {
     use crate::merkle_tree::TxMerkleNode;
     use crate::transaction::OutPointExt;
     use crate::{
-        transaction, Amount, BlockChecked, CompactTarget, OutPoint, ScriptBuf, Sequence, TxIn,
-        TxOut, Txid, Witness,
+        transaction, Amount, BlockChecked, CompactTarget, OutPoint, ScriptBuf, Sequence, Timestamp,
+        TxIn, TxOut, Txid, Witness,
     };
 
     fn dummy_tx(nonce: &[u8]) -> Transaction {
@@ -437,7 +437,7 @@ mod test {
             version: block::Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0x99; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0x77; 32]),
-            time: 2,
+            time: Timestamp::from_u32(2),
             bits: CompactTarget::from_consensus(3),
             nonce: 4,
         };
diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs
index 43ac31ad73..dfd039e557 100644
--- a/bitcoin/src/blockdata/block.rs
+++ b/bitcoin/src/blockdata/block.rs
@@ -13,6 +13,7 @@ use core::fmt;
 use hashes::{sha256d, HashEngine};
 use internals::{compact_size, ToU64};
 use io::{BufRead, Write};
+use units::Timestamp;
 
 use super::Weight;
 use crate::consensus::encode::WriteExt as _;
@@ -85,6 +86,18 @@ impl Decodable for Version {
     }
 }
 
+impl Encodable for Timestamp {
+    fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
+        self.to_u32().consensus_encode(w)
+    }
+}
+
+impl Decodable for Timestamp {
+    fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
+        Decodable::consensus_decode(r).map(Timestamp::from_u32)
+    }
+}
+
 /// Extension functionality for the [`Block<Unchecked>`] type.
 pub trait BlockUncheckedExt: sealed::Sealed {
     /// Validates (or checks) a block.
@@ -596,7 +609,7 @@ mod tests {
             block::compute_merkle_root(&transactions).unwrap()
         );
         assert_eq!(serialize(&real_decode.header().merkle_root), merkle);
-        assert_eq!(real_decode.header().time, 1231965655);
+        assert_eq!(real_decode.header().time, Timestamp::from_u32(1231965655));
         assert_eq!(real_decode.header().bits, CompactTarget::from_consensus(486604799));
         assert_eq!(real_decode.header().nonce, 2067413810);
         assert_eq!(real_decode.header().work(), work);
@@ -647,7 +660,7 @@ mod tests {
             real_decode.header().merkle_root,
             block::compute_merkle_root(&transactions).unwrap()
         );
-        assert_eq!(real_decode.header().time, 1472004949);
+        assert_eq!(real_decode.header().time, Timestamp::from_u32(1472004949));
         assert_eq!(real_decode.header().bits, CompactTarget::from_consensus(0x1a06d450));
         assert_eq!(real_decode.header().nonce, 1879759182);
         assert_eq!(real_decode.header().work(), work);
diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 4b7e51486c..2c5cb4e193 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -16,7 +16,7 @@ use crate::opcodes::all::*;
 use crate::pow::CompactTarget;
 use crate::transaction::{self, OutPoint, Transaction, TxIn, TxOut};
 use crate::witness::Witness;
-use crate::{script, Amount, BlockHash, Sequence, TestnetVersion};
+use crate::{script, Amount, BlockHash, Sequence, TestnetVersion, Timestamp};
 
 /// How many seconds between blocks we expect on average.
 pub const TARGET_BLOCK_SPACING: u32 = 600;
@@ -132,7 +132,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: 1231006505,
+                time: Timestamp::from_u32(1231006505),
                 bits: CompactTarget::from_consensus(0x1d00ffff),
                 nonce: 2083236893,
             },
@@ -144,7 +144,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: 1296688602,
+                time: Timestamp::from_u32(1296688602),
                 bits: CompactTarget::from_consensus(0x1d00ffff),
                 nonce: 414098458,
             },
@@ -156,7 +156,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: 1714777860,
+                time: Timestamp::from_u32(1714777860),
                 bits: CompactTarget::from_consensus(0x1d00ffff),
                 nonce: 393743547,
             },
@@ -168,7 +168,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: 1598918400,
+                time: Timestamp::from_u32(1598918400),
                 bits: CompactTarget::from_consensus(0x1e0377ae),
                 nonce: 52613770,
             },
@@ -180,7 +180,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: 1296688602,
+                time: Timestamp::from_u32(1296688602),
                 bits: CompactTarget::from_consensus(0x207fffff),
                 nonce: 2,
             },
@@ -320,7 +320,7 @@ mod test {
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
 
-        assert_eq!(gen.header().time, 1231006505);
+        assert_eq!(gen.header().time, Timestamp::from_u32(1231006505));
         assert_eq!(gen.header().bits, CompactTarget::from_consensus(0x1d00ffff));
         assert_eq!(gen.header().nonce, 2083236893);
         assert_eq!(
@@ -338,7 +338,7 @@ mod test {
             gen.header().merkle_root.to_string(),
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
-        assert_eq!(gen.header().time, 1296688602);
+        assert_eq!(gen.header().time, Timestamp::from_u32(1296688602));
         assert_eq!(gen.header().bits, CompactTarget::from_consensus(0x1d00ffff));
         assert_eq!(gen.header().nonce, 414098458);
         assert_eq!(
@@ -356,7 +356,7 @@ mod test {
             gen.header().merkle_root.to_string(),
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
-        assert_eq!(gen.header().time, 1598918400);
+        assert_eq!(gen.header().time, Timestamp::from_u32(1598918400));
         assert_eq!(gen.header().bits, CompactTarget::from_consensus(0x1e0377ae));
         assert_eq!(gen.header().nonce, 52613770);
         assert_eq!(
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index af6386a40c..ab1d7c9ac9 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -135,6 +135,7 @@ pub use units::{
     amount::{Amount, Denomination, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::FeeRate,
+    timestamp::{self, Timestamp},
     weight::Weight,
 };
 
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index e25319273d..09929f64f1 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -420,9 +420,9 @@ define_extension_trait! {
             current: Header,
             params: impl AsRef<Params>,
         ) -> CompactTarget {
-            let timespan = current.time - last_epoch_boundary.time;
+            let timespan = i64::from(current.time.to_u32()) - i64::from(last_epoch_boundary.time.to_u32());
             let bits = current.bits;
-            CompactTarget::from_next_work_required(bits, timespan.into(), params)
+            CompactTarget::from_next_work_required(bits, timespan, params)
         }
     }
 }
@@ -1078,6 +1078,7 @@ pub mod test_utils {
 mod tests {
     use super::*;
     use crate::pow::test_utils::{u128_to_work, u32_to_target, u64_to_target};
+    use crate::Timestamp;
 
     impl U256 {
         fn bit_at(&self, index: usize) -> bool {
@@ -1762,7 +1763,7 @@ mod tests {
             version: Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0; 32]),
-            time: 1599332177,
+            time: Timestamp::from_u32(1599332177),
             bits: epoch_start.bits,
             nonce: epoch_start.nonce,
         };
@@ -1784,7 +1785,7 @@ mod tests {
             version: Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0; 32]),
-            time: 1599332844,
+            time: Timestamp::from_u32(1599332844),
             bits: starting_bits,
             nonce: 0,
         };
@@ -1794,7 +1795,7 @@ mod tests {
             version: Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0; 32]),
-            time: 1600591200,
+            time: Timestamp::from_u32(1600591200),
             bits: starting_bits,
             nonce: 0,
         };
diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index b30a2c6c96..5de122e5e3 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -14,6 +14,7 @@ use core::marker::PhantomData;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use hashes::{sha256d, HashEngine as _};
+use units::Timestamp;
 
 use crate::merkle_tree::TxMerkleNode;
 #[cfg(feature = "alloc")]
@@ -170,7 +171,7 @@ pub struct Header {
     /// 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,
+    pub time: Timestamp,
     /// The target value below which the blockhash must lie.
     pub bits: CompactTarget,
     /// The nonce, selected to obtain a low enough blockhash.
@@ -189,7 +190,7 @@ impl Header {
         engine.input(&self.version.to_consensus().to_le_bytes());
         engine.input(self.prev_blockhash.as_byte_array());
         engine.input(self.merkle_root.as_byte_array());
-        engine.input(&self.time.to_le_bytes());
+        engine.input(&self.time.to_u32().to_le_bytes());
         engine.input(&self.bits.to_consensus().to_le_bytes());
         engine.input(&self.nonce.to_le_bytes());
 
@@ -388,7 +389,7 @@ mod tests {
             version: Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0x99; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0x77; 32]),
-            time: 2,
+            time: Timestamp::from(2),
             bits: CompactTarget::from_consensus(3),
             nonce: 4,
         };
@@ -398,7 +399,7 @@ mod tests {
         let header_size = header.version.to_consensus().to_le_bytes().len()
             + header.prev_blockhash.as_byte_array().len()
             + header.merkle_root.as_byte_array().len()
-            + header.time.to_le_bytes().len()
+            + header.time.to_u32().to_le_bytes().len()
             + header.bits.to_consensus().to_le_bytes().len()
             + header.nonce.to_le_bytes().len();
 
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index 5cd7150637..ebc44aa58f 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -59,6 +59,7 @@ pub use units::{
     amount::{self, Amount, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::{self, FeeRate},
+    timestamp::{self, Timestamp},
     weight::{self, Weight},
 };
 
diff --git a/units/src/lib.rs b/units/src/lib.rs
index 4d3be98ac2..a5f5434a5b 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -34,6 +34,7 @@ pub mod block;
 pub mod fee_rate;
 pub mod locktime;
 pub mod parse;
+pub mod timestamp;
 pub mod weight;
 
 #[doc(inline)]
@@ -42,5 +43,6 @@ pub use self::{
     amount::{Amount, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::FeeRate,
+    timestamp::Timestamp,
     weight::Weight
 };
diff --git a/units/src/timestamp.rs b/units/src/timestamp.rs
new file mode 100644
index 0000000000..35e59d8be6
--- /dev/null
+++ b/units/src/timestamp.rs
@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! A UNIX timestamp used as the Bitcoin block time.
+//!
+//! Also known as Epoch Time - January 1, 1970.
+//!
+//! This differs from other UNIX timestamps in that we only use non-negative values. The Epoch
+//! pre-dates Bitcoin so timestamps before this are not useful for block timestamps.
+
+#[cfg(feature = "arbitrary")]
+use arbitrary::{Arbitrary, Unstructured};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// A Bitcoin block timestamp.
+///
+/// > Each block contains a Unix time timestamp. In addition to serving as a source of variation for
+/// > the block hash, they also make it more difficult for an adversary to manipulate the block chain.
+/// >
+/// > A timestamp is accepted as valid if it is greater than the median timestamp of previous 11
+/// > blocks, and less than the network-adjusted time + 2 hours. "Network-adjusted time" is the
+/// > median of the timestamps returned by all nodes connected to you. As a result block timestamps
+/// > are not exactly accurate, and they do not need to be. Block times are accurate only to within
+/// > an hour or two.
+///
+/// ref: <https://en.bitcoin.it/wiki/Block_timestamp>
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct Timestamp(u32);
+
+impl Timestamp {
+    /// Constructs a new [`Timestamp`] from an unsigned 32 bit integer value.
+    #[inline]
+    pub const fn from_u32(t: u32) -> Self { Timestamp(t) }
+
+    /// Returns the inner `u32` value.
+    #[inline]
+    pub const fn to_u32(self) -> u32 { self.0 }
+}
+
+impl From<u32> for Timestamp {
+    #[inline]
+    fn from(t: u32) -> Self { Self::from_u32(t) }
+}
+
+impl From<Timestamp> for u32 {
+    #[inline]
+    fn from(t: Timestamp) -> Self { t.to_u32() }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a> Arbitrary<'a> for Timestamp {
+    #[inline]
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let t: u32 = u.arbitrary()?;
+        Ok(Timestamp::from(t))
+    }
+}
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 00ad9b0841..97a20e2a65 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -15,7 +15,7 @@ use arbitrary::{Arbitrary, Unstructured};
 use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::Height`.
 use bitcoin_units::{
     amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, FeeRate,
-    SignedAmount, Weight,
+    SignedAmount, Timestamp, Weight,
 };
 
 /// A struct that includes all public non-error enums.
@@ -42,6 +42,7 @@ struct Structs {
     i: relative::Height,
     j: relative::Time,
     k: Weight,
+    l: Timestamp,
 }
 
 impl Structs {
@@ -58,6 +59,7 @@ impl Structs {
             i: relative::Height::MAX,
             j: relative::Time::MAX,
             k: Weight::MAX,
+            l: Timestamp::from_u32(u32::MAX),
         }
     }
 }
@@ -87,6 +89,7 @@ struct CommonTraits {
     i: relative::Height,
     j: relative::Time,
     k: Weight,
+    l: Timestamp,
 }
 
 /// A struct that includes all types that implement `Default`.
@@ -138,12 +141,14 @@ struct Errors {
 
 #[test]
 fn api_can_use_modules_from_crate_root() {
-    use bitcoin_units::{amount, block, fee_rate, locktime, parse, weight};
+    use bitcoin_units::{amount, block, fee_rate, locktime, parse, timestamp, weight};
 }
 
 #[test]
 fn api_can_use_types_from_crate_root() {
-    use bitcoin_units::{Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Weight};
+    use bitcoin_units::{
+        Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Timestamp, Weight,
+    };
 }
 
 #[test]
@@ -183,6 +188,11 @@ fn api_can_use_all_types_from_module_parse() {
     use bitcoin_units::parse::{ParseIntError, PrefixedHexError, UnprefixedHexError};
 }
 
+#[test]
+fn api_can_use_all_types_from_module_timestamp() {
+    use bitcoin_units::timestamp::Timestamp;
+}
+
 #[test]
 fn api_can_use_all_types_from_module_weight() {
     use bitcoin_units::weight::Weight;
@@ -218,6 +228,8 @@ fn api_all_non_error_types_have_non_empty_debug() {
     assert!(!debug.is_empty());
     let debug = format!("{:?}", t.b.k);
     assert!(!debug.is_empty());
+    let debug = format!("{:?}", t.b.l);
+    assert!(!debug.is_empty());
 }
 
 #[test]
@@ -283,6 +295,7 @@ impl<'a> Arbitrary<'a> for Structs {
             i: relative::Height::arbitrary(u)?,
             j: relative::Time::arbitrary(u)?,
             k: Weight::arbitrary(u)?,
+            l: Timestamp::arbitrary(u)?,
         };
         Ok(a)
     }

From 5d38073afb4845f9806deaaa73b0b7ae0430ebb2 Mon Sep 17 00:00:00 2001
From: Liu-Cheng Xu <xuliuchengxlc@gmail.com>
Date: Tue, 25 Feb 2025 07:40:46 +0800
Subject: [PATCH 396/554] Fix `is_invalid_use_of_sighash_single()`
 incompatibility with Bitcoin Core

---
 bitcoin/src/crypto/sighash.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 5498211a04..32854bb85d 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -429,6 +429,16 @@ impl EcdsaSighashType {
         }
     }
 
+    /// Checks if the sighash type is [`Self::Single`] or [`Self::SinglePlusAnyoneCanPay`].
+    ///
+    /// This matches Bitcoin Core's behavior where SIGHASH_SINGLE bug check is based on the base
+    /// type (after masking with 0x1f), regardless of the ANYONECANPAY flag.
+    ///
+    /// See: <https://github.com/bitcoin/bitcoin/blob/e486597/src/script/interpreter.cpp#L1618-L1619>
+    pub fn is_single(&self) -> bool {
+        matches!(self, Self::Single | Self::SinglePlusAnyoneCanPay)
+    }
+
     /// Constructs a new [`EcdsaSighashType`] from a raw `u32`.
     ///
     /// **Note**: this replicates consensus behaviour, for current standardness rules correctness
@@ -1360,7 +1370,7 @@ impl std::error::Error for AnnexError {
 
 fn is_invalid_use_of_sighash_single(sighash: u32, input_index: usize, outputs_len: usize) -> bool {
     let ty = EcdsaSighashType::from_consensus(sighash);
-    ty == EcdsaSighashType::Single && input_index >= outputs_len
+    ty.is_single() && input_index >= outputs_len
 }
 
 /// Result of [`SighashCache::legacy_encode_signing_data_to`].

From 7ab2f5be4076c22e60eefcaa943444808eae3e3f Mon Sep 17 00:00:00 2001
From: Liu-Cheng Xu <xuliuchengxlc@gmail.com>
Date: Tue, 25 Feb 2025 07:38:36 +0800
Subject: [PATCH 397/554] Add test for sighash_single_bug incompatility fix

---
 bitcoin/src/crypto/sighash.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 32854bb85d..7167f64f09 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1545,8 +1545,6 @@ mod tests {
 
     #[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,
@@ -1557,10 +1555,16 @@ mod tests {
         let script = ScriptBuf::new();
         let cache = SighashCache::new(&tx);
 
-        let got = cache.legacy_signature_hash(1, &script, SIGHASH_SINGLE).expect("sighash");
+        let sighash_single = 3;
+        let got = cache.legacy_signature_hash(1, &script, sighash_single).expect("sighash");
         let want = LegacySighash::from_byte_array(UINT256_ONE);
+        assert_eq!(got, want);
 
-        assert_eq!(got, want)
+        // https://github.com/rust-bitcoin/rust-bitcoin/issues/4112
+        let sighash_single = 131;
+        let got = cache.legacy_signature_hash(1, &script, sighash_single).expect("sighash");
+        let want = LegacySighash::from_byte_array(UINT256_ONE);
+        assert_eq!(got, want);
     }
 
     #[test]

From 2d6ee57d9c67a49a39eaf89781129a63c7d05e1a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 25 Feb 2025 19:35:43 +1100
Subject: [PATCH 398/554] Grab missing changelog

We release `v0.32.4` and `v0.32.5` already but forgot to merge the
changelog entries back into master.

Grab the missing changelog entries from the `0.32.x` release branch.
---
 bitcoin/CHANGELOG.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/bitcoin/CHANGELOG.md b/bitcoin/CHANGELOG.md
index 3684890090..0972ca23b7 100644
--- a/bitcoin/CHANGELOG.md
+++ b/bitcoin/CHANGELOG.md
@@ -121,6 +121,20 @@ For changes to our dependencies included in this release see:
 - Change `TxIn::default()` to `TxIn::EMPTY_COINBASE` if appropriate.
 - Change `to_raw_hash()` to `to_byte_array()`.
 - `bitcoin::error::UnprefixedHexError` moved to `bitcoin::parse::UnprefixedHexError`.
+# 0.32.5 - 2024-11-27
+
+- Backport - Re-export `bech32` crate [#3662](https://github.com/rust-bitcoin/rust-bitcoin/pull/3662)
+- Backport - Add API for extracting the inner payload of `RawNetworkMessage` [#3523](https://github.com/rust-bitcoin/rust-bitcoin/pull/3523)
+- Backport - Fix bug in witness stack getters [#3626](https://github.com/rust-bitcoin/rust-bitcoin/pull/3626)
+- Backport - address: Add `Address::into_unchecked` [#3655](https://github.com/rust-bitcoin/rust-bitcoin/pull/3655)
+
+# 0.32.4 - 2024-10-24
+
+- Bound decode methods on `Read`, rather than `BufRead` [#3173](https://github.com/rust-bitcoin/rust-bitcoin/pull/3173)
+- Backport - Some additional inspectors on `Script` and `Witness` [#2646](https://github.com/rust-bitcoin/rust-bitcoin/pull/2646)
+- Backport - Add difficulty adjustment calculation [#3494](https://github.com/rust-bitcoin/rust-bitcoin/pull/3494)
+- Backport - Add testnet 4 support [#3453](https://github.com/rust-bitcoin/rust-bitcoin/pull/3453)
+- Backport - CI: Copy main workflow from master [#3418](https://github.com/rust-bitcoin/rust-bitcoin/pull/3418)
 
 # 0.32.3 - 2024-09-27
 

From f7c28ab44d0817f55679c5af4a01c8ad3e5aad1f Mon Sep 17 00:00:00 2001
From: leopardracer <136604165+leopardracer@users.noreply.github.com>
Date: Tue, 25 Feb 2025 12:03:03 +0200
Subject: [PATCH 399/554] Update input_string.rs

---
 internals/src/error/input_string.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internals/src/error/input_string.rs b/internals/src/error/input_string.rs
index 817d20e436..b544c73452 100644
--- a/internals/src/error/input_string.rs
+++ b/internals/src/error/input_string.rs
@@ -95,7 +95,7 @@ impl_from!(&str);
 ///
 /// 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
+/// error [`Display`](fmt::Display) implementation 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,

From 0e70e85a1a71b5df30e7bbf044f1fa0a4c758c65 Mon Sep 17 00:00:00 2001
From: leopardracer <136604165+leopardracer@users.noreply.github.com>
Date: Tue, 25 Feb 2025 12:03:35 +0200
Subject: [PATCH 400/554] Update key.rs

---
 bitcoin/src/crypto/key.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 1b3c3a4843..1fd74b1a58 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -324,7 +324,7 @@ impl CompressedPublicKey {
 
     /// Serializes the public key.
     ///
-    /// As the type name suggests, the key is serialzied in compressed format.
+    /// As the type name suggests, the key is serialized in compressed format.
     ///
     /// Note that this can be used as a sort key to get BIP67-compliant sorting.
     /// That's why this type doesn't have the `to_sort_key` method - it would duplicate this one.

From fc4ea874298e8a350fa1c29eecd9109c76f24869 Mon Sep 17 00:00:00 2001
From: leopardracer <136604165+leopardracer@users.noreply.github.com>
Date: Tue, 25 Feb 2025 12:10:23 +0200
Subject: [PATCH 401/554] Update transaction.rs

---
 bitcoin/src/blockdata/transaction.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 0979171ff3..9a3707d5d8 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -999,7 +999,7 @@ impl InputWeightPrediction {
     ///
     /// # Panics
     ///
-    /// The funcion panics in const context and debug builds if `bytes_to_grind` is higher than 62.
+    /// The function 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 {
@@ -1019,7 +1019,7 @@ impl InputWeightPrediction {
     ///
     /// # Panics
     ///
-    /// The funcion panics in const context and debug builds if `bytes_to_grind` is higher than 62.
+    /// The function panics in const context and debug builds if `bytes_to_grind` is higher than 62.
     ///
     /// [nested P2WPKH]: https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#p2wpkh-nested-in-bip16-p2sh
     /// [signature grinding]: https://bitcoin.stackexchange.com/questions/111660/what-is-signature-grinding
@@ -1040,7 +1040,7 @@ impl InputWeightPrediction {
     ///
     /// # Panics
     ///
-    /// The funcion panics in const context and debug builds if `bytes_to_grind` is higher than 62.
+    /// The function 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_p2pkh_compressed(bytes_to_grind: usize) -> Self {

From 83bd83385e0bbad993f96f5abbe51f71d199aad1 Mon Sep 17 00:00:00 2001
From: leopardracer <136604165+leopardracer@users.noreply.github.com>
Date: Tue, 25 Feb 2025 12:10:51 +0200
Subject: [PATCH 402/554] Update sighash.rs

---
 bitcoin/examples/sighash.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index 4f1f4d441a..bc29bbda76 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -155,7 +155,7 @@ fn sighash_p2wpkh() {
 }
 
 fn sighash_p2sh_multisig_2x2() {
-    //Spending transactoin:
+    //Spending transaction:
     //bitcoin-cli getrawtransaction 214646c4b563cd8c788754ec94468ab71602f5ed07d5e976a2b0e41a413bcc0e  3
     //after decoding ScriptSig from the input:0, its last ASM element is the scriptpubkey:
     //bitcoin-cli decodescript 5221032d7306898e980c66aefdfb6b377eaf71597c449bf9ce741a3380c5646354f6de2103e8c742e1f283ef810c1cd0c8875e5c2998a05fc5b23c30160d3d33add7af565752ae

From 083a33af85d6e6fb9080049b21fd3ddeb79a63de Mon Sep 17 00:00:00 2001
From: costcould <fliter@myyahoo.com>
Date: Wed, 26 Feb 2025 00:13:07 +0800
Subject: [PATCH 403/554] chore: remove redundant words in CONTRIBUTING.md

Signed-off-by: costcould <fliter@myyahoo.com>
---
 CONTRIBUTING.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c759dfa3ee..98107dc615 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -130,7 +130,7 @@ adhere to the ideas presented in the following two blog posts:
 Whenever any part of your code wants to mention the version number the code will
 be released in, primarily in deprecation notices, you should use the string
 `TBD` (verbatim), so that the release preparation script can detect the
-change and the correct version number can be filled in in preparation of the
+change and the correct version number can be filled in preparation of the
 release.
 
 ```rust
@@ -360,7 +360,7 @@ All errors that live in an `error` module (eg, `foo/error.rs`) and appear in a p
 
 With respect to `expect` messages, they should follow the
 [Rust standard library guidelines](https://doc.rust-lang.org/std/option/enum.Option.html#recommended-message-style).
-More specifically, `expect` messages should be used to to describe the reason
+More specifically, `expect` messages should be used to describe the reason
 you expect the operation to succeed.
 For example, this `expect` message clearly states why the operation should succeed:
 

From c90559de8e96172abf0ef1abf8ba55eefcc46f66 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 17 Feb 2025 14:25:21 +1100
Subject: [PATCH 404/554] Derive Copy for NumOpResult

The `NumOpResult` type is way more ergonomic to use if it derives
`Copy`. This restricts the `NumOpResult` to being `Copy` as well.

This does restrict what we can include in the error type in the future.

Derive Copy for `NumOpResult` and `NumOpResult`.
---
 units/src/amount/result.rs |  4 +--
 units/src/amount/tests.rs  | 52 +++++++++++++++++++-------------------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 645b3edde8..df26be7c74 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -12,7 +12,7 @@ use super::{Amount, SignedAmount};
 /// Result of an operation on [`Amount`] or [`SignedAmount`].
 ///
 /// The type parameter `T` should be normally `Amout` or `SignedAmount`.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[must_use]
 pub enum NumOpResult<T> {
     /// Result of a successful mathematical operation.
@@ -584,7 +584,7 @@ impl OptionExt<SignedAmount> for Option<SignedAmount> {
 }
 
 /// An error occurred while doing a mathematical operation.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub struct NumOpError;
 
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index f5b450fdb8..fa2db48749 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1329,44 +1329,44 @@ fn amount_op_result_all_ops() {
     // let sres: NumOpResult<SignedAmount> = ssat + ssat;
 
     // Operations that where RHS is the result of another operation.
-    let _ = sat + res.clone();
-    let _ = &sat + res.clone();
-    // let _ = sat + &res.clone();
-    // let _ = &sat + &res.clone();
+    let _ = sat + res;
+    let _ = &sat + res;
+    // let _ = sat + &res;
+    // let _ = &sat + &res;
 
-    let _ = sat - res.clone();
-    let _ = &sat - res.clone();
-    // let _ = sat - &res.clone();
-    // let _ = &sat - &res.clone();
+    let _ = sat - res;
+    let _ = &sat - res;
+    // let _ = sat - &res;
+    // let _ = &sat - &res;
 
     // Operations that where LHS is the result of another operation.
-    let _ = res.clone() + sat;
-    // let _ = &res.clone() + sat;
-    let _ = res.clone() + &sat;
-    // let _ = &res.clone() + &sat;
+    let _ = res + sat;
+    // let _ = &res + sat;
+    let _ = res + &sat;
+    // let _ = &res + &sat;
 
-    let _ = res.clone() - sat;
-    // let _ = &res.clone() - sat;
-    let _ = res.clone() - &sat;
-    // let _ = &res.clone() - &sat;
+    let _ = res - sat;
+    // let _ = &res - sat;
+    let _ = res - &sat;
+    // let _ = &res - &sat;
 
     // Operations that where both sides are the result of another operation.
-    let _ = res.clone() + res.clone();
-    // let _ = &res.clone() + res.clone();
-    // let _ = res.clone() + &res.clone();
-    // let _ = &res.clone() + &res.clone();
-
-    let _ = res.clone() - res.clone();
-    // let _ = &res.clone() - res.clone();
-    // let _ = res.clone() - &res.clone();
-    // let _ = &res.clone() - &res.clone();
+    let _ = res + res;
+    // let _ = &res + res;
+    // let _ = res + &res;
+    // let _ = &res + &res;
+
+    let _ = res - res;
+    // let _ = &res - res;
+    // let _ = res - &res;
+    // let _ = &res - &res;
 }
 
 // Verify we have implemented all `Sum` for the `NumOpResult` type.
 #[test]
 fn amount_op_result_sum() {
     let res = Amount::from_sat(1) + Amount::from_sat(1);
-    let amounts = [res.clone(), res.clone()];
+    let amounts = [res, res];
     let amount_refs = [&res, &res];
 
     // Sum iterators.

From 2da332e04a7092aa8430f2383b7162775fc27924 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Feb 2025 15:15:49 +0000
Subject: [PATCH 405/554] units: introduce impl_op_for_references and use it in
 three places

This macro can generally handle a lot of different cases where we
implement "the same trait but on references". We introduce it here and
use it in two places. We will use it in many more, but I wanted to make
the diff small on this commit, which introduces the actual macro code
and might take a bit of reading to understand.

You may want to use --color-moved-ws=allow-indentation-change to review
this, and the next commit.

The next set of changes will mechanically delete other macros that are
made redundant by this.
---
 units/src/amount/result.rs   | 31 +++++++++++----------
 units/src/internal_macros.rs | 53 ++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 15 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index df26be7c74..a8582a5e1a 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -123,23 +123,23 @@ impl From<&SignedAmount> for NumOpResult<SignedAmount> {
     fn from(a: &SignedAmount) -> Self { Self::Valid(*a) }
 }
 
-impl ops::Add for Amount {
-    type Output = NumOpResult<Amount>;
+crate::internal_macros::impl_op_for_references! {
+    impl ops::Add<Amount> for Amount {
+        type Output = NumOpResult<Amount>;
 
-    fn add(self, rhs: Amount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
+        fn add(self, rhs: Amount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
+    }
 }
-crate::internal_macros::impl_add_for_amount_references!(Amount);
 
-impl ops::Add<NumOpResult<Amount>> for Amount {
-    type Output = NumOpResult<Amount>;
+crate::internal_macros::impl_op_for_references! {
+    impl ops::Add<NumOpResult<Amount>> for Amount {
+        type Output = NumOpResult<Amount>;
 
-    fn add(self, rhs: NumOpResult<Amount>) -> Self::Output { rhs.and_then(|a| a + self) }
+        fn add(self, rhs: NumOpResult<Amount>) -> Self::Output { rhs.and_then(|a| a + self) }
+    }
 }
-impl ops::Add<NumOpResult<Amount>> for &Amount {
-    type Output = NumOpResult<Amount>;
 
-    fn add(self, rhs: NumOpResult<Amount>) -> Self::Output { rhs.and_then(|a| a + self) }
-}
+// FIXME these two should be covered by generic impls below
 impl ops::Add<Amount> for NumOpResult<Amount> {
     type Output = NumOpResult<Amount>;
 
@@ -151,12 +151,13 @@ impl ops::Add<&Amount> for NumOpResult<Amount> {
     fn add(self, rhs: &Amount) -> Self::Output { rhs + self }
 }
 
-impl ops::Sub for Amount {
-    type Output = NumOpResult<Amount>;
+crate::internal_macros::impl_op_for_references! {
+    impl ops::Sub<Amount> for Amount {
+        type Output = NumOpResult<Amount>;
 
-    fn sub(self, rhs: Amount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
+        fn sub(self, rhs: Amount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
+    }
 }
-crate::internal_macros::impl_sub_for_amount_references!(Amount);
 
 impl ops::Sub<NumOpResult<Amount>> for Amount {
     type Output = NumOpResult<Amount>;
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
index 1bae689861..d651675185 100644
--- a/units/src/internal_macros.rs
+++ b/units/src/internal_macros.rs
@@ -4,6 +4,59 @@
 //!
 //! Macros meant to be used inside the `bitcoin-units` library.
 
+/// Implements an opcode for various reference combinations.
+///
+/// Given `$ty`, assumes the `$op_trait<$other_ty>` trait is implemented on it,
+/// and implements the same trait with the full matrix of `&$ty` and `&$other_ty`:
+///
+/// - `Add<$other_ty> for &$ty`
+/// - `Add<&$other_ty> for $ty`
+/// - `Add<&$other_ty> for &$ty`
+///
+/// # Limitations
+///
+/// You must specify `$other_ty` and you may not use `Self`. So e.g. you need
+/// to write `impl ops::Add<Amount> for Amount { ... }` when calling this macro.
+macro_rules! impl_op_for_references {
+    (
+        impl $($op_trait:ident)::+<$other_ty:ty> for $ty:ty {
+            type Output = $($main_output:ty)*;
+            fn $op:ident($($main_args:tt)*) -> Self::Output {
+                $($main_impl:tt)*
+            }
+        }
+    ) => {
+        impl $($op_trait)::+<$other_ty> for $ty {
+            type Output = $($main_output)*;
+            fn $op($($main_args)*) -> Self::Output {
+                $($main_impl)*
+            }
+        }
+
+        impl $($op_trait)::+<$other_ty> for &$ty {
+            type Output = <$ty as $($op_trait)::+<$other_ty>>::Output;
+            fn $op(self, rhs: $other_ty) -> Self::Output {
+                (*self).$op(rhs)
+            }
+        }
+
+        impl $($op_trait)::+<&$other_ty> for $ty {
+            type Output = <$ty as $($op_trait)::+<$other_ty>>::Output;
+            fn $op(self, rhs: &$other_ty) -> Self::Output {
+                self.$op(*rhs)
+            }
+        }
+
+        impl<'a> $($op_trait)::+<&'a $other_ty> for &$ty {
+            type Output = <$ty as $($op_trait)::+<$other_ty>>::Output;
+            fn $op(self, rhs: &$other_ty) -> Self::Output {
+                (*self).$op(*rhs)
+            }
+        }
+    };
+}
+pub(crate) use impl_op_for_references;
+
 /// Implements `ops::Add` for various references.
 ///
 /// Requires `$ty` it implement `Add` e.g. 'impl Add<T> for T'. Adds impls of:

From a358e79a85b0677fc5a51de980add87c4f28cf41 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Feb 2025 15:55:14 +0000
Subject: [PATCH 406/554] units: allow multiple invocations in
 impl_op_for_references macro

This is not too complicated a change to support and it will reduce the
noise in the following commits a fair bit.
---
 units/src/amount/result.rs   | 2 --
 units/src/internal_macros.rs | 6 +++---
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index a8582a5e1a..4d052ff6ba 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -129,9 +129,7 @@ crate::internal_macros::impl_op_for_references! {
 
         fn add(self, rhs: Amount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
     }
-}
 
-crate::internal_macros::impl_op_for_references! {
     impl ops::Add<NumOpResult<Amount>> for Amount {
         type Output = NumOpResult<Amount>;
 
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
index d651675185..d5d0f14d1c 100644
--- a/units/src/internal_macros.rs
+++ b/units/src/internal_macros.rs
@@ -18,14 +18,14 @@
 /// You must specify `$other_ty` and you may not use `Self`. So e.g. you need
 /// to write `impl ops::Add<Amount> for Amount { ... }` when calling this macro.
 macro_rules! impl_op_for_references {
-    (
+    ($(
         impl $($op_trait:ident)::+<$other_ty:ty> for $ty:ty {
             type Output = $($main_output:ty)*;
             fn $op:ident($($main_args:tt)*) -> Self::Output {
                 $($main_impl:tt)*
             }
         }
-    ) => {
+    )+) => {$(
         impl $($op_trait)::+<$other_ty> for $ty {
             type Output = $($main_output)*;
             fn $op($($main_args)*) -> Self::Output {
@@ -53,7 +53,7 @@ macro_rules! impl_op_for_references {
                 (*self).$op(*rhs)
             }
         }
-    };
+    )+};
 }
 pub(crate) use impl_op_for_references;
 

From 0dc7f6cebdf92e14b73b1e74639f9cce531f5847 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Feb 2025 16:20:17 +0000
Subject: [PATCH 407/554] units: rearrange a bit of code to prep the next
 commit

The next commit changes a lot of code, but almost entirely by moving and
indenting it. We try to do the moves here ahead of time, so it the diff
for the next commit will be just deletions and indentations.
---
 units/src/amount/result.rs | 28 ++++++++++++++--------------
 units/src/fee_rate/mod.rs  |  6 +++---
 units/src/weight.rs        |  6 +++---
 3 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 4d052ff6ba..98ad8df4f9 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -137,18 +137,6 @@ crate::internal_macros::impl_op_for_references! {
     }
 }
 
-// FIXME these two should be covered by generic impls below
-impl ops::Add<Amount> for NumOpResult<Amount> {
-    type Output = NumOpResult<Amount>;
-
-    fn add(self, rhs: Amount) -> Self::Output { rhs + self }
-}
-impl ops::Add<&Amount> for NumOpResult<Amount> {
-    type Output = NumOpResult<Amount>;
-
-    fn add(self, rhs: &Amount) -> Self::Output { rhs + self }
-}
-
 crate::internal_macros::impl_op_for_references! {
     impl ops::Sub<Amount> for Amount {
         type Output = NumOpResult<Amount>;
@@ -261,7 +249,19 @@ impl ops::Rem<&u64> for &Amount {
     fn rem(self, modulus: &u64) -> Self::Output { (*self).rem(*modulus) }
 }
 
-impl ops::Add for SignedAmount {
+// FIXME these two should be covered by generic impls below
+impl ops::Add<Amount> for NumOpResult<Amount> {
+    type Output = NumOpResult<Amount>;
+
+    fn add(self, rhs: Amount) -> Self::Output { rhs + self }
+}
+impl ops::Add<&Amount> for NumOpResult<Amount> {
+    type Output = NumOpResult<Amount>;
+
+    fn add(self, rhs: &Amount) -> Self::Output { rhs + self }
+}
+
+impl ops::Add<SignedAmount> for SignedAmount {
     type Output = NumOpResult<SignedAmount>;
 
     fn add(self, rhs: SignedAmount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
@@ -289,7 +289,7 @@ impl ops::Add<&SignedAmount> for NumOpResult<SignedAmount> {
     fn add(self, rhs: &SignedAmount) -> Self::Output { rhs + self }
 }
 
-impl ops::Sub for SignedAmount {
+impl ops::Sub<SignedAmount> for SignedAmount {
     type Output = NumOpResult<SignedAmount>;
 
     fn sub(self, rhs: SignedAmount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
diff --git a/units/src/fee_rate/mod.rs b/units/src/fee_rate/mod.rs
index f9dca7b870..1579578cce 100644
--- a/units/src/fee_rate/mod.rs
+++ b/units/src/fee_rate/mod.rs
@@ -135,20 +135,20 @@ impl From<FeeRate> for u64 {
     fn from(value: FeeRate) -> Self { value.to_sat_per_kwu() }
 }
 
-impl ops::Add for FeeRate {
+impl ops::Add<FeeRate> for FeeRate {
     type Output = FeeRate;
 
     fn add(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
 }
 crate::internal_macros::impl_add_for_references!(FeeRate);
-crate::internal_macros::impl_add_assign!(FeeRate);
 
-impl ops::Sub for FeeRate {
+impl ops::Sub<FeeRate> for FeeRate {
     type Output = FeeRate;
 
     fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
 }
 crate::internal_macros::impl_sub_for_references!(FeeRate);
+crate::internal_macros::impl_add_assign!(FeeRate);
 crate::internal_macros::impl_sub_assign!(FeeRate);
 
 impl core::iter::Sum for FeeRate {
diff --git a/units/src/weight.rs b/units/src/weight.rs
index df654e9d41..a1ea4fa800 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -166,20 +166,20 @@ impl From<Weight> for u64 {
     fn from(value: Weight) -> Self { value.to_wu() }
 }
 
-impl ops::Add for Weight {
+impl ops::Add<Weight> for Weight {
     type Output = Weight;
 
     fn add(self, rhs: Weight) -> Self::Output { Weight(self.0 + rhs.0) }
 }
 crate::internal_macros::impl_add_for_references!(Weight);
-crate::internal_macros::impl_add_assign!(Weight);
 
-impl ops::Sub for Weight {
+impl ops::Sub<Weight> for Weight {
     type Output = Weight;
 
     fn sub(self, rhs: Weight) -> Self::Output { Weight(self.0 - rhs.0) }
 }
 crate::internal_macros::impl_sub_for_references!(Weight);
+crate::internal_macros::impl_add_assign!(Weight);
 crate::internal_macros::impl_sub_assign!(Weight);
 
 impl ops::Mul<u64> for Weight {

From ad9564895b2ada7bd0ff510a91986b9b02a45ca8 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Feb 2025 16:24:05 +0000
Subject: [PATCH 408/554] units: replace a gazillion more macro calls with new
 macro

Looks like a large diff but if you run

    git show --color-moved-ws=allow-indentation-change

you will see that it's 100% moves (though moves of code into the
reference macro). May be easier to just look at src/amount/result.rs
after this; it's pretty short now.
---
 units/src/amount/result.rs   | 298 +++++++++--------------------------
 units/src/fee_rate/mod.rs    |  18 +--
 units/src/internal_macros.rs | 120 --------------
 units/src/weight.rs          |  58 ++++---
 4 files changed, 109 insertions(+), 385 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 98ad8df4f9..67f76a6c26 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -135,269 +135,117 @@ crate::internal_macros::impl_op_for_references! {
 
         fn add(self, rhs: NumOpResult<Amount>) -> Self::Output { rhs.and_then(|a| a + self) }
     }
-}
 
-crate::internal_macros::impl_op_for_references! {
     impl ops::Sub<Amount> for Amount {
         type Output = NumOpResult<Amount>;
 
         fn sub(self, rhs: Amount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
     }
-}
 
-impl ops::Sub<NumOpResult<Amount>> for Amount {
-    type Output = NumOpResult<Amount>;
+    impl ops::Sub<NumOpResult<Amount>> for Amount {
+        type Output = NumOpResult<Amount>;
 
-    fn sub(self, rhs: NumOpResult<Amount>) -> Self::Output {
-        match rhs {
-            R::Valid(amount) => self - amount,
-            R::Error(_) => rhs,
+        fn sub(self, rhs: NumOpResult<Amount>) -> Self::Output {
+            match rhs {
+                R::Valid(amount) => self - amount,
+                R::Error(_) => rhs,
+            }
         }
     }
-}
-impl ops::Sub<NumOpResult<Amount>> for &Amount {
-    type Output = NumOpResult<Amount>;
 
-    fn sub(self, rhs: NumOpResult<Amount>) -> Self::Output {
-        match rhs {
-            R::Valid(amount) => self - amount,
-            R::Error(_) => rhs,
-        }
-    }
-}
-impl ops::Sub<Amount> for NumOpResult<Amount> {
-    type Output = NumOpResult<Amount>;
+    impl ops::Mul<u64> for Amount {
+        type Output = NumOpResult<Amount>;
 
-    fn sub(self, rhs: Amount) -> Self::Output {
-        match self {
-            R::Valid(amount) => amount - rhs,
-            R::Error(_) => self,
-        }
+        fn mul(self, rhs: u64) -> Self::Output { self.checked_mul(rhs).valid_or_error() }
     }
-}
-impl ops::Sub<&Amount> for NumOpResult<Amount> {
-    type Output = NumOpResult<Amount>;
+    impl ops::Div<u64> for Amount {
+        type Output = NumOpResult<Amount>;
 
-    fn sub(self, rhs: &Amount) -> Self::Output {
-        match self {
-            R::Valid(amount) => amount - (*rhs),
-            R::Error(_) => self,
-        }
+        fn div(self, rhs: u64) -> Self::Output { self.checked_div(rhs).valid_or_error() }
     }
-}
-
-impl ops::Mul<u64> for Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn mul(self, rhs: u64) -> Self::Output { self.checked_mul(rhs).valid_or_error() }
-}
-impl ops::Mul<&u64> for Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn mul(self, rhs: &u64) -> Self::Output { self.mul(*rhs) }
-}
-impl ops::Mul<u64> for &Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn mul(self, rhs: u64) -> Self::Output { (*self).mul(rhs) }
-}
-impl ops::Mul<&u64> for &Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn mul(self, rhs: &u64) -> Self::Output { self.mul(*rhs) }
-}
-
-impl ops::Div<u64> for Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn div(self, rhs: u64) -> Self::Output { self.checked_div(rhs).valid_or_error() }
-}
-impl ops::Div<&u64> for Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn div(self, rhs: &u64) -> Self::Output { self.div(*rhs) }
-}
-impl ops::Div<u64> for &Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn div(self, rhs: u64) -> Self::Output { (*self).div(rhs) }
-}
-impl ops::Div<&u64> for &Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn div(self, rhs: &u64) -> Self::Output { (*self).div(*rhs) }
-}
-
-impl ops::Rem<u64> for Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn rem(self, modulus: u64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
-}
-impl ops::Rem<&u64> for Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn rem(self, modulus: &u64) -> Self::Output { self.rem(*modulus) }
-}
-impl ops::Rem<u64> for &Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn rem(self, modulus: u64) -> Self::Output { (*self).rem(modulus) }
-}
-impl ops::Rem<&u64> for &Amount {
-    type Output = NumOpResult<Amount>;
-
-    fn rem(self, modulus: &u64) -> Self::Output { (*self).rem(*modulus) }
-}
-
-// FIXME these two should be covered by generic impls below
-impl ops::Add<Amount> for NumOpResult<Amount> {
-    type Output = NumOpResult<Amount>;
-
-    fn add(self, rhs: Amount) -> Self::Output { rhs + self }
-}
-impl ops::Add<&Amount> for NumOpResult<Amount> {
-    type Output = NumOpResult<Amount>;
-
-    fn add(self, rhs: &Amount) -> Self::Output { rhs + self }
-}
-
-impl ops::Add<SignedAmount> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
-
-    fn add(self, rhs: SignedAmount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
-}
-crate::internal_macros::impl_add_for_amount_references!(SignedAmount);
-
-impl ops::Add<NumOpResult<SignedAmount>> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
-
-    fn add(self, rhs: NumOpResult<SignedAmount>) -> Self::Output { rhs.and_then(|a| a + self) }
-}
-impl ops::Add<NumOpResult<SignedAmount>> for &SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
-
-    fn add(self, rhs: NumOpResult<SignedAmount>) -> Self::Output { rhs.and_then(|a| a + self) }
-}
-impl ops::Add<SignedAmount> for NumOpResult<SignedAmount> {
-    type Output = NumOpResult<SignedAmount>;
-
-    fn add(self, rhs: SignedAmount) -> Self::Output { rhs + self }
-}
-impl ops::Add<&SignedAmount> for NumOpResult<SignedAmount> {
-    type Output = NumOpResult<SignedAmount>;
-
-    fn add(self, rhs: &SignedAmount) -> Self::Output { rhs + self }
-}
-
-impl ops::Sub<SignedAmount> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
-
-    fn sub(self, rhs: SignedAmount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
-}
-crate::internal_macros::impl_sub_for_amount_references!(SignedAmount);
-
-impl ops::Sub<NumOpResult<SignedAmount>> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+    impl ops::Rem<u64> for Amount {
+        type Output = NumOpResult<Amount>;
 
-    fn sub(self, rhs: NumOpResult<SignedAmount>) -> Self::Output {
-        match rhs {
-            R::Valid(amount) => amount - rhs,
-            R::Error(_) => rhs,
-        }
+        fn rem(self, modulus: u64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
     }
-}
-impl ops::Sub<NumOpResult<SignedAmount>> for &SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
 
-    fn sub(self, rhs: NumOpResult<SignedAmount>) -> Self::Output {
-        match rhs {
-            R::Valid(amount) => amount - rhs,
-            R::Error(_) => rhs,
-        }
-    }
-}
-impl ops::Sub<SignedAmount> for NumOpResult<SignedAmount> {
-    type Output = NumOpResult<SignedAmount>;
+    // FIXME these two should be covered by generic impls below
+    impl ops::Add<Amount> for NumOpResult<Amount> {
+        type Output = NumOpResult<Amount>;
 
-    fn sub(self, rhs: SignedAmount) -> Self::Output {
-        match self {
-            R::Valid(amount) => amount - rhs,
-            R::Error(_) => self,
-        }
+        fn add(self, rhs: Amount) -> Self::Output { rhs + self }
     }
-}
-impl ops::Sub<&SignedAmount> for NumOpResult<SignedAmount> {
-    type Output = NumOpResult<SignedAmount>;
+    impl ops::Sub<Amount> for NumOpResult<Amount> {
+        type Output = NumOpResult<Amount>;
 
-    fn sub(self, rhs: &SignedAmount) -> Self::Output {
-        match self {
-            R::Valid(amount) => amount - *rhs,
-            R::Error(_) => self,
+        fn sub(self, rhs: Amount) -> Self::Output {
+            match self {
+                R::Valid(amount) => amount - rhs,
+                R::Error(_) => self,
+            }
         }
     }
-}
 
-impl ops::Mul<i64> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+    impl ops::Add<SignedAmount> for SignedAmount {
+        type Output = NumOpResult<SignedAmount>;
 
-    fn mul(self, rhs: i64) -> Self::Output { self.checked_mul(rhs).valid_or_error() }
-}
-impl ops::Mul<&i64> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+        fn add(self, rhs: SignedAmount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
+    }
 
-    fn mul(self, rhs: &i64) -> Self::Output { self.mul(*rhs) }
-}
-impl ops::Mul<i64> for &SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+    impl ops::Add<NumOpResult<SignedAmount>> for SignedAmount {
+        type Output = NumOpResult<SignedAmount>;
 
-    fn mul(self, rhs: i64) -> Self::Output { (*self).mul(rhs) }
-}
-impl ops::Mul<&i64> for &SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+        fn add(self, rhs: NumOpResult<SignedAmount>) -> Self::Output { rhs.and_then(|a| a + self) }
+    }
 
-    fn mul(self, rhs: &i64) -> Self::Output { self.mul(*rhs) }
-}
+    impl ops::Sub<SignedAmount> for SignedAmount {
+        type Output = NumOpResult<SignedAmount>;
 
-impl ops::Div<i64> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+        fn sub(self, rhs: SignedAmount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
+    }
+    impl ops::Sub<NumOpResult<SignedAmount>> for SignedAmount {
+        type Output = NumOpResult<SignedAmount>;
 
-    fn div(self, rhs: i64) -> Self::Output { self.checked_div(rhs).valid_or_error() }
-}
-impl ops::Div<&i64> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+        fn sub(self, rhs: NumOpResult<SignedAmount>) -> Self::Output {
+            match rhs {
+                R::Valid(amount) => amount - rhs,
+                R::Error(_) => rhs,
+            }
+        }
+    }
 
-    fn div(self, rhs: &i64) -> Self::Output { self.div(*rhs) }
-}
-impl ops::Div<i64> for &SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+    impl ops::Add<SignedAmount> for NumOpResult<SignedAmount> {
+        type Output = NumOpResult<SignedAmount>;
 
-    fn div(self, rhs: i64) -> Self::Output { (*self).div(rhs) }
-}
-impl ops::Div<&i64> for &SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+        fn add(self, rhs: SignedAmount) -> Self::Output { rhs + self }
+    }
 
-    fn div(self, rhs: &i64) -> Self::Output { (*self).div(*rhs) }
-}
+    impl ops::Sub<SignedAmount> for NumOpResult<SignedAmount> {
+        type Output = NumOpResult<SignedAmount>;
 
-impl ops::Rem<i64> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+        fn sub(self, rhs: SignedAmount) -> Self::Output {
+            match self {
+                R::Valid(amount) => amount - rhs,
+                R::Error(_) => self,
+            }
+        }
+    }
 
-    fn rem(self, modulus: i64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
-}
-impl ops::Rem<&i64> for SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+    impl ops::Mul<i64> for SignedAmount {
+        type Output = NumOpResult<SignedAmount>;
 
-    fn rem(self, modulus: &i64) -> Self::Output { self.rem(*modulus) }
-}
-impl ops::Rem<i64> for &SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+        fn mul(self, rhs: i64) -> Self::Output { self.checked_mul(rhs).valid_or_error() }
+    }
+    impl ops::Div<i64> for SignedAmount {
+        type Output = NumOpResult<SignedAmount>;
 
-    fn rem(self, modulus: i64) -> Self::Output { (*self).rem(modulus) }
-}
-impl ops::Rem<&i64> for &SignedAmount {
-    type Output = NumOpResult<SignedAmount>;
+        fn div(self, rhs: i64) -> Self::Output { self.checked_div(rhs).valid_or_error() }
+    }
+    impl ops::Rem<i64> for SignedAmount {
+        type Output = NumOpResult<SignedAmount>;
 
-    fn rem(self, modulus: &i64) -> Self::Output { (*self).rem(*modulus) }
+        fn rem(self, modulus: i64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
+    }
 }
 
 impl ops::Neg for SignedAmount {
diff --git a/units/src/fee_rate/mod.rs b/units/src/fee_rate/mod.rs
index 1579578cce..f3ec8fd7d9 100644
--- a/units/src/fee_rate/mod.rs
+++ b/units/src/fee_rate/mod.rs
@@ -135,19 +135,19 @@ impl From<FeeRate> for u64 {
     fn from(value: FeeRate) -> Self { value.to_sat_per_kwu() }
 }
 
-impl ops::Add<FeeRate> for FeeRate {
-    type Output = FeeRate;
+crate::internal_macros::impl_op_for_references! {
+    impl ops::Add<FeeRate> for FeeRate {
+        type Output = FeeRate;
 
-    fn add(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
-}
-crate::internal_macros::impl_add_for_references!(FeeRate);
+        fn add(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 + rhs.0) }
+    }
 
-impl ops::Sub<FeeRate> for FeeRate {
-    type Output = FeeRate;
+    impl ops::Sub<FeeRate> for FeeRate {
+        type Output = FeeRate;
 
-    fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
+        fn sub(self, rhs: FeeRate) -> Self::Output { FeeRate(self.0 - rhs.0) }
+    }
 }
-crate::internal_macros::impl_sub_for_references!(FeeRate);
 crate::internal_macros::impl_add_assign!(FeeRate);
 crate::internal_macros::impl_sub_assign!(FeeRate);
 
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
index d5d0f14d1c..668272aeb5 100644
--- a/units/src/internal_macros.rs
+++ b/units/src/internal_macros.rs
@@ -57,66 +57,6 @@ macro_rules! impl_op_for_references {
 }
 pub(crate) use impl_op_for_references;
 
-/// Implements `ops::Add` for various references.
-///
-/// Requires `$ty` it implement `Add` e.g. 'impl Add<T> for T'. Adds impls of:
-///
-/// - Add<T> for &T
-/// - Add<&T> for T
-/// - Add<&T> for &T
-macro_rules! impl_add_for_references {
-    ($ty:ident) => {
-        impl core::ops::Add<$ty> for &$ty {
-            type Output = $ty;
-
-            fn add(self, rhs: $ty) -> Self::Output { *self + rhs }
-        }
-
-        impl core::ops::Add<&$ty> for $ty {
-            type Output = $ty;
-
-            fn add(self, rhs: &$ty) -> Self::Output { self + *rhs }
-        }
-
-        impl<'a> core::ops::Add<&'a $ty> for &$ty {
-            type Output = $ty;
-
-            fn add(self, rhs: &'a $ty) -> Self::Output { *self + *rhs }
-        }
-    };
-}
-pub(crate) use impl_add_for_references;
-
-/// Implements `ops::Add` for various amount references.
-///
-/// Requires `$ty` it implement `Add` e.g. 'impl Add<T> for T'. Adds impls of:
-///
-/// - Add<T> for &T
-/// - Add<&T> for T
-/// - Add<&T> for &T
-macro_rules! impl_add_for_amount_references {
-    ($ty:ident) => {
-        impl core::ops::Add<$ty> for &$ty {
-            type Output = NumOpResult<$ty>;
-
-            fn add(self, rhs: $ty) -> Self::Output { *self + rhs }
-        }
-
-        impl core::ops::Add<&$ty> for $ty {
-            type Output = NumOpResult<$ty>;
-
-            fn add(self, rhs: &$ty) -> Self::Output { self + *rhs }
-        }
-
-        impl<'a> core::ops::Add<&'a $ty> for &$ty {
-            type Output = NumOpResult<$ty>;
-
-            fn add(self, rhs: &'a $ty) -> Self::Output { *self + *rhs }
-        }
-    };
-}
-pub(crate) use impl_add_for_amount_references;
-
 /// Implement `ops::AddAssign` for `$ty` and `&$ty`.
 macro_rules! impl_add_assign {
     ($ty:ident) => {
@@ -131,66 +71,6 @@ macro_rules! impl_add_assign {
 }
 pub(crate) use impl_add_assign;
 
-/// Implement `ops::Sub` for various references.
-///
-/// Requires `$ty` it implement `Sub` e.g. 'impl Sub<T> for T'. Adds impls of:
-///
-/// - Sub<T> for &T
-/// - Sub<&T> for T
-/// - Sub<&T> for &T
-macro_rules! impl_sub_for_references {
-    ($ty:ident) => {
-        impl core::ops::Sub<$ty> for &$ty {
-            type Output = $ty;
-
-            fn sub(self, rhs: $ty) -> Self::Output { *self - rhs }
-        }
-
-        impl core::ops::Sub<&$ty> for $ty {
-            type Output = $ty;
-
-            fn sub(self, rhs: &$ty) -> Self::Output { self - *rhs }
-        }
-
-        impl<'a> core::ops::Sub<&'a $ty> for &$ty {
-            type Output = $ty;
-
-            fn sub(self, rhs: &'a $ty) -> Self::Output { *self - *rhs }
-        }
-    };
-}
-pub(crate) use impl_sub_for_references;
-
-/// Implement `ops::Sub` for various amount references.
-///
-/// Requires `$ty` it implement `Sub` e.g. 'impl Sub<T> for T'. Adds impls of:
-///
-/// - Sub<T> for &T
-/// - Sub<&T> for T
-/// - Sub<&T> for &T
-macro_rules! impl_sub_for_amount_references {
-    ($ty:ident) => {
-        impl core::ops::Sub<$ty> for &$ty {
-            type Output = NumOpResult<$ty>;
-
-            fn sub(self, rhs: $ty) -> Self::Output { *self - rhs }
-        }
-
-        impl core::ops::Sub<&$ty> for $ty {
-            type Output = NumOpResult<$ty>;
-
-            fn sub(self, rhs: &$ty) -> Self::Output { self - *rhs }
-        }
-
-        impl<'a> core::ops::Sub<&'a $ty> for &$ty {
-            type Output = NumOpResult<$ty>;
-
-            fn sub(self, rhs: &'a $ty) -> Self::Output { *self - *rhs }
-        }
-    };
-}
-pub(crate) use impl_sub_for_amount_references;
-
 /// Implement `ops::SubAssign` for `$ty` and `&$ty`.
 macro_rules! impl_sub_assign {
     ($ty:ident) => {
diff --git a/units/src/weight.rs b/units/src/weight.rs
index a1ea4fa800..720dfd385b 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -166,50 +166,46 @@ impl From<Weight> for u64 {
     fn from(value: Weight) -> Self { value.to_wu() }
 }
 
-impl ops::Add<Weight> for Weight {
-    type Output = Weight;
+crate::internal_macros::impl_op_for_references! {
+    impl ops::Add<Weight> for Weight {
+        type Output = Weight;
 
-    fn add(self, rhs: Weight) -> Self::Output { Weight(self.0 + rhs.0) }
-}
-crate::internal_macros::impl_add_for_references!(Weight);
+        fn add(self, rhs: Weight) -> Self::Output { Weight(self.0 + rhs.0) }
+    }
+    impl ops::Sub<Weight> for Weight {
+        type Output = Weight;
 
-impl ops::Sub<Weight> for Weight {
-    type Output = Weight;
+        fn sub(self, rhs: Weight) -> Self::Output { Weight(self.0 - rhs.0) }
+    }
 
-    fn sub(self, rhs: Weight) -> Self::Output { Weight(self.0 - rhs.0) }
-}
-crate::internal_macros::impl_sub_for_references!(Weight);
-crate::internal_macros::impl_add_assign!(Weight);
-crate::internal_macros::impl_sub_assign!(Weight);
+    impl ops::Mul<u64> for Weight {
+        type Output = Weight;
 
-impl ops::Mul<u64> for Weight {
-    type Output = Weight;
+        fn mul(self, rhs: u64) -> Self::Output { Weight(self.0 * rhs) }
+    }
+    impl ops::Mul<Weight> for u64 {
+        type Output = Weight;
 
-    fn mul(self, rhs: u64) -> Self::Output { Weight(self.0 * rhs) }
-}
+        fn mul(self, rhs: Weight) -> Self::Output { Weight(self * rhs.0) }
+    }
+    impl ops::Div<u64> for Weight {
+        type Output = Weight;
 
-impl ops::Mul<Weight> for u64 {
-    type Output = Weight;
+        fn div(self, rhs: u64) -> Self::Output { Weight(self.0 / rhs) }
+    }
+    impl ops::Div<Weight> for Weight {
+        type Output = u64;
 
-    fn mul(self, rhs: Weight) -> Self::Output { Weight(self * rhs.0) }
+        fn div(self, rhs: Weight) -> Self::Output { self.to_wu() / rhs.to_wu() }
+    }
 }
+crate::internal_macros::impl_add_assign!(Weight);
+crate::internal_macros::impl_sub_assign!(Weight);
 
 impl ops::MulAssign<u64> for Weight {
     fn mul_assign(&mut self, rhs: u64) { self.0 *= rhs }
 }
 
-impl ops::Div<u64> for Weight {
-    type Output = Weight;
-
-    fn div(self, rhs: u64) -> Self::Output { Weight(self.0 / rhs) }
-}
-
-impl ops::Div<Weight> for Weight {
-    type Output = u64;
-
-    fn div(self, rhs: Weight) -> Self::Output { self.to_wu() / rhs.to_wu() }
-}
-
 impl ops::DivAssign<u64> for Weight {
     fn div_assign(&mut self, rhs: u64) { self.0 /= rhs }
 }

From 21ac5aefe0afb6863545b94b79cec46a09857cd4 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Feb 2025 19:58:15 +0000
Subject: [PATCH 409/554] units: extend op reference macro to handle generics
 and where clauses

This is a bit ugly and requires that we put our where-clauses in
parentheses because the macro_rules parser sucks, but it allows us to
move the blanket-impls on NumOpResult into the macro.

This commit moves one instance and updates the macro; the next commits
will change the rest.
---
 units/src/amount/result.rs   | 65 ++++++++----------------------------
 units/src/internal_macros.rs | 22 +++++++++---
 2 files changed, 30 insertions(+), 57 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 67f76a6c26..a526fbd0ba 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -246,65 +246,26 @@ crate::internal_macros::impl_op_for_references! {
 
         fn rem(self, modulus: i64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
     }
-}
-
-impl ops::Neg for SignedAmount {
-    type Output = Self;
-
-    fn neg(self) -> Self::Output { Self::from_sat(self.to_sat().neg()) }
-}
-
-impl<T> ops::Add for NumOpResult<T>
-where
-    T: ops::Add<Output = NumOpResult<T>>,
-{
-    type Output = NumOpResult<T>;
 
-    fn add(self, rhs: Self) -> Self::Output {
-        match (self, rhs) {
-            (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
-            (_, _) => R::Error(NumOpError {}),
-        }
-    }
-}
-impl<T> ops::Add<NumOpResult<T>> for &NumOpResult<T>
-where
-    T: ops::Add<Output = NumOpResult<T>> + Copy,
-{
-    type Output = NumOpResult<T>;
+    impl<T> ops::Add<NumOpResult<T>> for NumOpResult<T>
+    where
+        (T: Copy + ops::Add<Output = NumOpResult<T>>)
+    {
+        type Output = NumOpResult<T>;
 
-    fn add(self, rhs: NumOpResult<T>) -> Self::Output {
-        match (self, rhs) {
-            (R::Valid(lhs), R::Valid(rhs)) => *lhs + rhs,
-            (_, _) => R::Error(NumOpError {}),
+        fn add(self, rhs: Self) -> Self::Output {
+            match (self, rhs) {
+                (R::Valid(lhs), R::Valid(rhs)) => lhs + rhs,
+                (_, _) => R::Error(NumOpError {}),
+            }
         }
     }
 }
-impl<T> ops::Add<&NumOpResult<T>> for NumOpResult<T>
-where
-    T: ops::Add<Output = NumOpResult<T>> + Copy,
-{
-    type Output = NumOpResult<T>;
 
-    fn add(self, rhs: &NumOpResult<T>) -> Self::Output {
-        match (self, rhs) {
-            (R::Valid(lhs), R::Valid(rhs)) => lhs + *rhs,
-            (_, _) => R::Error(NumOpError {}),
-        }
-    }
-}
-impl<T> ops::Add for &NumOpResult<T>
-where
-    T: ops::Add<Output = NumOpResult<T>> + Copy,
-{
-    type Output = NumOpResult<T>;
+impl ops::Neg for SignedAmount {
+    type Output = Self;
 
-    fn add(self, rhs: &NumOpResult<T>) -> Self::Output {
-        match (self, rhs) {
-            (R::Valid(lhs), R::Valid(rhs)) => *lhs + *rhs,
-            (_, _) => R::Error(NumOpError {}),
-        }
-    }
+    fn neg(self) -> Self::Output { Self::from_sat(self.to_sat().neg()) }
 }
 
 impl<T> ops::Sub for NumOpResult<T>
diff --git a/units/src/internal_macros.rs b/units/src/internal_macros.rs
index 668272aeb5..c5f0ac6fcd 100644
--- a/units/src/internal_macros.rs
+++ b/units/src/internal_macros.rs
@@ -17,37 +17,49 @@
 ///
 /// You must specify `$other_ty` and you may not use `Self`. So e.g. you need
 /// to write `impl ops::Add<Amount> for Amount { ... }` when calling this macro.
+///
+/// Your where clause must include extra parenthesis, like `where (T: Copy)`.
 macro_rules! impl_op_for_references {
     ($(
-        impl $($op_trait:ident)::+<$other_ty:ty> for $ty:ty {
+        impl$(<$gen:ident>)? $($op_trait:ident)::+<$other_ty:ty> for $ty:ty
+        $(where ($($bounds:tt)*))?
+        {
             type Output = $($main_output:ty)*;
             fn $op:ident($($main_args:tt)*) -> Self::Output {
                 $($main_impl:tt)*
             }
         }
     )+) => {$(
-        impl $($op_trait)::+<$other_ty> for $ty {
+        impl$(<$gen>)?  $($op_trait)::+<$other_ty> for $ty
+        $(where $($bounds)*)?
+        {
             type Output = $($main_output)*;
             fn $op($($main_args)*) -> Self::Output {
                 $($main_impl)*
             }
         }
 
-        impl $($op_trait)::+<$other_ty> for &$ty {
+        impl$(<$gen>)?  $($op_trait)::+<$other_ty> for &$ty
+        $(where $($bounds)*)?
+        {
             type Output = <$ty as $($op_trait)::+<$other_ty>>::Output;
             fn $op(self, rhs: $other_ty) -> Self::Output {
                 (*self).$op(rhs)
             }
         }
 
-        impl $($op_trait)::+<&$other_ty> for $ty {
+        impl$(<$gen>)?  $($op_trait)::+<&$other_ty> for $ty
+        $(where $($bounds)*)?
+        {
             type Output = <$ty as $($op_trait)::+<$other_ty>>::Output;
             fn $op(self, rhs: &$other_ty) -> Self::Output {
                 self.$op(*rhs)
             }
         }
 
-        impl<'a> $($op_trait)::+<&'a $other_ty> for &$ty {
+        impl<'a, $($gen)?> $($op_trait)::+<&'a $other_ty> for &$ty
+        $(where $($bounds)*)?
+        {
             type Output = <$ty as $($op_trait)::+<$other_ty>>::Output;
             fn $op(self, rhs: &$other_ty) -> Self::Output {
                 (*self).$op(*rhs)

From 353c23fa0146bf01c1f4ca9af4b8fdc4a8f092ec Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Feb 2025 18:29:02 +0000
Subject: [PATCH 410/554] units: pull generic op impls on NumOpResult into
 macro

---
 units/src/amount/result.rs | 120 +++++++++++--------------------------
 1 file changed, 35 insertions(+), 85 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index a526fbd0ba..b2091a1b59 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -169,23 +169,6 @@ crate::internal_macros::impl_op_for_references! {
         fn rem(self, modulus: u64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
     }
 
-    // FIXME these two should be covered by generic impls below
-    impl ops::Add<Amount> for NumOpResult<Amount> {
-        type Output = NumOpResult<Amount>;
-
-        fn add(self, rhs: Amount) -> Self::Output { rhs + self }
-    }
-    impl ops::Sub<Amount> for NumOpResult<Amount> {
-        type Output = NumOpResult<Amount>;
-
-        fn sub(self, rhs: Amount) -> Self::Output {
-            match self {
-                R::Valid(amount) => amount - rhs,
-                R::Error(_) => self,
-            }
-        }
-    }
-
     impl ops::Add<SignedAmount> for SignedAmount {
         type Output = NumOpResult<SignedAmount>;
 
@@ -208,29 +191,12 @@ crate::internal_macros::impl_op_for_references! {
 
         fn sub(self, rhs: NumOpResult<SignedAmount>) -> Self::Output {
             match rhs {
-                R::Valid(amount) => amount - rhs,
+                R::Valid(amount) => self - amount,
                 R::Error(_) => rhs,
             }
         }
     }
 
-    impl ops::Add<SignedAmount> for NumOpResult<SignedAmount> {
-        type Output = NumOpResult<SignedAmount>;
-
-        fn add(self, rhs: SignedAmount) -> Self::Output { rhs + self }
-    }
-
-    impl ops::Sub<SignedAmount> for NumOpResult<SignedAmount> {
-        type Output = NumOpResult<SignedAmount>;
-
-        fn sub(self, rhs: SignedAmount) -> Self::Output {
-            match self {
-                R::Valid(amount) => amount - rhs,
-                R::Error(_) => self,
-            }
-        }
-    }
-
     impl ops::Mul<i64> for SignedAmount {
         type Output = NumOpResult<SignedAmount>;
 
@@ -260,65 +226,49 @@ crate::internal_macros::impl_op_for_references! {
             }
         }
     }
-}
 
-impl ops::Neg for SignedAmount {
-    type Output = Self;
+    impl<T> ops::Add<T> for NumOpResult<T>
+    where
+        (T: Copy + ops::Add<NumOpResult<T>, Output = NumOpResult<T>>)
+    {
+        type Output = NumOpResult<T>;
 
-    fn neg(self) -> Self::Output { Self::from_sat(self.to_sat().neg()) }
-}
+        fn add(self, rhs: T) -> Self::Output { rhs + self }
+    }
 
-impl<T> ops::Sub for NumOpResult<T>
-where
-    T: ops::Sub<Output = NumOpResult<T>>,
-{
-    type Output = NumOpResult<T>;
+    impl<T> ops::Sub<NumOpResult<T>> for NumOpResult<T>
+    where
+        (T: Copy + ops::Sub<Output = NumOpResult<T>>)
+    {
+        type Output = NumOpResult<T>;
 
-    fn sub(self, rhs: Self) -> Self::Output {
-        match (self, rhs) {
-            (R::Valid(lhs), R::Valid(rhs)) => lhs - rhs,
-            (_, _) => R::Error(NumOpError {}),
-        }
-    }
-}
-impl<T> ops::Sub<NumOpResult<T>> for &NumOpResult<T>
-where
-    T: ops::Sub<Output = NumOpResult<T>> + Copy,
-{
-    type Output = NumOpResult<T>;
-
-    fn sub(self, rhs: NumOpResult<T>) -> Self::Output {
-        match (self, rhs) {
-            (R::Valid(lhs), R::Valid(rhs)) => *lhs - rhs,
-            (_, _) => R::Error(NumOpError {}),
+        fn sub(self, rhs: Self) -> Self::Output {
+            match (self, rhs) {
+                (R::Valid(lhs), R::Valid(rhs)) => lhs - rhs,
+                (_, _) => R::Error(NumOpError {}),
+            }
         }
     }
-}
-impl<T> ops::Sub<&NumOpResult<T>> for NumOpResult<T>
-where
-    T: ops::Sub<Output = NumOpResult<T>> + Copy,
-{
-    type Output = NumOpResult<T>;
-
-    fn sub(self, rhs: &NumOpResult<T>) -> Self::Output {
-        match (self, rhs) {
-            (R::Valid(lhs), R::Valid(rhs)) => lhs - *rhs,
-            (_, _) => R::Error(NumOpError {}),
+
+    impl<T> ops::Sub<T> for NumOpResult<T>
+    where
+        (T: Copy + ops::Sub<Output = NumOpResult<T>>)
+    {
+        type Output = NumOpResult<T>;
+
+        fn sub(self, rhs: T) -> Self::Output {
+            match self {
+                R::Valid(amount) => amount - rhs,
+                R::Error(_) => self,
+            }
         }
     }
 }
-impl<T> ops::Sub for &NumOpResult<T>
-where
-    T: ops::Sub<Output = NumOpResult<T>> + Copy,
-{
-    type Output = NumOpResult<T>;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        match (self, rhs) {
-            (R::Valid(lhs), R::Valid(rhs)) => *lhs - *rhs,
-            (_, _) => R::Error(NumOpError {}),
-        }
-    }
+
+impl ops::Neg for SignedAmount {
+    type Output = Self;
+
+    fn neg(self) -> Self::Output { Self::from_sat(self.to_sat().neg()) }
 }
 
 impl core::iter::Sum<NumOpResult<Amount>> for NumOpResult<Amount> {

From a44a9d31f6ee728e8325e380e1c5500e00227a55 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 25 Feb 2025 20:45:56 +0000
Subject: [PATCH 411/554] Add a few impls to the result macro

Add a few missing impls to the `impl_op_for_references` macro.

Includes a minor whitespace change so that traits are grouped together.
---
 units/src/amount/result.rs | 37 ++++++++++++++++++++++++++++++++++---
 1 file changed, 34 insertions(+), 3 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index b2091a1b59..724230833e 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -129,7 +129,6 @@ crate::internal_macros::impl_op_for_references! {
 
         fn add(self, rhs: Amount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
     }
-
     impl ops::Add<NumOpResult<Amount>> for Amount {
         type Output = NumOpResult<Amount>;
 
@@ -141,7 +140,6 @@ crate::internal_macros::impl_op_for_references! {
 
         fn sub(self, rhs: Amount) -> Self::Output { self.checked_sub(rhs).valid_or_error() }
     }
-
     impl ops::Sub<NumOpResult<Amount>> for Amount {
         type Output = NumOpResult<Amount>;
 
@@ -158,23 +156,39 @@ crate::internal_macros::impl_op_for_references! {
 
         fn mul(self, rhs: u64) -> Self::Output { self.checked_mul(rhs).valid_or_error() }
     }
+    impl ops::Mul<u64> for NumOpResult<Amount> {
+        type Output = NumOpResult<Amount>;
+
+        fn mul(self, rhs: u64) -> Self::Output { self.and_then(|lhs| lhs * rhs) }
+    }
+
     impl ops::Div<u64> for Amount {
         type Output = NumOpResult<Amount>;
 
         fn div(self, rhs: u64) -> Self::Output { self.checked_div(rhs).valid_or_error() }
     }
+    impl ops::Div<u64> for NumOpResult<Amount> {
+        type Output = NumOpResult<Amount>;
+
+        fn div(self, rhs: u64) -> Self::Output { self.and_then(|lhs| lhs / rhs) }
+    }
+
     impl ops::Rem<u64> for Amount {
         type Output = NumOpResult<Amount>;
 
         fn rem(self, modulus: u64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
     }
+    impl ops::Rem<u64> for NumOpResult<Amount> {
+        type Output = NumOpResult<Amount>;
+
+        fn rem(self, modulus: u64) -> Self::Output { self.and_then(|lhs| lhs % modulus) }
+    }
 
     impl ops::Add<SignedAmount> for SignedAmount {
         type Output = NumOpResult<SignedAmount>;
 
         fn add(self, rhs: SignedAmount) -> Self::Output { self.checked_add(rhs).valid_or_error() }
     }
-
     impl ops::Add<NumOpResult<SignedAmount>> for SignedAmount {
         type Output = NumOpResult<SignedAmount>;
 
@@ -202,16 +216,33 @@ crate::internal_macros::impl_op_for_references! {
 
         fn mul(self, rhs: i64) -> Self::Output { self.checked_mul(rhs).valid_or_error() }
     }
+    impl ops::Mul<i64> for NumOpResult<SignedAmount> {
+        type Output = NumOpResult<SignedAmount>;
+
+        fn mul(self, rhs: i64) -> Self::Output { self.and_then(|lhs| lhs * rhs) }
+    }
+
     impl ops::Div<i64> for SignedAmount {
         type Output = NumOpResult<SignedAmount>;
 
         fn div(self, rhs: i64) -> Self::Output { self.checked_div(rhs).valid_or_error() }
     }
+    impl ops::Div<i64> for NumOpResult<SignedAmount> {
+        type Output = NumOpResult<SignedAmount>;
+
+        fn div(self, rhs: i64) -> Self::Output { self.and_then(|lhs| lhs / rhs) }
+    }
+
     impl ops::Rem<i64> for SignedAmount {
         type Output = NumOpResult<SignedAmount>;
 
         fn rem(self, modulus: i64) -> Self::Output { self.checked_rem(modulus).valid_or_error() }
     }
+    impl ops::Rem<i64> for NumOpResult<SignedAmount> {
+        type Output = NumOpResult<SignedAmount>;
+
+        fn rem(self, modulus: i64) -> Self::Output { self.and_then(|lhs| lhs % modulus) }
+    }
 
     impl<T> ops::Add<NumOpResult<T>> for NumOpResult<T>
     where

From 814685e551f00a896448b46b195f7dde69c2d32b Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 19 Feb 2025 15:31:32 +1100
Subject: [PATCH 412/554] Macroise the NumOpResult tests

Macroise the tests improving coverage along the way.

Includes a TODO to remind us to do `Neg` more fully.
---
 units/src/amount/tests.rs | 247 +++++++++++++++-----------------------
 1 file changed, 98 insertions(+), 149 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index fa2db48749..d3463660f7 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1196,170 +1196,122 @@ fn check_const() {
     assert_eq!(Amount::MAX_MONEY.to_sat() as i64, SignedAmount::MAX_MONEY.to_sat());
 }
 
-// Verify we have implemented all combinations of ops for `Amount` and `SignedAmount`.
-// It's easier to read this test that check the code.
+// Sanity check than stdlib supports the set of reference combinations for the ops we want.
 #[test]
 #[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
-fn amount_tyes_all_ops() {
-    // Sanity check than stdlib supports the set of reference combinations for the ops we want.
-    {
-        let x = 127;
+fn sanity_all_ops() {
+    let x = 127;
 
-        let _ = x + x;
-        let _ = &x + x;
-        let _ = x + &x;
-        let _ = &x + &x;
+    let _ = x + x;
+    let _ = &x + x;
+    let _ = x + &x;
+    let _ = &x + &x;
 
-        let _ = x - x;
-        let _ = &x - x;
-        let _ = x - &x;
-        let _ = &x - &x;
+    let _ = x - x;
+    let _ = &x - x;
+    let _ = x - &x;
+    let _ = &x - &x;
 
-        let _ = -x;
-    }
+    let _ = -x;
+}
 
+// Verify we have implemented all combinations of ops for the amount types and `NumOpResult` type.
+// It's easier to read this test than check the code.
+#[test]
+#[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
+fn num_op_result_ops() {
     let sat = Amount::from_sat(1);
     let ssat = SignedAmount::from_sat(1);
 
-    // Add
-    let _ = sat + sat;
-    let _ = &sat + sat;
-    let _ = sat + &sat;
-    let _ = &sat + &sat;
-
-    // let _ = ssat + sat;
-    // let _ = &ssat + sat;
-    // let _ = ssat + &sat;
-    // let _ = &ssat + &sat;
-
-    // let _ = sat + ssat;
-    // let _ = &sat + ssat;
-    // let _ = sat + &ssat;
-    // let _ = &sat + &ssat;
-
-    let _ = ssat + ssat;
-    let _ = &ssat + ssat;
-    let _ = ssat + &ssat;
-    let _ = &ssat + &ssat;
-
-    // Sub
-    let _ = sat - sat;
-    let _ = &sat - sat;
-    let _ = sat - &sat;
-    let _ = &sat - &sat;
-
-    // let _ = ssat - sat;
-    // let _ = &ssat - sat;
-    // let _ = ssat - &sat;
-    // let _ = &ssat - &sat;
-
-    // let _ = sat - ssat;
-    // let _ = &sat - ssat;
-    // let _ = sat - &ssat;
-    // let _ = &sat - &ssat;
-
-    let _ = ssat - ssat;
-    let _ = &ssat - ssat;
-    let _ = ssat - &ssat;
-    let _ = &ssat - &ssat;
-
-    // let _ = sat * sat;  // Intentionally not supported.
-
-    // Mul
-    let _ = sat * 3;
-    let _ = sat * &3;
-    let _ = &sat * 3;
-    let _ = &sat * &3;
-
-    let _ = ssat * 3_i64; // Explicit type for the benefit of the reader.
-    let _ = ssat * &3;
-    let _ = &ssat * 3;
-    let _ = &ssat * &3;
-
-    // Div
-    let _ = sat / 3;
-    let _ = &sat / 3;
-    let _ = sat / &3;
-    let _ = &sat / &3;
-
-    let _ = ssat / 3_i64; // Explicit type for the benefit of the reader.
-    let _ = &ssat / 3;
-    let _ = ssat / &3;
-    let _ = &ssat / &3;
-
-    // Rem
-    let _ = sat % 3;
-    let _ = &sat % 3;
-    let _ = sat % &3;
-    let _ = &sat % &3;
-
-    let _ = ssat % 3;
-    let _ = &ssat % 3;
-    let _ = ssat % &3;
-    let _ = &ssat % &3;
-
-    // FIXME: Do we want to support this?
-    // let _ = sat / sat;
-    //
-    // "How many times does this amount go into that amount?" - seems
-    // like a reasonable question to ask.
-
-    // FIXME: Do we want to support these?
-    // let _ = -sat;
-    // let _ = -ssat;
-}
+    // Explicit type as sanity check.
+    let res: NumOpResult<Amount> = sat + sat;
+    let sres: NumOpResult<SignedAmount> = ssat + ssat;
+
+    macro_rules! check_op {
+        ($(let _ = $lhs:ident $op:tt $rhs:ident);* $(;)?) => {
+            $(
+                let _ = $lhs $op $rhs;
+                let _ = &$lhs $op $rhs;
+                let _ = $lhs $op &$rhs;
+                let _ = &$lhs $op &$rhs;
+            )*
+        }
+    }
 
-// FIXME: Should we support this sort of thing?
-// It will be a lot more code for possibly not that much benefit.
-#[test]
-fn can_ops_on_amount_and_signed_amount() {
-    // let res: NumOpResult<SignedAmount> = sat + ssat;
+    // We do not currently support division involving `NumOpResult` and an amount type.
+    check_op! {
+        // Operations where RHS is the result of another operation.
+        let _ = sat + res;
+        let _ = sat - res;
+        // let _ = sat / res;
+        let _ = ssat + sres;
+        let _ = ssat - sres;
+        // let _ = ssat / sres;
+
+        // Operations where LHS is the result of another operation.
+        let _ = res + sat;
+        let _ = res - sat;
+        // let _ = res / sat;
+        let _ = sres + ssat;
+        let _ = sres - ssat;
+        // let _ = sres / ssat;
+
+        // Operations that where both sides are the result of another operation.
+        let _ = res + res;
+        let _ = res - res;
+        // let _ = res / res;
+        let _ = sres + sres;
+        let _ = sres - sres;
+        // let _ = sres / sres;
+    };
 }
 
-// Verify we have implemented all combinations of ops for the `NumOpResult` type.
-// It's easier to read this test that check the code.
+// Verify we have implemented all combinations of ops for the `NumOpResult` type and an integer.
+// It's easier to read this test than check the code.
 #[test]
 #[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
-fn amount_op_result_all_ops() {
+fn num_op_result_ops_integer() {
     let sat = Amount::from_sat(1);
-    // let ssat = SignedAmount::from_sat(1);
+    let ssat = SignedAmount::from_sat(1);
 
     // Explicit type as sanity check.
     let res: NumOpResult<Amount> = sat + sat;
-    // let sres: NumOpResult<SignedAmount> = ssat + ssat;
-
-    // Operations that where RHS is the result of another operation.
-    let _ = sat + res;
-    let _ = &sat + res;
-    // let _ = sat + &res;
-    // let _ = &sat + &res;
-
-    let _ = sat - res;
-    let _ = &sat - res;
-    // let _ = sat - &res;
-    // let _ = &sat - &res;
-
-    // Operations that where LHS is the result of another operation.
-    let _ = res + sat;
-    // let _ = &res + sat;
-    let _ = res + &sat;
-    // let _ = &res + &sat;
-
-    let _ = res - sat;
-    // let _ = &res - sat;
-    let _ = res - &sat;
-    // let _ = &res - &sat;
-
-    // Operations that where both sides are the result of another operation.
-    let _ = res + res;
-    // let _ = &res + res;
-    // let _ = res + &res;
-    // let _ = &res + &res;
-
-    let _ = res - res;
-    // let _ = &res - res;
-    // let _ = res - &res;
-    // let _ = &res - &res;
+    let sres: NumOpResult<SignedAmount> = ssat + ssat;
+
+    macro_rules! check_op {
+        ($(let _ = $lhs:ident $op:tt $rhs:literal);* $(;)?) => {
+            $(
+                let _ = $lhs $op $rhs;
+                let _ = &$lhs $op $rhs;
+                let _ = $lhs $op &$rhs;
+                let _ = &$lhs $op &$rhs;
+            )*
+        }
+    }
+    check_op! {
+        // Operations on a `NumOpResult` and integer.
+        let _ = res * 3_u64; // Explicit type for the benefit of the reader.
+        let _ = res / 3;
+        let _ = res % 3;
+
+        let _ = sres * 3_i64; // Explicit type for the benefit of the reader.
+        let _ = sres / 3;
+        let _ = sres % 3;
+    };
+}
+
+// Verify we have implemented all `Neg` for the amount types.
+#[test]
+fn amount_op_result_neg() {
+    // TODO: Implement Neg all round.
+
+    // let sat = Amount::from_sat(1);
+    let ssat = SignedAmount::from_sat(1);
+
+    // let _ = -sat;
+    let _ = -ssat;
+    // let _ = -res;
+    // let _ = -sres;
 }
 
 // Verify we have implemented all `Sum` for the `NumOpResult` type.
@@ -1373,7 +1325,4 @@ fn amount_op_result_sum() {
     let _ = amounts.iter().sum::<NumOpResult<Amount>>();
     let _ = amount_refs.iter().copied().sum::<NumOpResult<Amount>>();
     let _ = amount_refs.into_iter().sum::<NumOpResult<Amount>>();
-
-    // FIXME: Should we support this? I don't think so (Tobin).
-    // let _ = amount_refs.iter().sum::<NumOpResult<&Amount>>();
 }

From 2d8227f09127383ac22464a45250ef1adad79242 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 21 Feb 2025 09:32:35 +1100
Subject: [PATCH 413/554] Hide relative locktime error internals

As part of the 1.0 effort and forward maintainability hide the internals
of the two error types in the `relative` locktime module. Doing so
allows us to remove the `non_exhaustive` attribute. Add getters to get
at the error innards.
---
 primitives/src/locktime/relative.rs | 26 ++++++++++++++++++++------
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 663223efed..5acd781695 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -401,12 +401,19 @@ impl std::error::Error for DisabledLockTimeError {}
 
 /// Tried to satisfy a lock-by-blocktime lock using a height value.
 #[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
 pub struct IncompatibleHeightError {
     /// Attempted to satisfy a lock-by-blocktime lock with this height.
-    pub height: Height,
+    height: Height,
     /// The inner time value of the lock-by-blocktime lock.
-    pub time: Time,
+    time: Time,
+}
+
+impl IncompatibleHeightError {
+    /// Returns the height that was erroneously used to try and satisfy a lock-by-blocktime lock.
+    pub fn incompatible(&self) -> Height { self.height }
+
+    /// Returns the time value of the lock-by-blocktime lock.
+    pub fn expected(&self) -> Time { self.time }
 }
 
 impl fmt::Display for IncompatibleHeightError {
@@ -424,12 +431,19 @@ impl std::error::Error for IncompatibleHeightError {}
 
 /// Tried to satisfy a lock-by-blockheight lock using a time value.
 #[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
 pub struct IncompatibleTimeError {
     /// Attempted to satisfy a lock-by-blockheight lock with this time.
-    pub time: Time,
+    time: Time,
     /// The inner height value of the lock-by-blockheight lock.
-    pub height: Height,
+    height: Height,
+}
+
+impl IncompatibleTimeError {
+    /// Returns the time that was erroneously used to try and satisfy a lock-by-blockheight lock.
+    pub fn incompatible(&self) -> Time { self.time }
+
+    /// Returns the height value of the lock-by-blockheight lock.
+    pub fn expected(&self) -> Height { self.height }
 }
 
 impl fmt::Display for IncompatibleTimeError {

From 43ae9d751622c7bef548a469466d74cf01284129 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 21 Feb 2025 09:38:50 +1100
Subject: [PATCH 414/554] primitives: Hide script error internals

As part of the 1.0 effort and forward maintainability hide the internals
of the two error types in the `script` module. Add getters to get at the
invalid size.
---
 bitcoin/src/address/mod.rs   |  6 ++----
 primitives/src/script/mod.rs | 14 ++++++++++++--
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 45b547c742..e41a883203 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -1061,10 +1061,8 @@ mod tests {
     #[test]
     fn p2sh_parse_for_large_script() {
         let script = ScriptBuf::from_hex("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae12123122313123123ac1231231231231313123131231231231313212313213123123").unwrap();
-        assert_eq!(
-            Address::p2sh(&script, NetworkKind::Test),
-            Err(RedeemScriptSizeError { size: script.len() })
-        );
+        let res = Address::p2sh(&script, NetworkKind::Test);
+        assert_eq!(res.unwrap_err().invalid_size(), script.len())
     }
 
     #[test]
diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index dda2240225..dc2246c192 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -156,7 +156,12 @@ impl TryFrom<&Script> for WScriptHash {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RedeemScriptSizeError {
     /// Invalid redeem script size (cannot exceed 520 bytes).
-    pub size: usize,
+    size: usize,
+}
+
+impl RedeemScriptSizeError {
+    /// Returns the invalid redeem script size.
+    pub fn invalid_size(&self) -> usize { self.size }
 }
 
 impl From<Infallible> for RedeemScriptSizeError {
@@ -176,7 +181,12 @@ impl std::error::Error for RedeemScriptSizeError {}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct WitnessScriptSizeError {
     /// Invalid witness script size (cannot exceed 10,000 bytes).
-    pub size: usize,
+    size: usize,
+}
+
+impl WitnessScriptSizeError {
+    /// Returns the invalid witness script size.
+    pub fn invalid_size(&self) -> usize { self.size }
 }
 
 impl From<Infallible> for WitnessScriptSizeError {

From cf12ba262a646a6341098ee3f4c178a52fc90211 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 26 Feb 2025 15:44:53 +1100
Subject: [PATCH 415/554] Move taproot back to bitcoin crate

I don't know what I was thinking when I move the taproot hash types to
`primitives`. As correctly pointed out by Kix we agreed to only have
blockdata in `primitives`.

Move the taproot hash types back to `bitcoin::taproot` and remove the
extension traits.
---
 bitcoin/src/blockdata/script/borrowed.rs |   2 +-
 bitcoin/src/crypto/key.rs                |   2 +-
 bitcoin/src/crypto/sighash.rs            |   2 -
 bitcoin/src/taproot/mod.rs               | 159 ++++++++++++++---------
 primitives/src/lib.rs                    |   2 -
 primitives/src/taproot.rs                |  57 --------
 6 files changed, 97 insertions(+), 127 deletions(-)

diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs
index 14c32e3149..624feb3b54 100644
--- a/bitcoin/src/blockdata/script/borrowed.rs
+++ b/bitcoin/src/blockdata/script/borrowed.rs
@@ -14,7 +14,7 @@ use crate::opcodes::all::*;
 use crate::opcodes::{self, Opcode};
 use crate::policy::{DUST_RELAY_TX_FEE, MAX_OP_RETURN_RELAY};
 use crate::prelude::{sink, DisplayHex, String, ToString};
-use crate::taproot::{LeafVersion, TapLeafHash, TapLeafHashExt as _};
+use crate::taproot::{LeafVersion, TapLeafHash};
 use crate::{Amount, FeeRate};
 
 #[rustfmt::skip]            // Keep public re-exports separate.
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 1b3c3a4843..68a3c965b7 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -21,7 +21,7 @@ use crate::internal_macros::impl_asref_push_bytes;
 use crate::network::NetworkKind;
 use crate::prelude::{DisplayHex, String, Vec};
 use crate::script::{self, ScriptBuf};
-use crate::taproot::{TapNodeHash, TapTweakHash, TapTweakHashExt as _};
+use crate::taproot::{TapNodeHash, TapTweakHash};
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 pub use secp256k1::{constants, Keypair, Parity, Secp256k1, Verification, XOnlyPublicKey};
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 6fd66d045c..e1deed7e27 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -1864,8 +1864,6 @@ mod tests {
     fn bip_341_sighash_tests() {
         use hex::DisplayHex;
 
-        use crate::taproot::TapTweakHashExt as _;
-
         fn sighash_deser_numeric<'de, D>(deserializer: D) -> Result<TapSighashType, D::Error>
         where
             D: serde::Deserializer<'de>,
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 775357f07f..5511431acf 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -12,7 +12,7 @@ use core::convert::Infallible;
 use core::fmt;
 use core::iter::FusedIterator;
 
-use hashes::{sha256t, HashEngine};
+use hashes::{hash_newtype, sha256t, sha256t_tag, HashEngine};
 use internals::{impl_to_hex_from_lower_hex, write_err};
 use io::Write;
 use secp256k1::{Scalar, Secp256k1};
@@ -28,50 +28,91 @@ use crate::{Script, ScriptBuf};
 pub use crate::crypto::taproot::{SigFromSliceError, Signature};
 #[doc(inline)]
 pub use merkle_branch::TaprootMerkleBranch;
-pub use primitives::taproot::{
-    TapBranchTag, TapLeafHash, TapLeafTag, TapNodeHash, TapTweakHash, TapTweakTag,
-};
-
-crate::internal_macros::define_extension_trait! {
-    /// Extension functionality for the [`TapTweakHash`] type.
-    pub trait TapTweakHashExt impl for TapTweakHash {
-        /// Constructs 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.
-        fn from_key_and_tweak(
-            internal_key: UntweakedPublicKey,
-            merkle_root: Option<TapNodeHash>,
-        ) -> TapTweakHash {
-            let mut eng = sha256t::Hash::<TapTweakTag>::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
-            }
-            let inner = sha256t::Hash::<TapTweakTag>::from_engine(eng);
-            TapTweakHash::from_byte_array(inner.to_byte_array())
-        }
 
-        /// Converts a `TapTweakHash` into a `Scalar` ready for use with key tweaking API.
-        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")
+// Taproot test vectors from BIP-341 state the hashes without any reversing
+sha256t_tag! {
+    pub struct TapLeafTag = hash_str("TapLeaf");
+}
+
+hash_newtype! {
+    /// Taproot-tagged hash with tag \"TapLeaf\".
+    ///
+    /// This is used for computing tapscript script spend hash.
+    pub struct TapLeafHash(sha256t::Hash<TapLeafTag>);
+}
+
+hashes::impl_hex_for_newtype!(TapLeafHash);
+#[cfg(feature = "serde")]
+hashes::impl_serde_for_newtype!(TapLeafHash);
+
+sha256t_tag! {
+    pub struct TapBranchTag = hash_str("TapBranch");
+}
+
+hash_newtype! {
+    /// Tagged hash used in Taproot trees.
+    ///
+    /// See BIP-340 for tagging rules.
+    pub struct TapNodeHash(sha256t::Hash<TapBranchTag>);
+}
+
+hashes::impl_hex_for_newtype!(TapNodeHash);
+#[cfg(feature = "serde")]
+hashes::impl_serde_for_newtype!(TapNodeHash);
+
+sha256t_tag! {
+    pub struct TapTweakTag = hash_str("TapTweak");
+}
+
+hash_newtype! {
+    /// Taproot-tagged hash with tag \"TapTweak\".
+    ///
+    /// This hash type is used while computing the tweaked public key.
+    pub struct TapTweakHash(sha256t::Hash<TapTweakTag>);
+}
+
+hashes::impl_hex_for_newtype!(TapTweakHash);
+#[cfg(feature = "serde")]
+hashes::impl_serde_for_newtype!(TapTweakHash);
+
+impl From<TapLeafHash> for TapNodeHash {
+    fn from(leaf: TapLeafHash) -> TapNodeHash { TapNodeHash::from_byte_array(leaf.to_byte_array()) }
+}
+
+impl TapTweakHash {
+    /// Constructs 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 = sha256t::Hash::<TapTweakTag>::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
         }
+        let inner = sha256t::Hash::<TapTweakTag>::from_engine(eng);
+        TapTweakHash::from_byte_array(inner.to_byte_array())
+    }
+
+    /// 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")
     }
 }
 
-crate::internal_macros::define_extension_trait! {
-    /// Extension functionality for the [`TapLeafHash`] type.
-    pub trait TapLeafHashExt impl for TapLeafHash {
-        /// Computes the leaf hash from components.
-        fn from_script(script: &Script, ver: LeafVersion) -> TapLeafHash {
-            let mut eng = sha256t::Hash::<TapLeafTag>::engine();
-            ver.to_consensus().consensus_encode(&mut eng).expect("engines don't error");
-            script.consensus_encode(&mut eng).expect("engines don't error");
-            let inner = sha256t::Hash::<TapLeafTag>::from_engine(eng);
-            TapLeafHash::from_byte_array(inner.to_byte_array())
-        }
+impl TapLeafHash {
+    /// Computes the leaf hash from components.
+    pub fn from_script(script: &Script, ver: LeafVersion) -> TapLeafHash {
+        let mut eng = sha256t::Hash::<TapLeafTag>::engine();
+        ver.to_consensus().consensus_encode(&mut eng).expect("engines don't error");
+        script.consensus_encode(&mut eng).expect("engines don't error");
+        let inner = sha256t::Hash::<TapLeafTag>::from_engine(eng);
+        TapLeafHash::from_byte_array(inner.to_byte_array())
     }
 }
 
@@ -83,25 +124,22 @@ impl From<&LeafNode> for TapNodeHash {
     fn from(leaf: &LeafNode) -> TapNodeHash { leaf.node_hash() }
 }
 
-crate::internal_macros::define_extension_trait! {
-    /// Extension functionality for the [`TapNodeHash`] type.
-    pub trait TapNodeHashExt impl for TapNodeHash {
-        /// Computes branch hash given two hashes of the nodes underneath it.
-        fn from_node_hashes(a: TapNodeHash, b: TapNodeHash) -> TapNodeHash {
-            combine_node_hashes(a, b).0
-        }
+impl TapNodeHash {
+    /// Computes branch hash given two hashes of the nodes underneath it.
+    pub fn from_node_hashes(a: TapNodeHash, b: TapNodeHash) -> TapNodeHash {
+        combine_node_hashes(a, b).0
+    }
 
-        /// 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.
-        fn assume_hidden(hash: [u8; 32]) -> TapNodeHash { TapNodeHash::from_byte_array(hash) }
+    /// 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.
-        fn from_script(script: &Script, ver: LeafVersion) -> TapNodeHash {
-            TapNodeHash::from(TapLeafHash::from_script(script, ver))
-        }
+    /// 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))
     }
 }
 
@@ -1554,13 +1592,6 @@ impl fmt::Display for InvalidControlBlockSizeError {
 #[cfg(feature = "std")]
 impl std::error::Error for InvalidControlBlockSizeError {}
 
-mod sealed {
-    pub trait Sealed {}
-    impl Sealed for super::TapTweakHash {}
-    impl Sealed for super::TapLeafHash {}
-    impl Sealed for super::TapNodeHash {}
-}
-
 #[cfg(test)]
 mod test {
     use hashes::sha256;
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index 5cd7150637..451a3c1667 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -49,7 +49,6 @@ pub mod pow;
 #[cfg(feature = "alloc")]
 pub mod script;
 pub mod sequence;
-pub mod taproot;
 pub mod transaction;
 #[cfg(feature = "alloc")]
 pub mod witness;
@@ -80,7 +79,6 @@ pub use self::{
     opcodes::Opcode,
     pow::CompactTarget,
     sequence::Sequence,
-    taproot::{TapBranchTag, TapLeafHash, TapLeafTag, TapNodeHash, TapTweakHash, TapTweakTag},
     transaction::{OutPoint, Txid, Wtxid},
 };
 
diff --git a/primitives/src/taproot.rs b/primitives/src/taproot.rs
index 743980dcd2..e69de29bb2 100644
--- a/primitives/src/taproot.rs
+++ b/primitives/src/taproot.rs
@@ -1,57 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-
-//! Bitcoin Taproot.
-//!
-//! This module provides support for Taproot tagged hashes.
-
-use hashes::{hash_newtype, sha256t, sha256t_tag};
-
-// Taproot test vectors from BIP-341 state the hashes without any reversing
-sha256t_tag! {
-    pub struct TapLeafTag = hash_str("TapLeaf");
-}
-
-hash_newtype! {
-    /// Taproot-tagged hash with tag \"TapLeaf\".
-    ///
-    /// This is used for computing tapscript script spend hash.
-    pub struct TapLeafHash(sha256t::Hash<TapLeafTag>);
-}
-
-hashes::impl_hex_for_newtype!(TapLeafHash);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(TapLeafHash);
-
-sha256t_tag! {
-    pub struct TapBranchTag = hash_str("TapBranch");
-}
-
-hash_newtype! {
-    /// Tagged hash used in Taproot trees.
-    ///
-    /// See BIP-340 for tagging rules.
-    pub struct TapNodeHash(sha256t::Hash<TapBranchTag>);
-}
-
-hashes::impl_hex_for_newtype!(TapNodeHash);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(TapNodeHash);
-
-sha256t_tag! {
-    pub struct TapTweakTag = hash_str("TapTweak");
-}
-
-hash_newtype! {
-    /// Taproot-tagged hash with tag \"TapTweak\".
-    ///
-    /// This hash type is used while computing the tweaked public key.
-    pub struct TapTweakHash(sha256t::Hash<TapTweakTag>);
-}
-
-hashes::impl_hex_for_newtype!(TapTweakHash);
-#[cfg(feature = "serde")]
-hashes::impl_serde_for_newtype!(TapTweakHash);
-
-impl From<TapLeafHash> for TapNodeHash {
-    fn from(leaf: TapLeafHash) -> TapNodeHash { TapNodeHash::from_byte_array(leaf.to_byte_array()) }
-}

From 2688abad19198128d799d020d28945a0aaeb1fef Mon Sep 17 00:00:00 2001
From: Bruno Garcia <brunoely.gc@gmail.com>
Date: Wed, 26 Feb 2025 09:04:59 -0300
Subject: [PATCH 416/554] fuzz: add coverage for Display for Script

---
 fuzz/fuzz_targets/bitcoin/deserialize_script.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
index 8bd904fff0..6943bc64cd 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -9,6 +9,7 @@ fn do_test(data: &[u8]) {
     if let Ok(script) = s {
         let _: Result<Vec<script::Instruction>, script::Error> = script.instructions().collect();
 
+        let _ = script.to_string();
         let mut b = script::Builder::new();
         for ins in script.instructions_minimal() {
             if ins.is_err() {

From 2fe3687899b477dc1214c22b9967cdce3f69a3db Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Tue, 25 Feb 2025 00:30:31 +0700
Subject: [PATCH 417/554] Policy: Relax MIN_STANDARD_TX_NONWITNESS_SIZE to 65

Align with Bitcoin Core's policy by reducing the minimum non-witness
transaction size from 82 to 65 bytes. This change allows for more
minimal transaction cases (e.g., 1 input with 1 OP_RETURN output),
while still maintaining protection against CVE-2017-12842.

Matches bitcoin/bitcoin#26398
---
 bitcoin/src/policy.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/policy.rs b/bitcoin/src/policy.rs
index ca1bacb0d7..96b77bbab0 100644
--- a/bitcoin/src/policy.rs
+++ b/bitcoin/src/policy.rs
@@ -18,8 +18,8 @@ use super::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;
+/// Minimum non-witness size for a standard transaction, set to 65 bytes.
+pub const MIN_STANDARD_TX_NONWITNESS_SIZE: u32 = 65;
 
 /// Maximum number of sigops in a standard tx.
 pub const MAX_STANDARD_TX_SIGOPS_COST: u32 = MAX_BLOCK_SIGOPS_COST as u32 / 5;

From 25707da14af93fd7383cd721beae322abb13f36b Mon Sep 17 00:00:00 2001
From: ndungudedan <dnkibere@gmail.com>
Date: Wed, 26 Feb 2025 02:21:50 +0300
Subject: [PATCH 418/554] hashes: Remove Clone trait bound from Tag

Implementors of the Tag trait had to use the #[derive(Clone)] attribute.
This change eliminates this need by removing the Clone trait
bound from the Tag trait.
---
 hashes/src/sha256t/mod.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 56592820e5..22f835412a 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -10,7 +10,7 @@ use crate::sha256::Midstate;
 use crate::{sha256, HashEngine as _};
 
 /// Trait representing a tag that can be used as a context for SHA256t hashes.
-pub trait Tag: Clone {
+pub trait Tag {
     /// The [`Midstate`] after pre-tagging the hash engine.
     const MIDSTATE: sha256::Midstate;
 }
@@ -118,7 +118,7 @@ impl<T: Tag> core::hash::Hash for Hash<T> {
 crate::internal_macros::hash_trait_impls!(256, false, T: Tag);
 
 /// Engine to compute SHA256t hash function.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct HashEngine<T>(sha256::HashEngine, PhantomData<T>);
 
 impl<T: Tag> Default for HashEngine<T> {
@@ -128,6 +128,12 @@ impl<T: Tag> Default for HashEngine<T> {
     }
 }
 
+impl<T: Tag> Clone for HashEngine<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone(), PhantomData)
+    }
+}
+
 impl<T: Tag> crate::HashEngine for HashEngine<T> {
     const BLOCK_SIZE: usize = 64; // Same as sha256::HashEngine::BLOCK_SIZE;
     fn input(&mut self, data: &[u8]) { self.0.input(data) }

From f7ea6e50b578238b0a7ff421d18d7c7f71d43278 Mon Sep 17 00:00:00 2001
From: Erik De Smedt <contact@erikdesmedt.be>
Date: Mon, 24 Feb 2025 12:42:04 +0100
Subject: [PATCH 419/554] Add support for pay to anchor outputs

Add support for the newly created Pay2Anchor output-type.

See https://github.com/bitcoin/bitcoin/pull/30352
---
 bitcoin/src/address/mod.rs                    | 25 +++++++++++++++++++
 bitcoin/src/address/script_pubkey.rs          | 10 ++++++--
 .../src/blockdata/script/witness_program.rs   | 13 ++++++++++
 3 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 45b547c742..0bd448d138 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -91,6 +91,8 @@ pub enum AddressType {
     P2wsh,
     /// Pay to taproot.
     P2tr,
+    /// Pay to anchor.
+    P2a
 }
 
 impl fmt::Display for AddressType {
@@ -101,6 +103,7 @@ impl fmt::Display for AddressType {
             AddressType::P2wpkh => "p2wpkh",
             AddressType::P2wsh => "p2wsh",
             AddressType::P2tr => "p2tr",
+            AddressType::P2a => "p2a",
         })
     }
 }
@@ -114,6 +117,7 @@ impl FromStr for AddressType {
             "p2wpkh" => Ok(AddressType::P2wpkh),
             "p2wsh" => Ok(AddressType::P2wsh),
             "p2tr" => Ok(AddressType::P2tr),
+            "p2a" => Ok(AddressType::P2a),
             _ => Err(UnknownAddressTypeError(s.to_owned())),
         }
     }
@@ -572,6 +576,8 @@ impl Address {
                     Some(AddressType::P2wsh)
                 } else if program.is_p2tr() {
                     Some(AddressType::P2tr)
+                } else if program.is_p2a() {
+                    Some(AddressType::P2a)
                 } else {
                     None
                 },
@@ -1526,4 +1532,23 @@ mod tests {
         assert_eq!(&rinsed.address, foo_checked.address.as_unchecked());
         assert_eq!(rinsed, foo_unchecked);
     }
+
+
+    #[test]
+    fn pay_to_anchor_address_regtest() {
+        // Verify that p2a uses the expected address for regtest.
+        // This test-vector is borrowed from the bitcoin source code.
+        let address_str = "bcrt1pfeesnyr2tx";
+
+        let script = ScriptBuf::new_p2a();
+        let address_unchecked = address_str.parse().unwrap();
+        let address = Address::from_script(&script, Network::Regtest).unwrap();
+        assert_eq!(address.as_unchecked(), &address_unchecked);
+        assert_eq!(address.to_string(), address_str);
+
+        // Verify that the address is considered standard
+        // and that the output type is P2a
+        assert!(address.is_spend_standard());
+        assert_eq!(address.address_type(), Some(AddressType::P2a));
+    }
 }
diff --git a/bitcoin/src/address/script_pubkey.rs b/bitcoin/src/address/script_pubkey.rs
index 8204675619..208b5e8464 100644
--- a/bitcoin/src/address/script_pubkey.rs
+++ b/bitcoin/src/address/script_pubkey.rs
@@ -12,6 +12,7 @@ use crate::key::{
 use crate::opcodes::all::*;
 use crate::script::witness_program::WitnessProgram;
 use crate::script::witness_version::WitnessVersion;
+use crate::script::witness_program::P2A_PROGRAM;
 use crate::script::{
     self, Builder, PushBytes, RedeemScriptSizeError, Script, ScriptBuf, ScriptExt as _, ScriptHash,
     WScriptHash, WitnessScriptSizeError,
@@ -170,6 +171,11 @@ define_extension_trait! {
             new_witness_program_unchecked(WitnessVersion::V1, output_key.serialize())
         }
 
+        /// Generates pay to anchor output.
+        fn new_p2a() -> Self {
+            new_witness_program_unchecked(WitnessVersion::V1, P2A_PROGRAM)
+        }
+
         /// Generates P2WSH-type of scriptPubkey with a given [`WitnessProgram`].
         fn new_witness_program(witness_program: &WitnessProgram) -> Self {
             Builder::new()
@@ -183,14 +189,14 @@ define_extension_trait! {
 /// 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`.
+/// Convenience method used by `new_p2a`, `new_p2wpkh`, `new_p2wsh`, `new_p2tr`, and `new_p2tr_tweaked`.
 pub(super) fn new_witness_program_unchecked<T: AsRef<PushBytes>>(
     version: WitnessVersion,
     program: T,
 ) -> ScriptBuf {
     let program = program.as_ref();
     debug_assert!(program.len() >= 2 && program.len() <= 40);
-    // In SegWit v0, the program must be 20 or 32 bytes long.
+    // In SegWit v0, the program must be either 20 (P2WPKH) bytes or 32 (P2WSH) bytes long
     debug_assert!(version != WitnessVersion::V0 || program.len() == 20 || program.len() == 32);
     Builder::new().push_opcode(version.into()).push_slice(program).into_script()
 }
diff --git a/bitcoin/src/blockdata/script/witness_program.rs b/bitcoin/src/blockdata/script/witness_program.rs
index 4c60228dc9..989f722570 100644
--- a/bitcoin/src/blockdata/script/witness_program.rs
+++ b/bitcoin/src/blockdata/script/witness_program.rs
@@ -25,6 +25,9 @@ pub const MIN_SIZE: usize = 2;
 /// The maximum byte size of a segregated witness program.
 pub const MAX_SIZE: usize = 40;
 
+/// The P2A program which is given by 0x4e73.
+pub(crate) const P2A_PROGRAM: [u8;2] = [78, 115];
+
 /// The segregated witness program.
 ///
 /// The segregated witness program is technically only the program bytes _excluding_ the witness
@@ -105,6 +108,11 @@ impl WitnessProgram {
         WitnessProgram::new_p2tr(pubkey)
     }
 
+    /// Constructs a new pay to anchor address
+    pub const fn p2a() -> Self {
+        WitnessProgram { version: WitnessVersion::V1, program: ArrayVec::from_slice(&P2A_PROGRAM)}
+    }
+
     /// Returns the witness program version.
     pub fn version(&self) -> WitnessVersion { self.version }
 
@@ -128,6 +136,11 @@ impl WitnessProgram {
 
     /// Returns true if this witness program is for a P2TR output.
     pub fn is_p2tr(&self) -> bool { self.version == WitnessVersion::V1 && self.program.len() == 32 }
+
+    /// Returns true if this is a pay to anchor output.
+    pub fn is_p2a(&self) -> bool {
+        self.version == WitnessVersion::V1 && self.program == P2A_PROGRAM
+    }
 }
 
 /// Witness program error.

From 539d45420a4540e13099a61996db87aeb3887002 Mon Sep 17 00:00:00 2001
From: leonarddt05 <139609434+leonarddt05@users.noreply.github.com>
Date: Thu, 27 Feb 2025 12:40:30 +0300
Subject: [PATCH 420/554] Typo fix in: README.md

Hi,

I suggest some typo fix' for this doc:

1- "since these are needed to display hashes anway."
Should be "since these are needed to display hashes anyway." (spelling error).

2- "bench mark" and "bench marks" Should be "benchmark" and "benchmarks" (incorrect spacing; "benchmark" is a single word).

Thanks.
---
 hashes/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/hashes/README.md b/hashes/README.md
index 87ec9b345a..6052b3603a 100644
--- a/hashes/README.md
+++ b/hashes/README.md
@@ -3,7 +3,7 @@
 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
 ancillary thing, it exposes hexadecimal serialization and deserialization,
-since these are needed to display hashes anway.
+since these are needed to display hashes anyway.
 
 [Documentation](https://docs.rs/bitcoin_hashes/)
 
@@ -29,5 +29,5 @@ Alternatively add symlinks in your `.git/hooks` directory to any of the githooks
 
 ### 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`.
+We use a custom Rust compiler configuration conditional to guard the benchmark code. To run the
+benchmarks use: `RUSTFLAGS='--cfg=bench' cargo +nightly bench`.

From 8787304425c83cccfb1107bde0b0d82901470d38 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 27 Feb 2025 11:33:19 +1100
Subject: [PATCH 421/554] units: Improve code comment on macros

We have two macros that are hidden because they are code de-duplication
tools. However the output they produce is, and has to be, stable so that
we can use them in `units` and `primitives` without inadvertently
breaking semver in `primitives`.
---
 units/src/parse.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/units/src/parse.rs b/units/src/parse.rs
index 6d4b59ec13..3e6e34a523 100644
--- a/units/src/parse.rs
+++ b/units/src/parse.rs
@@ -149,7 +149,7 @@ fn int<T: Integer, S: AsRef<str> + Into<InputString>>(s: S) -> Result<T, ParseIn
 ///
 /// If parsing the string fails then a `units::parse::ParseIntError` is returned.
 #[macro_export]
-#[doc(hidden)] // This is an 'internal' macro that should not be used outside of the `rust-bitcoin` crate.
+#[doc(hidden)] // This macro is stable but is considered internal to the `rust-bitcoin` repository.
 macro_rules! impl_parse_str_from_int_infallible {
     ($to:ident, $inner:ident, $fn:ident) => {
         impl $crate::_export::_core::str::FromStr for $to {
@@ -214,7 +214,7 @@ macro_rules! impl_parse_str_from_int_infallible {
 ///
 /// All functions use the error returned by `$inner_fn`.
 #[macro_export]
-#[doc(hidden)] // This is an 'internal' macro that should not be used outside of the `rust-bitcoin` crate.
+#[doc(hidden)] // This macro is stable but is considered internal to the `rust-bitcoin` repository.
 macro_rules! impl_parse_str {
     ($to:ty, $err:ty, $inner_fn:expr) => {
         $crate::impl_tryfrom_str!(&str, $to, $err, $inner_fn);

From ce19d40a805e2b67f6199cce61a73c6592019b5c Mon Sep 17 00:00:00 2001
From: looklose <shishuaiqun@yeah.net>
Date: Fri, 28 Feb 2025 17:55:31 +0800
Subject: [PATCH 422/554] chore: fix some typos in comments

Signed-off-by: looklose <shishuaiqun@yeah.net>
---
 internals/src/array_vec.rs | 2 +-
 units/src/amount/mod.rs    | 2 +-
 units/src/amount/result.rs | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/internals/src/array_vec.rs b/internals/src/array_vec.rs
index bd4954aacb..76d0490d5f 100644
--- a/internals/src/array_vec.rs
+++ b/internals/src/array_vec.rs
@@ -25,7 +25,7 @@ mod safety_boundary {
         /// Constructs an empty `ArrayVec`.
         pub const fn new() -> Self { Self { len: 0, data: [MaybeUninit::uninit(); CAP] } }
 
-        /// Constructs a new `ArrayVec` initialized with the contets of `slice`.
+        /// Constructs a new `ArrayVec` initialized with the contents of `slice`.
         ///
         /// # Panics
         ///
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index e5e23417c8..345c3badfb 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -139,7 +139,7 @@ impl Denomination {
     }
 }
 
-/// These form are ambigous and could have many meanings.  For example, M could denote Mega or Milli.
+/// These form are ambiguous and could have many meanings.  For example, M could denote Mega or Milli.
 /// If any of these forms are used, an error type `PossiblyConfusingDenomination` is returned.
 const CONFUSING_FORMS: [&str; 6] = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"];
 
diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 724230833e..e229a02c7a 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -11,7 +11,7 @@ use super::{Amount, SignedAmount};
 
 /// Result of an operation on [`Amount`] or [`SignedAmount`].
 ///
-/// The type parameter `T` should be normally `Amout` or `SignedAmount`.
+/// The type parameter `T` should be normally `Amount` or `SignedAmount`.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[must_use]
 pub enum NumOpResult<T> {

From 1d2de62e01e5759fbe944dc388ba985f09226061 Mon Sep 17 00:00:00 2001
From: kilavvy <140459108+kilavvy@users.noreply.github.com>
Date: Fri, 28 Feb 2025 12:34:21 +0100
Subject: [PATCH 423/554] Update mod.rs

---
 units/src/amount/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index e5e23417c8..345c3badfb 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -139,7 +139,7 @@ impl Denomination {
     }
 }
 
-/// These form are ambigous and could have many meanings.  For example, M could denote Mega or Milli.
+/// These form are ambiguous and could have many meanings.  For example, M could denote Mega or Milli.
 /// If any of these forms are used, an error type `PossiblyConfusingDenomination` is returned.
 const CONFUSING_FORMS: [&str; 6] = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"];
 

From f61941bbe66f19fe9b583a8154542214d4e0982c Mon Sep 17 00:00:00 2001
From: kilavvy <140459108+kilavvy@users.noreply.github.com>
Date: Fri, 28 Feb 2025 12:34:45 +0100
Subject: [PATCH 424/554] Update serialized_signature.rs

---
 bitcoin/src/taproot/serialized_signature.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/taproot/serialized_signature.rs b/bitcoin/src/taproot/serialized_signature.rs
index d007306019..2bc849b846 100644
--- a/bitcoin/src/taproot/serialized_signature.rs
+++ b/bitcoin/src/taproot/serialized_signature.rs
@@ -217,7 +217,7 @@ mod into_iter {
 
         #[inline]
         fn size_hint(&self) -> (usize, Option<usize>) {
-            // can't underlflow thanks to the invariant
+            // can't underflow thanks to the invariant
             let len = self.signature.len() - self.pos;
             (len, Some(len))
         }

From 0ce622e66890f81bb5391a666cfd58e587a4d378 Mon Sep 17 00:00:00 2001
From: kilavvy <140459108+kilavvy@users.noreply.github.com>
Date: Fri, 28 Feb 2025 12:35:17 +0100
Subject: [PATCH 425/554] Update message.rs

---
 bitcoin/src/p2p/message.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/p2p/message.rs b/bitcoin/src/p2p/message.rs
index fda7cdd471..d02483a7f8 100644
--- a/bitcoin/src/p2p/message.rs
+++ b/bitcoin/src/p2p/message.rs
@@ -27,7 +27,7 @@ use crate::{block, consensus, transaction};
 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`
+/// This by necessity should be larger tham `MAX_VEC_SIZE`
 pub const MAX_MSG_SIZE: usize = 5_000_000;
 
 /// Serializer for command string

From bb8f833ca01688eaae75e0fa322f698d34243185 Mon Sep 17 00:00:00 2001
From: kilavvy <140459108+kilavvy@users.noreply.github.com>
Date: Fri, 28 Feb 2025 12:35:52 +0100
Subject: [PATCH 426/554] Update instruction.rs

---
 bitcoin/src/blockdata/script/instruction.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/script/instruction.rs b/bitcoin/src/blockdata/script/instruction.rs
index 6ec3d56130..575ba6311a 100644
--- a/bitcoin/src/blockdata/script/instruction.rs
+++ b/bitcoin/src/blockdata/script/instruction.rs
@@ -31,7 +31,7 @@ impl Instruction<'_> {
         }
     }
 
-    /// Returns the number interpretted by the script parser
+    /// Returns the number interpreted by the script parser
     /// if it can be coerced into a number.
     ///
     /// This does not require the script num to be minimal.

From c810a0ad58a71e57b1dbcf583fd50136e6c195ea Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 1 Mar 2025 01:50:11 +0000
Subject: [PATCH 427/554] Automated update to Github CI to rustc
 nightly-2025-02-28

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 48d0eb4ab6..bd3641e459 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-02-21
+nightly-2025-02-28

From 166e37161a2412c716e82f7046da304d4788a3c9 Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 2 Mar 2025 01:22:29 +0000
Subject: [PATCH 428/554] 2025-03-02 automated rustfmt nightly

---
 bitcoin/src/address/mod.rs                    |  3 +--
 bitcoin/src/address/script_pubkey.rs          |  3 +--
 .../src/blockdata/script/witness_program.rs   |  4 +--
 bitcoin/src/blockdata/witness.rs              | 27 +++++++++++--------
 bitcoin/src/crypto/sighash.rs                 |  4 +--
 hashes/src/sha256t/mod.rs                     |  4 +--
 primitives/src/script/owned.rs                |  8 +++---
 primitives/src/transaction.rs                 |  4 ++-
 8 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 59d47e0dbb..72a3ec7db6 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -92,7 +92,7 @@ pub enum AddressType {
     /// Pay to taproot.
     P2tr,
     /// Pay to anchor.
-    P2a
+    P2a,
 }
 
 impl fmt::Display for AddressType {
@@ -1531,7 +1531,6 @@ mod tests {
         assert_eq!(rinsed, foo_unchecked);
     }
 
-
     #[test]
     fn pay_to_anchor_address_regtest() {
         // Verify that p2a uses the expected address for regtest.
diff --git a/bitcoin/src/address/script_pubkey.rs b/bitcoin/src/address/script_pubkey.rs
index 208b5e8464..7c048680e9 100644
--- a/bitcoin/src/address/script_pubkey.rs
+++ b/bitcoin/src/address/script_pubkey.rs
@@ -10,9 +10,8 @@ use crate::key::{
     XOnlyPublicKey,
 };
 use crate::opcodes::all::*;
-use crate::script::witness_program::WitnessProgram;
+use crate::script::witness_program::{WitnessProgram, P2A_PROGRAM};
 use crate::script::witness_version::WitnessVersion;
-use crate::script::witness_program::P2A_PROGRAM;
 use crate::script::{
     self, Builder, PushBytes, RedeemScriptSizeError, Script, ScriptBuf, ScriptExt as _, ScriptHash,
     WScriptHash, WitnessScriptSizeError,
diff --git a/bitcoin/src/blockdata/script/witness_program.rs b/bitcoin/src/blockdata/script/witness_program.rs
index 989f722570..e0fe7bc60e 100644
--- a/bitcoin/src/blockdata/script/witness_program.rs
+++ b/bitcoin/src/blockdata/script/witness_program.rs
@@ -26,7 +26,7 @@ pub const MIN_SIZE: usize = 2;
 pub const MAX_SIZE: usize = 40;
 
 /// The P2A program which is given by 0x4e73.
-pub(crate) const P2A_PROGRAM: [u8;2] = [78, 115];
+pub(crate) const P2A_PROGRAM: [u8; 2] = [78, 115];
 
 /// The segregated witness program.
 ///
@@ -110,7 +110,7 @@ impl WitnessProgram {
 
     /// Constructs a new pay to anchor address
     pub const fn p2a() -> Self {
-        WitnessProgram { version: WitnessVersion::V1, program: ArrayVec::from_slice(&P2A_PROGRAM)}
+        WitnessProgram { version: WitnessVersion::V1, program: ArrayVec::from_slice(&P2A_PROGRAM) }
     }
 
     /// Returns the witness program version.
diff --git a/bitcoin/src/blockdata/witness.rs b/bitcoin/src/blockdata/witness.rs
index d0ac6f526d..99d42f3166 100644
--- a/bitcoin/src/blockdata/witness.rs
+++ b/bitcoin/src/blockdata/witness.rs
@@ -13,7 +13,10 @@ use crate::crypto::ecdsa;
 use crate::prelude::Vec;
 #[cfg(doc)]
 use crate::script::ScriptExt as _;
-use crate::taproot::{self, LeafScript, LeafVersion, TAPROOT_ANNEX_PREFIX, TAPROOT_CONTROL_BASE_SIZE, TAPROOT_LEAF_MASK};
+use crate::taproot::{
+    self, LeafScript, LeafVersion, TAPROOT_ANNEX_PREFIX, TAPROOT_CONTROL_BASE_SIZE,
+    TAPROOT_LEAF_MASK,
+};
 use crate::Script;
 
 #[rustfmt::skip]                // Keep public re-exports separate.
@@ -249,14 +252,16 @@ impl<'a> P2TrSpend<'a> {
         // for the fact that annex is still there.
         match witness.len() {
             0 => None,
-            1 => Some(P2TrSpend::Key { /* signature: witness.last().expect("len > 0") ,*/ annex: None }),
+            1 => Some(P2TrSpend::Key {
+                /* signature: witness.last().expect("len > 0") ,*/ annex: None,
+            }),
             2 if witness.last().expect("len > 0").starts_with(&[TAPROOT_ANNEX_PREFIX]) => {
                 let spend = P2TrSpend::Key {
                     // signature: witness.second_to_last().expect("len > 1"),
                     annex: witness.last(),
                 };
                 Some(spend)
-            },
+            }
             // 2 => this is script spend without annex - same as when there are 3+ elements and the
             //   last one does NOT start with TAPROOT_ANNEX_PREFIX. This is handled in the catchall
             //   arm.
@@ -267,7 +272,7 @@ impl<'a> P2TrSpend<'a> {
                     annex: witness.last(),
                 };
                 Some(spend)
-            },
+            }
             _ => {
                 let spend = P2TrSpend::Script {
                     leaf_script: Script::from_bytes(witness.second_to_last().expect("len > 1")),
@@ -275,7 +280,7 @@ impl<'a> P2TrSpend<'a> {
                     annex: None,
                 };
                 Some(spend)
-            },
+            }
         }
     }
 
@@ -390,7 +395,8 @@ mod test {
     #[test]
     fn get_taproot_leaf_script() {
         let tapscript = hex!("deadbeef");
-        let control_block = hex!("c0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+        let control_block =
+            hex!("c0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
         // annex starting with 0x50 causes the branching logic.
         let annex = hex!("50");
 
@@ -403,10 +409,8 @@ mod test {
         let witness = deserialize::<Witness>(&witness_serialized[..]).unwrap();
         let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
 
-        let expected_leaf_script = LeafScript {
-            version: LeafVersion::TapScript,
-            script: Script::from_bytes(&tapscript),
-        };
+        let expected_leaf_script =
+            LeafScript { version: LeafVersion::TapScript, script: Script::from_bytes(&tapscript) };
 
         // With or without annex, the tapscript should be returned.
         assert_eq!(witness.taproot_leaf_script().unwrap(), expected_leaf_script);
@@ -451,7 +455,8 @@ mod test {
 
         let witness = deserialize::<Witness>(&witness_serialized[..]).unwrap();
         let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
-        let witness_key_spend_annex = deserialize::<Witness>(&witness_serialized_key_spend_annex[..]).unwrap();
+        let witness_key_spend_annex =
+            deserialize::<Witness>(&witness_serialized_key_spend_annex[..]).unwrap();
 
         // With or without annex, the tapscript should be returned.
         assert_eq!(witness.taproot_control_block(), Some(&control_block[..]));
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index e1deed7e27..4c608e94f1 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -435,9 +435,7 @@ impl EcdsaSighashType {
     /// type (after masking with 0x1f), regardless of the ANYONECANPAY flag.
     ///
     /// See: <https://github.com/bitcoin/bitcoin/blob/e486597/src/script/interpreter.cpp#L1618-L1619>
-    pub fn is_single(&self) -> bool {
-        matches!(self, Self::Single | Self::SinglePlusAnyoneCanPay)
-    }
+    pub fn is_single(&self) -> bool { matches!(self, Self::Single | Self::SinglePlusAnyoneCanPay) }
 
     /// Constructs a new [`EcdsaSighashType`] from a raw `u32`.
     ///
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 22f835412a..19a6ef7680 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -129,9 +129,7 @@ impl<T: Tag> Default for HashEngine<T> {
 }
 
 impl<T: Tag> Clone for HashEngine<T> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone(), PhantomData)
-    }
+    fn clone(&self) -> Self { Self(self.0.clone(), PhantomData) }
 }
 
 impl<T: Tag> crate::HashEngine for HashEngine<T> {
diff --git a/primitives/src/script/owned.rs b/primitives/src/script/owned.rs
index f3c78516e3..3ab7b68294 100644
--- a/primitives/src/script/owned.rs
+++ b/primitives/src/script/owned.rs
@@ -61,7 +61,9 @@ impl ScriptBuf {
 
     /// Constructs a new empty script with pre-allocated capacity.
     #[inline]
-    pub fn with_capacity(capacity: usize) -> Self { ScriptBuf::from_bytes(Vec::with_capacity(capacity)) }
+    pub fn with_capacity(capacity: usize) -> Self {
+        ScriptBuf::from_bytes(Vec::with_capacity(capacity))
+    }
 
     /// Pre-allocates at least `additional_len` bytes if needed.
     ///
@@ -96,9 +98,7 @@ impl ScriptBuf {
     ///
     /// It is guaranteed that `script.capacity() >= script.len()` always holds.
     #[inline]
-    pub fn capacity(&self) -> usize {
-        self.0.capacity()
-    }
+    pub fn capacity(&self) -> usize { self.0.capacity() }
 }
 
 impl Deref for ScriptBuf {
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index cf24946fb9..d1ec78b02d 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -547,7 +547,9 @@ impl Version {
     /// As of Bitcoin Core 28.0 ([release notes](https://bitcoincore.org/en/releases/28.0/)),
     /// versions 1, 2, and 3 are considered standard.
     #[inline]
-    pub fn is_standard(&self) -> bool { *self == Version::ONE || *self == Version::TWO || *self == Version::THREE }
+    pub fn is_standard(&self) -> bool {
+        *self == Version::ONE || *self == Version::TWO || *self == Version::THREE
+    }
 }
 
 impl fmt::Display for Version {

From f80cf2cb2aa318978da3a6c5df49d82c49344763 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?19=E5=B9=B4=E6=A2=A6=E9=86=92?=
 <3949379+getong@users.noreply.github.com>
Date: Sun, 2 Mar 2025 02:04:31 +0800
Subject: [PATCH 429/554] update secp256k1 to 0.30.0

---
 Cargo-minimal.lock                  | 13 ++++++++++---
 Cargo-recent.lock                   | 13 ++++++++++---
 bitcoin/Cargo.toml                  |  4 ++--
 bitcoin/examples/sign-tx-taproot.rs |  2 +-
 bitcoin/examples/taproot-psbt.rs    |  2 +-
 bitcoin/src/bip32.rs                | 21 +++++++++++++++------
 bitcoin/src/crypto/key.rs           | 11 +++++++++--
 bitcoin/src/crypto/sighash.rs       |  3 ++-
 bitcoin/src/crypto/taproot.rs       | 14 ++++++++++----
 bitcoin/src/psbt/mod.rs             |  8 ++++----
 bitcoin/src/psbt/serialize.rs       |  5 ++++-
 bitcoin/src/sign_message.rs         |  4 ++--
 bitcoin/src/taproot/mod.rs          |  6 ++++--
 13 files changed, 74 insertions(+), 32 deletions(-)

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 228661483a..83c663c9cd 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -55,7 +55,7 @@ dependencies = [
  "bech32",
  "bincode",
  "bitcoin-internals",
- "bitcoin-io",
+ "bitcoin-io 0.2.0",
  "bitcoin-primitives",
  "bitcoin-units",
  "bitcoin_hashes 0.16.0",
@@ -92,6 +92,12 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "bitcoin-io"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf"
+
 [[package]]
 name = "bitcoin-io"
 version = "0.2.0"
@@ -132,6 +138,7 @@ version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16"
 dependencies = [
+ "bitcoin-io 0.1.3",
  "hex-conservative 0.2.0",
 ]
 
@@ -333,9 +340,9 @@ checksum = "c92464b447c0ee8c4fb3824ecc8383b81717b9f1e74ba2e72540aef7b9f82997"
 
 [[package]]
 name = "secp256k1"
-version = "0.29.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e0cc0f1cf93f4969faf3ea1c7d8a9faed25918d96affa959720823dfe86d4f3"
+checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
 dependencies = [
  "bitcoin_hashes 0.14.0",
  "rand",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index 2b4ef7378b..bb8ec5132d 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -54,7 +54,7 @@ dependencies = [
  "bech32",
  "bincode",
  "bitcoin-internals",
- "bitcoin-io",
+ "bitcoin-io 0.2.0",
  "bitcoin-primitives",
  "bitcoin-units",
  "bitcoin_hashes 0.16.0",
@@ -91,6 +91,12 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "bitcoin-io"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf"
+
 [[package]]
 name = "bitcoin-io"
 version = "0.2.0"
@@ -131,6 +137,7 @@ version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16"
 dependencies = [
+ "bitcoin-io 0.1.3",
  "hex-conservative 0.2.1",
 ]
 
@@ -334,9 +341,9 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "secp256k1"
-version = "0.29.1"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113"
+checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
 dependencies = [
  "bitcoin_hashes 0.14.0",
  "rand",
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index ab765c7e2f..56629a46c9 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -17,7 +17,7 @@ exclude = ["tests", "contrib"]
 [features]
 default = [ "std", "secp-recovery" ]
 std = ["base58/std", "bech32/std", "hashes/std", "hex/std", "internals/std", "io/std", "primitives/std", "secp256k1/std", "units/std", "bitcoinconsensus?/std"]
-rand-std = ["secp256k1/rand-std", "std"]
+rand-std = ["secp256k1/rand", "std"]
 rand = ["secp256k1/rand"]
 serde = ["dep:serde", "hashes/serde", "internals/serde", "primitives/serde", "secp256k1/serde", "units/serde"]
 secp-lowmemory = ["secp256k1/lowmemory"]
@@ -32,7 +32,7 @@ hex = { package = "hex-conservative", version = "0.3.0", default-features = fals
 internals = { package = "bitcoin-internals", version = "0.4.0", features = ["alloc"] }
 io = { package = "bitcoin-io", version = "0.2.0", default-features = false, features = ["alloc", "hashes"] }
 primitives = { package = "bitcoin-primitives", version = "0.101.0", default-features = false, features = ["alloc"] }
-secp256k1 = { version = "0.29.0", default-features = false, features = ["hashes", "alloc"] }
+secp256k1 = { version = "0.30.0", default-features = false, features = ["hashes", "alloc", "rand"] }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false, features = ["alloc"] }
 
 arbitrary = { version = "1.4", optional = true }
diff --git a/bitcoin/examples/sign-tx-taproot.rs b/bitcoin/examples/sign-tx-taproot.rs
index ade7f2dcfb..df7532cbd8 100644
--- a/bitcoin/examples/sign-tx-taproot.rs
+++ b/bitcoin/examples/sign-tx-taproot.rs
@@ -71,7 +71,7 @@ fn main() {
     // Sign the sighash using the secp256k1 library (exported by rust-bitcoin).
     let tweaked: TweakedKeypair = keypair.tap_tweak(&secp, None);
     let msg = Message::from(sighash);
-    let signature = secp.sign_schnorr(&msg, &tweaked.to_inner());
+    let signature = secp.sign_schnorr(msg.as_ref(), &tweaked.to_inner());
 
     // Update the witness stack.
     let signature = bitcoin::taproot::Signature { signature, sighash_type };
diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index c312cf3d7a..c5bb6d34ed 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -749,7 +749,7 @@ fn sign_psbt_taproot(
     };
 
     let msg = secp256k1::Message::from(hash);
-    let signature = secp.sign_schnorr(&msg, &keypair);
+    let signature = secp.sign_schnorr(msg.as_ref(), &keypair);
 
     let final_signature = taproot::Signature { signature, sighash_type };
 
diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 832b497ad6..a25ff424dd 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -593,7 +593,9 @@ impl Xpriv {
             depth: 0,
             parent_fingerprint: Default::default(),
             child_number: ChildNumber::ZERO_NORMAL,
-            private_key: secp256k1::SecretKey::from_slice(&hmac_result.as_ref()[..32])?,
+            private_key: secp256k1::SecretKey::from_byte_array(
+                &hmac_result.as_ref()[..32].try_into().expect("Slice should be exactly 32 bytes"),
+            )?,
             chain_code: ChainCode::from_hmac(hmac_result),
         })
     }
@@ -665,8 +667,10 @@ impl Xpriv {
 
         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.as_ref()[..32])
-            .expect("statistically impossible to hit");
+        let sk = secp256k1::SecretKey::from_byte_array(
+            &hmac_result.as_ref()[..32].try_into().expect("statistically impossible to hit"),
+        )
+        .expect("statistically impossible to hit");
         let tweaked =
             sk.add_tweak(&self.private_key.into()).expect("statistically impossible to hit");
 
@@ -705,7 +709,9 @@ impl Xpriv {
             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])?,
+            private_key: secp256k1::SecretKey::from_byte_array(
+                &data[46..78].try_into().expect("Slice should be exactly 32 bytes"),
+            )?,
         })
     }
 
@@ -812,8 +818,11 @@ impl Xpub {
                 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.as_ref()[..32])?;
+                let private_key = secp256k1::SecretKey::from_byte_array(
+                    &hmac_result.as_ref()[..32]
+                        .try_into()
+                        .expect("Slice should be exactly 32 bytes"),
+                )?;
                 let chain_code = ChainCode::from_hmac(hmac_result);
                 Ok((private_key, chain_code))
             }
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 69472b319a..7a045cfb5c 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -464,7 +464,12 @@ impl PrivateKey {
         data: &[u8],
         network: impl Into<NetworkKind>,
     ) -> Result<PrivateKey, secp256k1::Error> {
-        Ok(PrivateKey::new(secp256k1::SecretKey::from_slice(data)?, network))
+        Ok(PrivateKey::new(
+            secp256k1::SecretKey::from_byte_array(
+                data[..32].try_into().expect("Slice should be exactly 32 bytes"),
+            )?,
+            network,
+        ))
     }
 
     /// Formats the private key to WIF format.
@@ -519,7 +524,9 @@ impl PrivateKey {
         Ok(PrivateKey {
             compressed,
             network,
-            inner: secp256k1::SecretKey::from_slice(&data[1..33])?,
+            inner: secp256k1::SecretKey::from_byte_array(
+                &data[1..33].try_into().expect("Slice should be exactly 32 bytes"),
+            )?,
         })
     }
 }
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index e1deed7e27..ad99c3844e 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -2027,7 +2027,8 @@ mod tests {
                 .unwrap();
 
             let msg = secp256k1::Message::from(sighash);
-            let key_spend_sig = secp.sign_schnorr_with_aux_rand(&msg, &tweaked_keypair, &[0u8; 32]);
+            let key_spend_sig =
+                secp.sign_schnorr_with_aux_rand(msg.as_ref(), &tweaked_keypair, &[0u8; 32]);
 
             assert_eq!(expected.internal_pubkey, internal_key);
             assert_eq!(expected.tweak, tweak);
diff --git a/bitcoin/src/crypto/taproot.rs b/bitcoin/src/crypto/taproot.rs
index a0c73309ea..7a19f579ff 100644
--- a/bitcoin/src/crypto/taproot.rs
+++ b/bitcoin/src/crypto/taproot.rs
@@ -32,13 +32,17 @@ impl Signature {
         match sl.len() {
             64 => {
                 // default type
-                let signature = secp256k1::schnorr::Signature::from_slice(sl)?;
+                let signature = secp256k1::schnorr::Signature::from_byte_array(
+                    sl[0..64].try_into().expect("Slice should be exactly 64 bytes"),
+                );
                 Ok(Signature { signature, sighash_type: TapSighashType::Default })
             }
             65 => {
                 let (sighash_type, signature) = sl.split_last().expect("slice len checked == 65");
                 let sighash_type = TapSighashType::from_consensus_u8(*sighash_type)?;
-                let signature = secp256k1::schnorr::Signature::from_slice(signature)?;
+                let signature = secp256k1::schnorr::Signature::from_byte_array(
+                    signature[0..64].try_into().expect("Slice should be exactly 64 bytes"),
+                );
                 Ok(Signature { signature, sighash_type })
             }
             len => Err(SigFromSliceError::InvalidSignatureSize(len)),
@@ -70,7 +74,7 @@ impl Signature {
     /// You can get a slice from it using deref coercions or turn it into an iterator.
     pub fn serialize(self) -> SerializedSignature {
         let mut buf = [0; serialized_signature::MAX_LEN];
-        let ser_sig = self.signature.serialize();
+        let ser_sig = self.signature.to_byte_array();
         buf[..64].copy_from_slice(&ser_sig);
         let len = if self.sighash_type == TapSighashType::Default {
             // default sighash type, don't add extra sighash byte
@@ -140,7 +144,9 @@ impl<'a> Arbitrary<'a> for Signature {
         let arbitrary_bytes: [u8; secp256k1::constants::SCHNORR_SIGNATURE_SIZE] = u.arbitrary()?;
 
         Ok(Signature {
-            signature: secp256k1::schnorr::Signature::from_slice(&arbitrary_bytes).unwrap(),
+            signature: secp256k1::schnorr::Signature::from_byte_array(
+                arbitrary_bytes[0..64].try_into().expect("Slice should be exactly 64 bytes"),
+            ),
             sighash_type: TapSighashType::arbitrary(u)?,
         })
     }
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 2471fc41d5..d7d6c799ff 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -445,9 +445,9 @@ impl Psbt {
                         .to_inner();
 
                     #[cfg(feature = "rand-std")]
-                    let signature = secp.sign_schnorr(&msg, &key_pair);
+                    let signature = secp.sign_schnorr(msg.as_ref(), &key_pair);
                     #[cfg(not(feature = "rand-std"))]
-                    let signature = secp.sign_schnorr_no_aux_rand(&msg, &key_pair);
+                    let signature = secp.sign_schnorr_no_aux_rand(msg.as_ref(), &key_pair);
 
                     let signature = taproot::Signature { signature, sighash_type };
                     input.tap_key_sig = Some(signature);
@@ -472,9 +472,9 @@ impl Psbt {
                             self.sighash_taproot(input_index, cache, Some(lh))?;
 
                         #[cfg(feature = "rand-std")]
-                        let signature = secp.sign_schnorr(&msg, &key_pair);
+                        let signature = secp.sign_schnorr(msg.as_ref(), &key_pair);
                         #[cfg(not(feature = "rand-std"))]
-                        let signature = secp.sign_schnorr_no_aux_rand(&msg, &key_pair);
+                        let signature = secp.sign_schnorr_no_aux_rand(msg.as_ref(), &key_pair);
 
                         let signature = taproot::Signature { signature, sighash_type };
                         input.tap_script_sigs.insert((xonly, lh), signature);
diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
index 5b505d4b77..26bfc9b320 100644
--- a/bitcoin/src/psbt/serialize.rs
+++ b/bitcoin/src/psbt/serialize.rs
@@ -260,7 +260,10 @@ impl Serialize for XOnlyPublicKey {
 
 impl Deserialize for XOnlyPublicKey {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        XOnlyPublicKey::from_slice(bytes).map_err(|_| Error::InvalidXOnlyPublicKey)
+        XOnlyPublicKey::from_byte_array(
+            bytes[..32].try_into().expect("statistically impossible to hit"),
+        )
+        .map_err(|_| Error::InvalidXOnlyPublicKey)
     }
 }
 
diff --git a/bitcoin/src/sign_message.rs b/bitcoin/src/sign_message.rs
index 045544d5e3..d5f2be8481 100644
--- a/bitcoin/src/sign_message.rs
+++ b/bitcoin/src/sign_message.rs
@@ -104,7 +104,7 @@ mod message_signing {
         pub fn serialize(&self) -> [u8; 65] {
             let (recid, raw) = self.signature.serialize_compact();
             let mut serialized = [0u8; 65];
-            serialized[0] = recid.to_i32() as u8 + if self.compressed { 31 } else { 27 };
+            serialized[0] = i32::from(recid) as u8 + if self.compressed { 31 } else { 27 };
             serialized[1..].copy_from_slice(&raw[..]);
             serialized
         }
@@ -115,7 +115,7 @@ mod message_signing {
             if bytes[0] < 27 {
                 return Err(secp256k1::Error::InvalidRecoveryId);
             };
-            let recid = RecoveryId::from_i32(((bytes[0] - 27) & 0x03) as i32)?;
+            let recid = RecoveryId::try_from(((bytes[0] - 27) & 0x03) as i32)?;
             Ok(MessageSignature {
                 signature: RecoverableSignature::from_compact(&bytes[1..], recid)?,
                 compressed: ((bytes[0] - 27) & 0x04) != 0,
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 89fa711dbf..78616db365 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -1168,8 +1168,10 @@ impl ControlBlock {
         };
 
         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 internal_key = UntweakedPublicKey::from_byte_array(
+            &sl[1..TAPROOT_CONTROL_BASE_SIZE].try_into().expect("Slice should be exactly 32 bytes"),
+        )
+        .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 })
     }

From 8bb9ce3e472993f5820d9d66337343e5f956b937 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 05:20:01 +1100
Subject: [PATCH 430/554] Add tests for amount op int

We aim to support three ops on amount types that use an integer for the
right hand size. Prove that implement them.
---
 units/src/amount/tests.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index d3463660f7..e021448bce 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1289,6 +1289,15 @@ fn num_op_result_ops_integer() {
         }
     }
     check_op! {
+        // Operations on an amount type and an integer.
+        let _ = sat * 3_u64; // Explicit type for the benefit of the reader.
+        let _ = sat / 3;
+        let _ = sat % 3;
+
+        let _ = ssat * 3_i64; // Explicit type for the benefit of the reader.
+        let _ = ssat / 3;
+        let _ = ssat % 3;
+
         // Operations on a `NumOpResult` and integer.
         let _ = res * 3_u64; // Explicit type for the benefit of the reader.
         let _ = res / 3;

From 47923957b19c04ad8db131785adffe44bc542ebe Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 07:02:30 +1100
Subject: [PATCH 431/554] Improve add/sub tests for amount types

Add a few macros to test `Add` and `Sub` impls for both amount types,
all combos of type and res (eg `Amount` and `NumOpResult<Amount>`), and
all combos of references.
---
 units/src/amount/tests.rs | 96 ++++++++++++++++++---------------------
 1 file changed, 45 insertions(+), 51 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index e021448bce..f4b1010234 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1127,64 +1127,58 @@ fn trailing_zeros_for_amount() {
 }
 
 #[test]
-#[allow(clippy::op_ref)]
-fn unsigned_addition() {
-    let sat = Amount::from_sat;
-
-    let one = sat(1);
-    let two = sat(2);
-    let three = sat(3);
-
-    assert!((one + two) == three.into());
-    assert!((one + two) == three.into());
-    assert!((&one + two) == three.into());
-    assert!((one + &two) == three.into());
-    assert!((&one + &two) == three.into());
-}
-
-#[test]
-#[allow(clippy::op_ref)]
-fn unsigned_subtract() {
-    let sat = Amount::from_sat;
-
-    let one = sat(1);
-    let two = sat(2);
-    let three = sat(3);
+fn add_sub_combos() {
+    // Checks lhs op rhs for all reference combos.
+    macro_rules! check_ref {
+        ($($lhs:ident $op:tt $rhs:ident = $ans:ident);* $(;)?) => {
+            $(
+                assert_eq!($lhs $op $rhs, $ans);
+                assert_eq!(&$lhs $op $rhs, $ans);
+                assert_eq!($lhs $op &$rhs, $ans);
+                assert_eq!(&$lhs $op &$rhs, $ans);
+            )*
+        }
+    }
 
-    assert!(three - two == one.into());
-    assert!(&three - two == one.into());
-    assert!(three - &two == one.into());
-    assert!(&three - &two == one.into());
-}
+    // Checks lhs op rhs for all amount and `NumOpResult` combos.
+    macro_rules! check_res {
+        ($($amount:ident, $op:tt, $lhs:literal, $rhs:literal, $ans:literal);* $(;)?) => {
+            $(
+                let amt = |sat| $amount::from_sat(sat);
 
-#[test]
-#[allow(clippy::op_ref)]
-fn signed_addition() {
-    let ssat = SignedAmount::from_sat;
+                let sat_lhs = amt($lhs);
+                let sat_rhs = amt($rhs);
 
-    let one = ssat(1);
-    let two = ssat(2);
-    let three = ssat(3);
+                let res_lhs = NumOpResult::from(sat_lhs);
+                let res_rhs = NumOpResult::from(sat_rhs);
 
-    assert!(one + two == three.into());
-    assert!(&one + two == three.into());
-    assert!(one + &two == three.into());
-    assert!(&one + &two == three.into());
-}
+                let ans = NumOpResult::from(amt($ans));
 
-#[test]
-#[allow(clippy::op_ref)]
-fn signed_subtract() {
-    let ssat = SignedAmount::from_sat;
+                check_ref! {
+                    sat_lhs $op sat_rhs = ans;
+                    sat_lhs $op res_rhs = ans;
+                    res_lhs $op sat_rhs = ans;
+                    res_lhs $op res_rhs = ans;
+                }
+            )*
+        }
+    }
 
-    let one = ssat(1);
-    let two = ssat(2);
-    let three = ssat(3);
+    // Checks lhs op rhs for both amount types.
+    macro_rules! check_op {
+        ($($lhs:literal $op:tt $rhs:literal = $ans:literal);* $(;)?) => {
+            $(
+                check_res!(Amount, $op, $lhs, $rhs, $ans);
+                check_res!(SignedAmount, $op, $lhs, $rhs, $ans);
+            )*
+        }
+    }
 
-    assert!(three - two == one.into());
-    assert!(&three - two == one.into());
-    assert!(three - &two == one.into());
-    assert!(&three - &two == one.into());
+    // We do not currently support division involving `NumOpResult` and an amount type.
+    check_op! {
+        307 + 461 = 768;
+        461 - 307 = 154;
+    }
 }
 
 #[test]

From 851080d3b19eecea147224f8a36f9788d3e7d328 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 07:26:16 +1100
Subject: [PATCH 432/554] Add more add/sub tests

Add units tests for various values including negative values.
---
 units/src/amount/tests.rs | 55 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index f4b1010234..fc2dd2f594 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1181,6 +1181,61 @@ fn add_sub_combos() {
     }
 }
 
+#[test]
+fn unsigned_addition() {
+    let sat = Amount::from_sat;
+
+    assert_eq!(sat(0) + sat(0), NumOpResult::from(sat(0)));
+    assert_eq!(sat(0) + sat(307), NumOpResult::from(sat(307)));
+    assert_eq!(sat(307) + sat(0), NumOpResult::from(sat(307)));
+    assert_eq!(sat(307) + sat(461), NumOpResult::from(sat(768)));
+    assert_eq!(sat(0) + Amount::MAX_MONEY, NumOpResult::from(Amount::MAX_MONEY));
+}
+
+#[test]
+fn signed_addition() {
+    let ssat = SignedAmount::from_sat;
+
+    assert_eq!(ssat(0) + ssat(0), NumOpResult::from(ssat(0)));
+    assert_eq!(ssat(0) + ssat(307), NumOpResult::from(ssat(307)));
+    assert_eq!(ssat(307) + ssat(0), NumOpResult::from(ssat(307)));
+    assert_eq!(ssat(307) + ssat(461), NumOpResult::from(ssat(768)));
+    assert_eq!(ssat(0) + SignedAmount::MAX_MONEY, NumOpResult::from(SignedAmount::MAX_MONEY));
+
+    assert_eq!(ssat(0) + ssat(-307), NumOpResult::from(ssat(-307)));
+    assert_eq!(ssat(-307) + ssat(0), NumOpResult::from(ssat(-307)));
+    assert_eq!(ssat(-307) + ssat(461), NumOpResult::from(ssat(154)));
+    assert_eq!(ssat(307) + ssat(-461), NumOpResult::from(ssat(-154)));
+    assert_eq!(ssat(-307) + ssat(-461), NumOpResult::from(ssat(-768)));
+    assert_eq!(SignedAmount::MAX_MONEY + -SignedAmount::MAX_MONEY, NumOpResult::from(SignedAmount::ZERO));
+}
+
+#[test]
+fn unsigned_subtraction() {
+    let sat = Amount::from_sat;
+
+    assert_eq!(sat(0) - sat(0), NumOpResult::from(sat(0)));
+    assert_eq!(sat(307) - sat(0), NumOpResult::from(sat(307)));
+    assert_eq!(sat(461) - sat(307), NumOpResult::from(sat(154)));
+}
+
+#[test]
+fn signed_subtraction() {
+    let ssat = SignedAmount::from_sat;
+
+    assert_eq!(ssat(0) - ssat(0), NumOpResult::from(ssat(0)));
+    assert_eq!(ssat(0) - ssat(307), NumOpResult::from(ssat(-307)));
+    assert_eq!(ssat(307) - ssat(0), NumOpResult::from(ssat(307)));
+    assert_eq!(ssat(307) - ssat(461), NumOpResult::from(ssat(-154)));
+    assert_eq!(ssat(0) - SignedAmount::MAX_MONEY, NumOpResult::from(-SignedAmount::MAX_MONEY));
+
+    assert_eq!(ssat(0) - ssat(-307), NumOpResult::from(ssat(307)));
+    assert_eq!(ssat(-307) - ssat(0), NumOpResult::from(ssat(-307)));
+    assert_eq!(ssat(-307) - ssat(461), NumOpResult::from(ssat(-768)));
+    assert_eq!(ssat(307) - ssat(-461), NumOpResult::from(ssat(768)));
+    assert_eq!(ssat(-307) - ssat(-461), NumOpResult::from(ssat(154)));
+}
+
 #[test]
 fn check_const() {
     assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);

From 501c9ab89e6cee63b4ba8e493393bfc1c544a225 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 07:47:33 +1100
Subject: [PATCH 433/554] Test amount ops that involve an integer

From the amount types `Div`, `Mul`, and `Rem` can have an integer on one
side. Test them - includes commented out test for one missing combo.
---
 units/src/amount/tests.rs | 46 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index fc2dd2f594..3ab69af1d9 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1207,7 +1207,10 @@ fn signed_addition() {
     assert_eq!(ssat(-307) + ssat(461), NumOpResult::from(ssat(154)));
     assert_eq!(ssat(307) + ssat(-461), NumOpResult::from(ssat(-154)));
     assert_eq!(ssat(-307) + ssat(-461), NumOpResult::from(ssat(-768)));
-    assert_eq!(SignedAmount::MAX_MONEY + -SignedAmount::MAX_MONEY, NumOpResult::from(SignedAmount::ZERO));
+    assert_eq!(
+        SignedAmount::MAX_MONEY + -SignedAmount::MAX_MONEY,
+        NumOpResult::from(SignedAmount::ZERO)
+    );
 }
 
 #[test]
@@ -1236,6 +1239,47 @@ fn signed_subtraction() {
     assert_eq!(ssat(-307) - ssat(-461), NumOpResult::from(ssat(154)));
 }
 
+#[test]
+fn op_int_combos() {
+    let sat = Amount::from_sat;
+    let ssat = SignedAmount::from_sat;
+
+    let res = |sat| NumOpResult::from(Amount::from_sat(sat));
+    let sres = |ssat| NumOpResult::from(SignedAmount::from_sat(ssat));
+
+    assert_eq!(sat(23) * 31, res(713));
+    assert_eq!(ssat(23) * 31, sres(713));
+    assert_eq!(res(23) * 31, res(713));
+    assert_eq!(sres(23) * 31, sres(713));
+
+    // assert_eq!(31 * sat(23), res(713));
+    // assert_eq!(31 * ssat(23), sres(713));
+
+    // No remainder.
+    assert_eq!(sat(1897) / 7, res(271));
+    assert_eq!(ssat(1897) / 7, sres(271));
+    assert_eq!(res(1897) / 7, res(271));
+    assert_eq!(sres(1897) / 7, sres(271));
+
+    // Truncation works as expected.
+    assert_eq!(sat(1901) / 7, res(271));
+    assert_eq!(ssat(1901) / 7, sres(271));
+    assert_eq!(res(1901) / 7, res(271));
+    assert_eq!(sres(1901) / 7, sres(271));
+
+    // No remainder.
+    assert_eq!(sat(1897) % 7, res(0));
+    assert_eq!(ssat(1897) % 7, sres(0));
+    assert_eq!(res(1897) % 7, res(0));
+    assert_eq!(sres(1897) % 7, sres(0));
+
+    // Remainder works as expected.
+    assert_eq!(sat(1901) % 7, res(4));
+    assert_eq!(ssat(1901) % 7, sres(4));
+    assert_eq!(res(1901) % 7, res(4));
+    assert_eq!(sres(1901) % 7, sres(4));
+}
+
 #[test]
 fn check_const() {
     assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);

From b57bfb9bc53107d7a2f6f9f7cb2f4c6c5d733534 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 07:51:54 +1100
Subject: [PATCH 434/554] Add missing Mul impls for amount types

Add and test missing `Mul` impls for both amount types.
---
 units/src/amount/result.rs | 20 ++++++++++++++++++++
 units/src/amount/tests.rs  |  6 ++++--
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 724230833e..5f1d7742b1 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -161,6 +161,16 @@ crate::internal_macros::impl_op_for_references! {
 
         fn mul(self, rhs: u64) -> Self::Output { self.and_then(|lhs| lhs * rhs) }
     }
+    impl ops::Mul<Amount> for u64 {
+        type Output = NumOpResult<Amount>;
+
+        fn mul(self, rhs: Amount) -> Self::Output { rhs.checked_mul(self).valid_or_error() }
+    }
+    impl ops::Mul<NumOpResult<Amount>> for u64 {
+        type Output = NumOpResult<Amount>;
+
+        fn mul(self, rhs: NumOpResult<Amount>) -> Self::Output { rhs.and_then(|rhs| self * rhs) }
+    }
 
     impl ops::Div<u64> for Amount {
         type Output = NumOpResult<Amount>;
@@ -221,6 +231,16 @@ crate::internal_macros::impl_op_for_references! {
 
         fn mul(self, rhs: i64) -> Self::Output { self.and_then(|lhs| lhs * rhs) }
     }
+    impl ops::Mul<SignedAmount> for i64 {
+        type Output = NumOpResult<SignedAmount>;
+
+        fn mul(self, rhs: SignedAmount) -> Self::Output { rhs.checked_mul(self).valid_or_error() }
+    }
+    impl ops::Mul<NumOpResult<SignedAmount>> for i64 {
+        type Output = NumOpResult<SignedAmount>;
+
+        fn mul(self, rhs: NumOpResult<SignedAmount>) -> Self::Output { rhs.and_then(|rhs| self * rhs) }
+    }
 
     impl ops::Div<i64> for SignedAmount {
         type Output = NumOpResult<SignedAmount>;
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 3ab69af1d9..4a87ba4208 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1252,8 +1252,10 @@ fn op_int_combos() {
     assert_eq!(res(23) * 31, res(713));
     assert_eq!(sres(23) * 31, sres(713));
 
-    // assert_eq!(31 * sat(23), res(713));
-    // assert_eq!(31 * ssat(23), sres(713));
+    assert_eq!(31 * sat(23), res(713));
+    assert_eq!(31 * ssat(23), sres(713));
+    assert_eq!(31 * res(23), res(713));
+    assert_eq!(31 * sres(23), sres(713));
 
     // No remainder.
     assert_eq!(sat(1897) / 7, res(271));

From 0a9f14f7b036c5232449d058fb6d425c8376d87a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 08:00:14 +1100
Subject: [PATCH 435/554] Implement Div by amount for amount types

It is semantically valid to divide an amount by another amount. The
result of the operation is an integer.

Note that we cannot implement `Div` by `NumOpResult` because there is no
way to show the div by invalid case.

Implement `Div` by amount for both amount types.
---
 units/src/amount/result.rs | 10 ++++++++++
 units/src/amount/tests.rs  | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+)

diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 5f1d7742b1..be106d6b1e 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -182,6 +182,11 @@ crate::internal_macros::impl_op_for_references! {
 
         fn div(self, rhs: u64) -> Self::Output { self.and_then(|lhs| lhs / rhs) }
     }
+    impl ops::Div<Amount> for Amount {
+        type Output = u64;
+
+        fn div(self, rhs: Amount) -> Self::Output { self.to_sat() / rhs.to_sat() }
+    }
 
     impl ops::Rem<u64> for Amount {
         type Output = NumOpResult<Amount>;
@@ -252,6 +257,11 @@ crate::internal_macros::impl_op_for_references! {
 
         fn div(self, rhs: i64) -> Self::Output { self.and_then(|lhs| lhs / rhs) }
     }
+    impl ops::Div<SignedAmount> for SignedAmount {
+        type Output = i64;
+
+        fn div(self, rhs: SignedAmount) -> Self::Output { self.to_sat() / rhs.to_sat() }
+    }
 
     impl ops::Rem<i64> for SignedAmount {
         type Output = NumOpResult<SignedAmount>;
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 4a87ba4208..b3e8593419 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -1282,6 +1282,38 @@ fn op_int_combos() {
     assert_eq!(sres(1901) % 7, sres(4));
 }
 
+#[test]
+fn unsigned_amount_div_by_amount() {
+    let sat = Amount::from_sat;
+
+    assert_eq!(sat(0) / sat(7), 0);
+    assert_eq!(sat(1897) / sat(7), 271);
+}
+
+#[test]
+#[should_panic(expected = "attempt to divide by zero")]
+fn unsigned_amount_div_by_amount_zero() {
+    let _ = Amount::from_sat(1897) / Amount::ZERO;
+}
+
+#[test]
+fn signed_amount_div_by_amount() {
+    let ssat = SignedAmount::from_sat;
+
+    assert_eq!(ssat(0) / ssat(7), 0);
+
+    assert_eq!(ssat(1897) / ssat(7), 271);
+    assert_eq!(ssat(1897) / ssat(-7), -271);
+    assert_eq!(ssat(-1897) / ssat(7), -271);
+    assert_eq!(ssat(-1897) / ssat(-7), 271);
+}
+
+#[test]
+#[should_panic(expected = "attempt to divide by zero")]
+fn signed_amount_div_by_amount_zero() {
+    let _ = SignedAmount::from_sat(1897) / SignedAmount::ZERO;
+}
+
 #[test]
 fn check_const() {
     assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);

From 5da506b506aa41b88aa7e8ecdffdcc0478ec72b6 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 19 Feb 2025 15:23:49 +1100
Subject: [PATCH 436/554] Add additional re-exports

As we do for other types add two new alias' at the crate root of
`primitives` and mirror it in `bitcoin`:

- `BlockVersion`
- `TransactionVersion`
---
 bitcoin/src/lib.rs    | 5 +++--
 primitives/src/lib.rs | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index af6386a40c..926cd78b6f 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -120,14 +120,15 @@ pub mod taproot;
 pub use primitives::{
     block::{
         Block, BlockHash, Checked as BlockChecked, Header as BlockHeader,
-        Unchecked as BlockUnchecked, Validation as BlockValidation, WitnessCommitment,
+        Unchecked as BlockUnchecked, Validation as BlockValidation, Version as BlockVersion,
+        WitnessCommitment,
     },
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
     opcodes::Opcode,
     pow::CompactTarget, // No `pow` module outside of `primitives`.
     script::{Script, ScriptBuf},
     sequence::{self, Sequence}, // No `sequence` module outside of `primitives`.
-    transaction::{OutPoint, Transaction, TxIn, TxOut, Txid, Wtxid},
+    transaction::{OutPoint, Transaction, TxIn, TxOut, Txid, Version as TransactionVersion, Wtxid},
     witness::Witness,
 };
 #[doc(inline)]
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index 451a3c1667..8c073af502 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -73,13 +73,13 @@ pub use self::{
 };
 #[doc(inline)]
 pub use self::{
-    block::{BlockHash, Header as BlockHeader, WitnessCommitment},
+    block::{BlockHash, Header as BlockHeader, Version as BlockVersion, WitnessCommitment},
     locktime::{absolute, relative},
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
     opcodes::Opcode,
     pow::CompactTarget,
     sequence::Sequence,
-    transaction::{OutPoint, Txid, Wtxid},
+    transaction::{OutPoint, Txid, Version as TransactionVersion, Wtxid},
 };
 
 #[rustfmt::skip]

From a74393324bd47f89fd47281d567ab15ab6bcb2ba Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 11:50:26 +1100
Subject: [PATCH 437/554] Move opcodes back to bitcoin

Duplicate `opcodes` in `bitcoin` and hide it in `primitives` so we do
not have to commit to the API.

We use opcodes in `impl fmt::Display for Script`.

Close: #4144
---
 bitcoin/src/blockdata/mod.rs          |   7 +-
 bitcoin/src/blockdata/opcodes.rs      | 901 ++++++++++++++++++++++++++
 bitcoin/src/blockdata/script/mod.rs   |   4 +-
 bitcoin/src/blockdata/script/tests.rs |   3 +-
 bitcoin/src/lib.rs                    |   4 +-
 primitives/src/lib.rs                 |   3 +-
 primitives/src/opcodes.rs             |   1 +
 7 files changed, 909 insertions(+), 14 deletions(-)
 create mode 100644 bitcoin/src/blockdata/opcodes.rs

diff --git a/bitcoin/src/blockdata/mod.rs b/bitcoin/src/blockdata/mod.rs
index 02fcb250ff..cc4b1ecb50 100644
--- a/bitcoin/src/blockdata/mod.rs
+++ b/bitcoin/src/blockdata/mod.rs
@@ -7,6 +7,7 @@
 
 pub mod block;
 pub mod constants;
+pub mod opcodes;
 pub mod script;
 pub mod transaction;
 pub mod witness;
@@ -70,12 +71,6 @@ pub mod locktime {
     }
 }
 
-/// Bitcoin script opcodes.
-pub mod opcodes {
-    /// Re-export everything from the [`primitives::opcodes`] module.
-    pub use primitives::opcodes::*;
-}
-
 /// Implements `Weight` and associated features.
 pub mod weight {
     /// Re-export everything from the [`units::weight`] module.
diff --git a/bitcoin/src/blockdata/opcodes.rs b/bitcoin/src/blockdata/opcodes.rs
new file mode 100644
index 0000000000..5da0295d39
--- /dev/null
+++ b/bitcoin/src/blockdata/opcodes.rs
@@ -0,0 +1,901 @@
+// 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::fmt;
+
+#[cfg(feature = "serde")]
+use crate::prelude::ToString;
+
+/// A script Opcode.
+///
+/// We do not implement Ord on this type because there is no natural ordering on opcodes, but there
+/// may appear to be one (e.g. because all the push opcodes appear in a consecutive block) and we
+/// don't want to encourage subtly buggy code. Please use [`Opcode::classify`] to distinguish different
+/// types of opcodes.
+///
+/// <details>
+///   <summary>Example of Core bug caused by assuming ordering</summary>
+///
+///   Bitcoin Core's `IsPushOnly` considers `OP_RESERVED` to be a "push code", allowing this opcode
+///   in contexts where only pushes are supposed to be allowed.
+/// </details>
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct Opcode {
+    code: u8,
+}
+
+use self::all::*;
+
+macro_rules! all_opcodes {
+    ($($op:ident => $val:expr, $doc:expr);*) => {
+        /// Enables wildcard imports to bring into scope all opcodes and nothing else.
+        ///
+        /// The `all` module is provided so one can use a wildcard import `use bitcoin::opcodes::all::*` to
+        /// get all the `OP_FOO` opcodes without getting other types defined in `opcodes` (e.g. `Opcode`, `Class`).
+        ///
+        /// This module is guaranteed to never contain anything except opcode constants and all opcode
+        /// constants are guaranteed to begin with OP_.
+        pub mod all {
+            use super::Opcode;
+            $(
+                #[doc = $doc]
+                pub const $op: Opcode = Opcode { code: $val};
+            )*
+        }
+
+        /// Push an empty array onto the stack.
+        pub static OP_0: Opcode = OP_PUSHBYTES_0;
+        /// Empty stack is also FALSE.
+        pub static OP_FALSE: Opcode = OP_PUSHBYTES_0;
+        /// Number 1 is also TRUE.
+        pub static OP_TRUE: Opcode = OP_PUSHNUM_1;
+        /// Previously called OP_NOP2.
+        pub static OP_NOP2: Opcode = OP_CLTV;
+        /// Previously called OP_NOP3.
+        pub static OP_NOP3: Opcode = OP_CSV;
+
+        impl fmt::Display for Opcode {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                 match *self {
+                   $(
+                        $op => core::fmt::Display::fmt(stringify!($op), f),
+                    )+
+                }
+            }
+        }
+    }
+}
+
+all_opcodes! {
+    OP_PUSHBYTES_0 => 0x00, "Push an empty array onto the stack.";
+    OP_PUSHBYTES_1 => 0x01, "Push the next byte as an array onto the stack.";
+    OP_PUSHBYTES_2 => 0x02, "Push the next 2 bytes as an array onto the stack.";
+    OP_PUSHBYTES_3 => 0x03, "Push the next 3 bytes as an array onto the stack.";
+    OP_PUSHBYTES_4 => 0x04, "Push the next 4 bytes as an array onto the stack.";
+    OP_PUSHBYTES_5 => 0x05, "Push the next 5 bytes as an array onto the stack.";
+    OP_PUSHBYTES_6 => 0x06, "Push the next 6 bytes as an array onto the stack.";
+    OP_PUSHBYTES_7 => 0x07, "Push the next 7 bytes as an array onto the stack.";
+    OP_PUSHBYTES_8 => 0x08, "Push the next 8 bytes as an array onto the stack.";
+    OP_PUSHBYTES_9 => 0x09, "Push the next 9 bytes as an array onto the stack.";
+    OP_PUSHBYTES_10 => 0x0a, "Push the next 10 bytes as an array onto the stack.";
+    OP_PUSHBYTES_11 => 0x0b, "Push the next 11 bytes as an array onto the stack.";
+    OP_PUSHBYTES_12 => 0x0c, "Push the next 12 bytes as an array onto the stack.";
+    OP_PUSHBYTES_13 => 0x0d, "Push the next 13 bytes as an array onto the stack.";
+    OP_PUSHBYTES_14 => 0x0e, "Push the next 14 bytes as an array onto the stack.";
+    OP_PUSHBYTES_15 => 0x0f, "Push the next 15 bytes as an array onto the stack.";
+    OP_PUSHBYTES_16 => 0x10, "Push the next 16 bytes as an array onto the stack.";
+    OP_PUSHBYTES_17 => 0x11, "Push the next 17 bytes as an array onto the stack.";
+    OP_PUSHBYTES_18 => 0x12, "Push the next 18 bytes as an array onto the stack.";
+    OP_PUSHBYTES_19 => 0x13, "Push the next 19 bytes as an array onto the stack.";
+    OP_PUSHBYTES_20 => 0x14, "Push the next 20 bytes as an array onto the stack.";
+    OP_PUSHBYTES_21 => 0x15, "Push the next 21 bytes as an array onto the stack.";
+    OP_PUSHBYTES_22 => 0x16, "Push the next 22 bytes as an array onto the stack.";
+    OP_PUSHBYTES_23 => 0x17, "Push the next 23 bytes as an array onto the stack.";
+    OP_PUSHBYTES_24 => 0x18, "Push the next 24 bytes as an array onto the stack.";
+    OP_PUSHBYTES_25 => 0x19, "Push the next 25 bytes as an array onto the stack.";
+    OP_PUSHBYTES_26 => 0x1a, "Push the next 26 bytes as an array onto the stack.";
+    OP_PUSHBYTES_27 => 0x1b, "Push the next 27 bytes as an array onto the stack.";
+    OP_PUSHBYTES_28 => 0x1c, "Push the next 28 bytes as an array onto the stack.";
+    OP_PUSHBYTES_29 => 0x1d, "Push the next 29 bytes as an array onto the stack.";
+    OP_PUSHBYTES_30 => 0x1e, "Push the next 30 bytes as an array onto the stack.";
+    OP_PUSHBYTES_31 => 0x1f, "Push the next 31 bytes as an array onto the stack.";
+    OP_PUSHBYTES_32 => 0x20, "Push the next 32 bytes as an array onto the stack.";
+    OP_PUSHBYTES_33 => 0x21, "Push the next 33 bytes as an array onto the stack.";
+    OP_PUSHBYTES_34 => 0x22, "Push the next 34 bytes as an array onto the stack.";
+    OP_PUSHBYTES_35 => 0x23, "Push the next 35 bytes as an array onto the stack.";
+    OP_PUSHBYTES_36 => 0x24, "Push the next 36 bytes as an array onto the stack.";
+    OP_PUSHBYTES_37 => 0x25, "Push the next 37 bytes as an array onto the stack.";
+    OP_PUSHBYTES_38 => 0x26, "Push the next 38 bytes as an array onto the stack.";
+    OP_PUSHBYTES_39 => 0x27, "Push the next 39 bytes as an array onto the stack.";
+    OP_PUSHBYTES_40 => 0x28, "Push the next 40 bytes as an array onto the stack.";
+    OP_PUSHBYTES_41 => 0x29, "Push the next 41 bytes as an array onto the stack.";
+    OP_PUSHBYTES_42 => 0x2a, "Push the next 42 bytes as an array onto the stack.";
+    OP_PUSHBYTES_43 => 0x2b, "Push the next 43 bytes as an array onto the stack.";
+    OP_PUSHBYTES_44 => 0x2c, "Push the next 44 bytes as an array onto the stack.";
+    OP_PUSHBYTES_45 => 0x2d, "Push the next 45 bytes as an array onto the stack.";
+    OP_PUSHBYTES_46 => 0x2e, "Push the next 46 bytes as an array onto the stack.";
+    OP_PUSHBYTES_47 => 0x2f, "Push the next 47 bytes as an array onto the stack.";
+    OP_PUSHBYTES_48 => 0x30, "Push the next 48 bytes as an array onto the stack.";
+    OP_PUSHBYTES_49 => 0x31, "Push the next 49 bytes as an array onto the stack.";
+    OP_PUSHBYTES_50 => 0x32, "Push the next 50 bytes as an array onto the stack.";
+    OP_PUSHBYTES_51 => 0x33, "Push the next 51 bytes as an array onto the stack.";
+    OP_PUSHBYTES_52 => 0x34, "Push the next 52 bytes as an array onto the stack.";
+    OP_PUSHBYTES_53 => 0x35, "Push the next 53 bytes as an array onto the stack.";
+    OP_PUSHBYTES_54 => 0x36, "Push the next 54 bytes as an array onto the stack.";
+    OP_PUSHBYTES_55 => 0x37, "Push the next 55 bytes as an array onto the stack.";
+    OP_PUSHBYTES_56 => 0x38, "Push the next 56 bytes as an array onto the stack.";
+    OP_PUSHBYTES_57 => 0x39, "Push the next 57 bytes as an array onto the stack.";
+    OP_PUSHBYTES_58 => 0x3a, "Push the next 58 bytes as an array onto the stack.";
+    OP_PUSHBYTES_59 => 0x3b, "Push the next 59 bytes as an array onto the stack.";
+    OP_PUSHBYTES_60 => 0x3c, "Push the next 60 bytes as an array onto the stack.";
+    OP_PUSHBYTES_61 => 0x3d, "Push the next 61 bytes as an array onto the stack.";
+    OP_PUSHBYTES_62 => 0x3e, "Push the next 62 bytes as an array onto the stack.";
+    OP_PUSHBYTES_63 => 0x3f, "Push the next 63 bytes as an array onto the stack.";
+    OP_PUSHBYTES_64 => 0x40, "Push the next 64 bytes as an array onto the stack.";
+    OP_PUSHBYTES_65 => 0x41, "Push the next 65 bytes as an array onto the stack.";
+    OP_PUSHBYTES_66 => 0x42, "Push the next 66 bytes as an array onto the stack.";
+    OP_PUSHBYTES_67 => 0x43, "Push the next 67 bytes as an array onto the stack.";
+    OP_PUSHBYTES_68 => 0x44, "Push the next 68 bytes as an array onto the stack.";
+    OP_PUSHBYTES_69 => 0x45, "Push the next 69 bytes as an array onto the stack.";
+    OP_PUSHBYTES_70 => 0x46, "Push the next 70 bytes as an array onto the stack.";
+    OP_PUSHBYTES_71 => 0x47, "Push the next 71 bytes as an array onto the stack.";
+    OP_PUSHBYTES_72 => 0x48, "Push the next 72 bytes as an array onto the stack.";
+    OP_PUSHBYTES_73 => 0x49, "Push the next 73 bytes as an array onto the stack.";
+    OP_PUSHBYTES_74 => 0x4a, "Push the next 74 bytes as an array onto the stack.";
+    OP_PUSHBYTES_75 => 0x4b, "Push the next 75 bytes as an array onto the stack.";
+    OP_PUSHDATA1 => 0x4c, "Read the next byte as N; push the next N bytes as an array onto the stack.";
+    OP_PUSHDATA2 => 0x4d, "Read the next 2 bytes as N; push the next N bytes as an array onto the stack.";
+    OP_PUSHDATA4 => 0x4e, "Read the next 4 bytes as N; push the next N bytes as an array onto the stack.";
+    OP_PUSHNUM_NEG1 => 0x4f, "Push the array `0x81` onto the stack.";
+    OP_RESERVED => 0x50, "Synonym for OP_RETURN.";
+    OP_PUSHNUM_1 => 0x51, "Push the array `0x01` onto the stack.";
+    OP_PUSHNUM_2 => 0x52, "Push the array `0x02` onto the stack.";
+    OP_PUSHNUM_3 => 0x53, "Push the array `0x03` onto the stack.";
+    OP_PUSHNUM_4 => 0x54, "Push the array `0x04` onto the stack.";
+    OP_PUSHNUM_5 => 0x55, "Push the array `0x05` onto the stack.";
+    OP_PUSHNUM_6 => 0x56, "Push the array `0x06` onto the stack.";
+    OP_PUSHNUM_7 => 0x57, "Push the array `0x07` onto the stack.";
+    OP_PUSHNUM_8 => 0x58, "Push the array `0x08` onto the stack.";
+    OP_PUSHNUM_9 => 0x59, "Push the array `0x09` onto the stack.";
+    OP_PUSHNUM_10 => 0x5a, "Push the array `0x0a` onto the stack.";
+    OP_PUSHNUM_11 => 0x5b, "Push the array `0x0b` onto the stack.";
+    OP_PUSHNUM_12 => 0x5c, "Push the array `0x0c` onto the stack.";
+    OP_PUSHNUM_13 => 0x5d, "Push the array `0x0d` onto the stack.";
+    OP_PUSHNUM_14 => 0x5e, "Push the array `0x0e` onto the stack.";
+    OP_PUSHNUM_15 => 0x5f, "Push the array `0x0f` onto the stack.";
+    OP_PUSHNUM_16 => 0x60, "Push the array `0x10` onto the stack.";
+    OP_NOP => 0x61, "Does nothing.";
+    OP_VER => 0x62, "Synonym for OP_RETURN.";
+    OP_IF => 0x63, "Pop and execute the next statements if a nonzero element was popped.";
+    OP_NOTIF => 0x64, "Pop and execute the next statements if a zero element was popped.";
+    OP_VERIF => 0x65, "Fail the script unconditionally, does not even need to be executed.";
+    OP_VERNOTIF => 0x66, "Fail the script unconditionally, does not even need to be executed.";
+    OP_ELSE => 0x67, "Execute statements if those after the previous OP_IF were not, and vice-versa. \
+             If there is no previous OP_IF, this acts as a RETURN.";
+    OP_ENDIF => 0x68, "Pop and execute the next statements if a zero element was popped.";
+    OP_VERIFY => 0x69, "If the top value is zero or the stack is empty, fail; otherwise, pop the stack.";
+    OP_RETURN => 0x6a, "Fail the script immediately. (Must be executed.).";
+    OP_TOALTSTACK => 0x6b, "Pop one element from the main stack onto the alt stack.";
+    OP_FROMALTSTACK => 0x6c, "Pop one element from the alt stack onto the main stack.";
+    OP_2DROP => 0x6d, "Drops the top two stack items.";
+    OP_2DUP => 0x6e, "Duplicates the top two stack items as AB -> ABAB.";
+    OP_3DUP => 0x6f, "Duplicates the two three stack items as ABC -> ABCABC.";
+    OP_2OVER => 0x70, "Copies the two stack items of items two spaces back to the front, as xxAB -> ABxxAB.";
+    OP_2ROT => 0x71, "Moves the two stack items four spaces back to the front, as xxxxAB -> ABxxxx.";
+    OP_2SWAP => 0x72, "Swaps the top two pairs, as ABCD -> CDAB.";
+    OP_IFDUP => 0x73, "Duplicate the top stack element unless it is zero.";
+    OP_DEPTH => 0x74, "Push the current number of stack items onto the stack.";
+    OP_DROP => 0x75, "Drops the top stack item.";
+    OP_DUP => 0x76, "Duplicates the top stack item.";
+    OP_NIP => 0x77, "Drops the second-to-top stack item.";
+    OP_OVER => 0x78, "Copies the second-to-top stack item, as xA -> AxA.";
+    OP_PICK => 0x79, "Pop the top stack element as N. Copy the Nth stack element to the top.";
+    OP_ROLL => 0x7a, "Pop the top stack element as N. Move the Nth stack element to the top.";
+    OP_ROT => 0x7b, "Rotate the top three stack items, as [top next1 next2] -> [next2 top next1].";
+    OP_SWAP => 0x7c, "Swap the top two stack items.";
+    OP_TUCK => 0x7d, "Copy the top stack item to before the second item, as [top next] -> [top next top].";
+    OP_CAT => 0x7e, "Fail the script unconditionally, does not even need to be executed.";
+    OP_SUBSTR => 0x7f, "Fail the script unconditionally, does not even need to be executed.";
+    OP_LEFT => 0x80, "Fail the script unconditionally, does not even need to be executed.";
+    OP_RIGHT => 0x81, "Fail the script unconditionally, does not even need to be executed.";
+    OP_SIZE => 0x82, "Pushes the length of the top stack item onto the stack.";
+    OP_INVERT => 0x83, "Fail the script unconditionally, does not even need to be executed.";
+    OP_AND => 0x84, "Fail the script unconditionally, does not even need to be executed.";
+    OP_OR => 0x85, "Fail the script unconditionally, does not even need to be executed.";
+    OP_XOR => 0x86, "Fail the script unconditionally, does not even need to be executed.";
+    OP_EQUAL => 0x87, "Pushes 1 if the inputs are exactly equal, 0 otherwise.";
+    OP_EQUALVERIFY => 0x88, "Returns success if the inputs are exactly equal, failure otherwise.";
+    OP_RESERVED1 => 0x89, "Synonym for OP_RETURN.";
+    OP_RESERVED2 => 0x8a, "Synonym for OP_RETURN.";
+    OP_1ADD => 0x8b, "Increment the top stack element in place.";
+    OP_1SUB => 0x8c, "Decrement the top stack element in place.";
+    OP_2MUL => 0x8d, "Fail the script unconditionally, does not even need to be executed.";
+    OP_2DIV => 0x8e, "Fail the script unconditionally, does not even need to be executed.";
+    OP_NEGATE => 0x8f, "Multiply the top stack item by -1 in place.";
+    OP_ABS => 0x90, "Absolute value the top stack item in place.";
+    OP_NOT => 0x91, "Map 0 to 1 and everything else to 0, in place.";
+    OP_0NOTEQUAL => 0x92, "Map 0 to 0 and everything else to 1, in place.";
+    OP_ADD => 0x93, "Pop two stack items and push their sum.";
+    OP_SUB => 0x94, "Pop two stack items and push the second minus the top.";
+    OP_MUL => 0x95, "Fail the script unconditionally, does not even need to be executed.";
+    OP_DIV => 0x96, "Fail the script unconditionally, does not even need to be executed.";
+    OP_MOD => 0x97, "Fail the script unconditionally, does not even need to be executed.";
+    OP_LSHIFT => 0x98, "Fail the script unconditionally, does not even need to be executed.";
+    OP_RSHIFT => 0x99, "Fail the script unconditionally, does not even need to be executed.";
+    OP_BOOLAND => 0x9a, "Pop the top two stack items and push 1 if both are nonzero, else push 0.";
+    OP_BOOLOR => 0x9b, "Pop the top two stack items and push 1 if either is nonzero, else push 0.";
+    OP_NUMEQUAL => 0x9c, "Pop the top two stack items and push 1 if both are numerically equal, else push 0.";
+    OP_NUMEQUALVERIFY => 0x9d, "Pop the top two stack items and return success if both are numerically equal, else return failure.";
+    OP_NUMNOTEQUAL => 0x9e, "Pop the top two stack items and push 0 if both are numerically equal, else push 1.";
+    OP_LESSTHAN  => 0x9f, "Pop the top two items; push 1 if the second is less than the top, 0 otherwise.";
+    OP_GREATERTHAN  => 0xa0, "Pop the top two items; push 1 if the second is greater than the top, 0 otherwise.";
+    OP_LESSTHANOREQUAL  => 0xa1, "Pop the top two items; push 1 if the second is <= the top, 0 otherwise.";
+    OP_GREATERTHANOREQUAL  => 0xa2, "Pop the top two items; push 1 if the second is >= the top, 0 otherwise.";
+    OP_MIN => 0xa3, "Pop the top two items; push the smaller.";
+    OP_MAX => 0xa4, "Pop the top two items; push the larger.";
+    OP_WITHIN => 0xa5, "Pop the top three items; if the top is >= the second and < the third, push 1, otherwise push 0.";
+    OP_RIPEMD160 => 0xa6, "Pop the top stack item and push its RIPEMD160 hash.";
+    OP_SHA1 => 0xa7, "Pop the top stack item and push its SHA1 hash.";
+    OP_SHA256 => 0xa8, "Pop the top stack item and push its SHA256 hash.";
+    OP_HASH160 => 0xa9, "Pop the top stack item and push its RIPEMD(SHA256) hash.";
+    OP_HASH256 => 0xaa, "Pop the top stack item and push its SHA256(SHA256) hash.";
+    OP_CODESEPARATOR => 0xab, "Ignore this and everything preceding when deciding what to sign when signature-checking.";
+    OP_CHECKSIG => 0xac, "<https://en.bitcoin.it/wiki/OP_CHECKSIG> pushing 1/0 for success/failure.";
+    OP_CHECKSIGVERIFY => 0xad, "<https://en.bitcoin.it/wiki/OP_CHECKSIG> returning success/failure.";
+    OP_CHECKMULTISIG => 0xae, "Pop N, N pubkeys, M, M signatures, a dummy (due to bug in reference code), \
+                      and verify that all M signatures are valid. Push 1 for 'all valid', 0 otherwise.";
+    OP_CHECKMULTISIGVERIFY => 0xaf, "Like the above but return success/failure.";
+    OP_NOP1 => 0xb0, "Does nothing.";
+    OP_CLTV => 0xb1, "<https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>";
+    OP_CSV => 0xb2, "<https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki>";
+    OP_NOP4 => 0xb3, "Does nothing.";
+    OP_NOP5 => 0xb4, "Does nothing.";
+    OP_NOP6 => 0xb5, "Does nothing.";
+    OP_NOP7 => 0xb6, "Does nothing.";
+    OP_NOP8 => 0xb7, "Does nothing.";
+    OP_NOP9 => 0xb8, "Does nothing.";
+    OP_NOP10 => 0xb9, "Does nothing.";
+    // Every other opcode acts as OP_RETURN
+    OP_CHECKSIGADD => 0xba, "OP_CHECKSIGADD post tapscript.";
+    OP_RETURN_187 => 0xbb, "Synonym for OP_RETURN.";
+    OP_RETURN_188 => 0xbc, "Synonym for OP_RETURN.";
+    OP_RETURN_189 => 0xbd, "Synonym for OP_RETURN.";
+    OP_RETURN_190 => 0xbe, "Synonym for OP_RETURN.";
+    OP_RETURN_191 => 0xbf, "Synonym for OP_RETURN.";
+    OP_RETURN_192 => 0xc0, "Synonym for OP_RETURN.";
+    OP_RETURN_193 => 0xc1, "Synonym for OP_RETURN.";
+    OP_RETURN_194 => 0xc2, "Synonym for OP_RETURN.";
+    OP_RETURN_195 => 0xc3, "Synonym for OP_RETURN.";
+    OP_RETURN_196 => 0xc4, "Synonym for OP_RETURN.";
+    OP_RETURN_197 => 0xc5, "Synonym for OP_RETURN.";
+    OP_RETURN_198 => 0xc6, "Synonym for OP_RETURN.";
+    OP_RETURN_199 => 0xc7, "Synonym for OP_RETURN.";
+    OP_RETURN_200 => 0xc8, "Synonym for OP_RETURN.";
+    OP_RETURN_201 => 0xc9, "Synonym for OP_RETURN.";
+    OP_RETURN_202 => 0xca, "Synonym for OP_RETURN.";
+    OP_RETURN_203 => 0xcb, "Synonym for OP_RETURN.";
+    OP_RETURN_204 => 0xcc, "Synonym for OP_RETURN.";
+    OP_RETURN_205 => 0xcd, "Synonym for OP_RETURN.";
+    OP_RETURN_206 => 0xce, "Synonym for OP_RETURN.";
+    OP_RETURN_207 => 0xcf, "Synonym for OP_RETURN.";
+    OP_RETURN_208 => 0xd0, "Synonym for OP_RETURN.";
+    OP_RETURN_209 => 0xd1, "Synonym for OP_RETURN.";
+    OP_RETURN_210 => 0xd2, "Synonym for OP_RETURN.";
+    OP_RETURN_211 => 0xd3, "Synonym for OP_RETURN.";
+    OP_RETURN_212 => 0xd4, "Synonym for OP_RETURN.";
+    OP_RETURN_213 => 0xd5, "Synonym for OP_RETURN.";
+    OP_RETURN_214 => 0xd6, "Synonym for OP_RETURN.";
+    OP_RETURN_215 => 0xd7, "Synonym for OP_RETURN.";
+    OP_RETURN_216 => 0xd8, "Synonym for OP_RETURN.";
+    OP_RETURN_217 => 0xd9, "Synonym for OP_RETURN.";
+    OP_RETURN_218 => 0xda, "Synonym for OP_RETURN.";
+    OP_RETURN_219 => 0xdb, "Synonym for OP_RETURN.";
+    OP_RETURN_220 => 0xdc, "Synonym for OP_RETURN.";
+    OP_RETURN_221 => 0xdd, "Synonym for OP_RETURN.";
+    OP_RETURN_222 => 0xde, "Synonym for OP_RETURN.";
+    OP_RETURN_223 => 0xdf, "Synonym for OP_RETURN.";
+    OP_RETURN_224 => 0xe0, "Synonym for OP_RETURN.";
+    OP_RETURN_225 => 0xe1, "Synonym for OP_RETURN.";
+    OP_RETURN_226 => 0xe2, "Synonym for OP_RETURN.";
+    OP_RETURN_227 => 0xe3, "Synonym for OP_RETURN.";
+    OP_RETURN_228 => 0xe4, "Synonym for OP_RETURN.";
+    OP_RETURN_229 => 0xe5, "Synonym for OP_RETURN.";
+    OP_RETURN_230 => 0xe6, "Synonym for OP_RETURN.";
+    OP_RETURN_231 => 0xe7, "Synonym for OP_RETURN.";
+    OP_RETURN_232 => 0xe8, "Synonym for OP_RETURN.";
+    OP_RETURN_233 => 0xe9, "Synonym for OP_RETURN.";
+    OP_RETURN_234 => 0xea, "Synonym for OP_RETURN.";
+    OP_RETURN_235 => 0xeb, "Synonym for OP_RETURN.";
+    OP_RETURN_236 => 0xec, "Synonym for OP_RETURN.";
+    OP_RETURN_237 => 0xed, "Synonym for OP_RETURN.";
+    OP_RETURN_238 => 0xee, "Synonym for OP_RETURN.";
+    OP_RETURN_239 => 0xef, "Synonym for OP_RETURN.";
+    OP_RETURN_240 => 0xf0, "Synonym for OP_RETURN.";
+    OP_RETURN_241 => 0xf1, "Synonym for OP_RETURN.";
+    OP_RETURN_242 => 0xf2, "Synonym for OP_RETURN.";
+    OP_RETURN_243 => 0xf3, "Synonym for OP_RETURN.";
+    OP_RETURN_244 => 0xf4, "Synonym for OP_RETURN.";
+    OP_RETURN_245 => 0xf5, "Synonym for OP_RETURN.";
+    OP_RETURN_246 => 0xf6, "Synonym for OP_RETURN.";
+    OP_RETURN_247 => 0xf7, "Synonym for OP_RETURN.";
+    OP_RETURN_248 => 0xf8, "Synonym for OP_RETURN.";
+    OP_RETURN_249 => 0xf9, "Synonym for OP_RETURN.";
+    OP_RETURN_250 => 0xfa, "Synonym for OP_RETURN.";
+    OP_RETURN_251 => 0xfb, "Synonym for OP_RETURN.";
+    OP_RETURN_252 => 0xfc, "Synonym for OP_RETURN.";
+    OP_RETURN_253 => 0xfd, "Synonym for OP_RETURN.";
+    OP_RETURN_254 => 0xfe, "Synonym for OP_RETURN.";
+    OP_INVALIDOPCODE => 0xff, "Synonym for OP_RETURN."
+}
+
+/// Classification context for the opcode.
+///
+/// Some opcodes like [`OP_RESERVED`] abort the script in `ClassifyContext::Legacy` context,
+/// but will act as `OP_SUCCESSx` in `ClassifyContext::TapScript` (see BIP342 for full list).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ClassifyContext {
+    /// Opcode used in tapscript context.
+    TapScript,
+    /// Opcode used in legacy context.
+    Legacy,
+}
+
+impl Opcode {
+    /// Classifies an Opcode into a broad class.
+    #[inline]
+    #[must_use]
+    pub fn classify(self, ctx: ClassifyContext) -> Class {
+        match (self, ctx) {
+            // 3 opcodes illegal in all contexts
+            (OP_VERIF, _) | (OP_VERNOTIF, _) | (OP_INVALIDOPCODE, _) => Class::IllegalOp,
+
+            // 15 opcodes illegal in Legacy context
+            #[rustfmt::skip]
+            (OP_CAT, ctx) | (OP_SUBSTR, ctx)
+            | (OP_LEFT, ctx) | (OP_RIGHT, ctx)
+            | (OP_INVERT, ctx)
+            | (OP_AND, ctx) | (OP_OR, ctx) | (OP_XOR, ctx)
+            | (OP_2MUL, ctx) | (OP_2DIV, ctx)
+            | (OP_MUL, ctx) | (OP_DIV, ctx) | (OP_MOD, ctx)
+            | (OP_LSHIFT, ctx) | (OP_RSHIFT, ctx) if ctx == ClassifyContext::Legacy => Class::IllegalOp,
+
+            // 87 opcodes of SuccessOp class only in TapScript context
+            (op, ClassifyContext::TapScript)
+                if op.code == 80
+                    || op.code == 98
+                    || (op.code >= 126 && op.code <= 129)
+                    || (op.code >= 131 && op.code <= 134)
+                    || (op.code >= 137 && op.code <= 138)
+                    || (op.code >= 141 && op.code <= 142)
+                    || (op.code >= 149 && op.code <= 153)
+                    || (op.code >= 187 && op.code <= 254) =>
+                Class::SuccessOp,
+
+            // 11 opcodes of NoOp class
+            (OP_NOP, _) => Class::NoOp,
+            (op, _) if op.code >= OP_NOP1.code && op.code <= OP_NOP10.code => Class::NoOp,
+
+            // 1 opcode for `OP_RETURN`
+            (OP_RETURN, _) => Class::ReturnOp,
+
+            // 4 opcodes operating equally to `OP_RETURN` only in Legacy context
+            (OP_RESERVED, ctx) | (OP_RESERVED1, ctx) | (OP_RESERVED2, ctx) | (OP_VER, ctx)
+                if ctx == ClassifyContext::Legacy =>
+                Class::ReturnOp,
+
+            // 71 opcodes operating equally to `OP_RETURN` only in Legacy context
+            (op, ClassifyContext::Legacy) if op.code >= OP_CHECKSIGADD.code => Class::ReturnOp,
+
+            // 2 opcodes operating equally to `OP_RETURN` only in TapScript context
+            (OP_CHECKMULTISIG, ClassifyContext::TapScript)
+            | (OP_CHECKMULTISIGVERIFY, ClassifyContext::TapScript) => Class::ReturnOp,
+
+            // 1 opcode of PushNum class
+            (OP_PUSHNUM_NEG1, _) => Class::PushNum(-1),
+
+            // 16 opcodes of PushNum class
+            (op, _) if op.code >= OP_PUSHNUM_1.code && op.code <= OP_PUSHNUM_16.code =>
+                Class::PushNum(1 + 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: 61 for Legacy and 60 for TapScript context
+            (_, _) => Class::Ordinary(Ordinary::with(self)),
+        }
+    }
+
+    /// Encodes [`Opcode`] as a byte.
+    #[inline]
+    pub const fn to_u8(self) -> u8 { self.code }
+
+    /// Encodes PUSHNUM [`Opcode`] as a `u8` representing its number (1-16).
+    ///
+    /// Does not convert `OP_FALSE` to 0. Only `1` to `OP_PUSHNUM_16` are covered.
+    ///
+    /// # Returns
+    ///
+    /// Returns `None` if `self` is not a PUSHNUM.
+    #[inline]
+    #[must_use]
+    pub const fn decode_pushnum(self) -> Option<u8> {
+        const START: u8 = OP_PUSHNUM_1.code;
+        const END: u8 = OP_PUSHNUM_16.code;
+        match self.code {
+            START..=END => Some(self.code - START + 1),
+            _ => None,
+        }
+    }
+}
+
+impl From<u8> for Opcode {
+    #[inline]
+    fn from(b: u8) -> Opcode { Opcode { code: b } }
+}
+
+impl fmt::Debug for Opcode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fmt::Display::fmt(self, f) }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Opcode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+/// Broad categories of opcodes with similar behavior.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum Class {
+    /// Pushes the given number onto the stack.
+    PushNum(i32),
+    /// Pushes the given number of bytes onto the stack.
+    PushBytes(u32),
+    /// Fails the script if executed.
+    ReturnOp,
+    /// Succeeds the script even if not executed.
+    SuccessOp,
+    /// Fails the script even if not executed.
+    IllegalOp,
+    /// Does nothing.
+    NoOp,
+    /// Any opcode not covered above.
+    Ordinary(Ordinary),
+}
+
+macro_rules! ordinary_opcode {
+    ($($op:ident),*) => (
+        #[repr(u8)]
+        #[doc(hidden)]
+        #[derive(Copy, Clone, PartialEq, Eq, Debug)]
+        pub enum Ordinary {
+            $( $op = $op.code ),*
+        }
+
+        impl fmt::Display for Ordinary {
+            fn fmt(&self, f: &mut fmt::Formatter) -> core::fmt::Result {
+                match *self {
+                   $(Ordinary::$op => { f.pad(stringify!($op)) }),*
+                }
+            }
+        }
+
+        impl Ordinary {
+            fn with(b: Opcode) -> Self {
+                match b {
+                    $( $op => { Ordinary::$op } ),*
+                    _ => unreachable!("construction of `Ordinary` type from non-ordinary opcode {}", b),
+                }
+            }
+
+            /// Constructs a new [`Ordinary`] from an [`Opcode`].
+            pub fn from_opcode(b: Opcode) -> Option<Self> {
+                match b {
+                    $( $op => { Some(Ordinary::$op) } ),*
+                    _ => None,
+                }
+            }
+        }
+    );
+}
+
+// "Ordinary" opcodes -- should be 61 of these
+ordinary_opcode! {
+    // pushdata
+    OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4,
+    // control flow
+    OP_IF, OP_NOTIF, OP_ELSE, OP_ENDIF, OP_VERIFY,
+    // stack
+    OP_TOALTSTACK, OP_FROMALTSTACK,
+    OP_2DROP, OP_2DUP, OP_3DUP, OP_2OVER, OP_2ROT, OP_2SWAP,
+    OP_DROP, OP_DUP, OP_NIP, OP_OVER, OP_PICK, OP_ROLL, OP_ROT, OP_SWAP, OP_TUCK,
+    OP_IFDUP, OP_DEPTH, OP_SIZE,
+    // equality
+    OP_EQUAL, OP_EQUALVERIFY,
+    // arithmetic
+    OP_1ADD, OP_1SUB, OP_NEGATE, OP_ABS, OP_NOT, OP_0NOTEQUAL,
+    OP_ADD, OP_SUB, OP_BOOLAND, OP_BOOLOR,
+    OP_NUMEQUAL, OP_NUMEQUALVERIFY, OP_NUMNOTEQUAL, OP_LESSTHAN,
+    OP_GREATERTHAN, OP_LESSTHANOREQUAL, OP_GREATERTHANOREQUAL,
+    OP_MIN, OP_MAX, OP_WITHIN,
+    // crypto
+    OP_RIPEMD160, OP_SHA1, OP_SHA256, OP_HASH160, OP_HASH256,
+    OP_CODESEPARATOR, OP_CHECKSIG, OP_CHECKSIGVERIFY,
+    OP_CHECKMULTISIG, OP_CHECKMULTISIGVERIFY,
+    OP_CHECKSIGADD
+}
+
+impl Ordinary {
+    /// Encodes [`Opcode`] as a byte.
+    #[inline]
+    pub fn to_u8(self) -> u8 { self as u8 }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use super::*;
+
+    macro_rules! roundtrip {
+        ($unique:expr, $op:ident) => {
+            assert_eq!($op, Opcode::from($op.to_u8()));
+
+            let s1 = format!("{}", $op);
+            let s2 = format!("{:?}", $op);
+            assert_eq!(s1, s2);
+            assert_eq!(s1, stringify!($op));
+            assert!($unique.insert(s1));
+        };
+    }
+
+    #[test]
+    fn formatting_works() {
+        let op = all::OP_NOP;
+        let s = format!("{:>10}", op);
+        assert_eq!(s, "    OP_NOP");
+    }
+
+    #[test]
+    fn ordinary_op_code() {
+        let ordinary_op = Ordinary::from_opcode(OP_PUSHDATA1).expect("0x4C");
+        assert_eq!(ordinary_op.to_u8(), 0x4C_u8);
+    }
+
+    #[test]
+    fn decode_pushnum() {
+        // Test all possible opcodes
+        // - Sanity check
+        assert_eq!(OP_PUSHNUM_1.code, 0x51_u8);
+        assert_eq!(OP_PUSHNUM_16.code, 0x60_u8);
+        for i in 0x00..=0xff_u8 {
+            let expected = match i {
+                // OP_PUSHNUM_1 ..= OP_PUSHNUM_16
+                0x51..=0x60 => Some(i - 0x50),
+                _ => None,
+            };
+            assert_eq!(Opcode::from(i).decode_pushnum(), expected);
+        }
+
+        // Test the named opcode constants
+        // - This is the OP right before PUSHNUMs start
+        assert!(OP_RESERVED.decode_pushnum().is_none());
+        assert_eq!(OP_PUSHNUM_1.decode_pushnum().expect("pushnum"), 1);
+        assert_eq!(OP_PUSHNUM_2.decode_pushnum().expect("pushnum"), 2);
+        assert_eq!(OP_PUSHNUM_3.decode_pushnum().expect("pushnum"), 3);
+        assert_eq!(OP_PUSHNUM_4.decode_pushnum().expect("pushnum"), 4);
+        assert_eq!(OP_PUSHNUM_5.decode_pushnum().expect("pushnum"), 5);
+        assert_eq!(OP_PUSHNUM_6.decode_pushnum().expect("pushnum"), 6);
+        assert_eq!(OP_PUSHNUM_7.decode_pushnum().expect("pushnum"), 7);
+        assert_eq!(OP_PUSHNUM_8.decode_pushnum().expect("pushnum"), 8);
+        assert_eq!(OP_PUSHNUM_9.decode_pushnum().expect("pushnum"), 9);
+        assert_eq!(OP_PUSHNUM_10.decode_pushnum().expect("pushnum"), 10);
+        assert_eq!(OP_PUSHNUM_11.decode_pushnum().expect("pushnum"), 11);
+        assert_eq!(OP_PUSHNUM_12.decode_pushnum().expect("pushnum"), 12);
+        assert_eq!(OP_PUSHNUM_13.decode_pushnum().expect("pushnum"), 13);
+        assert_eq!(OP_PUSHNUM_14.decode_pushnum().expect("pushnum"), 14);
+        assert_eq!(OP_PUSHNUM_15.decode_pushnum().expect("pushnum"), 15);
+        assert_eq!(OP_PUSHNUM_16.decode_pushnum().expect("pushnum"), 16);
+        // - This is the OP right after PUSHNUMs end
+        assert!(OP_NOP.decode_pushnum().is_none());
+    }
+
+    #[test]
+    fn classify_test() {
+        let op174 = OP_CHECKMULTISIG;
+        assert_eq!(
+            op174.classify(ClassifyContext::Legacy),
+            Class::Ordinary(Ordinary::OP_CHECKMULTISIG)
+        );
+        assert_eq!(op174.classify(ClassifyContext::TapScript), Class::ReturnOp);
+
+        let op175 = OP_CHECKMULTISIGVERIFY;
+        assert_eq!(
+            op175.classify(ClassifyContext::Legacy),
+            Class::Ordinary(Ordinary::OP_CHECKMULTISIGVERIFY)
+        );
+        assert_eq!(op175.classify(ClassifyContext::TapScript), Class::ReturnOp);
+
+        let op186 = OP_CHECKSIGADD;
+        assert_eq!(op186.classify(ClassifyContext::Legacy), Class::ReturnOp);
+        assert_eq!(
+            op186.classify(ClassifyContext::TapScript),
+            Class::Ordinary(Ordinary::OP_CHECKSIGADD)
+        );
+
+        let op187 = OP_RETURN_187;
+        assert_eq!(op187.classify(ClassifyContext::Legacy), Class::ReturnOp);
+        assert_eq!(op187.classify(ClassifyContext::TapScript), Class::SuccessOp);
+    }
+
+    #[test]
+    fn str_roundtrip() {
+        let mut unique = HashSet::new();
+        roundtrip!(unique, OP_PUSHBYTES_0);
+        roundtrip!(unique, OP_PUSHBYTES_1);
+        roundtrip!(unique, OP_PUSHBYTES_2);
+        roundtrip!(unique, OP_PUSHBYTES_3);
+        roundtrip!(unique, OP_PUSHBYTES_4);
+        roundtrip!(unique, OP_PUSHBYTES_5);
+        roundtrip!(unique, OP_PUSHBYTES_6);
+        roundtrip!(unique, OP_PUSHBYTES_7);
+        roundtrip!(unique, OP_PUSHBYTES_8);
+        roundtrip!(unique, OP_PUSHBYTES_9);
+        roundtrip!(unique, OP_PUSHBYTES_10);
+        roundtrip!(unique, OP_PUSHBYTES_11);
+        roundtrip!(unique, OP_PUSHBYTES_12);
+        roundtrip!(unique, OP_PUSHBYTES_13);
+        roundtrip!(unique, OP_PUSHBYTES_14);
+        roundtrip!(unique, OP_PUSHBYTES_15);
+        roundtrip!(unique, OP_PUSHBYTES_16);
+        roundtrip!(unique, OP_PUSHBYTES_17);
+        roundtrip!(unique, OP_PUSHBYTES_18);
+        roundtrip!(unique, OP_PUSHBYTES_19);
+        roundtrip!(unique, OP_PUSHBYTES_20);
+        roundtrip!(unique, OP_PUSHBYTES_21);
+        roundtrip!(unique, OP_PUSHBYTES_22);
+        roundtrip!(unique, OP_PUSHBYTES_23);
+        roundtrip!(unique, OP_PUSHBYTES_24);
+        roundtrip!(unique, OP_PUSHBYTES_25);
+        roundtrip!(unique, OP_PUSHBYTES_26);
+        roundtrip!(unique, OP_PUSHBYTES_27);
+        roundtrip!(unique, OP_PUSHBYTES_28);
+        roundtrip!(unique, OP_PUSHBYTES_29);
+        roundtrip!(unique, OP_PUSHBYTES_30);
+        roundtrip!(unique, OP_PUSHBYTES_31);
+        roundtrip!(unique, OP_PUSHBYTES_32);
+        roundtrip!(unique, OP_PUSHBYTES_33);
+        roundtrip!(unique, OP_PUSHBYTES_34);
+        roundtrip!(unique, OP_PUSHBYTES_35);
+        roundtrip!(unique, OP_PUSHBYTES_36);
+        roundtrip!(unique, OP_PUSHBYTES_37);
+        roundtrip!(unique, OP_PUSHBYTES_38);
+        roundtrip!(unique, OP_PUSHBYTES_39);
+        roundtrip!(unique, OP_PUSHBYTES_40);
+        roundtrip!(unique, OP_PUSHBYTES_41);
+        roundtrip!(unique, OP_PUSHBYTES_42);
+        roundtrip!(unique, OP_PUSHBYTES_43);
+        roundtrip!(unique, OP_PUSHBYTES_44);
+        roundtrip!(unique, OP_PUSHBYTES_45);
+        roundtrip!(unique, OP_PUSHBYTES_46);
+        roundtrip!(unique, OP_PUSHBYTES_47);
+        roundtrip!(unique, OP_PUSHBYTES_48);
+        roundtrip!(unique, OP_PUSHBYTES_49);
+        roundtrip!(unique, OP_PUSHBYTES_50);
+        roundtrip!(unique, OP_PUSHBYTES_51);
+        roundtrip!(unique, OP_PUSHBYTES_52);
+        roundtrip!(unique, OP_PUSHBYTES_53);
+        roundtrip!(unique, OP_PUSHBYTES_54);
+        roundtrip!(unique, OP_PUSHBYTES_55);
+        roundtrip!(unique, OP_PUSHBYTES_56);
+        roundtrip!(unique, OP_PUSHBYTES_57);
+        roundtrip!(unique, OP_PUSHBYTES_58);
+        roundtrip!(unique, OP_PUSHBYTES_59);
+        roundtrip!(unique, OP_PUSHBYTES_60);
+        roundtrip!(unique, OP_PUSHBYTES_61);
+        roundtrip!(unique, OP_PUSHBYTES_62);
+        roundtrip!(unique, OP_PUSHBYTES_63);
+        roundtrip!(unique, OP_PUSHBYTES_64);
+        roundtrip!(unique, OP_PUSHBYTES_65);
+        roundtrip!(unique, OP_PUSHBYTES_66);
+        roundtrip!(unique, OP_PUSHBYTES_67);
+        roundtrip!(unique, OP_PUSHBYTES_68);
+        roundtrip!(unique, OP_PUSHBYTES_69);
+        roundtrip!(unique, OP_PUSHBYTES_70);
+        roundtrip!(unique, OP_PUSHBYTES_71);
+        roundtrip!(unique, OP_PUSHBYTES_72);
+        roundtrip!(unique, OP_PUSHBYTES_73);
+        roundtrip!(unique, OP_PUSHBYTES_74);
+        roundtrip!(unique, OP_PUSHBYTES_75);
+        roundtrip!(unique, OP_PUSHDATA1);
+        roundtrip!(unique, OP_PUSHDATA2);
+        roundtrip!(unique, OP_PUSHDATA4);
+        roundtrip!(unique, OP_PUSHNUM_NEG1);
+        roundtrip!(unique, OP_RESERVED);
+        roundtrip!(unique, OP_PUSHNUM_1);
+        roundtrip!(unique, OP_PUSHNUM_2);
+        roundtrip!(unique, OP_PUSHNUM_3);
+        roundtrip!(unique, OP_PUSHNUM_4);
+        roundtrip!(unique, OP_PUSHNUM_5);
+        roundtrip!(unique, OP_PUSHNUM_6);
+        roundtrip!(unique, OP_PUSHNUM_7);
+        roundtrip!(unique, OP_PUSHNUM_8);
+        roundtrip!(unique, OP_PUSHNUM_9);
+        roundtrip!(unique, OP_PUSHNUM_10);
+        roundtrip!(unique, OP_PUSHNUM_11);
+        roundtrip!(unique, OP_PUSHNUM_12);
+        roundtrip!(unique, OP_PUSHNUM_13);
+        roundtrip!(unique, OP_PUSHNUM_14);
+        roundtrip!(unique, OP_PUSHNUM_15);
+        roundtrip!(unique, OP_PUSHNUM_16);
+        roundtrip!(unique, OP_NOP);
+        roundtrip!(unique, OP_VER);
+        roundtrip!(unique, OP_IF);
+        roundtrip!(unique, OP_NOTIF);
+        roundtrip!(unique, OP_VERIF);
+        roundtrip!(unique, OP_VERNOTIF);
+        roundtrip!(unique, OP_ELSE);
+        roundtrip!(unique, OP_ENDIF);
+        roundtrip!(unique, OP_VERIFY);
+        roundtrip!(unique, OP_RETURN);
+        roundtrip!(unique, OP_TOALTSTACK);
+        roundtrip!(unique, OP_FROMALTSTACK);
+        roundtrip!(unique, OP_2DROP);
+        roundtrip!(unique, OP_2DUP);
+        roundtrip!(unique, OP_3DUP);
+        roundtrip!(unique, OP_2OVER);
+        roundtrip!(unique, OP_2ROT);
+        roundtrip!(unique, OP_2SWAP);
+        roundtrip!(unique, OP_IFDUP);
+        roundtrip!(unique, OP_DEPTH);
+        roundtrip!(unique, OP_DROP);
+        roundtrip!(unique, OP_DUP);
+        roundtrip!(unique, OP_NIP);
+        roundtrip!(unique, OP_OVER);
+        roundtrip!(unique, OP_PICK);
+        roundtrip!(unique, OP_ROLL);
+        roundtrip!(unique, OP_ROT);
+        roundtrip!(unique, OP_SWAP);
+        roundtrip!(unique, OP_TUCK);
+        roundtrip!(unique, OP_CAT);
+        roundtrip!(unique, OP_SUBSTR);
+        roundtrip!(unique, OP_LEFT);
+        roundtrip!(unique, OP_RIGHT);
+        roundtrip!(unique, OP_SIZE);
+        roundtrip!(unique, OP_INVERT);
+        roundtrip!(unique, OP_AND);
+        roundtrip!(unique, OP_OR);
+        roundtrip!(unique, OP_XOR);
+        roundtrip!(unique, OP_EQUAL);
+        roundtrip!(unique, OP_EQUALVERIFY);
+        roundtrip!(unique, OP_RESERVED1);
+        roundtrip!(unique, OP_RESERVED2);
+        roundtrip!(unique, OP_1ADD);
+        roundtrip!(unique, OP_1SUB);
+        roundtrip!(unique, OP_2MUL);
+        roundtrip!(unique, OP_2DIV);
+        roundtrip!(unique, OP_NEGATE);
+        roundtrip!(unique, OP_ABS);
+        roundtrip!(unique, OP_NOT);
+        roundtrip!(unique, OP_0NOTEQUAL);
+        roundtrip!(unique, OP_ADD);
+        roundtrip!(unique, OP_SUB);
+        roundtrip!(unique, OP_MUL);
+        roundtrip!(unique, OP_DIV);
+        roundtrip!(unique, OP_MOD);
+        roundtrip!(unique, OP_LSHIFT);
+        roundtrip!(unique, OP_RSHIFT);
+        roundtrip!(unique, OP_BOOLAND);
+        roundtrip!(unique, OP_BOOLOR);
+        roundtrip!(unique, OP_NUMEQUAL);
+        roundtrip!(unique, OP_NUMEQUALVERIFY);
+        roundtrip!(unique, OP_NUMNOTEQUAL);
+        roundtrip!(unique, OP_LESSTHAN);
+        roundtrip!(unique, OP_GREATERTHAN);
+        roundtrip!(unique, OP_LESSTHANOREQUAL);
+        roundtrip!(unique, OP_GREATERTHANOREQUAL);
+        roundtrip!(unique, OP_MIN);
+        roundtrip!(unique, OP_MAX);
+        roundtrip!(unique, OP_WITHIN);
+        roundtrip!(unique, OP_RIPEMD160);
+        roundtrip!(unique, OP_SHA1);
+        roundtrip!(unique, OP_SHA256);
+        roundtrip!(unique, OP_HASH160);
+        roundtrip!(unique, OP_HASH256);
+        roundtrip!(unique, OP_CODESEPARATOR);
+        roundtrip!(unique, OP_CHECKSIG);
+        roundtrip!(unique, OP_CHECKSIGVERIFY);
+        roundtrip!(unique, OP_CHECKMULTISIG);
+        roundtrip!(unique, OP_CHECKMULTISIGVERIFY);
+        roundtrip!(unique, OP_NOP1);
+        roundtrip!(unique, OP_CLTV);
+        roundtrip!(unique, OP_CSV);
+        roundtrip!(unique, OP_NOP4);
+        roundtrip!(unique, OP_NOP5);
+        roundtrip!(unique, OP_NOP6);
+        roundtrip!(unique, OP_NOP7);
+        roundtrip!(unique, OP_NOP8);
+        roundtrip!(unique, OP_NOP9);
+        roundtrip!(unique, OP_NOP10);
+        roundtrip!(unique, OP_CHECKSIGADD);
+        roundtrip!(unique, OP_RETURN_187);
+        roundtrip!(unique, OP_RETURN_188);
+        roundtrip!(unique, OP_RETURN_189);
+        roundtrip!(unique, OP_RETURN_190);
+        roundtrip!(unique, OP_RETURN_191);
+        roundtrip!(unique, OP_RETURN_192);
+        roundtrip!(unique, OP_RETURN_193);
+        roundtrip!(unique, OP_RETURN_194);
+        roundtrip!(unique, OP_RETURN_195);
+        roundtrip!(unique, OP_RETURN_196);
+        roundtrip!(unique, OP_RETURN_197);
+        roundtrip!(unique, OP_RETURN_198);
+        roundtrip!(unique, OP_RETURN_199);
+        roundtrip!(unique, OP_RETURN_200);
+        roundtrip!(unique, OP_RETURN_201);
+        roundtrip!(unique, OP_RETURN_202);
+        roundtrip!(unique, OP_RETURN_203);
+        roundtrip!(unique, OP_RETURN_204);
+        roundtrip!(unique, OP_RETURN_205);
+        roundtrip!(unique, OP_RETURN_206);
+        roundtrip!(unique, OP_RETURN_207);
+        roundtrip!(unique, OP_RETURN_208);
+        roundtrip!(unique, OP_RETURN_209);
+        roundtrip!(unique, OP_RETURN_210);
+        roundtrip!(unique, OP_RETURN_211);
+        roundtrip!(unique, OP_RETURN_212);
+        roundtrip!(unique, OP_RETURN_213);
+        roundtrip!(unique, OP_RETURN_214);
+        roundtrip!(unique, OP_RETURN_215);
+        roundtrip!(unique, OP_RETURN_216);
+        roundtrip!(unique, OP_RETURN_217);
+        roundtrip!(unique, OP_RETURN_218);
+        roundtrip!(unique, OP_RETURN_219);
+        roundtrip!(unique, OP_RETURN_220);
+        roundtrip!(unique, OP_RETURN_221);
+        roundtrip!(unique, OP_RETURN_222);
+        roundtrip!(unique, OP_RETURN_223);
+        roundtrip!(unique, OP_RETURN_224);
+        roundtrip!(unique, OP_RETURN_225);
+        roundtrip!(unique, OP_RETURN_226);
+        roundtrip!(unique, OP_RETURN_227);
+        roundtrip!(unique, OP_RETURN_228);
+        roundtrip!(unique, OP_RETURN_229);
+        roundtrip!(unique, OP_RETURN_230);
+        roundtrip!(unique, OP_RETURN_231);
+        roundtrip!(unique, OP_RETURN_232);
+        roundtrip!(unique, OP_RETURN_233);
+        roundtrip!(unique, OP_RETURN_234);
+        roundtrip!(unique, OP_RETURN_235);
+        roundtrip!(unique, OP_RETURN_236);
+        roundtrip!(unique, OP_RETURN_237);
+        roundtrip!(unique, OP_RETURN_238);
+        roundtrip!(unique, OP_RETURN_239);
+        roundtrip!(unique, OP_RETURN_240);
+        roundtrip!(unique, OP_RETURN_241);
+        roundtrip!(unique, OP_RETURN_242);
+        roundtrip!(unique, OP_RETURN_243);
+        roundtrip!(unique, OP_RETURN_244);
+        roundtrip!(unique, OP_RETURN_245);
+        roundtrip!(unique, OP_RETURN_246);
+        roundtrip!(unique, OP_RETURN_247);
+        roundtrip!(unique, OP_RETURN_248);
+        roundtrip!(unique, OP_RETURN_249);
+        roundtrip!(unique, OP_RETURN_250);
+        roundtrip!(unique, OP_RETURN_251);
+        roundtrip!(unique, OP_RETURN_252);
+        roundtrip!(unique, OP_RETURN_253);
+        roundtrip!(unique, OP_RETURN_254);
+        roundtrip!(unique, OP_INVALIDOPCODE);
+        assert_eq!(unique.len(), 256);
+    }
+}
diff --git a/bitcoin/src/blockdata/script/mod.rs b/bitcoin/src/blockdata/script/mod.rs
index b77acb2c77..1bd2bddf35 100644
--- a/bitcoin/src/blockdata/script/mod.rs
+++ b/bitcoin/src/blockdata/script/mod.rs
@@ -61,12 +61,12 @@ use core::convert::Infallible;
 use core::fmt;
 
 use io::{BufRead, Write};
-use primitives::opcodes::all::*;
-use primitives::opcodes::Opcode;
 
 use crate::consensus::{encode, Decodable, Encodable};
 use crate::internal_macros::impl_asref_push_bytes;
 use crate::key::WPubkeyHash;
+use crate::opcodes::all::*;
+use crate::opcodes::Opcode;
 use crate::prelude::Vec;
 use crate::OutPoint;
 
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 4085085d2f..9b47ef6528 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use hex_lit::hex;
-use primitives::opcodes;
 
 use super::*;
 use crate::address::script_pubkey::{
@@ -9,7 +8,7 @@ use crate::address::script_pubkey::{
 };
 use crate::consensus::encode::{deserialize, serialize};
 use crate::crypto::key::{PublicKey, XOnlyPublicKey};
-use crate::{Amount, FeeRate};
+use crate::{Amount, FeeRate, opcodes};
 
 #[test]
 #[rustfmt::skip]
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index af6386a40c..aa6d639550 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -123,7 +123,6 @@ pub use primitives::{
         Unchecked as BlockUnchecked, Validation as BlockValidation, WitnessCommitment,
     },
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
-    opcodes::Opcode,
     pow::CompactTarget, // No `pow` module outside of `primitives`.
     script::{Script, ScriptBuf},
     sequence::{self, Sequence}, // No `sequence` module outside of `primitives`.
@@ -161,12 +160,13 @@ pub use crate::{
 pub use crate::{
     // Also, re-export types and modules from `blockdata` that don't come from `primitives`.
     blockdata::locktime::{absolute, relative},
+    blockdata::opcodes::{self, Opcode},
     blockdata::script::witness_program::{self, WitnessProgram},
     blockdata::script::witness_version::{self, WitnessVersion},
     blockdata::script::{ScriptHash, WScriptHash}, // TODO: Move these down below after they are in primitives.
     // These modules also re-export all the respective `primitives` types.
     blockdata::{
-        block, constants, fee_rate, locktime, opcodes, script, transaction, weight, witness,
+        block, constants, fee_rate, locktime, script, transaction, weight, witness,
     },
 };
 
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index 451a3c1667..974e8dc374 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -44,7 +44,7 @@ pub mod _export {
 pub mod block;
 pub mod locktime;
 pub mod merkle_tree;
-pub mod opcodes;
+mod opcodes;
 pub mod pow;
 #[cfg(feature = "alloc")]
 pub mod script;
@@ -76,7 +76,6 @@ pub use self::{
     block::{BlockHash, Header as BlockHeader, WitnessCommitment},
     locktime::{absolute, relative},
     merkle_tree::{TxMerkleNode, WitnessMerkleNode},
-    opcodes::Opcode,
     pow::CompactTarget,
     sequence::Sequence,
     transaction::{OutPoint, Txid, Wtxid},
diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index 5da0295d39..61a66a025f 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -6,6 +6,7 @@
 //! all of the opcodes for that language.
 
 #![allow(non_camel_case_types)]
+#![allow(dead_code)]            // This module is private and is duplicated in `bitcoin`.
 
 use core::fmt;
 

From cc66838e804a6ceed6e1ac596727db948c9bda08 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:05:35 +1100
Subject: [PATCH 438/554] units: Remove unnecessary code comments

These comments to not add much value - remove them.
---
 units/src/block.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/units/src/block.rs b/units/src/block.rs
index 49bd88ac9d..9e8475db4c 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -44,11 +44,9 @@ impl BlockHeight {
     pub const MAX: Self = BlockHeight(u32::MAX);
 
     /// Constructs a new block height from a `u32`.
-    // Because From<u32> is not const.
     pub const fn from_u32(inner: u32) -> Self { Self(inner) }
 
     /// Returns block height as a `u32`.
-    // Because type inference doesn't always work using `Into`.
     pub const fn to_u32(self) -> u32 { self.0 }
 }
 
@@ -111,11 +109,9 @@ impl BlockInterval {
     pub const MAX: Self = BlockInterval(u32::MAX);
 
     /// Constructs a new block interval from a `u32`.
-    // Because From<u32> is not const.
     pub const fn from_u32(inner: u32) -> Self { Self(inner) }
 
     /// Returns block interval as a `u32`.
-    // Because type inference doesn't always work using `Into`.
     pub const fn to_u32(self) -> u32 { self.0 }
 }
 

From f5e17914b6698e4b08e80aef7f2276e6897b0843 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:09:10 +1100
Subject: [PATCH 439/554] Move Assign impls together

Next patch will move all the impls of `Add` and `Sub` into a macro call.
In order to make that patch smaller move the assign impls to be together
below the add/sub impls.

Code move only, no logic change.
---
 units/src/block.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/units/src/block.rs b/units/src/block.rs
index 9e8475db4c..af4d30b414 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -211,10 +211,6 @@ impl ops::Add<BlockInterval> for BlockInterval {
     }
 }
 
-impl ops::AddAssign<BlockInterval> for BlockInterval {
-    fn add_assign(&mut self, rhs: BlockInterval) { self.0 = self.to_u32() + rhs.to_u32(); }
-}
-
 // interval - interval = interval
 impl ops::Sub<BlockInterval> for BlockInterval {
     type Output = BlockInterval;
@@ -225,6 +221,10 @@ impl ops::Sub<BlockInterval> for BlockInterval {
     }
 }
 
+impl ops::AddAssign<BlockInterval> for BlockInterval {
+    fn add_assign(&mut self, rhs: BlockInterval) { self.0 = self.to_u32() + rhs.to_u32(); }
+}
+
 impl ops::SubAssign<BlockInterval> for BlockInterval {
     fn sub_assign(&mut self, rhs: BlockInterval) { self.0 = self.to_u32() - rhs.to_u32(); }
 }

From 9d559229529790da70d7342b5566294bbf162650 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:11:19 +1100
Subject: [PATCH 440/554] Use impl_op_for_references for block height/interval

We have a new macro for implementing ops with a bunch of reference
combos. Lets use it for block `Height` and `Interval`.

This patch is strictly additive.
---
 units/src/block.rs | 72 ++++++++++++++++++++++++----------------------
 1 file changed, 37 insertions(+), 35 deletions(-)

diff --git a/units/src/block.rs b/units/src/block.rs
index af4d30b414..a402853fd3 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -171,53 +171,55 @@ impl fmt::Display for TooBigForRelativeBlockHeightError {
 #[cfg(feature = "std")]
 impl std::error::Error for TooBigForRelativeBlockHeightError {}
 
-// height - height = interval
-impl ops::Sub<BlockHeight> for BlockHeight {
-    type Output = BlockInterval;
-
-    fn sub(self, rhs: BlockHeight) -> Self::Output {
-        let interval = self.to_u32() - rhs.to_u32();
-        BlockInterval::from_u32(interval)
+crate::internal_macros::impl_op_for_references! {
+    // height - height = interval
+    impl ops::Sub<BlockHeight> for BlockHeight {
+        type Output = BlockInterval;
+
+        fn sub(self, rhs: BlockHeight) -> Self::Output {
+            let interval = self.to_u32() - rhs.to_u32();
+            BlockInterval::from_u32(interval)
+        }
     }
-}
 
-// height + interval = height
-impl ops::Add<BlockInterval> for BlockHeight {
-    type Output = BlockHeight;
+    // height + interval = height
+    impl ops::Add<BlockInterval> for BlockHeight {
+        type Output = BlockHeight;
 
-    fn add(self, rhs: BlockInterval) -> Self::Output {
-        let height = self.to_u32() + rhs.to_u32();
-        BlockHeight::from_u32(height)
+        fn add(self, rhs: BlockInterval) -> Self::Output {
+            let height = self.to_u32() + rhs.to_u32();
+            BlockHeight::from_u32(height)
+        }
     }
-}
 
-// height - interval = height
-impl ops::Sub<BlockInterval> for BlockHeight {
-    type Output = BlockHeight;
+    // height - interval = height
+    impl ops::Sub<BlockInterval> for BlockHeight {
+        type Output = BlockHeight;
 
-    fn sub(self, rhs: BlockInterval) -> Self::Output {
-        let height = self.to_u32() - rhs.to_u32();
-        BlockHeight::from_u32(height)
+        fn sub(self, rhs: BlockInterval) -> Self::Output {
+            let height = self.to_u32() - rhs.to_u32();
+            BlockHeight::from_u32(height)
+        }
     }
-}
 
-// interval + interval = interval
-impl ops::Add<BlockInterval> for BlockInterval {
-    type Output = BlockInterval;
+    // interval + interval = interval
+    impl ops::Add<BlockInterval> for BlockInterval {
+        type Output = BlockInterval;
 
-    fn add(self, rhs: BlockInterval) -> Self::Output {
-        let height = self.to_u32() + rhs.to_u32();
-        BlockInterval::from_u32(height)
+        fn add(self, rhs: BlockInterval) -> Self::Output {
+            let height = self.to_u32() + rhs.to_u32();
+            BlockInterval::from_u32(height)
+        }
     }
-}
 
-// interval - interval = interval
-impl ops::Sub<BlockInterval> for BlockInterval {
-    type Output = BlockInterval;
+    // interval - interval = interval
+    impl ops::Sub<BlockInterval> for BlockInterval {
+        type Output = BlockInterval;
 
-    fn sub(self, rhs: BlockInterval) -> Self::Output {
-        let height = self.to_u32() - rhs.to_u32();
-        BlockInterval::from_u32(height)
+        fn sub(self, rhs: BlockInterval) -> Self::Output {
+            let height = self.to_u32() - rhs.to_u32();
+            BlockInterval::from_u32(height)
+        }
     }
 }
 

From 3ae21d5111444f5e01f6cfb1a2b9b314f66418a3 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:16:10 +1100
Subject: [PATCH 441/554] Use impl_add/sub_assign for block interval

We have a macro for implementing `AddAssign` and `SubAssign`.

Use the macro, gets us an additional ref impl for both.
---
 units/src/block.rs | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/units/src/block.rs b/units/src/block.rs
index a402853fd3..5d0dc90b81 100644
--- a/units/src/block.rs
+++ b/units/src/block.rs
@@ -223,13 +223,8 @@ crate::internal_macros::impl_op_for_references! {
     }
 }
 
-impl ops::AddAssign<BlockInterval> for BlockInterval {
-    fn add_assign(&mut self, rhs: BlockInterval) { self.0 = self.to_u32() + rhs.to_u32(); }
-}
-
-impl ops::SubAssign<BlockInterval> for BlockInterval {
-    fn sub_assign(&mut self, rhs: BlockInterval) { self.0 = self.to_u32() - rhs.to_u32(); }
-}
+crate::internal_macros::impl_add_assign!(BlockInterval);
+crate::internal_macros::impl_sub_assign!(BlockInterval);
 
 impl core::iter::Sum for BlockInterval {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {

From 6f4eb609367918220f91b7b1f89241e488d17f5c Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:28:01 +1100
Subject: [PATCH 442/554] Improve docs crate headings

I took a look at the rendered HMTL of `bitcoin`, `primitives`, `units`,
`serde`, and `tokio` and picked a header style that I thought looked
good.

Use it for `primitives` and `units`.
---
 primitives/src/lib.rs | 2 +-
 units/src/lib.rs      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index 451a3c1667..f73a7ce176 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! # Rust Bitcoin - primitive types.
+//! # Rust Bitcoin - primitive types
 //!
 //! Primitive data types that are used throughout the [`rust-bitcoin`] ecosystem.
 //!
diff --git a/units/src/lib.rs b/units/src/lib.rs
index 4d3be98ac2..5a9742986b 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Rust Bitcoin units library
+//! # Rust Bitcoin - unit types
 //!
 //! This library provides basic types used by the Rust Bitcoin ecosystem.
 

From c466554948734be20559fb3b31bc1d9200f8598a Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:29:19 +1100
Subject: [PATCH 443/554] hashes: Improve crate docs heading

Use same for as the other crates and emphasise that this is a Bitcoin
hashes crate.
---
 hashes/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 2b8d5924c2..06cfbcda39 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Rust hashes library.
+//! # Rust Bitcoin Hashes Library
 //!
 //! This library implements the hash functions needed by Bitcoin. As an ancillary thing, it exposes
 //! hexadecimal serialization and deserialization, since these are needed to display hashes.

From d4417f96669585201b7a69f4418f259e0d7b4062 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:30:52 +1100
Subject: [PATCH 444/554] io: Improve crate docs heading

Use the same format as the other crates.
---
 io/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/io/src/lib.rs b/io/src/lib.rs
index 3c020d0b4d..0b7ee50939 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Rust-Bitcoin I/O Library
+//! # Rust Bitcoin I/O Library
 //!
 //! The [`std::io`] module is not exposed in `no-std` Rust so building `no-std` applications which
 //! require reading and writing objects via standard traits is not generally possible. Thus, this

From 4451724d31f2ef5388f06728ca28b804c00322b5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:32:15 +1100
Subject: [PATCH 445/554] chacha20: Add a docs heading

Like we do for the other crates add a heading to the crate docs.
---
 chacha20_poly1305/src/lib.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/chacha20_poly1305/src/lib.rs b/chacha20_poly1305/src/lib.rs
index 42b2df3afe..16c82a9cac 100644
--- a/chacha20_poly1305/src/lib.rs
+++ b/chacha20_poly1305/src/lib.rs
@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
+//! # ChaCha20 - Poly1305
+//!
 //! Combine the ChaCha20 stream cipher with the Poly1305 message authentication code
 //! to form an authenticated encryption with additional data (AEAD) algorithm.
 #![no_std]

From 83d071e54be0bc4ebd760a490a3ca887c0bf90a8 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:33:19 +1100
Subject: [PATCH 446/554] chacha20: Add whitespace

Mirror the other crates. Whitespace only.
---
 chacha20_poly1305/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/chacha20_poly1305/src/lib.rs b/chacha20_poly1305/src/lib.rs
index 16c82a9cac..0deea843df 100644
--- a/chacha20_poly1305/src/lib.rs
+++ b/chacha20_poly1305/src/lib.rs
@@ -4,6 +4,7 @@
 //!
 //! Combine the ChaCha20 stream cipher with the Poly1305 message authentication code
 //! to form an authenticated encryption with additional data (AEAD) algorithm.
+
 #![no_std]
 // Experimental features we need.
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]

From 1fe984552e0a691c836136a82fe1733cea4f0763 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:44:14 +1100
Subject: [PATCH 447/554] Improve Weight rustdocs

Do trivial improvement to rustdocs for the `Weight` type.
---
 units/src/weight.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/units/src/weight.rs b/units/src/weight.rs
index 720dfd385b..c7fb19913b 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -12,10 +12,10 @@ use serde::{Deserialize, Serialize};
 /// The factor that non-witness serialization data is multiplied by during weight calculation.
 pub const WITNESS_SCALE_FACTOR: usize = 4;
 
-/// Represents block weight - the weight of a transaction or block.
+/// Represents weight - the weight of a transaction or block.
 ///
 /// This is an integer newtype representing [`Weight`] in `wu`. It provides protection against mixing
-/// up the types as well as basic formatting features.
+/// up 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(transparent))]

From 2434afc40dadd213f8695c5ce91d397c03f337be Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 13:46:42 +1100
Subject: [PATCH 448/554] Make Weigth::from_kwu const

The other two `Weight` constructors are const already.
---
 units/src/weight.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/units/src/weight.rs b/units/src/weight.rs
index c7fb19913b..ecd50b8042 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -48,7 +48,13 @@ impl Weight {
     pub const fn from_wu(wu: u64) -> Self { Weight(wu) }
 
     /// Constructs a new [`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) }
+    pub const fn from_kwu(wu: u64) -> Option<Self> {
+        // No `map()` in const context.
+        match wu.checked_mul(1000) {
+            Some(wu) => Some(Weight::from_wu(wu)),
+            None => None,
+        }
+    }
 
     /// Constructs a new [`Weight`] from virtual bytes, returning [`None`] if an overflow occurred.
     pub const fn from_vb(vb: u64) -> Option<Self> {

From 85612908af936c7f0866227e24a3359115991ca2 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 14:01:00 +1100
Subject: [PATCH 449/554] Use uniform return statement in docs

We have a bunch of 'Returns [`None`] if .. ' statements. Make the whole
module uniform.
---
 units/src/fee.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/units/src/fee.rs b/units/src/fee.rs
index 2cf8d5bb68..1bb3b9b665 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -144,7 +144,7 @@ impl FeeRate {
     /// ensuring that the transaction fee is enough instead of falling short if
     /// rounded down.
     ///
-    /// [`None`] is returned if an overflow occurred.
+    /// Returns [`None`] if overflow occurred.
     #[must_use]
     pub const fn checked_mul_by_weight(self, weight: Weight) -> Option<Amount> {
         // No `?` operator in const context.
@@ -206,7 +206,7 @@ impl Weight {
     /// ensuring that the transaction fee is enough instead of falling short if
     /// rounded down.
     ///
-    /// [`None`] is returned if an overflow occurred.
+    /// Returns [`None`] if overflow occurred.
     #[must_use]
     pub const fn checked_mul_by_fee_rate(self, fee_rate: FeeRate) -> Option<Amount> {
         fee_rate.checked_mul_by_weight(self)

From a4b9c196b13a2029ef0de198114a29c71a192d03 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 14:57:03 +1100
Subject: [PATCH 450/554] Manually update nightly version

While trying to use the `macro_use_imports` lint I found that there is a
bug in last weeks nightly. It has been fixed already so lets update.

Update to todays nightly compiler. Doing so causes some new linter
warnings, for now we just allow them.
---
 bitcoin/src/psbt/mod.rs | 4 ++++
 nightly-version         | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 2471fc41d5..1d83f55833 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -135,6 +135,7 @@ impl Psbt {
     /// An alias for [`extract_tx_fee_rate_limit`].
     ///
     /// [`extract_tx_fee_rate_limit`]: Psbt::extract_tx_fee_rate_limit
+    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx(self) -> Result<Transaction, ExtractTxError> {
         self.internal_extract_tx_with_fee_rate_limit(Self::DEFAULT_MAX_FEE_RATE)
     }
@@ -146,6 +147,7 @@ impl Psbt {
     /// [`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.
+    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx_fee_rate_limit(self) -> Result<Transaction, ExtractTxError> {
         self.internal_extract_tx_with_fee_rate_limit(Self::DEFAULT_MAX_FEE_RATE)
     }
@@ -157,6 +159,7 @@ impl Psbt {
     /// See [`extract_tx`].
     ///
     /// [`extract_tx`]: Psbt::extract_tx
+    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx_with_fee_rate_limit(
         self,
         max_fee_rate: FeeRate,
@@ -184,6 +187,7 @@ impl Psbt {
     }
 
     #[inline]
+    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
     fn internal_extract_tx_with_fee_rate_limit(
         self,
         max_fee_rate: FeeRate,
diff --git a/nightly-version b/nightly-version
index bd3641e459..44b3e69d4a 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-02-28
+nightly-2025-03-03

From b656d7a16c2d0cdd6d8a94fffeac842ffc0fabf4 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Thu, 27 Feb 2025 10:13:51 +0000
Subject: [PATCH 451/554] Inline small functions

Functions that just delegate or do trivial operations should be inline.

Add `#[inline]` to all functions in `primitives` that fit the criteria.
---
 primitives/src/block.rs             | 13 +++++++++++++
 primitives/src/locktime/absolute.rs |  3 +++
 primitives/src/locktime/relative.rs |  7 +++++++
 primitives/src/opcodes.rs           |  1 +
 primitives/src/pow.rs               |  2 ++
 primitives/src/sequence.rs          |  9 +++++++++
 primitives/src/transaction.rs       | 16 ++++++++++++++++
 primitives/src/witness.rs           | 18 ++++++++++++++++++
 8 files changed, 69 insertions(+)

diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index b30a2c6c96..b819734e5e 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -70,6 +70,7 @@ where
 #[cfg(feature = "alloc")]
 impl Block<Unchecked> {
     /// Constructs a new `Block` without doing any validation.
+    #[inline]
     pub fn new_unchecked(header: Header, transactions: Vec<Transaction>) -> Block<Unchecked> {
         Block { header, transactions, witness_root: None, marker: PhantomData::<Unchecked> }
     }
@@ -78,6 +79,7 @@ impl Block<Unchecked> {
     ///
     /// You should only use this function if you trust the block i.e., it comes from a trusted node.
     #[must_use]
+    #[inline]
     pub fn assume_checked(self, witness_root: Option<WitnessMerkleNode>) -> Block<Checked> {
         Block {
             header: self.header,
@@ -88,37 +90,44 @@ impl Block<Unchecked> {
     }
 
     /// Decomposes block into its constituent parts.
+    #[inline]
     pub fn into_parts(self) -> (Header, Vec<Transaction>) { (self.header, self.transactions) }
 }
 
 #[cfg(feature = "alloc")]
 impl Block<Checked> {
     /// Gets a reference to the block header.
+    #[inline]
     pub fn header(&self) -> &Header { &self.header }
 
     /// Gets a reference to the block's list of transactions.
+    #[inline]
     pub fn transactions(&self) -> &[Transaction] { &self.transactions }
 
     /// Returns the cached witness root if one is present.
     ///
     /// It is assumed that a block will have the witness root calculated and cached as part of the
     /// validation process.
+    #[inline]
     pub fn cached_witness_root(&self) -> Option<WitnessMerkleNode> { self.witness_root }
 }
 
 #[cfg(feature = "alloc")]
 impl<V: Validation> Block<V> {
     /// Returns the block hash.
+    #[inline]
     pub fn block_hash(&self) -> BlockHash { self.header.block_hash() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<Block> for BlockHash {
+    #[inline]
     fn from(block: Block) -> BlockHash { block.block_hash() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<&Block> for BlockHash {
+    #[inline]
     fn from(block: &Block) -> BlockHash { block.block_hash() }
 }
 
@@ -212,10 +221,12 @@ impl fmt::Debug for Header {
 }
 
 impl From<Header> for BlockHash {
+    #[inline]
     fn from(header: Header) -> BlockHash { header.block_hash() }
 }
 
 impl From<&Header> for BlockHash {
+    #[inline]
     fn from(header: &Header) -> BlockHash { header.block_hash() }
 }
 
@@ -263,6 +274,7 @@ impl Version {
     /// Returns the inner `i32` value.
     ///
     /// This is the data type used in consensus code in Bitcoin Core.
+    #[inline]
     pub fn to_consensus(self) -> i32 { self.0 }
 
     /// Checks whether the version number is signalling a soft fork at the given bit.
@@ -286,6 +298,7 @@ impl Version {
 }
 
 impl Default for Version {
+    #[inline]
     fn default() -> Version { Self::NO_SOFT_FORK_SIGNALLING }
 }
 
diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index b6321f772d..639963aa72 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -102,6 +102,7 @@ impl LockTime {
     ///
     /// # Ok::<_, units::parse::PrefixedHexError>(())
     /// ```
+    #[inline]
     pub fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
         let lock_time = parse::hex_u32_prefixed(s)?;
         Ok(Self::from_consensus(lock_time))
@@ -119,6 +120,7 @@ impl LockTime {
     ///
     /// # Ok::<_, units::parse::UnprefixedHexError>(())
     /// ```
+    #[inline]
     pub fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
         let lock_time = parse::hex_u32_unprefixed(s)?;
         Ok(Self::from_consensus(lock_time))
@@ -320,6 +322,7 @@ impl From<Time> for LockTime {
 }
 
 impl fmt::Debug for LockTime {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use LockTime::*;
 
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 5acd781695..81518aa4a3 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -89,6 +89,7 @@ impl LockTime {
     ///
     /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
     /// ```
+    #[inline]
     pub fn from_consensus(n: u32) -> Result<Self, DisabledLockTimeError> {
         let sequence = crate::Sequence::from_consensus(n);
         sequence.to_relative_lock_time().ok_or(DisabledLockTimeError(n))
@@ -370,12 +371,14 @@ impl fmt::Display for LockTime {
 
 impl convert::TryFrom<Sequence> for LockTime {
     type Error = DisabledLockTimeError;
+    #[inline]
     fn try_from(seq: Sequence) -> Result<LockTime, DisabledLockTimeError> {
         LockTime::from_sequence(seq)
     }
 }
 
 impl From<LockTime> for Sequence {
+    #[inline]
     fn from(lt: LockTime) -> Sequence { lt.to_sequence() }
 }
 
@@ -387,10 +390,12 @@ pub struct DisabledLockTimeError(u32);
 impl DisabledLockTimeError {
     /// Accessor for the `u32` whose "disable" flag was set, preventing
     /// it from being parsed as a relative locktime.
+    #[inline]
     pub fn disabled_locktime_value(&self) -> u32 { self.0 }
 }
 
 impl fmt::Display for DisabledLockTimeError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "lock time 0x{:08x} has disable flag set", self.0)
     }
@@ -417,6 +422,7 @@ impl IncompatibleHeightError {
 }
 
 impl fmt::Display for IncompatibleHeightError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
@@ -447,6 +453,7 @@ impl IncompatibleTimeError {
 }
 
 impl fmt::Display for IncompatibleTimeError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index 5da0295d39..09444e2e52 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -440,6 +440,7 @@ impl From<u8> for Opcode {
 }
 
 impl fmt::Debug for Opcode {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { fmt::Display::fmt(self, f) }
 }
 
diff --git a/primitives/src/pow.rs b/primitives/src/pow.rs
index 95743c7a28..df452dedf6 100644
--- a/primitives/src/pow.rs
+++ b/primitives/src/pow.rs
@@ -24,9 +24,11 @@ pub struct CompactTarget(u32);
 
 impl CompactTarget {
     /// Constructs a new [`CompactTarget`] from a consensus encoded `u32`.
+    #[inline]
     pub fn from_consensus(bits: u32) -> Self { Self(bits) }
 
     /// Returns the consensus encoded `u32` representation of this [`CompactTarget`].
+    #[inline]
     pub fn to_consensus(self) -> u32 { self.0 }
 }
 
diff --git a/primitives/src/sequence.rs b/primitives/src/sequence.rs
index e225739f8e..a4e7dbff56 100644
--- a/primitives/src/sequence.rs
+++ b/primitives/src/sequence.rs
@@ -124,12 +124,14 @@ impl Sequence {
     }
 
     /// Constructs a new `Sequence` from a prefixed hex string.
+    #[inline]
     pub fn from_hex(s: &str) -> Result<Self, PrefixedHexError> {
         let lock_time = parse::hex_u32_prefixed(s)?;
         Ok(Self::from_consensus(lock_time))
     }
 
     /// Constructs a new `Sequence` from an unprefixed hex string.
+    #[inline]
     pub fn from_unprefixed_hex(s: &str) -> Result<Self, UnprefixedHexError> {
         let lock_time = parse::hex_u32_unprefixed(s)?;
         Ok(Self::from_consensus(lock_time))
@@ -203,23 +205,28 @@ impl Sequence {
     /// Returns the low 16 bits from sequence number.
     ///
     /// BIP-68 only uses the low 16 bits for relative lock value.
+    #[inline]
     fn low_u16(&self) -> u16 { self.0 as u16 }
 }
 
 impl Default for Sequence {
     /// The default value of sequence is 0xffffffff.
+    #[inline]
     fn default() -> Self { Sequence::MAX }
 }
 
 impl From<Sequence> for u32 {
+    #[inline]
     fn from(sequence: Sequence) -> u32 { sequence.0 }
 }
 
 impl fmt::Display for Sequence {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
 
 impl fmt::LowerHex for Sequence {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
 }
 #[cfg(feature = "alloc")]
@@ -228,10 +235,12 @@ internals::impl_to_hex_from_lower_hex!(Sequence, |sequence: &Sequence| {
 });
 
 impl fmt::UpperHex for Sequence {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::UpperHex::fmt(&self.0, f) }
 }
 
 impl fmt::Debug for Sequence {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // 10 because its 8 digits + 2 for the '0x'
         write!(f, "Sequence({:#010x})", self.0)
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index d1ec78b02d..7e708e2502 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -115,15 +115,19 @@ impl Transaction {
     pub const MAX_STANDARD_WEIGHT: Weight = Weight::from_wu(400_000);
 
     /// Returns a reference to the transaction inputs.
+    #[inline]
     pub fn inputs(&self) -> &[TxIn] { &self.input }
 
     /// Returns a mutable reference to the transaction inputs.
+    #[inline]
     pub fn inputs_mut(&mut self) -> &mut [TxIn] { &mut self.input }
 
     /// Returns a reference to the transaction outputs.
+    #[inline]
     pub fn outputs(&self) -> &[TxOut] { &self.output }
 
     /// Returns a mutable reference to the transaction outputs.
+    #[inline]
     pub fn outputs_mut(&mut self) -> &mut [TxOut] { &mut self.output }
 
     /// Computes a "normalized TXID" which does not include any signatures.
@@ -155,6 +159,7 @@ impl Transaction {
     /// witness fields themselves). For non-SegWit transactions which do not have any SegWit data,
     /// this will be equal to [`Transaction::compute_wtxid()`].
     #[doc(alias = "txid")]
+    #[inline]
     pub fn compute_txid(&self) -> Txid {
         let hash = hash_transaction(self, false);
         Txid::from_byte_array(hash.to_byte_array())
@@ -166,6 +171,7 @@ impl Transaction {
     /// witness fields themselves). For non-SegWit transactions which do not have any SegWit data,
     /// this will be equal to [`Transaction::compute_txid()`].
     #[doc(alias = "wtxid")]
+    #[inline]
     pub fn compute_wtxid(&self) -> Wtxid {
         let hash = hash_transaction(self, self.uses_segwit_serialization());
         Wtxid::from_byte_array(hash.to_byte_array())
@@ -173,6 +179,7 @@ impl Transaction {
 
     /// Returns whether or not to serialize transaction as specified in BIP-144.
     // This is duplicated in `bitcoin`, if you change it please do so in both places.
+    #[inline]
     fn uses_segwit_serialization(&self) -> bool {
         if self.input.iter().any(|input| !input.witness.is_empty()) {
             return true;
@@ -185,6 +192,7 @@ impl Transaction {
 
 #[cfg(feature = "alloc")]
 impl cmp::PartialOrd for Transaction {
+    #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> { Some(self.cmp(other)) }
 }
 
@@ -201,21 +209,25 @@ impl cmp::Ord for Transaction {
 
 #[cfg(feature = "alloc")]
 impl From<Transaction> for Txid {
+    #[inline]
     fn from(tx: Transaction) -> Txid { tx.compute_txid() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<&Transaction> for Txid {
+    #[inline]
     fn from(tx: &Transaction) -> Txid { tx.compute_txid() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<Transaction> for Wtxid {
+    #[inline]
     fn from(tx: Transaction) -> Wtxid { tx.compute_wtxid() }
 }
 
 #[cfg(feature = "alloc")]
 impl From<&Transaction> for Wtxid {
+    #[inline]
     fn from(tx: &Transaction) -> Wtxid { tx.compute_wtxid() }
 }
 
@@ -377,6 +389,7 @@ impl OutPoint {
 }
 
 impl fmt::Display for OutPoint {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}:{}", self.txid, self.vout)
     }
@@ -439,6 +452,7 @@ pub enum ParseOutPointError {
 
 #[cfg(feature = "alloc")]
 impl From<Infallible> for ParseOutPointError {
+    #[inline]
     fn from(never: Infallible) -> Self { match never {} }
 }
 
@@ -553,10 +567,12 @@ impl Version {
 }
 
 impl fmt::Display for Version {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
 
 impl From<Version> for u32 {
+    #[inline]
     fn from(version: Version) -> Self { version.0 }
 }
 
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index e892334f1a..f8328b8200 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -99,18 +99,22 @@ impl Witness {
     }
 
     /// Convenience method to create an array of byte-arrays from this witness.
+    #[inline]
     pub fn to_vec(&self) -> Vec<Vec<u8>> { self.iter().map(|s| s.to_vec()).collect() }
 
     /// Returns `true` if the witness contains no element.
+    #[inline]
     pub fn is_empty(&self) -> bool { self.witness_elements == 0 }
 
     /// Returns a struct implementing [`Iterator`].
     #[must_use = "iterators are lazy and do nothing unless consumed"]
+    #[inline]
     pub fn iter(&self) -> Iter {
         Iter { inner: self.content.as_slice(), indices_start: self.indices_start, current_index: 0 }
     }
 
     /// Returns the number of elements this witness holds.
+    #[inline]
     pub fn len(&self) -> usize { self.witness_elements }
 
     /// Returns the number of bytes this witness contributes to a transactions total size.
@@ -130,6 +134,7 @@ impl Witness {
     }
 
     /// Clear the witness.
+    #[inline]
     pub fn clear(&mut self) {
         self.content.clear();
         self.witness_elements = 0;
@@ -137,6 +142,7 @@ impl Witness {
     }
 
     /// Push a new element on the witness, requires an allocation.
+    #[inline]
     pub fn push<T: AsRef<[u8]>>(&mut self, new_element: T) {
         self.push_slice(new_element.as_ref());
     }
@@ -178,6 +184,7 @@ impl Witness {
     }
 
     /// Returns the last element in the witness, if any.
+    #[inline]
     pub fn last(&self) -> Option<&[u8]> {
         if self.witness_elements == 0 {
             None
@@ -187,6 +194,7 @@ impl Witness {
     }
 
     /// Returns the second-to-last element in the witness, if any.
+    #[inline]
     pub fn second_to_last(&self) -> Option<&[u8]> {
         if self.witness_elements <= 1 {
             None
@@ -196,6 +204,7 @@ impl Witness {
     }
 
     /// Returns the third-to-last element in the witness, if any.
+    #[inline]
     pub fn third_to_last(&self) -> Option<&[u8]> {
         if self.witness_elements <= 2 {
             None
@@ -205,6 +214,7 @@ impl Witness {
     }
 
     /// Return the nth element in the witness, if any
+    #[inline]
     pub fn nth(&self, index: usize) -> Option<&[u8]> {
         let pos = decode_cursor(&self.content, self.indices_start, index)?;
         self.element_at(pos)
@@ -264,6 +274,7 @@ pub struct Iter<'a> {
 impl Index<usize> for Witness {
     type Output = [u8];
 
+    #[inline]
     fn index(&self, index: usize) -> &Self::Output { self.nth(index).expect("out of bounds") }
 }
 
@@ -281,6 +292,7 @@ impl<'a> Iterator for Iter<'a> {
         Some(&slice[..end])
     }
 
+    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let total_count = (self.inner.len() - self.indices_start) / 4;
         let remaining = total_count - self.current_index;
@@ -294,6 +306,7 @@ impl<'a> IntoIterator for &'a Witness {
     type IntoIter = Iter<'a>;
     type Item = &'a [u8];
 
+    #[inline]
     fn into_iter(self) -> Self::IntoIter { self.iter() }
 }
 
@@ -381,22 +394,27 @@ impl<'de> serde::Deserialize<'de> for Witness {
 }
 
 impl From<Vec<Vec<u8>>> for Witness {
+    #[inline]
     fn from(vec: Vec<Vec<u8>>) -> Self { Witness::from_slice(&vec) }
 }
 
 impl From<&[&[u8]]> for Witness {
+    #[inline]
     fn from(slice: &[&[u8]]) -> Self { Witness::from_slice(slice) }
 }
 
 impl From<&[Vec<u8>]> for Witness {
+    #[inline]
     fn from(slice: &[Vec<u8>]) -> Self { Witness::from_slice(slice) }
 }
 
 impl From<Vec<&[u8]>> for Witness {
+    #[inline]
     fn from(vec: Vec<&[u8]>) -> Self { Witness::from_slice(&vec) }
 }
 
 impl Default for Witness {
+    #[inline]
     fn default() -> Self { Self::new() }
 }
 

From cab8a6134fe701d3aa99b526910a594a0a4c5e3e Mon Sep 17 00:00:00 2001
From: Bruno Garcia <brunoely.gc@gmail.com>
Date: Mon, 3 Mar 2025 12:06:55 -0300
Subject: [PATCH 452/554] fuzz: cover count_sigops{_legacy} for Script

---
 fuzz/fuzz_targets/bitcoin/deserialize_script.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
index 6943bc64cd..2518061e40 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -10,6 +10,9 @@ fn do_test(data: &[u8]) {
         let _: Result<Vec<script::Instruction>, script::Error> = script.instructions().collect();
 
         let _ = script.to_string();
+        let _ = script.count_sigops();
+        let _ = script.count_sigops_legacy();
+
         let mut b = script::Builder::new();
         for ins in script.instructions_minimal() {
             if ins.is_err() {

From eb8ecd5e3cf42bb01dbf6e16422da7b4ddc78b29 Mon Sep 17 00:00:00 2001
From: Bruno Garcia <brunoely.gc@gmail.com>
Date: Mon, 3 Mar 2025 12:24:15 -0300
Subject: [PATCH 453/554] fuzz: cover minimal_non_dust for Script

---
 fuzz/fuzz_targets/bitcoin/deserialize_script.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
index 2518061e40..866c76983b 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -12,6 +12,7 @@ fn do_test(data: &[u8]) {
         let _ = script.to_string();
         let _ = script.count_sigops();
         let _ = script.count_sigops_legacy();
+        let _ = script.minimal_non_dust();
 
         let mut b = script::Builder::new();
         for ins in script.instructions_minimal() {

From 35e7027a083ddfe7674567ab60f9b7d6cf3d0bef Mon Sep 17 00:00:00 2001
From: Bruno Garcia <brunoely.gc@gmail.com>
Date: Mon, 3 Mar 2025 13:47:52 -0300
Subject: [PATCH 454/554] fuzz: move consume_random_bytes to a util file

---
 fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs | 13 ++-----------
 fuzz/fuzz_targets/bitcoin/fuzz_utils.rs       | 11 +++++++++++
 2 files changed, 13 insertions(+), 11 deletions(-)
 create mode 100644 fuzz/fuzz_targets/bitcoin/fuzz_utils.rs

diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs b/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
index 59d28142cb..b3fe54bbdd 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
@@ -1,16 +1,7 @@
 use honggfuzz::fuzz;
 
-fn consume_random_bytes<'a>(data: &mut &'a [u8]) -> &'a [u8] {
-    if data.is_empty() {
-        return &[];
-    }
-
-    let length = (data[0] as usize) % (data.len() + 1);
-    let (bytes, rest) = data.split_at(length);
-    *data = rest;
-
-    bytes
-}
+mod fuzz_utils;
+use fuzz_utils::consume_random_bytes;
 
 fn do_test(data: &[u8]) {
     let mut new_data = data;
diff --git a/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs b/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs
new file mode 100644
index 0000000000..518d6a5bdd
--- /dev/null
+++ b/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs
@@ -0,0 +1,11 @@
+pub fn consume_random_bytes<'a>(data: &mut &'a [u8]) -> &'a [u8] {
+    if data.is_empty() {
+        return &[];
+    }
+
+    let length = (data[0] as usize) % (data.len() + 1);
+    let (bytes, rest) = data.split_at(length);
+    *data = rest;
+
+    bytes
+}

From fe685b824f1c63ad0e4aea74a18081d71ccd044d Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 3 Mar 2025 17:25:34 +0000
Subject: [PATCH 455/554] Fix the release script that checks for TBD

`release.sh` is missing `units`.

Add `units` to the list of crates to check.
Reorder the crates alphabetically.
---
 contrib/release.sh | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/contrib/release.sh b/contrib/release.sh
index b30f2fb846..c02657948d 100755
--- a/contrib/release.sh
+++ b/contrib/release.sh
@@ -6,7 +6,7 @@
 set -euox pipefail
 
 main () {
-    for crate in "internals" "hashes" "bitcoin"; do
+    for crate in "bitcoin" "hashes" "internals" "units"; do
         if release_changes $crate; then
             echo "$crate has changes implying this is a release PR, checking if we can publish ..."
 
@@ -35,12 +35,14 @@ release_changes() {
 # 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
+    if [ "$crate" == "bitcoin" ]; then
+        cargo publish -p "bitcoin" --dry-run
+    elif [ "$crate" == "hashes" ]; then
         cargo publish -p "bitcoin_hashes" --dry-run
     elif [ "$crate" == "internals" ]; then
         cargo publish -p "bitcoin-internals" --dry-run
-    elif [ "$crate" == "bitcoin" ]; then
-        cargo publish -p "bitcoin" --dry-run
+    elif [ "$crate" == "units" ]; then
+        cargo publish -p "bitcoin-units" --dry-run
     fi
 }
 

From 4787aa1f896df4857d8cf4051ce96c2b531f35ad Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 3 Mar 2025 17:36:26 +0000
Subject: [PATCH 456/554] Implement Rem for Weight

`Weight` implements `Div` but not `Rem`

Add `Rem` impl for `Weight`
---
 units/src/weight.rs | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/units/src/weight.rs b/units/src/weight.rs
index 720dfd385b..533158e0a3 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -198,6 +198,16 @@ crate::internal_macros::impl_op_for_references! {
 
         fn div(self, rhs: Weight) -> Self::Output { self.to_wu() / rhs.to_wu() }
     }
+    impl ops::Rem<u64> for Weight {
+        type Output = Weight;
+
+        fn rem(self, rhs: u64) -> Self::Output { Weight(self.0 % rhs) }
+    }
+    impl ops::Rem<Weight> for Weight {
+        type Output = u64;
+
+        fn rem(self, rhs: Weight) -> Self::Output { self.0 % rhs.0 }
+    }
 }
 crate::internal_macros::impl_add_assign!(Weight);
 crate::internal_macros::impl_sub_assign!(Weight);
@@ -210,6 +220,10 @@ impl ops::DivAssign<u64> for Weight {
     fn div_assign(&mut self, rhs: u64) { self.0 /= rhs }
 }
 
+impl ops::RemAssign<u64> for Weight {
+    fn rem_assign(&mut self, rhs: u64) { self.0 %= rhs }
+}
+
 impl core::iter::Sum for Weight {
     fn sum<I>(iter: I) -> Self
     where

From 80078406768aa5f8e4d21d42cc1d1fe9abeed1ea Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Mon, 3 Mar 2025 17:43:04 +0000
Subject: [PATCH 457/554] Add a test for remainder

A remainder operation has been implemented for `Weight`.

Test the functionality of remainder with both a `Weight` and `u64`
---
 units/src/weight.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/units/src/weight.rs b/units/src/weight.rs
index 533158e0a3..3cdd9f2297 100644
--- a/units/src/weight.rs
+++ b/units/src/weight.rs
@@ -453,4 +453,23 @@ mod tests {
         w /= Weight(4).into();
         assert_eq!(w, Weight(2));
     }
+
+    #[test]
+    fn remainder() {
+        let weight10 = Weight(10);
+        let weight3 = Weight(3);
+
+        let remainder = weight10 % weight3;
+        assert_eq!(remainder, 1);
+
+        let remainder = weight10 % 3;
+        assert_eq!(remainder, Weight(1));
+    }
+
+    #[test]
+    fn remainder_assign() {
+        let mut weight = Weight(10);
+        weight %= 3;
+        assert_eq!(weight, Weight(1));
+    }
 }

From 852bcf60178c9491ebcbf13243cf79857592ccec Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 11:25:24 +1100
Subject: [PATCH 458/554] bitcoin: Remove hash type re-exports

The `{W}PubkeyHash` and `{W}ScriptHash` types are not likely to be used
directly by consumers of the library because we have other function that
return them and are more ergonomic to use. There is therefor no good
reason to re-export them from the crate root.
---
 bitcoin/examples/ecdsa-psbt-simple.rs | 3 ++-
 bitcoin/examples/sign-tx-segwit-v0.rs | 3 ++-
 bitcoin/src/hash_types.rs             | 7 +++----
 bitcoin/src/lib.rs                    | 5 +----
 4 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/bitcoin/examples/ecdsa-psbt-simple.rs b/bitcoin/examples/ecdsa-psbt-simple.rs
index 45014db096..024f71c56f 100644
--- a/bitcoin/examples/ecdsa-psbt-simple.rs
+++ b/bitcoin/examples/ecdsa-psbt-simple.rs
@@ -26,13 +26,14 @@ use std::collections::BTreeMap;
 
 use bitcoin::address::script_pubkey::ScriptBufExt as _;
 use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, IntoDerivationPath, Xpriv, Xpub};
+use bitcoin::key::WPubkeyHash;
 use bitcoin::locktime::absolute;
 use bitcoin::psbt::Input;
 use bitcoin::secp256k1::{Secp256k1, Signing};
 use bitcoin::witness::WitnessExt as _;
 use bitcoin::{
     consensus, transaction, Address, Amount, EcdsaSighashType, Network, OutPoint, Psbt, ScriptBuf,
-    Sequence, Transaction, TxIn, TxOut, Txid, WPubkeyHash, Witness,
+    Sequence, Transaction, TxIn, TxOut, Txid, Witness,
 };
 
 // The master xpriv, from which we derive the keys we control.
diff --git a/bitcoin/examples/sign-tx-segwit-v0.rs b/bitcoin/examples/sign-tx-segwit-v0.rs
index f7d35c5842..a30c02d939 100644
--- a/bitcoin/examples/sign-tx-segwit-v0.rs
+++ b/bitcoin/examples/sign-tx-segwit-v0.rs
@@ -3,13 +3,14 @@
 //! Demonstrate creating a transaction that spends to and from p2wpkh outputs.
 
 use bitcoin::address::script_pubkey::ScriptBufExt as _;
+use bitcoin::key::WPubkeyHash;
 use bitcoin::locktime::absolute;
 use bitcoin::secp256k1::{rand, Message, Secp256k1, SecretKey, Signing};
 use bitcoin::sighash::{EcdsaSighashType, SighashCache};
 use bitcoin::witness::WitnessExt as _;
 use bitcoin::{
     transaction, Address, Amount, Network, OutPoint, ScriptBuf, Sequence, Transaction, TxIn, TxOut,
-    Txid, WPubkeyHash, Witness,
+    Txid, Witness,
 };
 
 const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_unchecked(20_000_000);
diff --git a/bitcoin/src/hash_types.rs b/bitcoin/src/hash_types.rs
index 10a995de68..e564999ca2 100644
--- a/bitcoin/src/hash_types.rs
+++ b/bitcoin/src/hash_types.rs
@@ -13,10 +13,9 @@ pub use crate::{
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        LegacySighash, PubkeyHash, ScriptHash, SegwitV0Sighash, TapSighash, WPubkeyHash,
-        WScriptHash, XKeyIdentifier,
-    };
+    use crate::key::{PubkeyHash, WPubkeyHash};
+    use crate::script::{ScriptHash, WScriptHash};
+    use crate::{LegacySighash, SegwitV0Sighash, TapSighash, XKeyIdentifier};
 
     #[rustfmt::skip]
     /// sha256d of the empty string
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index af6386a40c..b34fc7bebe 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -144,9 +144,7 @@ pub use crate::{
     bip158::{FilterHash, FilterHeader},
     bip32::XKeyIdentifier,
     crypto::ecdsa,
-    crypto::key::{
-        self, CompressedPublicKey, PrivateKey, PubkeyHash, PublicKey, WPubkeyHash, XOnlyPublicKey,
-    },
+    crypto::key::{self, CompressedPublicKey, PrivateKey, PublicKey, XOnlyPublicKey},
     crypto::sighash::{self, LegacySighash, SegwitV0Sighash, TapSighash, TapSighashTag},
     merkle_tree::MerkleBlock,
     network::params::{self, Params},
@@ -163,7 +161,6 @@ pub use crate::{
     blockdata::locktime::{absolute, relative},
     blockdata::script::witness_program::{self, WitnessProgram},
     blockdata::script::witness_version::{self, WitnessVersion},
-    blockdata::script::{ScriptHash, WScriptHash}, // TODO: Move these down below after they are in primitives.
     // These modules also re-export all the respective `primitives` types.
     blockdata::{
         block, constants, fee_rate, locktime, opcodes, script, transaction, weight, witness,

From d1d483491f5f0181e60778e557fadd99b44b5d30 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Tue, 4 Mar 2025 12:33:04 +0100
Subject: [PATCH 459/554] Make `hex` in `internals` optional

The `hex` crate is not always desirable - e.g. when the consumer wants
to work with raw data only. We already had this optional in `hashes` but
if `hashes` is going to depend on `internals` it would break this
property.

This change makes `hash` optional, since it's easy: there's just one
struct that depends on it.
---
 bitcoin/Cargo.toml     | 2 +-
 internals/Cargo.toml   | 6 +++---
 internals/src/serde.rs | 2 ++
 primitives/Cargo.toml  | 2 +-
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index 56629a46c9..d792a3a7ec 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -29,7 +29,7 @@ base58 = { package = "base58ck", version = "0.2.0", default-features = false, fe
 bech32 = { version = "0.11.0", default-features = false, features = ["alloc"] }
 hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["alloc", "hex"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, features = ["alloc"] }
-internals = { package = "bitcoin-internals", version = "0.4.0", features = ["alloc"] }
+internals = { package = "bitcoin-internals", version = "0.4.0", features = ["alloc", "hex"] }
 io = { package = "bitcoin-io", version = "0.2.0", default-features = false, features = ["alloc", "hashes"] }
 primitives = { package = "bitcoin-primitives", version = "0.101.0", default-features = false, features = ["alloc"] }
 secp256k1 = { version = "0.30.0", default-features = false, features = ["hashes", "alloc", "rand"] }
diff --git a/internals/Cargo.toml b/internals/Cargo.toml
index 12a5daa1dc..374fe62d79 100644
--- a/internals/Cargo.toml
+++ b/internals/Cargo.toml
@@ -15,13 +15,13 @@ exclude = ["tests", "contrib"]
 
 [features]
 default = []
-std = ["alloc", "hex/std"]
-alloc = ["hex/alloc"]
+std = ["alloc", "hex?/std"]
+alloc = ["hex?/alloc"]
 
 test-serde = ["serde", "serde_json", "bincode"]
 
 [dependencies]
-hex = { package = "hex-conservative", version = "0.3.0", default-features = false }
+hex = { package = "hex-conservative", version = "0.3.0", default-features = false, optional = true }
 serde = { version = "1.0.103", default-features = false, optional = true }
 
 # Don't enable these directly, use `test-serde` feature instead.
diff --git a/internals/src/serde.rs b/internals/src/serde.rs
index f48bc63463..7c25cfae49 100644
--- a/internals/src/serde.rs
+++ b/internals/src/serde.rs
@@ -310,9 +310,11 @@ macro_rules! serde_round_trip (
     })
 );
 
+#[cfg(feature = "hex")]
 /// Serializes a byte slice using the `hex` crate.
 pub struct SerializeBytesAsHex<'a>(pub &'a [u8]);
 
+#[cfg(feature = "hex")]
 impl serde::Serialize for SerializeBytesAsHex<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index afb74fd00e..013c71493b 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -24,7 +24,7 @@ arbitrary = ["dep:arbitrary", "units/arbitrary"]
 [dependencies]
 hashes = { package = "bitcoin_hashes", version = "0.16.0", default-features = false, features = ["hex"] }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false }
-internals = { package = "bitcoin-internals", version = "0.4.0" }
+internals = { package = "bitcoin-internals", version = "0.4.0", features = ["hex"] }
 units = { package = "bitcoin-units", version = "0.2.0", default-features = false }
 
 arbitrary = { version = "1.4", optional = true }

From 2dad19a20ff0bdf7d99669a18905f1fa253ab6ec Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 4 Mar 2025 11:37:58 +0000
Subject: [PATCH 460/554] Bump GitHub Actions Artifacts to v4

v3 is deprecated and causes an automatic fail of fuzz workflow.

Bump the version of `actions/upload-artifact` and
`actions/download-artifact` to v4.
---
 .github/workflows/cron-daily-fuzz.yml | 4 ++--
 fuzz/generate-files.sh                | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/cron-daily-fuzz.yml b/.github/workflows/cron-daily-fuzz.yml
index 2686f70ffd..b5f83c5c63 100644
--- a/.github/workflows/cron-daily-fuzz.yml
+++ b/.github/workflows/cron-daily-fuzz.yml
@@ -59,7 +59,7 @@ jobs:
           echo "Using RUSTFLAGS $RUSTFLAGS"
           cd fuzz && ./fuzz.sh "${{ matrix.fuzz_target }}"
       - run: echo "${{ matrix.fuzz_target }}" >executed_${{ matrix.fuzz_target }}
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: executed_${{ matrix.fuzz_target }}
           path: executed_${{ matrix.fuzz_target }}
@@ -70,7 +70,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
       - name: Display structure of downloaded files
         run: ls -R
       - run: find executed_* -type f -exec cat {} + | sort > executed
diff --git a/fuzz/generate-files.sh b/fuzz/generate-files.sh
index e1c8a9d463..bc742f2680 100755
--- a/fuzz/generate-files.sh
+++ b/fuzz/generate-files.sh
@@ -89,7 +89,7 @@ $(for name in $(listTargetNames); do echo "          $name,"; done)
           echo "Using RUSTFLAGS \$RUSTFLAGS"
           cd fuzz && ./fuzz.sh "\${{ matrix.fuzz_target }}"
       - run: echo "\${{ matrix.fuzz_target }}" >executed_\${{ matrix.fuzz_target }}
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: executed_\${{ matrix.fuzz_target }}
           path: executed_\${{ matrix.fuzz_target }}
@@ -100,7 +100,7 @@ $(for name in $(listTargetNames); do echo "          $name,"; done)
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
       - name: Display structure of downloaded files
         run: ls -R
       - run: find executed_* -type f -exec cat {} + | sort > executed

From 66fee1ef8722e4ada86c9f5493d0ec5aed1a816b Mon Sep 17 00:00:00 2001
From: Bruno Garcia <brunoely.gc@gmail.com>
Date: Mon, 3 Mar 2025 15:05:57 -0300
Subject: [PATCH 461/554] fuzz: add consume_u64

---
 fuzz/fuzz_targets/bitcoin/fuzz_utils.rs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs b/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs
index 518d6a5bdd..aeaa11ae21 100644
--- a/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs
+++ b/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs
@@ -9,3 +9,25 @@ pub fn consume_random_bytes<'a>(data: &mut &'a [u8]) -> &'a [u8] {
 
     bytes
 }
+
+#[allow(dead_code)]
+pub fn consume_u64(data: &mut &[u8]) -> u64 {
+    // We need at least 8 bytes to read a u64
+    if data.len() < 8 {
+        return 0;
+    }
+
+    let (u64_bytes, rest) = data.split_at(8);
+    *data = rest;
+
+    u64::from_le_bytes([
+        u64_bytes[0],
+        u64_bytes[1],
+        u64_bytes[2],
+        u64_bytes[3],
+        u64_bytes[4],
+        u64_bytes[5],
+        u64_bytes[6],
+        u64_bytes[7],
+    ])
+}

From 08e0d4f0e53d97edd655ec1103d60a2b4715fb91 Mon Sep 17 00:00:00 2001
From: Bruno Garcia <brunoely.gc@gmail.com>
Date: Mon, 3 Mar 2025 16:44:04 -0300
Subject: [PATCH 462/554] fuzz: cover minimal_non_dust_custom  for Script

---
 fuzz/fuzz_targets/bitcoin/deserialize_script.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
index 866c76983b..e7c1191b40 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -1,11 +1,16 @@
 use bitcoin::address::Address;
 use bitcoin::consensus::encode;
 use bitcoin::script::{self, ScriptExt as _};
-use bitcoin::Network;
+use bitcoin::{FeeRate, Network};
 use honggfuzz::fuzz;
 
+mod fuzz_utils;
+use fuzz_utils::{consume_random_bytes, consume_u64};
+
 fn do_test(data: &[u8]) {
-    let s: Result<script::ScriptBuf, _> = encode::deserialize(data);
+    let mut new_data = data;
+    let bytes = consume_random_bytes(&mut new_data);
+    let s: Result<script::ScriptBuf, _> = encode::deserialize(bytes);
     if let Ok(script) = s {
         let _: Result<Vec<script::Instruction>, script::Error> = script.instructions().collect();
 
@@ -14,6 +19,9 @@ fn do_test(data: &[u8]) {
         let _ = script.count_sigops_legacy();
         let _ = script.minimal_non_dust();
 
+        let fee_rate = FeeRate::from_sat_per_kwu(consume_u64(&mut new_data));
+        let _ = script.minimal_non_dust_custom(fee_rate);
+
         let mut b = script::Builder::new();
         for ins in script.instructions_minimal() {
             if ins.is_err() {

From e3f409e3c4327c647b64416caa401c883b459c86 Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Tue, 4 Mar 2025 13:13:37 -0300
Subject: [PATCH 463/554] ci: update Kani GitHub Actions runners to
 ubuntu-24.04

GitHub is deprecating the ubuntu-20.04 runner, with removal scheduled for
2025-04-01 (see: https://github.com/actions/runner-images/issues/11101)
This commit updates workflow files to use ubuntu-24.04 instead.
---
 .github/workflows/cron-daily-kani.yml | 2 +-
 .github/workflows/rust.yml            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/cron-daily-kani.yml b/.github/workflows/cron-daily-kani.yml
index dff1e54be8..61ef6e3957 100644
--- a/.github/workflows/cron-daily-kani.yml
+++ b/.github/workflows/cron-daily-kani.yml
@@ -5,7 +5,7 @@ on:
     - cron: '59 23 * * *'       # midnight every day.
 jobs:
   run-kani:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: 'Checkout your code.'
         uses: actions/checkout@v4
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 37ad742a47..d9da41a592 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -296,7 +296,7 @@ jobs:
 
   Kani:
     name: Kani codegen - stable toolchain
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
     steps:
       - name: "Checkout repo"
         uses: actions/checkout@v4

From b87ddc0043697b51dea7a7ed41020ea7f6862cd0 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Tue, 4 Mar 2025 20:25:45 +0100
Subject: [PATCH 464/554] Don't panic in `PrivateKey::from_slice`

During upgrade of `secp256k1` a number of function calls needed to be
rewritten to not use `from_slice` but `from_byte_array`. Unfortunately,
the conversions wasn't correct and caused panics on invalid inputs
rather than errors.

This fixes it simply by calling `try_into` on the entire slice and
converting the error.
---
 bitcoin/src/crypto/key.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 7a045cfb5c..d73f84180f 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -466,7 +466,7 @@ impl PrivateKey {
     ) -> Result<PrivateKey, secp256k1::Error> {
         Ok(PrivateKey::new(
             secp256k1::SecretKey::from_byte_array(
-                data[..32].try_into().expect("Slice should be exactly 32 bytes"),
+                data.try_into().map_err(|_| secp256k1::Error::InvalidSecretKey)?,
             )?,
             network,
         ))

From 1778fea66ef860774e4a722ff109d000d10f5942 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Tue, 4 Mar 2025 20:34:59 +0100
Subject: [PATCH 465/554] Add a test checking `PrivateKey::from_slice`

This test checks the previous fix - if ordered before the previous
commit it will fail.
---
 bitcoin/src/crypto/key.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index d73f84180f..2fcacba37f 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -1600,4 +1600,11 @@ mod tests {
             panic!("Expected Invalid char error");
         }
     }
+
+    #[test]
+    fn invalid_private_key_len() {
+        use crate::Network;
+        assert!(PrivateKey::from_slice(&[1u8; 31], Network::Regtest).is_err());
+        assert!(PrivateKey::from_slice(&[1u8; 33], Network::Regtest).is_err());
+    }
 }

From 0d5cd7af435f420e76d2e69f0e76be30d230238e Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Tue, 4 Mar 2025 20:39:47 +0100
Subject: [PATCH 466/554] Add `from_byte_array` to `PrivateKey`.

Private keys have statically-known length of 32 bytes and we are
migrating types with known lenths to use `from_byte_array` methods. This
adds the method to `PrivateKey` as well and uses it to implement
`from_slice`.
---
 bitcoin/src/crypto/key.rs | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 2fcacba37f..ed16e7a727 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -459,17 +459,21 @@ impl PrivateKey {
     /// Serializes the private key to bytes.
     pub fn to_vec(self) -> Vec<u8> { self.inner[..].to_vec() }
 
+    /// Deserializes a private key from a byte array.
+    pub fn from_byte_array(
+        data: [u8; 32],
+        network: impl Into<NetworkKind>
+    ) -> Result<PrivateKey, secp256k1::Error> {
+        Ok(PrivateKey::new(secp256k1::SecretKey::from_byte_array(&data)?, network))
+    }
+
     /// Deserializes a private key from a slice.
     pub fn from_slice(
         data: &[u8],
         network: impl Into<NetworkKind>,
     ) -> Result<PrivateKey, secp256k1::Error> {
-        Ok(PrivateKey::new(
-            secp256k1::SecretKey::from_byte_array(
-                data.try_into().map_err(|_| secp256k1::Error::InvalidSecretKey)?,
-            )?,
-            network,
-        ))
+        let array = data.try_into().map_err(|_| secp256k1::Error::InvalidSecretKey)?;
+        Self::from_byte_array(array, network)
     }
 
     /// Formats the private key to WIF format.

From 8efacd4dda359bffae2120dfd58942637f32a52c Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Tue, 4 Mar 2025 20:43:39 +0100
Subject: [PATCH 467/554] Deprecate `PrivateKey::from_slice` method

Since arrays better convey the intention than slices when parsing
fixed-sized bytes we're migrating to them. This deprecates the
`from_slice` method similarly to how we do it elsewhere.
---
 bitcoin/src/crypto/key.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index ed16e7a727..c1d67bb644 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -468,6 +468,7 @@ impl PrivateKey {
     }
 
     /// Deserializes a private key from a slice.
+    #[deprecated(since = "TBD", note = "use from_byte_array instead")]
     pub fn from_slice(
         data: &[u8],
         network: impl Into<NetworkKind>,
@@ -1606,6 +1607,8 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)] // tests the deprecated function
+    #[allow(deprecated_in_future)]
     fn invalid_private_key_len() {
         use crate::Network;
         assert!(PrivateKey::from_slice(&[1u8; 31], Network::Regtest).is_err());

From 90d909becc4638c03003845154e9cc1eb5f3ad41 Mon Sep 17 00:00:00 2001
From: Shing Him Ng <shinghim@protonmail.com>
Date: Tue, 4 Mar 2025 20:32:10 -0600
Subject: [PATCH 468/554] Kill mutants in primitives and units

This kills 15 mutants found with the mutants workflow
---
 primitives/src/transaction.rs | 12 ++++++++++++
 units/src/amount/tests.rs     | 11 +++++++++++
 2 files changed, 23 insertions(+)

diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 7e708e2502..05210ee299 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -645,6 +645,18 @@ impl<'a> Arbitrary<'a> for Txid {
 mod tests {
     use super::*;
 
+    #[test]
+    fn sanity_check() {
+        let version = Version(123);
+        assert_eq!(version.to_u32(), 123);
+        assert_eq!(u32::from(version), 123);
+
+        assert!(!version.is_standard());
+        assert!(Version::ONE.is_standard());
+        assert!(Version::TWO.is_standard());
+        assert!(Version::THREE.is_standard());
+    }
+
     #[test]
     fn transaction_functions() {
         let txin = TxIn {
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index d3463660f7..e0d506abb8 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -37,6 +37,11 @@ fn sanity_check() {
         assert_eq!(Amount::from_float_in(2_f64, Denomination::Bitcoin).unwrap(), sat(200_000_000));
         assert!(Amount::from_float_in(-100_f64, Denomination::Bitcoin).is_err());
     }
+
+    let result = NumOpResult::Valid(sat(123));
+    assert_eq!(Some(sat(123)), result.ok());
+    assert!(result.is_valid());
+    assert!(!result.is_error());
 }
 
 #[test]
@@ -1010,6 +1015,12 @@ fn sum_amounts() {
     assert_eq!([].iter().sum::<NumOpResult<Amount>>(), Amount::ZERO.into());
     assert_eq!([].iter().sum::<NumOpResult<SignedAmount>>(), SignedAmount::ZERO.into());
 
+    let results = [NumOpResult::Valid(sat(42)), NumOpResult::Valid(sat(1337)), NumOpResult::Valid(sat(21))];
+    assert_eq!(results.iter().sum::<NumOpResult<Amount>>(), NumOpResult::Valid(sat(1400)));
+
+    let signed_results = [NumOpResult::Valid(ssat(42)), NumOpResult::Valid(ssat(1337)), NumOpResult::Valid(ssat(21))];
+    assert_eq!(signed_results.iter().sum::<NumOpResult<SignedAmount>>(), NumOpResult::Valid(ssat(1400)));
+
     let amounts = [sat(42), sat(1337), sat(21)];
     assert_eq!(
         amounts.iter().map(|a| NumOpResult::Valid(*a)).sum::<NumOpResult<Amount>>(),

From bbe87eccf2b9f01295e3c94a06130c6e7ac9bfa4 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Wed, 5 Mar 2025 13:05:04 +0100
Subject: [PATCH 469/554] Fix bug in PSBT `Deserialize` for `XOnlyPublicKey`

During upgrade of `secp256k1` a number of function calls needed to be
rewritten to not use `from_slice` but `from_byte_array`. Unfortunately,
the conversion wasn't correct and caused panics on invalid inputs
rather than errors.

This fixes it simply by calling `try_into` on the entire slice and
converting the error.
---
 bitcoin/src/psbt/serialize.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
index 26bfc9b320..b21a5ac0c9 100644
--- a/bitcoin/src/psbt/serialize.rs
+++ b/bitcoin/src/psbt/serialize.rs
@@ -261,7 +261,7 @@ impl Serialize for XOnlyPublicKey {
 impl Deserialize for XOnlyPublicKey {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
         XOnlyPublicKey::from_byte_array(
-            bytes[..32].try_into().expect("statistically impossible to hit"),
+            bytes.try_into().map_err(|_| Error::InvalidXOnlyPublicKey)?,
         )
         .map_err(|_| Error::InvalidXOnlyPublicKey)
     }

From ecc5791930b88581fcbc8f2417b0221486bd1031 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Wed, 5 Mar 2025 13:09:44 +0100
Subject: [PATCH 470/554] Add test checking `XOnlyPublicKey::deserialize`

This test checks the previous fix - if ordered before the previous
commit it will fail.
---
 bitcoin/src/psbt/serialize.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
index b21a5ac0c9..89de08dcb0 100644
--- a/bitcoin/src/psbt/serialize.rs
+++ b/bitcoin/src/psbt/serialize.rs
@@ -461,6 +461,12 @@ mod tests {
         assert!(sighash.is_ok())
     }
 
+    #[test]
+    fn deserialize_xonly_public_key_len() {
+        assert!(XOnlyPublicKey::deserialize(&[1; 31]).is_err());
+        assert!(XOnlyPublicKey::deserialize(&[1; 33]).is_err());
+    }
+
     #[test]
     #[should_panic(expected = "InvalidMagic")]
     fn invalid_vector_1() {

From 1bb3d6a371d6a09b3d27e1aaec0f40f4f12e5c3b Mon Sep 17 00:00:00 2001
From: Peter Todd <pete@petertodd.org>
Date: Wed, 5 Mar 2025 18:17:50 +0000
Subject: [PATCH 471/554] Minor: fix typo

---
 base58/src/error.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base58/src/error.rs b/base58/src/error.rs
index 67409d2865..678c22d930 100644
--- a/base58/src/error.rs
+++ b/base58/src/error.rs
@@ -30,7 +30,7 @@ impl From<Infallible> for ErrorInner {
 }
 
 impl Error {
-    /// Returns the invalid base58 ssscharacter, if encountered.
+    /// Returns the invalid base58 character, if encountered.
     pub fn invalid_character(&self) -> Option<u8> {
         match self.0 {
             ErrorInner::Decode(ref e) => Some(e.invalid_character()),

From 2a6cbda3043e2ac5e8b37cd2132244c4a6f1c9df Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Wed, 5 Mar 2025 16:24:41 -0300
Subject: [PATCH 472/554] ci: Update GitHub workflows to use ubuntu-24.04
 instead of ubuntu-latest

---
 .github/workflows/coveralls.yml               |  2 +-
 .github/workflows/cron-daily-fuzz.yml         |  4 +--
 .../workflows/cron-weekly-cargo-mutants.yml   |  2 +-
 .github/workflows/cron-weekly-rustfmt.yml     |  2 +-
 ...cron-weekly-update-cargo-semver-checks.yml |  2 +-
 .../workflows/cron-weekly-update-nightly.yml  |  2 +-
 .../workflows/cron-weekly-update-stable.yml   |  2 +-
 .github/workflows/gh-release.yml              |  2 +-
 .github/workflows/manage-pr.yml               |  2 +-
 .github/workflows/miri.yml                    |  2 +-
 .github/workflows/release.yml                 |  2 +-
 .github/workflows/rust.yml                    | 26 +++++++++----------
 .github/workflows/semver-checks-pr-label.yml  |  2 +-
 .github/workflows/semver-checks.yml           |  4 +--
 .github/workflows/shellcheck.yml              |  2 +-
 fuzz/generate-files.sh                        |  4 +--
 16 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/.github/workflows/coveralls.yml b/.github/workflows/coveralls.yml
index a3d37cd3c5..688481ef81 100644
--- a/.github/workflows/coveralls.yml
+++ b/.github/workflows/coveralls.yml
@@ -7,7 +7,7 @@ name: Code coverage with llvm-cov
 jobs:
   Coveralls:
     name: Code coverage - stable toolchain
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
     steps:
diff --git a/.github/workflows/cron-daily-fuzz.yml b/.github/workflows/cron-daily-fuzz.yml
index b5f83c5c63..253be2af24 100644
--- a/.github/workflows/cron-daily-fuzz.yml
+++ b/.github/workflows/cron-daily-fuzz.yml
@@ -11,7 +11,7 @@ on:
 jobs:
   fuzz:
     if: ${{ !github.event.act }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -67,7 +67,7 @@ jobs:
   verify-execution:
     if: ${{ !github.event.act }}
     needs: fuzz
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/download-artifact@v4
diff --git a/.github/workflows/cron-weekly-cargo-mutants.yml b/.github/workflows/cron-weekly-cargo-mutants.yml
index 30896e4027..74ec346299 100644
--- a/.github/workflows/cron-weekly-cargo-mutants.yml
+++ b/.github/workflows/cron-weekly-cargo-mutants.yml
@@ -5,7 +5,7 @@ on:
   workflow_dispatch: # allows manual triggering
 jobs:
   cargo-mutants:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: taiki-e/install-action@v2
diff --git a/.github/workflows/cron-weekly-rustfmt.yml b/.github/workflows/cron-weekly-rustfmt.yml
index 81a5323fb1..d35073c4a6 100644
--- a/.github/workflows/cron-weekly-rustfmt.yml
+++ b/.github/workflows/cron-weekly-rustfmt.yml
@@ -6,7 +6,7 @@ on:
 jobs:
   format:
     name: Nightly rustfmt
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
diff --git a/.github/workflows/cron-weekly-update-cargo-semver-checks.yml b/.github/workflows/cron-weekly-update-cargo-semver-checks.yml
index c3c86f9035..75f706a1cc 100644
--- a/.github/workflows/cron-weekly-update-cargo-semver-checks.yml
+++ b/.github/workflows/cron-weekly-update-cargo-semver-checks.yml
@@ -6,7 +6,7 @@ on:
 jobs:
   format:
     name: Update cargo-semver-checks
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - name: Update semver-checks to use latest crates.io published version
diff --git a/.github/workflows/cron-weekly-update-nightly.yml b/.github/workflows/cron-weekly-update-nightly.yml
index ea9c4f434d..b31ad20cc0 100644
--- a/.github/workflows/cron-weekly-update-nightly.yml
+++ b/.github/workflows/cron-weekly-update-nightly.yml
@@ -6,7 +6,7 @@ on:
 jobs:
   format:
     name: Update nightly rustc
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
diff --git a/.github/workflows/cron-weekly-update-stable.yml b/.github/workflows/cron-weekly-update-stable.yml
index 42f49cc772..456ccd9ae4 100644
--- a/.github/workflows/cron-weekly-update-stable.yml
+++ b/.github/workflows/cron-weekly-update-stable.yml
@@ -6,7 +6,7 @@ on:
 jobs:
   format:
     name: Update stable rustc
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
diff --git a/.github/workflows/gh-release.yml b/.github/workflows/gh-release.yml
index 69ea930c5e..86014a98cf 100644
--- a/.github/workflows/gh-release.yml
+++ b/.github/workflows/gh-release.yml
@@ -7,7 +7,7 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v4
     - uses: ncipollo/release-action@v1
diff --git a/.github/workflows/manage-pr.yml b/.github/workflows/manage-pr.yml
index 49407eead0..3e92b33f94 100644
--- a/.github/workflows/manage-pr.yml
+++ b/.github/workflows/manage-pr.yml
@@ -7,7 +7,7 @@ jobs:
     permissions:
       contents: read
       pull-requests: write
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout master
         uses: actions/checkout@v4
diff --git a/.github/workflows/miri.yml b/.github/workflows/miri.yml
index 38eaa4afd0..ed9f05a702 100644
--- a/.github/workflows/miri.yml
+++ b/.github/workflows/miri.yml
@@ -11,7 +11,7 @@ name: Miri
 jobs:
   Miri:
     name: Miri
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
     steps:
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index cd2a872550..1241ecf9ba 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -12,7 +12,7 @@ name: Release
 jobs:
   release:
     name: Release - dry-run
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout Crate
         uses: actions/checkout@v4
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index d9da41a592..ea83c99cbc 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -10,7 +10,7 @@ name: Continuous integration
 
 jobs:
   Prepare:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     outputs:
       nightly_version: ${{ steps.read_toolchain.outputs.nightly_version }}
     steps:
@@ -22,7 +22,7 @@ jobs:
 
   Stable:                       # 2 jobs, one per manifest.
     name: Test - stable toolchain
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -46,7 +46,7 @@ jobs:
   Nightly:                      # 2 jobs, one per manifest.
     name: Test - nightly toolchain
     needs: Prepare
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -71,7 +71,7 @@ jobs:
 
   MSRV:                         # 2 jobs, one per manifest.
     name: Test - MSRV toolchain
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -97,7 +97,7 @@ jobs:
   Lint:
     name: Lint - nightly toolchain
     needs: Prepare
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -124,7 +124,7 @@ jobs:
 
   Docs:
     name: Docs - stable toolchain
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -148,7 +148,7 @@ jobs:
   Docsrs:
     name: Docs - nightly toolchain
     needs: Prepare
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -174,7 +174,7 @@ jobs:
   Bench:
     name: Bench - nightly toolchain
     needs: Prepare
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -199,7 +199,7 @@ jobs:
 
   Arch32bit:
     name: Test 32-bit version
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - name: "Checkout repo"
         uses: actions/checkout@v4
@@ -217,7 +217,7 @@ jobs:
   Cross:
     name: Cross test - stable toolchain
     if: ${{ !github.event.act }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - name: "Checkout repo"
         uses: actions/checkout@v4
@@ -233,7 +233,7 @@ jobs:
   Embedded:
     name: Embedded - nightly toolchain
     needs: Prepare
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     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"
@@ -261,7 +261,7 @@ jobs:
   ASAN:                         # hashes crate only.
     name: ASAN - nightly toolchain
     needs: Prepare
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -282,7 +282,7 @@ jobs:
 
   WASM:                         # hashes crate only.
     name: WASM - stable toolchain
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       # Note we do not use the recent lock file for wasm testing.
diff --git a/.github/workflows/semver-checks-pr-label.yml b/.github/workflows/semver-checks-pr-label.yml
index 56ce356de1..c7f9b1c66c 100644
--- a/.github/workflows/semver-checks-pr-label.yml
+++ b/.github/workflows/semver-checks-pr-label.yml
@@ -8,7 +8,7 @@ name: Check semver breaks - Label and Comment PR
 jobs:
   Download:
     name: Download, Unzip and Add Labels/Comments
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     permissions:
       contents: read
       pull-requests: write
diff --git a/.github/workflows/semver-checks.yml b/.github/workflows/semver-checks.yml
index 93f37d2692..32d01b6b28 100644
--- a/.github/workflows/semver-checks.yml
+++ b/.github/workflows/semver-checks.yml
@@ -6,7 +6,7 @@ name: Check semver breaks
 jobs:
   PR:
     name: PR Semver - stable toolchain
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
     steps:
@@ -45,7 +45,7 @@ jobs:
 
   Feature:
     name: Non additive cargo features - stable toolchain
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
     steps:
diff --git a/.github/workflows/shellcheck.yml b/.github/workflows/shellcheck.yml
index 8577c05033..dea02c3a04 100644
--- a/.github/workflows/shellcheck.yml
+++ b/.github/workflows/shellcheck.yml
@@ -6,7 +6,7 @@ on:
 jobs:
   shellcheck:
     name: Shellcheck
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
     - uses: actions/checkout@v4
     - name: Run ShellCheck
diff --git a/fuzz/generate-files.sh b/fuzz/generate-files.sh
index bc742f2680..e85f20ed54 100755
--- a/fuzz/generate-files.sh
+++ b/fuzz/generate-files.sh
@@ -57,7 +57,7 @@ on:
 jobs:
   fuzz:
     if: \${{ !github.event.act }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
@@ -97,7 +97,7 @@ $(for name in $(listTargetNames); do echo "          $name,"; done)
   verify-execution:
     if: \${{ !github.event.act }}
     needs: fuzz
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - uses: actions/download-artifact@v4

From df500e9b71187fe658da76adafdb3300a51de2ef Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 3 Mar 2025 15:06:44 +1100
Subject: [PATCH 473/554] primitives: Enable pedantic lints

Enable all the pedantic lints and fix warnings.

Notable items:

- `enum_glob_used` import types with a single character alias
- `doc_markdown`: add a whitelist that includes SegWit and OpenSSL
---
 clippy.toml                         |   1 +
 primitives/Cargo.toml               | 128 ++++++++++++++++++++++++++++
 primitives/src/block.rs             |  26 +++---
 primitives/src/lib.rs               |   6 --
 primitives/src/locktime/absolute.rs |  99 ++++++++++-----------
 primitives/src/locktime/relative.rs |  58 ++++++-------
 primitives/src/opcodes.rs           |  14 +--
 primitives/src/pow.rs               |  10 +--
 primitives/src/script/mod.rs        |  18 ++--
 primitives/src/sequence.rs          |  42 ++++-----
 primitives/src/transaction.rs       |  40 ++++-----
 primitives/src/witness.rs           |  36 ++++----
 12 files changed, 301 insertions(+), 177 deletions(-)

diff --git a/clippy.toml b/clippy.toml
index 0d54166663..47eac63c91 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -1,3 +1,4 @@
 msrv = "1.63.0"
 too-many-arguments-threshold = 13
 avoid-breaking-exported-api = false
+doc-valid-idents = ["SegWit", "OpenSSL"]
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index afb74fd00e..3b7e3b9164 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -40,3 +40,131 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = ['cfg(mutate)'] }
+
+[lints.clippy]
+# Exclude lints we don't think are valuable.
+needless_question_mark = "allow" # https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
+manual_range_contains = "allow" # More readable than clippy's format.
+# Exhaustive list of pedantic clippy lints
+assigning_clones = "warn"
+bool_to_int_with_if = "warn"
+borrow_as_ptr = "warn"
+case_sensitive_file_extension_comparisons = "warn"
+cast_lossless = "warn"
+cast_possible_truncation = "allow" # All casts should include a code comment (except test code).
+cast_possible_wrap = "allow" # Same as above re code comment.
+cast_precision_loss = "warn"
+cast_ptr_alignment = "warn"
+cast_sign_loss = "allow" # All casts should include a code comment (except in test code).
+checked_conversions = "warn"
+cloned_instead_of_copied = "warn"
+copy_iterator = "warn"
+default_trait_access = "warn"
+doc_link_with_quotes = "warn"
+doc_markdown = "warn"
+empty_enum = "warn"
+enum_glob_use = "warn"
+expl_impl_clone_on_copy = "warn"
+explicit_deref_methods = "warn"
+explicit_into_iter_loop = "warn"
+explicit_iter_loop = "warn"
+filter_map_next = "warn"
+flat_map_option = "warn"
+float_cmp = "allow" # Bitcoin floats are typically limited to 8 decimal places and we want them exact.
+fn_params_excessive_bools = "warn"
+from_iter_instead_of_collect = "warn"
+if_not_else = "warn"
+ignored_unit_patterns = "warn"
+implicit_clone = "warn"
+implicit_hasher = "warn"
+inconsistent_struct_constructor = "warn"
+index_refutable_slice = "warn"
+inefficient_to_string = "warn"
+inline_always = "warn"
+into_iter_without_iter = "warn"
+invalid_upcast_comparisons = "warn"
+items_after_statements = "warn"
+iter_filter_is_ok = "warn"
+iter_filter_is_some = "warn"
+iter_not_returning_iterator = "warn"
+iter_without_into_iter = "warn"
+large_digit_groups = "warn"
+large_futures = "warn"
+large_stack_arrays = "warn"
+large_types_passed_by_value = "warn"
+linkedlist = "warn"
+macro_use_imports = "warn"
+manual_assert = "warn"
+manual_instant_elapsed = "warn"
+manual_is_power_of_two = "warn"
+manual_is_variant_and = "warn"
+manual_let_else = "warn"
+manual_ok_or = "warn"
+manual_string_new = "warn"
+many_single_char_names = "warn"
+map_unwrap_or = "warn"
+match_bool = "allow" # Adds extra indentation and LOC.
+match_on_vec_items = "warn"
+match_same_arms = "allow" # Collapses things that are conceptually unrelated to each other.
+match_wild_err_arm = "warn"
+match_wildcard_for_single_variants = "warn"
+maybe_infinite_iter = "warn"
+mismatching_type_param_order = "warn"
+missing_errors_doc = "allow"      # TODO: Write errors section in docs.
+missing_fields_in_debug = "warn"
+missing_panics_doc = "warn"
+must_use_candidate = "allow" # Useful for audit but many false positives.
+mut_mut = "warn"
+naive_bytecount = "warn"
+needless_bitwise_bool = "warn"
+needless_continue = "warn"
+needless_for_each = "warn"
+needless_pass_by_value = "warn"
+needless_raw_string_hashes = "warn"
+no_effect_underscore_binding = "warn"
+no_mangle_with_rust_abi = "warn"
+option_as_ref_cloned = "warn"
+option_option = "warn"
+ptr_as_ptr = "warn"
+ptr_cast_constness = "warn"
+pub_underscore_fields = "warn"
+range_minus_one = "warn"
+range_plus_one = "warn"
+redundant_closure_for_method_calls = "warn"
+redundant_else = "warn"
+ref_as_ptr = "warn"
+ref_binding_to_reference = "warn"
+ref_option = "warn"
+ref_option_ref = "warn"
+return_self_not_must_use = "warn"
+same_functions_in_if_condition = "warn"
+semicolon_if_nothing_returned = "warn"
+should_panic_without_expect = "warn"
+similar_names = "allow" # Too many (subjectively) false positives.
+single_char_pattern = "warn"
+single_match_else = "warn"
+stable_sort_primitive = "warn"
+str_split_at_newline = "warn"
+string_add_assign = "warn"
+struct_excessive_bools = "warn"
+struct_field_names = "allow" # TODO: Triggers warning for `witness_elements`.
+too_many_lines = "warn"
+transmute_ptr_to_ptr = "warn"
+trivially_copy_pass_by_ref = "warn"
+unchecked_duration_subtraction = "warn"
+unicode_not_nfc = "warn"
+uninlined_format_args = "allow" # This is a subjective style choice.
+unnecessary_box_returns = "warn"
+unnecessary_join = "warn"
+unnecessary_literal_bound = "warn"
+unnecessary_wraps = "warn"
+unnested_or_patterns = "allow"  # TODO
+unreadable_literal = "warn"
+unsafe_derive_deserialize = "warn"
+unused_async = "warn"
+unused_self = "warn"
+used_underscore_binding = "warn"
+used_underscore_items = "warn"
+verbose_bit_mask = "warn"
+wildcard_imports = "warn"
+zero_sized_map_values = "warn"
diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index b819734e5e..4afe23c325 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -281,7 +281,7 @@ impl Version {
     ///
     /// 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 {
+    pub fn is_signalling_soft_fork(self, bit: u8) -> bool {
         // Only bits [0, 28] inclusive are used for signalling.
         if bit > 28 {
             return false;
@@ -362,36 +362,36 @@ mod tests {
 
     #[test]
     fn version_is_not_signalling_with_invalid_bit() {
-        let arbitrary_version = Version::from_consensus(1234567890);
+        let arbitrary_version = Version::from_consensus(1_234_567_890);
         // The max bit number to signal is 28.
-        assert!(!Version::is_signalling_soft_fork(&arbitrary_version, 29));
+        assert!(!Version::is_signalling_soft_fork(arbitrary_version, 29));
     }
 
     #[test]
     fn version_is_not_signalling_when_use_version_bit_not_set() {
-        let version = Version::from_consensus(0b01000000000000000000000000000000);
+        let version = Version::from_consensus(0b0100_0000_0000_0000_0000_0000_0000_0000);
         // Top three bits must be 001 to signal.
-        assert!(!Version::is_signalling_soft_fork(&version, 1));
+        assert!(!Version::is_signalling_soft_fork(version, 1));
     }
 
     #[test]
     fn version_is_signalling() {
-        let version = Version::from_consensus(0b00100000000000000000000000000010);
-        assert!(Version::is_signalling_soft_fork(&version, 1));
-        let version = Version::from_consensus(0b00110000000000000000000000000000);
-        assert!(Version::is_signalling_soft_fork(&version, 28));
+        let version = Version::from_consensus(0b0010_0000_0000_0000_0000_0000_0000_0010);
+        assert!(Version::is_signalling_soft_fork(version, 1));
+        let version = Version::from_consensus(0b0011_0000_0000_0000_0000_0000_0000_0000);
+        assert!(Version::is_signalling_soft_fork(version, 28));
     }
 
     #[test]
     fn version_is_not_signalling() {
-        let version = Version::from_consensus(0b00100000000000000000000000000010);
-        assert!(!Version::is_signalling_soft_fork(&version, 0));
+        let version = Version::from_consensus(0b0010_0000_0000_0000_0000_0000_0000_0010);
+        assert!(!Version::is_signalling_soft_fork(version, 0));
     }
 
     #[test]
     fn version_to_consensus() {
-        let version = Version::from_consensus(1234567890);
-        assert_eq!(version.to_consensus(), 1234567890);
+        let version = Version::from_consensus(1_234_567_890);
+        assert_eq!(version.to_consensus(), 1_234_567_890);
     }
 
     // Check that the size of the header consensus serialization matches the const SIZE value
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index 77b74b8891..b01717ddd9 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -16,12 +16,6 @@
 #![warn(missing_docs)]
 #![warn(deprecated_in_future)]
 #![doc(test(attr(warn(unused))))]
-// Pedantic lints that we enforce.
-// #![warn(clippy::must_use_candidate)]
-#![warn(clippy::return_self_not_must_use)]
-// Exclude lints we don't think are valuable.
-#![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
-#![allow(clippy::manual_range_contains)] // More readable than clippy's format.
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 639963aa72..8d90cf2548 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Provides type [`LockTime`] that implements the logic around nLockTime/OP_CHECKLOCKTIMEVERIFY.
+//! Provides type [`LockTime`] that implements the logic around `nLockTime`/`OP_CHECKLOCKTIMEVERIFY`.
 //!
 //! There are two types of lock time: lock-by-blockheight and lock-by-blocktime, distinguished by
 //! whether `LockTime < LOCKTIME_THRESHOLD`.
@@ -22,7 +22,7 @@ pub use units::locktime::absolute::{ConversionError, Height, ParseHeightError, P
 /// since epoch).
 ///
 /// Used for transaction lock time (`nLockTime` in Bitcoin Core and [`Transaction::lock_time`]
-/// in this library) and also for the argument to opcode 'OP_CHECKLOCKTIMEVERIFY`.
+/// in this library) and also for the argument to opcode `OP_CHECKLOCKTIMEVERIFY`.
 ///
 /// ### Note on ordering
 ///
@@ -42,13 +42,13 @@ pub use units::locktime::absolute::{ConversionError, Height, ParseHeightError, P
 /// # Examples
 ///
 /// ```
-/// # use bitcoin_primitives::absolute::{self, LockTime::*};
+/// use bitcoin_primitives::absolute::{self, LockTime as L};
 /// # let n = absolute::LockTime::from_consensus(741521);          // n OP_CHECKLOCKTIMEVERIFY
 /// # let lock_time = absolute::LockTime::from_consensus(741521);  // nLockTime
 /// // To compare absolute lock times there are various `is_satisfied_*` methods, you may also use:
 /// let _is_satisfied = match (n, lock_time) {
-///     (Blocks(n), Blocks(lock_time)) => n <= lock_time,
-///     (Seconds(n), Seconds(lock_time)) => n <= lock_time,
+///     (L::Blocks(n), L::Blocks(lock_time)) => n <= lock_time,
+///     (L::Seconds(n), L::Seconds(lock_time)) => n <= lock_time,
 ///     _ => panic!("handle invalid comparison error"),
 /// };
 /// ```
@@ -126,7 +126,7 @@ impl LockTime {
         Ok(Self::from_consensus(lock_time))
     }
 
-    /// Constructs a new `LockTime` from an nLockTime value or the argument to OP_CHEKCLOCKTIMEVERIFY.
+    /// Constructs a new `LockTime` from an `nLockTime` value or the argument to `OP_CHEKCLOCKTIMEVERIFY`.
     ///
     /// # Examples
     ///
@@ -138,6 +138,7 @@ impl LockTime {
     /// let lock_time = absolute::LockTime::from_consensus(n_lock_time);
     /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
     #[inline]
+    #[allow(clippy::missing_panics_doc)]
     pub fn from_consensus(n: u32) -> Self {
         if units::locktime::absolute::is_block_height(n) {
             Self::Blocks(Height::from_consensus(n).expect("n is valid"))
@@ -197,7 +198,7 @@ impl LockTime {
 
     /// Returns true if both lock times use the same unit i.e., both height based or both time based.
     #[inline]
-    pub const fn is_same_unit(&self, other: LockTime) -> bool {
+    pub const fn is_same_unit(self, other: LockTime) -> bool {
         matches!(
             (self, other),
             (LockTime::Blocks(_), LockTime::Blocks(_))
@@ -207,11 +208,11 @@ impl LockTime {
 
     /// Returns true if this lock time value is a block height.
     #[inline]
-    pub const fn is_block_height(&self) -> bool { matches!(*self, LockTime::Blocks(_)) }
+    pub const fn is_block_height(self) -> bool { matches!(self, LockTime::Blocks(_)) }
 
     /// Returns true if this lock time value is a block time (UNIX timestamp).
     #[inline]
-    pub const fn is_block_time(&self) -> bool { !self.is_block_height() }
+    pub const fn is_block_time(self) -> bool { !self.is_block_height() }
 
     /// Returns true if this timelock constraint is satisfied by the respective `height`/`time`.
     ///
@@ -219,7 +220,7 @@ impl LockTime {
     /// blocktime based lock it is checked against `time`.
     ///
     /// A 'timelock constraint' refers to the `n` from `n OP_CHEKCLOCKTIMEVERIFY`, this constraint
-    /// is satisfied if a transaction with nLockTime ([`Transaction::lock_time`]) set to
+    /// is satisfied if a transaction with `nLockTime` ([`Transaction::lock_time`]) set to
     /// `height`/`time` is valid.
     ///
     /// # Examples
@@ -236,12 +237,12 @@ impl LockTime {
     /// }
     /// ````
     #[inline]
-    pub fn is_satisfied_by(&self, height: Height, time: Time) -> bool {
-        use LockTime::*;
+    pub fn is_satisfied_by(self, height: Height, time: Time) -> bool {
+        use LockTime as L;
 
-        match *self {
-            Blocks(n) => n <= height,
-            Seconds(n) => n <= time,
+        match self {
+            L::Blocks(n) => n <= height,
+            L::Seconds(n) => n <= time,
         }
     }
 
@@ -265,18 +266,18 @@ impl LockTime {
     /// assert!(lock_time.is_implied_by(check));
     /// ```
     #[inline]
-    pub fn is_implied_by(&self, other: LockTime) -> bool {
-        use LockTime::*;
+    pub fn is_implied_by(self, other: LockTime) -> bool {
+        use LockTime as L;
 
-        match (*self, other) {
-            (Blocks(this), Blocks(other)) => this <= other,
-            (Seconds(this), Seconds(other)) => this <= other,
+        match (self, other) {
+            (L::Blocks(this), L::Blocks(other)) => this <= other,
+            (L::Seconds(this), L::Seconds(other)) => this <= other,
             _ => false, // Not the same units.
         }
     }
 
     /// Returns the inner `u32` value. This is the value used when creating this `LockTime`
-    /// i.e., `n OP_CHECKLOCKTIMEVERIFY` or nLockTime.
+    /// i.e., `n OP_CHECKLOCKTIMEVERIFY` or `nLockTime`.
     ///
     /// # Warning
     ///
@@ -287,13 +288,13 @@ impl LockTime {
     /// # Examples
     ///
     /// ```rust
-    /// # use bitcoin_primitives::absolute::{self, LockTime::*};
+    /// use bitcoin_primitives::absolute::{self, LockTime as L};
     /// # let n = absolute::LockTime::from_consensus(741521);  // n OP_CHECKLOCKTIMEVERIFY
     /// # let lock_time = absolute::LockTime::from_consensus(741521 + 1);  // nLockTime
     ///
     /// let _is_satisfied = match (n, lock_time) {
-    ///     (Blocks(n), Blocks(lock_time)) => n <= lock_time,
-    ///     (Seconds(n), Seconds(lock_time)) => n <= lock_time,
+    ///     (L::Blocks(n), L::Blocks(lock_time)) => n <= lock_time,
+    ///     (L::Seconds(n), L::Seconds(lock_time)) => n <= lock_time,
     ///     _ => panic!("invalid comparison"),
     /// };
     ///
@@ -324,28 +325,28 @@ impl From<Time> for LockTime {
 impl fmt::Debug for LockTime {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTime::*;
+        use LockTime as L;
 
         match *self {
-            Blocks(ref h) => write!(f, "{} blocks", h),
-            Seconds(ref t) => write!(f, "{} seconds", t),
+            L::Blocks(ref h) => write!(f, "{} blocks", h),
+            L::Seconds(ref t) => write!(f, "{} seconds", t),
         }
     }
 }
 
 impl fmt::Display for LockTime {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTime::*;
+        use LockTime as L;
 
         if f.alternate() {
             match *self {
-                Blocks(ref h) => write!(f, "block-height {}", h),
-                Seconds(ref t) => write!(f, "block-time {} (seconds since epoch)", t),
+                L::Blocks(ref h) => write!(f, "block-height {}", h),
+                L::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),
+                L::Blocks(ref h) => fmt::Display::fmt(h, f),
+                L::Seconds(ref t) => fmt::Display::fmt(t, f),
             }
         }
     }
@@ -404,7 +405,7 @@ mod tests {
 
     #[test]
     fn display_and_alternate() {
-        let lock_by_height = LockTime::from_consensus(741521);
+        let lock_by_height = LockTime::from_consensus(741_521);
         let s = format!("{}", lock_by_height);
         assert_eq!(&s, "741521");
 
@@ -415,25 +416,25 @@ mod tests {
     #[test]
     fn lock_time_from_hex_lower() {
         let lock_by_time = LockTime::from_hex("0x6289c350").unwrap();
-        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289C350));
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
     }
 
     #[test]
     fn lock_time_from_hex_upper() {
         let lock_by_time = LockTime::from_hex("0X6289C350").unwrap();
-        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289C350));
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
     }
 
     #[test]
     fn lock_time_from_unprefixed_hex_lower() {
         let lock_by_time = LockTime::from_unprefixed_hex("6289c350").unwrap();
-        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289C350));
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
     }
 
     #[test]
     fn lock_time_from_unprefixed_hex_upper() {
         let lock_by_time = LockTime::from_unprefixed_hex("6289C350").unwrap();
-        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289C350));
+        assert_eq!(lock_by_time, LockTime::from_consensus(0x6289_C350));
     }
 
     #[test]
@@ -450,7 +451,7 @@ mod tests {
         assert!(lock_by_height.is_block_height());
         assert!(!lock_by_height.is_block_time());
 
-        let t: u32 = 1653195600; // May 22nd, 5am UTC.
+        let t: u32 = 1_653_195_600; // May 22nd, 5am UTC.
         let lock_by_time = LockTime::from_consensus(t);
 
         assert!(!lock_by_time.is_block_height());
@@ -459,7 +460,7 @@ mod tests {
         // Test is_same_unit() logic
         assert!(lock_by_height.is_same_unit(LockTime::from_consensus(800_000)));
         assert!(!lock_by_height.is_same_unit(lock_by_time));
-        assert!(lock_by_time.is_same_unit(LockTime::from_consensus(1653282000)));
+        assert!(lock_by_time.is_same_unit(LockTime::from_consensus(1_653_282_000)));
         assert!(!lock_by_time.is_same_unit(lock_by_height));
     }
 
@@ -471,7 +472,7 @@ mod tests {
         let height_above = Height::from_consensus(800_000).expect("failed to parse height");
         let height_below = Height::from_consensus(700_000).expect("failed to parse height");
 
-        let t: u32 = 1653195600; // May 22nd, 5am UTC.
+        let t: u32 = 1_653_195_600; // May 22nd, 5am UTC.
         let time = Time::from_consensus(t).expect("invalid time value");
 
         assert!(lock_by_height.is_satisfied_by(height_same, time));
@@ -481,11 +482,11 @@ mod tests {
 
     #[test]
     fn satisfied_by_time() {
-        let lock_by_time = LockTime::from_consensus(1653195600); // May 22nd 2022, 5am UTC.
+        let lock_by_time = LockTime::from_consensus(1_653_195_600); // May 22nd 2022, 5am UTC.
 
-        let time_same = Time::from_consensus(1653195600).expect("May 22nd 2022, 5am UTC");
-        let time_after = Time::from_consensus(1653282000).expect("May 23rd 2022, 5am UTC");
-        let time_before = Time::from_consensus(1653109200).expect("May 21th 2022, 5am UTC");
+        let time_same = Time::from_consensus(1_653_195_600).expect("May 22nd 2022, 5am UTC");
+        let time_after = Time::from_consensus(1_653_282_000).expect("May 23rd 2022, 5am UTC");
+        let time_before = Time::from_consensus(1_653_109_200).expect("May 21th 2022, 5am UTC");
 
         let height = Height::from_consensus(800_000).expect("failed to parse height");
 
@@ -505,17 +506,17 @@ mod tests {
 
     #[test]
     fn time_correctly_implies() {
-        let t: u32 = 1700000005;
+        let t: u32 = 1_700_000_005;
         let lock_by_time = LockTime::from_consensus(t);
 
-        assert!(!lock_by_time.is_implied_by(LockTime::from_consensus(1700000004)));
-        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1700000005)));
-        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1700000006)));
+        assert!(!lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_004)));
+        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_005)));
+        assert!(lock_by_time.is_implied_by(LockTime::from_consensus(1_700_000_006)));
     }
 
     #[test]
     fn incorrect_units_do_not_imply() {
         let lock_by_height = LockTime::from_consensus(750_005);
-        assert!(!lock_by_height.is_implied_by(LockTime::from_consensus(1700000004)));
+        assert!(!lock_by_height.is_implied_by(LockTime::from_consensus(1_700_000_004)));
     }
 }
diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 81518aa4a3..8c03a9459b 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Provides type [`LockTime`] that implements the logic around nSequence/OP_CHECKSEQUENCEVERIFY.
+//! 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.
@@ -18,7 +18,7 @@ pub use units::locktime::relative::{Height, Time, TimeOverflowError};
 /// A relative lock time value, representing either a block height or time (512 second intervals).
 ///
 /// Used for sequence numbers (`nSequence` in Bitcoin Core and [`TxIn::sequence`]
-/// in this library) and also for the argument to opcode 'OP_CHECKSEQUENCEVERIFY`.
+/// in this library) and also for the argument to opcode `OP_CHECKSEQUENCEVERIFY`.
 ///
 /// ### Note on ordering
 ///
@@ -64,7 +64,7 @@ impl LockTime {
     /// The number of bytes that the locktime contributes to the size of a transaction.
     pub const SIZE: usize = 4; // Serialized length of a u32.
 
-    /// Constructs a new `LockTime` from an nSequence value or the argument to OP_CHECKSEQUENCEVERIFY.
+    /// Constructs a new `LockTime` from an `nSequence` value or the argument to `OP_CHECKSEQUENCEVERIFY`.
     ///
     /// This method will **not** round-trip with [`Self::to_consensus_u32`], because relative
     /// locktimes only use some bits of the underlying `u32` value and discard the rest. If
@@ -95,7 +95,7 @@ impl LockTime {
         sequence.to_relative_lock_time().ok_or(DisabledLockTimeError(n))
     }
 
-    /// Returns the `u32` value used to encode this locktime in an nSequence field or
+    /// Returns the `u32` value used to encode this locktime in an `nSequence` field or
     /// argument to `OP_CHECKSEQUENCEVERIFY`.
     ///
     /// # Warning
@@ -178,7 +178,7 @@ impl LockTime {
 
     /// Returns true if both lock times use the same unit i.e., both height based or both time based.
     #[inline]
-    pub const fn is_same_unit(&self, other: LockTime) -> bool {
+    pub const fn is_same_unit(self, other: LockTime) -> bool {
         matches!(
             (self, other),
             (LockTime::Blocks(_), LockTime::Blocks(_)) | (LockTime::Time(_), LockTime::Time(_))
@@ -187,11 +187,11 @@ impl LockTime {
 
     /// Returns true if this lock time value is in units of block height.
     #[inline]
-    pub const fn is_block_height(&self) -> bool { matches!(*self, LockTime::Blocks(_)) }
+    pub const fn is_block_height(self) -> bool { matches!(self, LockTime::Blocks(_)) }
 
     /// Returns true if this lock time value is in units of time.
     #[inline]
-    pub const fn is_block_time(&self) -> bool { !self.is_block_height() }
+    pub const fn is_block_time(self) -> bool { !self.is_block_height() }
 
     /// Returns true if this [`relative::LockTime`] is satisfied by either height or time.
     ///
@@ -211,7 +211,7 @@ impl LockTime {
     /// assert!(lock.is_satisfied_by(current_height(), current_time()));
     /// ```
     #[inline]
-    pub fn is_satisfied_by(&self, h: Height, t: Time) -> bool {
+    pub fn is_satisfied_by(self, h: Height, t: Time) -> bool {
         if let Ok(true) = self.is_satisfied_by_height(h) {
             true
         } else {
@@ -249,12 +249,12 @@ impl LockTime {
     /// assert!(satisfied);
     /// ```
     #[inline]
-    pub fn is_implied_by(&self, other: LockTime) -> bool {
-        use LockTime::*;
+    pub fn is_implied_by(self, other: LockTime) -> bool {
+        use LockTime as L;
 
-        match (*self, other) {
-            (Blocks(this), Blocks(other)) => this.value() <= other.value(),
-            (Time(this), Time(other)) => this.value() <= other.value(),
+        match (self, other) {
+            (L::Blocks(this), L::Blocks(other)) => this.value() <= other.value(),
+            (L::Time(this), L::Time(other)) => this.value() <= other.value(),
             _ => false, // Not the same units.
         }
     }
@@ -280,7 +280,7 @@ impl LockTime {
     /// # Ok::<_, bitcoin_primitives::relative::DisabledLockTimeError>(())
     /// ```
     #[inline]
-    pub fn is_implied_by_sequence(&self, other: Sequence) -> bool {
+    pub fn is_implied_by_sequence(self, other: Sequence) -> bool {
         if let Ok(other) = LockTime::from_sequence(other) {
             self.is_implied_by(other)
         } else {
@@ -305,12 +305,12 @@ impl LockTime {
     /// assert!(lock.is_satisfied_by_height(relative::Height::from(required_height + 1)).expect("a height"));
     /// ```
     #[inline]
-    pub fn is_satisfied_by_height(&self, height: Height) -> Result<bool, IncompatibleHeightError> {
-        use LockTime::*;
+    pub fn is_satisfied_by_height(self, height: Height) -> Result<bool, IncompatibleHeightError> {
+        use LockTime as L;
 
-        match *self {
-            Blocks(ref required_height) => Ok(required_height.value() <= height.value()),
-            Time(time) => Err(IncompatibleHeightError { height, time }),
+        match self {
+            L::Blocks(ref required_height) => Ok(required_height.value() <= height.value()),
+            L::Time(time) => Err(IncompatibleHeightError { height, time }),
         }
     }
 
@@ -331,12 +331,12 @@ impl LockTime {
     /// assert!(lock.is_satisfied_by_time(relative::Time::from_512_second_intervals(intervals + 10)).expect("a time"));
     /// ```
     #[inline]
-    pub fn is_satisfied_by_time(&self, time: Time) -> Result<bool, IncompatibleTimeError> {
-        use LockTime::*;
+    pub fn is_satisfied_by_time(self, time: Time) -> Result<bool, IncompatibleTimeError> {
+        use LockTime as L;
 
-        match *self {
-            Time(ref t) => Ok(t.value() <= time.value()),
-            Blocks(height) => Err(IncompatibleTimeError { time, height }),
+        match self {
+            L::Time(ref t) => Ok(t.value() <= time.value()),
+            L::Blocks(height) => Err(IncompatibleTimeError { time, height }),
         }
     }
 }
@@ -353,17 +353,17 @@ impl From<Time> for LockTime {
 
 impl fmt::Display for LockTime {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use LockTime::*;
+        use LockTime as L;
 
         if f.alternate() {
             match *self {
-                Blocks(ref h) => write!(f, "block-height {}", h),
-                Time(ref t) => write!(f, "block-time {} (512 second intervals)", t),
+                L::Blocks(ref h) => write!(f, "block-height {}", h),
+                L::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),
+                L::Blocks(ref h) => fmt::Display::fmt(h, f),
+                L::Time(ref t) => fmt::Display::fmt(t, f),
             }
         }
     }
diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index 4283566250..3a3bce70f6 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -31,6 +31,7 @@ pub struct Opcode {
     code: u8,
 }
 
+#[allow(clippy::wildcard_imports)]
 use self::all::*;
 
 macro_rules! all_opcodes {
@@ -41,7 +42,7 @@ macro_rules! all_opcodes {
         /// 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_.
+        /// constants are guaranteed to begin with `OP_`.
         pub mod all {
             use super::Opcode;
             $(
@@ -52,13 +53,13 @@ macro_rules! all_opcodes {
 
         /// Push an empty array onto the stack.
         pub static OP_0: Opcode = OP_PUSHBYTES_0;
-        /// Empty stack is also FALSE.
+        /// 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.
+        /// Previously called `OP_NOP2`.
         pub static OP_NOP2: Opcode = OP_CLTV;
-        /// Previously called OP_NOP3.
+        /// Previously called `OP_NOP3`.
         pub static OP_NOP3: Opcode = OP_CSV;
 
         impl fmt::Display for Opcode {
@@ -402,10 +403,10 @@ impl Opcode {
 
             // 16 opcodes of PushNum class
             (op, _) if op.code >= OP_PUSHNUM_1.code && op.code <= OP_PUSHNUM_16.code =>
-                Class::PushNum(1 + self.code as i32 - OP_PUSHNUM_1.code as i32),
+                Class::PushNum(1 + i32::from(self.code) - i32::from(OP_PUSHNUM_1.code)),
 
             // 76 opcodes of PushBytes class
-            (op, _) if op.code <= OP_PUSHBYTES_75.code => Class::PushBytes(self.code as u32),
+            (op, _) if op.code <= OP_PUSHBYTES_75.code => Class::PushBytes(u32::from(self.code)),
 
             // opcodes of Ordinary class: 61 for Legacy and 60 for TapScript context
             (_, _) => Class::Ordinary(Ordinary::with(self)),
@@ -640,6 +641,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::too_many_lines)] // This is fine, we never need to read it.
     fn str_roundtrip() {
         let mut unique = HashSet::new();
         roundtrip!(unique, OP_PUSHBYTES_0);
diff --git a/primitives/src/pow.rs b/primitives/src/pow.rs
index df452dedf6..b7f5fc46ce 100644
--- a/primitives/src/pow.rs
+++ b/primitives/src/pow.rs
@@ -52,9 +52,9 @@ mod tests {
 
     #[test]
     fn compact_target_ordering() {
-        let lower = CompactTarget::from_consensus(0x1d00fffe);
-        let lower_copy = CompactTarget::from_consensus(0x1d00fffe);
-        let higher = CompactTarget::from_consensus(0x1d00ffff);
+        let lower = CompactTarget::from_consensus(0x1d00_fffe);
+        let lower_copy = CompactTarget::from_consensus(0x1d00_fffe);
+        let higher = CompactTarget::from_consensus(0x1d00_ffff);
 
         assert!(lower < higher);
         assert!(lower == lower_copy);
@@ -62,9 +62,9 @@ mod tests {
 
     #[test]
     fn compact_target_formatting() {
-        let compact_target = CompactTarget::from_consensus(0x1d00ffff);
+        let compact_target = CompactTarget::from_consensus(0x1d00_ffff);
         assert_eq!(format!("{:x}", compact_target), "1d00ffff");
         assert_eq!(format!("{:X}", compact_target), "1D00FFFF");
-        assert_eq!(compact_target.to_consensus(), 0x1d00ffff);
+        assert_eq!(compact_target.to_consensus(), 0x1d00_ffff);
     }
 }
diff --git a/primitives/src/script/mod.rs b/primitives/src/script/mod.rs
index db5fff8080..c263b4d688 100644
--- a/primitives/src/script/mod.rs
+++ b/primitives/src/script/mod.rs
@@ -13,6 +13,7 @@ use hashes::{hash160, sha256};
 use hex::DisplayHex;
 use internals::script::{self, PushDataLenLen};
 
+#[allow(clippy::wildcard_imports)]
 use crate::opcodes::all::*;
 use crate::opcodes::{self, Opcode};
 use crate::prelude::rc::Rc;
@@ -522,14 +523,6 @@ impl<'de> serde::Deserialize<'de> for &'de Script {
     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;
@@ -545,6 +538,15 @@ impl<'de> serde::Deserialize<'de> for &'de Script {
                 Ok(Script::from_bytes(v))
             }
         }
+
+        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",
+            ));
+        }
+
         deserializer.deserialize_bytes(Visitor)
     }
 }
diff --git a/primitives/src/sequence.rs b/primitives/src/sequence.rs
index a4e7dbff56..75e9569417 100644
--- a/primitives/src/sequence.rs
+++ b/primitives/src/sequence.rs
@@ -36,7 +36,7 @@ impl Sequence {
     /// The maximum allowable sequence number.
     ///
     /// The sequence number that disables replace-by-fee, absolute lock time and relative lock time.
-    pub const MAX: Self = Sequence(0xFFFFFFFF);
+    pub const MAX: Self = Sequence(0xFFFF_FFFF);
     /// Zero value sequence.
     ///
     /// This sequence number enables replace-by-fee and absolute lock time.
@@ -49,12 +49,12 @@ impl Sequence {
     /// The sequence number that enables replace-by-fee and absolute lock time but
     /// disables relative lock time.
     #[deprecated(since = "TBD", note = "use `ENABLE_LOCKTIME_AND_RBF` instead")]
-    pub const ENABLE_RBF_NO_LOCKTIME: Self = Sequence(0xFFFFFFFD);
+    pub const ENABLE_RBF_NO_LOCKTIME: Self = Sequence(0xFFFF_FFFD);
     /// The maximum sequence number that enables replace-by-fee and absolute lock time but
     /// disables relative lock time.
     ///
     /// This sequence number has no meaning other than to enable RBF and the absolute locktime.
-    pub const ENABLE_LOCKTIME_AND_RBF: Self = Sequence(0xFFFFFFFD);
+    pub const ENABLE_LOCKTIME_AND_RBF: Self = Sequence(0xFFFF_FFFD);
 
     /// The number of bytes that a sequence number contributes to the size of a transaction.
     pub const SIZE: usize = 4; // Serialized length of a u32.
@@ -66,15 +66,15 @@ impl Sequence {
     /// (Explicit Signalling [BIP-125]).
     ///
     /// [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki]>
-    const MIN_NO_RBF: Self = Sequence(0xFFFFFFFE);
+    const MIN_NO_RBF: Self = Sequence(0xFFFF_FFFE);
     /// BIP-68 relative lock time disable flag mask.
-    const LOCK_TIME_DISABLE_FLAG_MASK: u32 = 0x80000000;
+    const LOCK_TIME_DISABLE_FLAG_MASK: u32 = 0x8000_0000;
     /// BIP-68 relative lock time type flag mask.
-    const LOCK_TYPE_MASK: u32 = 0x00400000;
+    const LOCK_TYPE_MASK: u32 = 0x0040_0000;
 
     /// Returns `true` if the sequence number enables absolute lock-time ([`Transaction::lock_time`]).
     #[inline]
-    pub fn enables_absolute_lock_time(&self) -> bool { *self != Sequence::MAX }
+    pub fn enables_absolute_lock_time(self) -> bool { self != Sequence::MAX }
 
     /// Returns `true` if the sequence number indicates that the transaction is finalized.
     ///
@@ -96,30 +96,30 @@ impl Sequence {
     ///
     /// [BIP-112]: <https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki>
     #[inline]
-    pub fn is_final(&self) -> bool { !self.enables_absolute_lock_time() }
+    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 }
+    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 {
+    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 {
+    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 {
+    pub fn is_time_locked(self) -> bool {
         self.is_relative_lock_time() & (self.0 & Sequence::LOCK_TYPE_MASK > 0)
     }
 
@@ -206,7 +206,7 @@ impl Sequence {
     ///
     /// BIP-68 only uses the low 16 bits for relative lock value.
     #[inline]
-    fn low_u16(&self) -> u16 { self.0 as u16 }
+    fn low_u16(self) -> u16 { self.0 as u16 }
 }
 
 impl Default for Sequence {
@@ -319,9 +319,9 @@ mod tests {
 
     #[test]
     fn sequence_properties() {
-        let seq_max = Sequence(0xFFFFFFFF);
-        let seq_no_rbf = Sequence(0xFFFFFFFE);
-        let seq_rbf = Sequence(0xFFFFFFFD);
+        let seq_max = Sequence(0xFFFF_FFFF);
+        let seq_no_rbf = Sequence(0xFFFF_FFFE);
+        let seq_rbf = Sequence(0xFFFF_FFFD);
 
         assert!(seq_max.is_final());
         assert!(!seq_no_rbf.is_final());
@@ -332,12 +332,12 @@ mod tests {
         assert!(seq_rbf.is_rbf());
         assert!(!seq_no_rbf.is_rbf());
 
-        let seq_relative = Sequence(0x7FFFFFFF);
+        let seq_relative = Sequence(0x7FFF_FFFF);
         assert!(seq_relative.is_relative_lock_time());
         assert!(!seq_max.is_relative_lock_time());
 
-        let seq_height_locked = Sequence(0x00399999);
-        let seq_time_locked = Sequence(0x00400000);
+        let seq_height_locked = Sequence(0x0039_9999);
+        let seq_time_locked = Sequence(0x0040_0000);
         assert!(seq_height_locked.is_height_locked());
         assert!(seq_time_locked.is_time_locked());
         assert!(!seq_time_locked.is_height_locked());
@@ -346,12 +346,12 @@ mod tests {
 
     #[test]
     fn sequence_formatting() {
-        let sequence = Sequence(0x7FFFFFFF);
+        let sequence = Sequence(0x7FFF_FFFF);
         assert_eq!(format!("{:x}", sequence), "7fffffff");
         assert_eq!(format!("{:X}", sequence), "7FFFFFFF");
 
         // Test From<Sequence> for u32
         let sequence_u32: u32 = sequence.into();
-        assert_eq!(sequence_u32, 0x7FFFFFFF);
+        assert_eq!(sequence_u32, 0x7FFF_FFFF);
     }
 }
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 7e708e2502..8df70d4179 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -265,7 +265,7 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
         enc.input(compact_size::encode(script_sig_bytes.len()).as_slice());
         enc.input(script_sig_bytes);
 
-        enc.input(&input.sequence.0.to_le_bytes())
+        enc.input(&input.sequence.0.to_le_bytes());
     }
 
     // Encode outputs with leading compact size encoded int.
@@ -285,7 +285,7 @@ fn hash_transaction(tx: &Transaction, uses_segwit_serialization: bool) -> sha256
         for input in &tx.input {
             // Same as `Encodable for Witness`.
             enc.input(compact_size::encode(input.witness.len()).as_slice());
-            for element in input.witness.iter() {
+            for element in &input.witness {
                 enc.input(compact_size::encode(element.len()).as_slice());
                 enc.input(element);
             }
@@ -322,9 +322,9 @@ pub struct TxIn {
     /// 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
+    /// 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
+    /// Transaction. It *is* (de)serialized with the rest of the `TxIn` in other
     /// (de)serialization routines.
     pub witness: Witness,
 }
@@ -459,14 +459,14 @@ impl From<Infallible> for ParseOutPointError {
 #[cfg(feature = "alloc")]
 impl fmt::Display for ParseOutPointError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use ParseOutPointError::*;
+        use ParseOutPointError as E;
 
         match *self {
-            Txid(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"),
+            E::Txid(ref e) => write_err!(f, "error parsing TXID"; e),
+            E::Vout(ref e) => write_err!(f, "error parsing vout"; e),
+            E::Format => write!(f, "OutPoint not in <txid>:<vout> format"),
+            E::TooLong => write!(f, "vout should be at most 10 digits"),
+            E::VoutNotCanonical => write!(f, "no leading zeroes or + allowed in vout part"),
         }
     }
 }
@@ -474,12 +474,12 @@ impl fmt::Display for ParseOutPointError {
 #[cfg(feature = "std")]
 impl std::error::Error for ParseOutPointError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        use ParseOutPointError::*;
+        use ParseOutPointError as E;
 
         match self {
-            Txid(e) => Some(e),
-            Vout(e) => Some(e),
-            Format | TooLong | VoutNotCanonical => None,
+            E::Txid(e) => Some(e),
+            E::Vout(e) => Some(e),
+            E::Format | E::TooLong | E::VoutNotCanonical => None,
         }
     }
 }
@@ -561,8 +561,8 @@ impl Version {
     /// As of Bitcoin Core 28.0 ([release notes](https://bitcoincore.org/en/releases/28.0/)),
     /// versions 1, 2, and 3 are considered standard.
     #[inline]
-    pub fn is_standard(&self) -> bool {
-        *self == Version::ONE || *self == Version::TWO || *self == Version::THREE
+    pub fn is_standard(self) -> bool {
+        self == Version::ONE || self == Version::TWO || self == Version::THREE
     }
 }
 
@@ -657,11 +657,11 @@ mod tests {
             witness: Witness::new(),
         };
 
-        let txout = TxOut { value: Amount::from_sat(123456789), script_pubkey: ScriptBuf::new() };
+        let txout = TxOut { value: Amount::from_sat(123_456_789), script_pubkey: ScriptBuf::new() };
 
         let tx_orig = Transaction {
             version: Version::ONE,
-            lock_time: absolute::LockTime::from_consensus(1738968231), // The time this was written
+            lock_time: absolute::LockTime::from_consensus(1_738_968_231), // The time this was written
             input: vec![txin.clone()],
             output: vec![txout.clone()],
         };
@@ -669,9 +669,9 @@ mod tests {
         // Test changing the transaction
         let mut tx = tx_orig.clone();
         tx.inputs_mut()[0].previous_output.txid = Txid::from_byte_array([0xFF; 32]);
-        tx.outputs_mut()[0].value = Amount::from_sat(987654321);
+        tx.outputs_mut()[0].value = Amount::from_sat(987_654_321);
         assert_eq!(tx.inputs()[0].previous_output.txid.to_byte_array(), [0xFF; 32]);
-        assert_eq!(tx.outputs()[0].value.to_sat(), 987654321);
+        assert_eq!(tx.outputs()[0].value.to_sat(), 987_654_321);
 
         // Test uses_segwit_serialization
         assert!(!tx.uses_segwit_serialization());
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index f8328b8200..a0782e3425 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -100,7 +100,7 @@ impl Witness {
 
     /// Convenience method to create an array of byte-arrays from this witness.
     #[inline]
-    pub fn to_vec(&self) -> Vec<Vec<u8>> { self.iter().map(|s| s.to_vec()).collect() }
+    pub fn to_vec(&self) -> Vec<Vec<u8>> { self.iter().map(<[u8]>::to_vec).collect() }
 
     /// Returns `true` if the witness contains no element.
     #[inline]
@@ -172,17 +172,6 @@ impl Witness {
             .copy_from_slice(new_element);
     }
 
-    /// Note `index` is the index into the `content` vector and should be the result of calling
-    /// `decode_cursor`, which returns a valid index.
-    fn element_at(&self, index: usize) -> Option<&[u8]> {
-        let mut slice = &self.content[index..]; // Start of element.
-        let element_len = compact_size::decode_unchecked(&mut slice);
-        // Compact size should always fit into a u32 because of `MAX_SIZE` in Core.
-        // ref: https://github.com/rust-bitcoin/rust-bitcoin/issues/3264
-        let end = element_len as usize;
-        Some(&slice[..end])
-    }
-
     /// Returns the last element in the witness, if any.
     #[inline]
     pub fn last(&self) -> Option<&[u8]> {
@@ -217,7 +206,13 @@ impl Witness {
     #[inline]
     pub fn nth(&self, index: usize) -> Option<&[u8]> {
         let pos = decode_cursor(&self.content, self.indices_start, index)?;
-        self.element_at(pos)
+
+        let mut slice = &self.content[pos..]; // Start of element.
+        let element_len = compact_size::decode_unchecked(&mut slice);
+        // Compact size should always fit into a u32 because of `MAX_SIZE` in Core.
+        // ref: https://github.com/rust-bitcoin/rust-bitcoin/issues/3264
+        let end = element_len as usize;
+        Some(&slice[..end])
     }
 }
 
@@ -247,9 +242,10 @@ fn decode_cursor(bytes: &[u8], start_of_indices: usize, index: usize) -> Option<
 /// - Number of witness elements
 /// - Total bytes across all elements
 /// - List of hex-encoded witness elements
+#[allow(clippy::missing_fields_in_debug)] // We don't want to show `indices_start`.
 impl fmt::Debug for Witness {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let total_bytes: usize = self.iter().map(|elem| elem.len()).sum();
+        let total_bytes: usize = self.iter().map(<[u8]>::len).sum();
 
         f.debug_struct("Witness")
             .field("num_elements", &self.witness_elements)
@@ -257,7 +253,7 @@ impl fmt::Debug for Witness {
             .field(
                 "elements",
                 &WrapDebug(|f| {
-                    f.debug_list().entries(self.iter().map(|elem| elem.as_hex())).finish()
+                    f.debug_list().entries(self.iter().map(DisplayHex::as_hex)).finish()
                 }),
             )
             .finish()
@@ -323,7 +319,7 @@ impl serde::Serialize for Witness {
         let mut seq = serializer.serialize_seq(Some(self.witness_elements))?;
 
         // Note that the `Iter` strips the varints out when iterating.
-        for elem in self.iter() {
+        for elem in self {
             if human_readable {
                 seq.serialize_element(&internals::serde::SerializeBytesAsHex(elem))?;
             } else {
@@ -355,7 +351,7 @@ impl<'de> serde::Deserialize<'de> for Witness {
                 mut a: A,
             ) -> Result<Self::Value, A::Error> {
                 use hex::FromHex;
-                use hex::HexToBytesError::*;
+                use hex::HexToBytesError as E;
                 use serde::de::{self, Unexpected};
 
                 let mut ret = match a.size_hint() {
@@ -365,7 +361,7 @@ impl<'de> serde::Deserialize<'de> for Witness {
 
                 while let Some(elem) = a.next_element::<String>()? {
                     let vec = Vec::<u8>::from_hex(&elem).map_err(|e| match e {
-                        InvalidChar(ref e) => match core::char::from_u32(e.invalid_char().into()) {
+                        E::InvalidChar(ref e) => match core::char::from_u32(e.invalid_char().into()) {
                             Some(c) => de::Error::invalid_value(
                                 Unexpected::Char(c),
                                 &"a valid hex character",
@@ -375,7 +371,7 @@ impl<'de> serde::Deserialize<'de> for Witness {
                                 &"a valid hex character",
                             ),
                         },
-                        OddLengthString(ref e) =>
+                        E::OddLengthString(ref e) =>
                             de::Error::invalid_length(e.length(), &"an even length string"),
                     })?;
                     ret.push(vec);
@@ -459,7 +455,7 @@ mod test {
         let mut got = Witness::new();
         got.push([]);
         let want = single_empty_element();
-        assert_eq!(got, want)
+        assert_eq!(got, want);
     }
 
     #[test]

From 97453ef9bc2b99a67252419ff015f13679df7312 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 26 Feb 2025 12:18:36 +1100
Subject: [PATCH 474/554] units: Prevent casting pub enums as ints

A public enum with simple variants gets an automatic integer variant
that can be cast by library consumers. This puts a unnecessary
maintenance burden upon us because we cannot then add variants in the
middle of others.

Add a hidden variant to the single public non-error enum in `units`.
---
 units/src/amount/mod.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 345c3badfb..8af21f0a1f 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -91,6 +91,10 @@ pub enum Denomination {
     Bit,
     /// satoshi (1 BTC = 100,000,000 satoshi).
     Satoshi,
+    /// Stops users from casting this enum to an integer.
+    // May get removed if one day Rust supports disabling casts natively.
+    #[doc(hidden)]
+    _DoNotUse(Infallible),
 }
 
 impl Denomination {
@@ -109,6 +113,7 @@ impl Denomination {
             Denomination::MicroBitcoin => -2,
             Denomination::Bit => -2,
             Denomination::Satoshi => 0,
+            Denomination::_DoNotUse(infallible) => match infallible {}
         }
     }
 
@@ -121,6 +126,7 @@ impl Denomination {
             Denomination::MicroBitcoin => "uBTC",
             Denomination::Bit => "bits",
             Denomination::Satoshi => "satoshi",
+            Denomination::_DoNotUse(infallible) => match infallible {}
         }
     }
 

From 84623ffaf9673310405ba48d3b4b36890a0abc29 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Feb 2025 13:38:22 +1100
Subject: [PATCH 475/554] Add hash_again regression test

Add a simple regression test prior to patching the
`sha256::Hash::hash_again` function.
---
 hashes/tests/regression.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/hashes/tests/regression.rs b/hashes/tests/regression.rs
index 319d6ecf37..2bacd7ff2b 100644
--- a/hashes/tests/regression.rs
+++ b/hashes/tests/regression.rs
@@ -87,3 +87,13 @@ fn regression_siphash24_with_key() {
     let want = "e823ed82311d601a";
     assert_eq!(got, want);
 }
+
+#[test]
+fn regression_sha256_hash_again() {
+    let hash = sha256::Hash::hash(b"Don't explain your philosophy. Embody it.");
+    let again = hash.hash_again();
+
+    let got = format!("{}", again);
+    let want = "28273103bcd88ab99e2b1007174770ff3f0ea91ee4b3ac942879ed1a2d264b4c";
+    assert_eq!(got, want);
+}

From ab63b7a0ffb7fac57dc0070002133547cda1adc4 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Feb 2025 10:46:08 +1100
Subject: [PATCH 476/554] Add Hash type and finalize method to HashEngine

Add an associated const `Hash` to the `HashEngine` trait. Also add a
`finalize` method that converts the engine to the associated hash.

For now just use the existent `from_engine` stuff. We can refactor
later.
---
 hashes/src/hash160/mod.rs    | 3 +++
 hashes/src/hmac/mod.rs       | 3 ++-
 hashes/src/lib.rs            | 6 ++++++
 hashes/src/ripemd160/mod.rs  | 3 ++-
 hashes/src/sha1/mod.rs       | 3 +++
 hashes/src/sha256/mod.rs     | 3 ++-
 hashes/src/sha256d/mod.rs    | 3 +++
 hashes/src/sha256t/mod.rs    | 3 +++
 hashes/src/sha384/mod.rs     | 3 ++-
 hashes/src/sha512/mod.rs     | 3 ++-
 hashes/src/sha512_256/mod.rs | 3 ++-
 hashes/src/siphash24/mod.rs  | 3 +++
 12 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/hashes/src/hash160/mod.rs b/hashes/src/hash160/mod.rs
index 282d653d76..328ad9513c 100644
--- a/hashes/src/hash160/mod.rs
+++ b/hashes/src/hash160/mod.rs
@@ -38,9 +38,12 @@ impl Default for HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = 64; // Same as sha256::HashEngine::BLOCK_SIZE;
+
     fn input(&mut self, data: &[u8]) { self.0.input(data) }
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
 
 #[cfg(test)]
diff --git a/hashes/src/hmac/mod.rs b/hashes/src/hmac/mod.rs
index 8215e48a75..fa50389db9 100644
--- a/hashes/src/hmac/mod.rs
+++ b/hashes/src/hmac/mod.rs
@@ -92,11 +92,12 @@ impl<T: GeneralHash> HmacEngine<T> {
 }
 
 impl<T: GeneralHash> HashEngine for HmacEngine<T> {
+    type Hash = Hmac<T>;
     const BLOCK_SIZE: usize = T::Engine::BLOCK_SIZE;
 
     fn n_bytes_hashed(&self) -> u64 { self.iengine.n_bytes_hashed() }
-
     fn input(&mut self, buf: &[u8]) { self.iengine.input(buf) }
+    fn finalize(self) -> Self::Hash { Hmac::from_engine(self) }
 }
 
 impl<T: GeneralHash + fmt::Debug> fmt::Debug for Hmac<T> {
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 06cfbcda39..329273b949 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -186,6 +186,9 @@ pub type HkdfSha512 = Hkdf<sha512::Hash>;
 
 /// A hashing engine which bytes can be serialized into.
 pub trait HashEngine: Clone {
+    /// The `Hash` type returned when finalizing this engine.
+    type Hash: Hash;
+
     /// Length of the hash's internal block size, in bytes.
     const BLOCK_SIZE: usize;
 
@@ -194,6 +197,9 @@ pub trait HashEngine: Clone {
 
     /// Return the number of bytes already input into the engine.
     fn n_bytes_hashed(&self) -> u64;
+
+    /// Finalizes this engine.
+    fn finalize(self) -> Self::Hash;
 }
 
 /// Trait describing hash digests which can be constructed by hashing arbitrary data.
diff --git a/hashes/src/ripemd160/mod.rs b/hashes/src/ripemd160/mod.rs
index e6be175370..c91dc8b683 100644
--- a/hashes/src/ripemd160/mod.rs
+++ b/hashes/src/ripemd160/mod.rs
@@ -87,9 +87,10 @@ impl Default for HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = 64;
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
-
     crate::internal_macros::engine_input_impl!();
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
diff --git a/hashes/src/sha1/mod.rs b/hashes/src/sha1/mod.rs
index dc32d31dd1..6abbf0a9c9 100644
--- a/hashes/src/sha1/mod.rs
+++ b/hashes/src/sha1/mod.rs
@@ -79,9 +79,12 @@ impl Default for HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = 64;
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
 
     crate::internal_macros::engine_input_impl!();
+
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
diff --git a/hashes/src/sha256/mod.rs b/hashes/src/sha256/mod.rs
index 6ae83b879b..fd40401bdc 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -128,11 +128,12 @@ impl Default for HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = 64;
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
-
     crate::internal_macros::engine_input_impl!();
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
 
 impl Hash {
diff --git a/hashes/src/sha256d/mod.rs b/hashes/src/sha256d/mod.rs
index adb2ffa715..3137608526 100644
--- a/hashes/src/sha256d/mod.rs
+++ b/hashes/src/sha256d/mod.rs
@@ -33,9 +33,12 @@ impl Default for HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = 64; // Same as sha256::HashEngine::BLOCK_SIZE;
+
     fn input(&mut self, data: &[u8]) { self.0.input(data) }
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
 
 #[cfg(test)]
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 19a6ef7680..7b58bc9918 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -133,9 +133,12 @@ impl<T: Tag> Clone for HashEngine<T> {
 }
 
 impl<T: Tag> crate::HashEngine for HashEngine<T> {
+    type Hash = Hash<T>;
     const BLOCK_SIZE: usize = 64; // Same as sha256::HashEngine::BLOCK_SIZE;
+
     fn input(&mut self, data: &[u8]) { self.0.input(data) }
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
 
 crate::internal_macros::impl_write!(
diff --git a/hashes/src/sha384/mod.rs b/hashes/src/sha384/mod.rs
index c20b356dcd..9918afa2f4 100644
--- a/hashes/src/sha384/mod.rs
+++ b/hashes/src/sha384/mod.rs
@@ -30,11 +30,12 @@ impl Default for HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = sha512::BLOCK_SIZE;
 
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
-
     fn input(&mut self, inp: &[u8]) { self.0.input(inp); }
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
 
 #[cfg(test)]
diff --git a/hashes/src/sha512/mod.rs b/hashes/src/sha512/mod.rs
index 65bf75c18e..617f34cd8e 100644
--- a/hashes/src/sha512/mod.rs
+++ b/hashes/src/sha512/mod.rs
@@ -120,9 +120,10 @@ impl HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = 128;
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
-
     crate::internal_macros::engine_input_impl!();
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
diff --git a/hashes/src/sha512_256/mod.rs b/hashes/src/sha512_256/mod.rs
index 40b4ca6517..04e6d9be39 100644
--- a/hashes/src/sha512_256/mod.rs
+++ b/hashes/src/sha512_256/mod.rs
@@ -40,11 +40,12 @@ impl Default for HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = sha512::BLOCK_SIZE;
 
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
-
     fn input(&mut self, inp: &[u8]) { self.0.input(inp); }
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
 
 #[cfg(test)]
diff --git a/hashes/src/siphash24/mod.rs b/hashes/src/siphash24/mod.rs
index 1db7477332..4f8de24ff1 100644
--- a/hashes/src/siphash24/mod.rs
+++ b/hashes/src/siphash24/mod.rs
@@ -121,6 +121,7 @@ impl HashEngine {
 }
 
 impl crate::HashEngine for HashEngine {
+    type Hash = Hash;
     const BLOCK_SIZE: usize = 8;
 
     #[inline]
@@ -165,6 +166,8 @@ impl crate::HashEngine for HashEngine {
     }
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
+
+    fn finalize(self) -> Self::Hash { Hash::from_engine(self) }
 }
 
 impl Hash {

From e1bac7da55c4809367facc2e242c0d76ddcf6ac2 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Feb 2025 13:02:09 +1100
Subject: [PATCH 477/554] Bound HmacEngine on HashEngine

We would like to do away with the `GeneralHash` trait. Currently we
bound `Hmac` and `HmacEngine` on it but this is unnecessary now that we
have added `HashEngine::finalize` and `HashEngine::Hash`.

Bound the `HmacEngine` on `HashEngine` (which has an associated `Hash`
type returned by `finilalize`).

Bound `Hmac` type on `T::Hash` where `T` is `HashEngine`.

Includes some minor shortening of local variable names around hmac
engine usage.

Note this means that `Hmac` no longer implements `GeneralHash`.
---
 bitcoin/src/bip32.rs         |  43 +++++++-------
 hashes/src/hash160/mod.rs    |   1 +
 hashes/src/hkdf/mod.rs       |  40 ++++++-------
 hashes/src/hmac/mod.rs       | 105 +++++++++++++++--------------------
 hashes/src/lib.rs            |   6 ++
 hashes/src/ripemd160/mod.rs  |   1 +
 hashes/src/sha1/mod.rs       |   1 +
 hashes/src/sha256/mod.rs     |   1 +
 hashes/src/sha256d/mod.rs    |   1 +
 hashes/src/sha256t/mod.rs    |   1 +
 hashes/src/sha384/mod.rs     |   1 +
 hashes/src/sha512/mod.rs     |   1 +
 hashes/src/sha512_256/mod.rs |   1 +
 hashes/src/siphash24/mod.rs  |   1 +
 hashes/tests/regression.rs   |  10 ++--
 io/src/hash.rs               |  24 ++++----
 16 files changed, 117 insertions(+), 121 deletions(-)

diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index a25ff424dd..5b83327e84 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -10,7 +10,7 @@ use core::ops::Index;
 use core::str::FromStr;
 use core::{fmt, slice};
 
-use hashes::{hash160, hash_newtype, sha512, GeneralHash, HashEngine, Hmac, HmacEngine};
+use hashes::{hash160, hash_newtype, sha512, HashEngine, Hmac, HmacEngine};
 use internals::write_err;
 use secp256k1::{Secp256k1, XOnlyPublicKey};
 
@@ -584,9 +584,9 @@ impl From<InvalidBase58PayloadLengthError> for Error {
 impl Xpriv {
     /// Constructs a new master key from a seed value
     pub fn new_master(network: impl Into<NetworkKind>, seed: &[u8]) -> Result<Xpriv, 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);
+        let mut engine = HmacEngine::<sha512::HashEngine>::new(b"Bitcoin seed");
+        engine.input(seed);
+        let hmac = engine.finalize();
 
         Ok(Xpriv {
             network: network.into(),
@@ -594,9 +594,9 @@ impl Xpriv {
             parent_fingerprint: Default::default(),
             child_number: ChildNumber::ZERO_NORMAL,
             private_key: secp256k1::SecretKey::from_byte_array(
-                &hmac_result.as_ref()[..32].try_into().expect("Slice should be exactly 32 bytes"),
+                &hmac.as_ref()[..32].try_into().expect("Slice should be exactly 32 bytes"),
             )?,
-            chain_code: ChainCode::from_hmac(hmac_result),
+            chain_code: ChainCode::from_hmac(hmac),
         })
     }
 
@@ -650,25 +650,25 @@ impl Xpriv {
 
     /// Private->Private child key derivation
     fn ckd_priv<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>, i: ChildNumber) -> Xpriv {
-        let mut hmac_engine: HmacEngine<sha512::Hash> = HmacEngine::new(&self.chain_code[..]);
+        let mut engine = HmacEngine::<sha512::HashEngine>::new(&self.chain_code[..]);
         match i {
             ChildNumber::Normal { .. } => {
                 // Non-hardened key: compute public data and use that
-                hmac_engine.input(
+                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[..]);
+                engine.input(&[0u8]);
+                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);
+        engine.input(&u32::from(i).to_be_bytes());
+        let hmac: Hmac<sha512::Hash> = engine.finalize();
         let sk = secp256k1::SecretKey::from_byte_array(
-            &hmac_result.as_ref()[..32].try_into().expect("statistically impossible to hit"),
+            &hmac.as_ref()[..32].try_into().expect("statistically impossible to hit"),
         )
         .expect("statistically impossible to hit");
         let tweaked =
@@ -680,7 +680,7 @@ impl Xpriv {
             parent_fingerprint: self.fingerprint(secp),
             child_number: i,
             private_key: tweaked,
-            chain_code: ChainCode::from_hmac(hmac_result),
+            chain_code: ChainCode::from_hmac(hmac),
         }
     }
 
@@ -812,18 +812,15 @@ impl Xpub {
         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 mut engine = HmacEngine::<sha512::HashEngine>::new(&self.chain_code[..]);
+                engine.input(&self.public_key.serialize()[..]);
+                engine.input(&n.to_be_bytes());
 
-                let hmac_result: Hmac<sha512::Hash> = Hmac::from_engine(hmac_engine);
+                let hmac = engine.finalize();
                 let private_key = secp256k1::SecretKey::from_byte_array(
-                    &hmac_result.as_ref()[..32]
-                        .try_into()
-                        .expect("Slice should be exactly 32 bytes"),
+                    &hmac.as_ref()[..32].try_into().expect("Slice should be exactly 32 bytes"),
                 )?;
-                let chain_code = ChainCode::from_hmac(hmac_result);
+                let chain_code = ChainCode::from_hmac(hmac);
                 Ok((private_key, chain_code))
             }
         }
diff --git a/hashes/src/hash160/mod.rs b/hashes/src/hash160/mod.rs
index 328ad9513c..bf03d1d1f1 100644
--- a/hashes/src/hash160/mod.rs
+++ b/hashes/src/hash160/mod.rs
@@ -39,6 +39,7 @@ impl Default for HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 20];
     const BLOCK_SIZE: usize = 64; // Same as sha256::HashEngine::BLOCK_SIZE;
 
     fn input(&mut self, data: &[u8]) { self.0.input(data) }
diff --git a/hashes/src/hkdf/mod.rs b/hashes/src/hkdf/mod.rs
index f02e0dd479..c381422da4 100644
--- a/hashes/src/hkdf/mod.rs
+++ b/hashes/src/hkdf/mod.rs
@@ -11,7 +11,7 @@ use alloc::vec;
 use alloc::vec::Vec;
 use core::fmt;
 
-use crate::{GeneralHash, HashEngine, Hmac, HmacEngine, IsByteArray};
+use crate::{HashEngine, Hmac, HmacEngine, IsByteArray};
 
 /// Output keying material max length multiple.
 const MAX_OUTPUT_BLOCKS: usize = 255;
@@ -33,20 +33,20 @@ impl std::error::Error for MaxLengthError {}
 
 /// HMAC-based Extract-and-Expand Key Derivation Function (HKDF).
 #[derive(Copy, Clone)]
-pub struct Hkdf<T: GeneralHash> {
+pub struct Hkdf<T: HashEngine> {
     /// Pseudorandom key based on the extract step.
-    prk: Hmac<T>,
+    prk: Hmac<T::Hash>,
 }
 
-impl<T: GeneralHash> Hkdf<T>
+impl<T: HashEngine> Hkdf<T>
 where
-    <T as GeneralHash>::Engine: Default,
+    T: Default,
 {
     /// Initialize a HKDF by performing the extract step.
     pub fn new(salt: &[u8], ikm: &[u8]) -> Self {
-        let mut hmac_engine: HmacEngine<T> = HmacEngine::new(salt);
-        hmac_engine.input(ikm);
-        Self { prk: Hmac::from_engine(hmac_engine) }
+        let mut engine: HmacEngine<T> = HmacEngine::new(salt);
+        engine.input(ikm);
+        Self { prk: engine.finalize() }
     }
 
     /// Expand the key to generate output key material in okm.
@@ -65,19 +65,19 @@ where
         let total_blocks = (okm.len() + T::Bytes::LEN - 1) / T::Bytes::LEN;
 
         while counter <= total_blocks as u8 {
-            let mut hmac_engine: HmacEngine<T> = HmacEngine::new(self.prk.as_ref());
+            let mut engine: HmacEngine<T> = HmacEngine::new(self.prk.as_ref());
 
             // First block does not have a previous block,
             // all other blocks include last block in the HMAC input.
             if counter != 1u8 {
                 let previous_start_index = (counter as usize - 2) * T::Bytes::LEN;
                 let previous_end_index = (counter as usize - 1) * T::Bytes::LEN;
-                hmac_engine.input(&okm[previous_start_index..previous_end_index]);
+                engine.input(&okm[previous_start_index..previous_end_index]);
             }
-            hmac_engine.input(info);
-            hmac_engine.input(&[counter]);
+            engine.input(info);
+            engine.input(&[counter]);
 
-            let t = Hmac::from_engine(hmac_engine);
+            let t = engine.finalize();
             let start_index = (counter as usize - 1) * T::Bytes::LEN;
             // Last block might not take full hash length.
             let end_index = if counter == (total_blocks as u8) {
@@ -106,7 +106,7 @@ where
     }
 }
 
-impl<T: GeneralHash> fmt::Debug for Hkdf<T> {
+impl<T: HashEngine> fmt::Debug for Hkdf<T> {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         use crate::{sha256t, sha256t_tag};
 
@@ -141,7 +141,7 @@ mod tests {
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
         let info = Vec::from_hex("f0f1f2f3f4f5f6f7f8f9").unwrap();
 
-        let hkdf = Hkdf::<sha256::Hash>::new(&salt, &ikm);
+        let hkdf = Hkdf::<sha256::HashEngine>::new(&salt, &ikm);
         let mut okm = [0u8; 42];
         hkdf.expand(&info, &mut okm).unwrap();
 
@@ -163,7 +163,7 @@ mod tests {
             "b0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"
         ).unwrap();
 
-        let hkdf = Hkdf::<sha256::Hash>::new(&salt, &ikm);
+        let hkdf = Hkdf::<sha256::HashEngine>::new(&salt, &ikm);
         let mut okm = [0u8; 82];
         hkdf.expand(&info, &mut okm).unwrap();
 
@@ -179,7 +179,7 @@ mod tests {
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
         let info = Vec::from_hex("f0f1f2f3f4f5f6f7f8f9").unwrap();
 
-        let hkdf = Hkdf::<sha256::Hash>::new(&salt, &ikm);
+        let hkdf = Hkdf::<sha256::HashEngine>::new(&salt, &ikm);
         let mut okm = [0u8; 256 * 32];
         let e = hkdf.expand(&info, &mut okm);
 
@@ -192,7 +192,7 @@ mod tests {
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
         let info = Vec::from_hex("f0f1f2f3f4f5f6f7f8f9").unwrap();
 
-        let hkdf = Hkdf::<sha256::Hash>::new(&salt, &ikm);
+        let hkdf = Hkdf::<sha256::HashEngine>::new(&salt, &ikm);
         let mut okm = [0u8; 1];
         hkdf.expand(&info, &mut okm).unwrap();
 
@@ -205,7 +205,7 @@ mod tests {
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
         let info = Vec::from_hex("f0f1f2f3f4f5f6f7f8f9").unwrap();
 
-        let hkdf = Hkdf::<sha256::Hash>::new(&salt, &ikm);
+        let hkdf = Hkdf::<sha256::HashEngine>::new(&salt, &ikm);
         let okm = hkdf.expand_to_len(&info, 42).unwrap();
 
         assert_eq!(
@@ -219,7 +219,7 @@ mod tests {
         let salt = Vec::from_hex("000102030405060708090a0b0c").unwrap();
         let ikm = Vec::from_hex("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b").unwrap();
 
-        let hkdf = Hkdf::<sha256::Hash>::new(&salt, &ikm);
+        let hkdf = Hkdf::<sha256::HashEngine>::new(&salt, &ikm);
         let debug = alloc::format!("{:?}", hkdf);
 
         assert_eq!(debug, "Hkdf(#ec7bd36ab2ed4045)");
diff --git a/hashes/src/hmac/mod.rs b/hashes/src/hmac/mod.rs
index fa50389db9..2d70253fca 100644
--- a/hashes/src/hmac/mod.rs
+++ b/hashes/src/hmac/mod.rs
@@ -12,36 +12,26 @@ use core::{convert, fmt, str};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-use crate::{GeneralHash, Hash, HashEngine};
+use crate::{Hash, HashEngine};
 
 /// A hash computed from a RFC 2104 HMAC. Parameterized by the underlying hash function.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
-pub struct Hmac<T: GeneralHash>(T);
+pub struct Hmac<T: Hash>(T);
 
-impl<T: GeneralHash> Hmac<T> {
-    /// Constructs a new keyed HMAC engine from `key`.
-    pub fn engine(key: &[u8]) -> HmacEngine<T>
-    where
-        <T as GeneralHash>::Engine: Default,
-    {
-        HmacEngine::new(key)
-    }
-}
-
-impl<T: GeneralHash + str::FromStr> str::FromStr for Hmac<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 engines, used for the inner and outer hash of HMAC.
 #[derive(Debug, Clone)]
-pub struct HmacEngine<T: GeneralHash> {
-    iengine: T::Engine,
-    oengine: T::Engine,
+pub struct HmacEngine<T: HashEngine> {
+    iengine: T,
+    oengine: T,
 }
 
-impl<T: GeneralHash> HmacEngine<T> {
+impl<T: HashEngine> HmacEngine<T> {
     /// Constructs a new keyed HMAC engine from `key`.
     ///
     /// We only support underlying hashes whose block sizes are ≤ 128 bytes.
@@ -51,24 +41,23 @@ impl<T: GeneralHash> HmacEngine<T> {
     /// Larger hashes will result in a panic.
     pub fn new(key: &[u8]) -> HmacEngine<T>
     where
-        <T as GeneralHash>::Engine: Default,
+        T: Default,
     {
-        debug_assert!(T::Engine::BLOCK_SIZE <= 128);
+        debug_assert!(T::BLOCK_SIZE <= 128);
 
         let mut ipad = [0x36u8; 128];
         let mut opad = [0x5cu8; 128];
-        let mut ret = HmacEngine {
-            iengine: <T as GeneralHash>::engine(),
-            oengine: <T as GeneralHash>::engine(),
-        };
+        let mut ret = HmacEngine { iengine: T::default(), oengine: T::default() };
 
-        if key.len() > T::Engine::BLOCK_SIZE {
-            let hash = <T as GeneralHash>::hash(key);
-            let hash = hash.as_byte_array().as_ref();
-            for (b_i, b_h) in ipad.iter_mut().zip(hash) {
+        if key.len() > T::BLOCK_SIZE {
+            let mut engine = T::default();
+            engine.input(key);
+            let hash = engine.finalize();
+
+            for (b_i, b_h) in ipad.iter_mut().zip(hash.as_ref()) {
                 *b_i ^= *b_h;
             }
-            for (b_o, b_h) in opad.iter_mut().zip(hash) {
+            for (b_o, b_h) in opad.iter_mut().zip(hash.as_ref()) {
                 *b_o ^= *b_h;
             }
         } else {
@@ -80,55 +69,49 @@ impl<T: GeneralHash> HmacEngine<T> {
             }
         };
 
-        HashEngine::input(&mut ret.iengine, &ipad[..T::Engine::BLOCK_SIZE]);
-        HashEngine::input(&mut ret.oengine, &opad[..T::Engine::BLOCK_SIZE]);
+        ret.iengine.input(&ipad[..T::BLOCK_SIZE]);
+        ret.oengine.input(&opad[..T::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> {
+    pub fn from_inner_engines(iengine: T, oengine: T) -> HmacEngine<T> {
         HmacEngine { iengine, oengine }
     }
 }
 
-impl<T: GeneralHash> HashEngine for HmacEngine<T> {
-    type Hash = Hmac<T>;
-    const BLOCK_SIZE: usize = T::Engine::BLOCK_SIZE;
+impl<T: HashEngine> HashEngine for HmacEngine<T> {
+    type Hash = Hmac<T::Hash>;
+    type Bytes = T::Bytes;
+    const BLOCK_SIZE: usize = T::BLOCK_SIZE;
 
     fn n_bytes_hashed(&self) -> u64 { self.iengine.n_bytes_hashed() }
     fn input(&mut self, buf: &[u8]) { self.iengine.input(buf) }
-    fn finalize(self) -> Self::Hash { Hmac::from_engine(self) }
+    fn finalize(mut self) -> Self::Hash {
+        let ihash = self.iengine.finalize();
+        self.oengine.input(ihash.as_ref());
+        Hmac(self.oengine.finalize())
+    }
 }
 
-impl<T: GeneralHash + fmt::Debug> fmt::Debug for Hmac<T> {
+impl<T: Hash + fmt::Debug> fmt::Debug for Hmac<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(&self.0, f) }
 }
 
-impl<T: GeneralHash + fmt::Display> fmt::Display for Hmac<T> {
+impl<T: Hash + fmt::Display> fmt::Display for Hmac<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self.0, f) }
 }
 
-impl<T: GeneralHash + fmt::LowerHex> fmt::LowerHex for Hmac<T> {
+impl<T: Hash + fmt::LowerHex> fmt::LowerHex for Hmac<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::LowerHex::fmt(&self.0, f) }
 }
 
-impl<T: GeneralHash> convert::AsRef<[u8]> for Hmac<T> {
+impl<T: Hash> convert::AsRef<[u8]> for Hmac<T> {
     // Calling as_byte_array is more reliable
     fn as_ref(&self) -> &[u8] { self.0.as_byte_array().as_ref() }
 }
 
-impl<T: GeneralHash> GeneralHash for Hmac<T> {
-    type Engine = HmacEngine<T>;
-
-    fn from_engine(mut e: HmacEngine<T>) -> Hmac<T> {
-        let ihash = T::from_engine(e.iengine);
-        e.oengine.input(ihash.as_byte_array().as_ref());
-        let ohash = T::from_engine(e.oengine);
-        Hmac(ohash)
-    }
-}
-
-impl<T: GeneralHash> Hash for Hmac<T> {
+impl<T: Hash> Hash for Hmac<T> {
     type Bytes = T::Bytes;
 
     fn from_byte_array(bytes: T::Bytes) -> Self { Hmac(T::from_byte_array(bytes)) }
@@ -144,14 +127,14 @@ impl<T: GeneralHash> Hash for Hmac<T> {
 }
 
 #[cfg(feature = "serde")]
-impl<T: GeneralHash + Serialize> Serialize for Hmac<T> {
+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: GeneralHash + Deserialize<'de>> Deserialize<'de> for Hmac<T> {
+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))
@@ -166,14 +149,14 @@ crate::internal_macros::impl_write!(
         Ok(buf.len())
     },
     |_us| { Ok(()) },
-    T: crate::GeneralHash
+    T: crate::HashEngine
 );
 
 #[cfg(test)]
 mod tests {
     #[test]
     fn test() {
-        use crate::{sha256, GeneralHash as _, Hash as _, HashEngine, Hmac, HmacEngine};
+        use crate::{sha256, Hash as _, HashEngine, HmacEngine};
 
         #[derive(Clone)]
         struct Test {
@@ -288,9 +271,9 @@ mod tests {
         ];
 
         for test in tests {
-            let mut engine = HmacEngine::<sha256::Hash>::new(test.key);
+            let mut engine = HmacEngine::<sha256::HashEngine>::new(test.key);
             engine.input(test.input);
-            let hash = Hmac::<sha256::Hash>::from_engine(engine);
+            let hash = engine.finalize();
             assert_eq!(hash.as_ref(), test.output);
             assert_eq!(hash.to_byte_array(), test.output);
         }
@@ -331,11 +314,11 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{sha256, GeneralHash as _, HashEngine, Hmac};
+    use crate::{sha256, HashEngine as _, HmacEngine};
 
     #[bench]
     pub fn hmac_sha256_10(bh: &mut Bencher) {
-        let mut engine = Hmac::<sha256::Hash>::engine(&[]);
+        let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
         let bytes = [1u8; 10];
         bh.iter(|| {
             engine.input(&bytes);
@@ -345,7 +328,7 @@ mod benches {
 
     #[bench]
     pub fn hmac_sha256_1k(bh: &mut Bencher) {
-        let mut engine = Hmac::<sha256::Hash>::engine(&[]);
+        let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
         let bytes = [1u8; 1024];
         bh.iter(|| {
             engine.input(&bytes);
@@ -355,7 +338,7 @@ mod benches {
 
     #[bench]
     pub fn hmac_sha256_64k(bh: &mut Bencher) {
-        let mut engine = Hmac::<sha256::Hash>::engine(&[]);
+        let mut engine = HmacEngine::<sha256::HashEngine>::new(&[]);
         let bytes = [1u8; 65536];
         bh.iter(|| {
             engine.input(&bytes);
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 329273b949..4201b0ea0e 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -189,6 +189,12 @@ pub trait HashEngine: Clone {
     /// The `Hash` type returned when finalizing this engine.
     type Hash: Hash;
 
+    /// The byte array that is used internally in `finalize`.
+    type Bytes: Copy + IsByteArray;
+
+    /// Length of the hash, in bytes.
+    const LEN: usize = Self::Bytes::LEN;
+
     /// Length of the hash's internal block size, in bytes.
     const BLOCK_SIZE: usize;
 
diff --git a/hashes/src/ripemd160/mod.rs b/hashes/src/ripemd160/mod.rs
index c91dc8b683..d6ec93f9de 100644
--- a/hashes/src/ripemd160/mod.rs
+++ b/hashes/src/ripemd160/mod.rs
@@ -88,6 +88,7 @@ impl Default for HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 20];
     const BLOCK_SIZE: usize = 64;
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
diff --git a/hashes/src/sha1/mod.rs b/hashes/src/sha1/mod.rs
index 6abbf0a9c9..18f620253b 100644
--- a/hashes/src/sha1/mod.rs
+++ b/hashes/src/sha1/mod.rs
@@ -80,6 +80,7 @@ impl Default for HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 20];
     const BLOCK_SIZE: usize = 64;
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
diff --git a/hashes/src/sha256/mod.rs b/hashes/src/sha256/mod.rs
index fd40401bdc..323e4de8f7 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -129,6 +129,7 @@ impl Default for HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 32];
     const BLOCK_SIZE: usize = 64;
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
diff --git a/hashes/src/sha256d/mod.rs b/hashes/src/sha256d/mod.rs
index 3137608526..69bb8a72a3 100644
--- a/hashes/src/sha256d/mod.rs
+++ b/hashes/src/sha256d/mod.rs
@@ -34,6 +34,7 @@ impl Default for HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 32];
     const BLOCK_SIZE: usize = 64; // Same as sha256::HashEngine::BLOCK_SIZE;
 
     fn input(&mut self, data: &[u8]) { self.0.input(data) }
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 7b58bc9918..11e2240580 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -134,6 +134,7 @@ impl<T: Tag> Clone for HashEngine<T> {
 
 impl<T: Tag> crate::HashEngine for HashEngine<T> {
     type Hash = Hash<T>;
+    type Bytes = [u8; 32];
     const BLOCK_SIZE: usize = 64; // Same as sha256::HashEngine::BLOCK_SIZE;
 
     fn input(&mut self, data: &[u8]) { self.0.input(data) }
diff --git a/hashes/src/sha384/mod.rs b/hashes/src/sha384/mod.rs
index 9918afa2f4..3d6538af08 100644
--- a/hashes/src/sha384/mod.rs
+++ b/hashes/src/sha384/mod.rs
@@ -31,6 +31,7 @@ impl Default for HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 48];
     const BLOCK_SIZE: usize = sha512::BLOCK_SIZE;
 
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
diff --git a/hashes/src/sha512/mod.rs b/hashes/src/sha512/mod.rs
index 617f34cd8e..0256cde212 100644
--- a/hashes/src/sha512/mod.rs
+++ b/hashes/src/sha512/mod.rs
@@ -121,6 +121,7 @@ impl HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 64];
     const BLOCK_SIZE: usize = 128;
 
     fn n_bytes_hashed(&self) -> u64 { self.bytes_hashed }
diff --git a/hashes/src/sha512_256/mod.rs b/hashes/src/sha512_256/mod.rs
index 04e6d9be39..cf12d46047 100644
--- a/hashes/src/sha512_256/mod.rs
+++ b/hashes/src/sha512_256/mod.rs
@@ -41,6 +41,7 @@ impl Default for HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 64];
     const BLOCK_SIZE: usize = sha512::BLOCK_SIZE;
 
     fn n_bytes_hashed(&self) -> u64 { self.0.n_bytes_hashed() }
diff --git a/hashes/src/siphash24/mod.rs b/hashes/src/siphash24/mod.rs
index 4f8de24ff1..50abe8575c 100644
--- a/hashes/src/siphash24/mod.rs
+++ b/hashes/src/siphash24/mod.rs
@@ -122,6 +122,7 @@ impl HashEngine {
 
 impl crate::HashEngine for HashEngine {
     type Hash = Hash;
+    type Bytes = [u8; 8];
     const BLOCK_SIZE: usize = 8;
 
     #[inline]
diff --git a/hashes/tests/regression.rs b/hashes/tests/regression.rs
index 2bacd7ff2b..31aeec5f80 100644
--- a/hashes/tests/regression.rs
+++ b/hashes/tests/regression.rs
@@ -8,7 +8,7 @@
 
 use bitcoin_hashes::{
     hash160, ripemd160, sha1, sha256, sha256d, sha256t, sha384, sha512, sha512_256, siphash24,
-    GeneralHash as _, HashEngine as _, Hmac, HmacEngine,
+    HashEngine as _, HmacEngine,
 };
 
 const DATA: &str = "arbitrary data to hash as a regression test";
@@ -57,9 +57,9 @@ fn regression_sha256t() {
 
 #[test]
 fn regression_hmac_sha256_with_key() {
-    let mut engine = HmacEngine::<sha256::Hash>::new(HMAC_KEY);
+    let mut engine = HmacEngine::<sha256::HashEngine>::new(HMAC_KEY);
     engine.input(DATA.as_bytes());
-    let hash = Hmac::from_engine(engine);
+    let hash = engine.finalize();
 
     let got = format!("{}", hash);
     let want = "d159cecaf4adf90b6a641bab767e4817d3a51c414acea3682686c35ec0b37b52";
@@ -68,9 +68,9 @@ fn regression_hmac_sha256_with_key() {
 
 #[test]
 fn regression_hmac_sha512_with_key() {
-    let mut engine = HmacEngine::<sha512::Hash>::new(HMAC_KEY);
+    let mut engine = HmacEngine::<sha512::HashEngine>::new(HMAC_KEY);
     engine.input(DATA.as_bytes());
-    let hash = Hmac::from_engine(engine);
+    let hash = engine.finalize();
 
     let got = format!("{}", hash);
     let want = "8511773748f89ba22c07fb3a2981a12c1823695119de41f4a62aead6b848bd34939acf16475c35ed7956114fead3e794cc162ecd35e447a4dabc3227d55f757b";
diff --git a/io/src/hash.rs b/io/src/hash.rs
index a6a364e945..6a311b8fde 100644
--- a/io/src/hash.rs
+++ b/io/src/hash.rs
@@ -128,7 +128,7 @@ impl_write!(
         Ok(buf.len())
     },
     |_us| { Ok(()) },
-    T: hashes::GeneralHash
+    T: hashes::HashEngine
 );
 
 /// Hashes data from a reader.
@@ -172,7 +172,7 @@ mod sealed {
 mod tests {
     use alloc::format;
 
-    use hashes::{hmac, Hmac};
+    use hashes::hmac;
 
     use super::*;
     use crate::{Cursor, Write as _};
@@ -257,24 +257,24 @@ mod tests {
 
     #[test]
     fn hmac() {
-        let mut engine = hmac::HmacEngine::<sha256::Hash>::new(&[0xde, 0xad, 0xbe, 0xef]);
+        let mut engine = hmac::HmacEngine::<sha256::HashEngine>::new(&[0xde, 0xad, 0xbe, 0xef]);
         engine.write_all(&[]).unwrap();
         assert_eq!(
-            format!("{}", hmac::Hmac::from_engine(engine)),
+            format!("{}", engine.finalize()),
             "bf5515149cf797955c4d3194cca42472883281951697c8375d9d9b107f384225"
         );
 
-        let mut engine = hmac::HmacEngine::<sha256::Hash>::new(&[0xde, 0xad, 0xbe, 0xef]);
+        let mut engine = hmac::HmacEngine::<sha256::HashEngine>::new(&[0xde, 0xad, 0xbe, 0xef]);
         engine.write_all(&[1; 256]).unwrap();
         assert_eq!(
-            format!("{}", hmac::Hmac::from_engine(engine)),
+            format!("{}", engine.finalize()),
             "59c9aca10c81c73cb4c196d94db741b6bf2050e0153d5a45f2526bff34675ac5"
         );
 
-        let mut engine = hmac::HmacEngine::<sha256::Hash>::new(&[0xde, 0xad, 0xbe, 0xef]);
+        let mut engine = hmac::HmacEngine::<sha256::HashEngine>::new(&[0xde, 0xad, 0xbe, 0xef]);
         engine.write_all(&[99; 64000]).unwrap();
         assert_eq!(
-            format!("{}", hmac::Hmac::from_engine(engine)),
+            format!("{}", engine.finalize()),
             "30df499717415a395379a1eaabe50038036e4abb5afc94aa55c952f4aa57be08"
         );
     }
@@ -345,9 +345,9 @@ mod tests {
 
     #[test]
     fn regression_hmac_sha256_with_key() {
-        let mut engine = HmacEngine::<sha256::Hash>::new(HMAC_KEY);
+        let mut engine = HmacEngine::<sha256::HashEngine>::new(HMAC_KEY);
         engine.input(DATA.as_bytes());
-        let hash = Hmac::from_engine(engine);
+        let hash = engine.finalize();
 
         let got = format!("{}", hash);
         let want = "d159cecaf4adf90b6a641bab767e4817d3a51c414acea3682686c35ec0b37b52";
@@ -356,9 +356,9 @@ mod tests {
 
     #[test]
     fn regression_hmac_sha512_with_key() {
-        let mut engine = HmacEngine::<sha512::Hash>::new(HMAC_KEY);
+        let mut engine = HmacEngine::<sha512::HashEngine>::new(HMAC_KEY);
         engine.input(DATA.as_bytes());
-        let hash = Hmac::from_engine(engine);
+        let hash = engine.finalize();
 
         let got = format!("{}", hash);
         let want = "8511773748f89ba22c07fb3a2981a12c1823695119de41f4a62aead6b848bd34939acf16475c35ed7956114fead3e794cc162ecd35e447a4dabc3227d55f757b";

From d3846895d790e4782795afc4b83130bc7d73de7d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Feb 2025 13:20:12 +1100
Subject: [PATCH 478/554] hashes: Add hash function to modules

Add a standalone `hash` function that is a drop in replacement for
`GeneralHash::hash`. Do not add it to `hmac` - this is in parity with
the current code because `Hmac` does not implement `GeneralHash::hash`.

Use the new function in `bitcoin` removing all occurrences of
`GeneralHash` from `bitcoin`.

In `hashes` replace usage of `GeneralHash::hash` with the new `hash`
function.
---
 bitcoin/src/consensus/encode.rs |  4 ++--
 bitcoin/src/psbt/macros.rs      |  6 +++---
 bitcoin/src/psbt/map/input.rs   |  8 ++++----
 hashes/src/internal_macros.rs   | 11 ++++++++++-
 hashes/src/sha256/mod.rs        |  4 +---
 hashes/src/sha256t/mod.rs       | 12 ++++++++++++
 6 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/bitcoin/src/consensus/encode.rs b/bitcoin/src/consensus/encode.rs
index e2946b16b6..a8637c2c6f 100644
--- a/bitcoin/src/consensus/encode.rs
+++ b/bitcoin/src/consensus/encode.rs
@@ -16,7 +16,7 @@
 
 use core::mem;
 
-use hashes::{sha256, sha256d, GeneralHash, Hash};
+use hashes::{sha256, sha256d, Hash};
 use hex::DisplayHex as _;
 use internals::{compact_size, ToU64};
 use io::{BufRead, Cursor, Read, Write};
@@ -629,7 +629,7 @@ impl Decodable for Box<[u8]> {
 
 /// Does a double-SHA256 on `data` and returns the first 4 bytes.
 fn sha2_checksum(data: &[u8]) -> [u8; 4] {
-    let checksum = <sha256d::Hash as GeneralHash>::hash(data);
+    let checksum = sha256d::hash(data);
     let checksum = checksum.to_byte_array();
     [checksum[0], checksum[1], checksum[2], checksum[3]]
 }
diff --git a/bitcoin/src/psbt/macros.rs b/bitcoin/src/psbt/macros.rs
index 089d705b48..4044a5e527 100644
--- a/bitcoin/src/psbt/macros.rs
+++ b/bitcoin/src/psbt/macros.rs
@@ -113,15 +113,15 @@ macro_rules! impl_psbt_insert_pair {
 
 #[rustfmt::skip]
 macro_rules! psbt_insert_hash_pair {
-    (&mut $slf:ident.$map:ident <= $raw_key:ident|$raw_value:ident|$hash:path|$hash_type_error:path) => {
+    (&mut $slf:ident.$map:ident <= $raw_key:ident|$raw_value:ident|$hash:ident|$hash_type_error:path) => {
         if $raw_key.key_data.is_empty() {
             return Err($crate::psbt::Error::InvalidKey($raw_key));
         }
-        let key_val: $hash = Deserialize::deserialize(&$raw_key.key_data)?;
+        let key_val: $hash::Hash = Deserialize::deserialize(&$raw_key.key_data)?;
         match $slf.$map.entry(key_val) {
             btree_map::Entry::Vacant(empty_key) => {
                 let val: Vec<u8> = Deserialize::deserialize(&$raw_value)?;
-                if <$hash as hashes::GeneralHash>::hash(&val) != key_val {
+                if $hash::hash(&val) != key_val {
                     return Err($crate::psbt::Error::InvalidPreimageHashPair {
                         preimage: val.into_boxed_slice(),
                         hash: Box::from(key_val.borrow()),
diff --git a/bitcoin/src/psbt/map/input.rs b/bitcoin/src/psbt/map/input.rs
index 401bc34b4a..66802623b1 100644
--- a/bitcoin/src/psbt/map/input.rs
+++ b/bitcoin/src/psbt/map/input.rs
@@ -317,22 +317,22 @@ impl Input {
             }
             PSBT_IN_RIPEMD160 => {
                 psbt_insert_hash_pair! {
-                    &mut self.ripemd160_preimages <= raw_key|raw_value|ripemd160::Hash|error::PsbtHash::Ripemd
+                    &mut self.ripemd160_preimages <= raw_key|raw_value|ripemd160|error::PsbtHash::Ripemd
                 }
             }
             PSBT_IN_SHA256 => {
                 psbt_insert_hash_pair! {
-                    &mut self.sha256_preimages <= raw_key|raw_value|sha256::Hash|error::PsbtHash::Sha256
+                    &mut self.sha256_preimages <= raw_key|raw_value|sha256|error::PsbtHash::Sha256
                 }
             }
             PSBT_IN_HASH160 => {
                 psbt_insert_hash_pair! {
-                    &mut self.hash160_preimages <= raw_key|raw_value|hash160::Hash|error::PsbtHash::Hash160
+                    &mut self.hash160_preimages <= raw_key|raw_value|hash160|error::PsbtHash::Hash160
                 }
             }
             PSBT_IN_HASH256 => {
                 psbt_insert_hash_pair! {
-                    &mut self.hash256_preimages <= raw_key|raw_value|sha256d::Hash|error::PsbtHash::Hash256
+                    &mut self.hash256_preimages <= raw_key|raw_value|sha256d|error::PsbtHash::Hash256
                 }
             }
             PSBT_IN_TAP_KEY_SIG => {
diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index fe5d6aa713..41ffab5937 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -71,6 +71,15 @@ pub(crate) use hash_trait_impls;
 /// [`hash_trait_impls`].
 macro_rules! general_hash_type {
     ($bits:expr, $reverse:expr, $doc:literal) => {
+        /// Hashes some bytes.
+        pub fn hash(data: &[u8]) -> Hash {
+            use crate::HashEngine as _;
+
+            let mut engine = Hash::engine();
+            engine.input(data);
+            engine.finalize()
+        }
+
         $crate::internal_macros::hash_type_no_default!($bits, $reverse, $doc);
 
         impl Hash {
@@ -82,7 +91,7 @@ macro_rules! general_hash_type {
 
             /// Hashes some bytes.
             #[allow(clippy::self_named_constructors)] // Hash is a noun and a verb.
-            pub fn hash(data: &[u8]) -> Self { <Self as $crate::GeneralHash>::hash(data) }
+            pub fn hash(data: &[u8]) -> Self { hash(data) }
 
             /// Hashes all the byte slices retrieved from the iterator together.
             pub fn hash_byte_chunks<B, I>(byte_slices: I) -> Self
diff --git a/hashes/src/sha256/mod.rs b/hashes/src/sha256/mod.rs
index 323e4de8f7..5d8fe125b2 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -140,9 +140,7 @@ impl crate::HashEngine for HashEngine {
 impl Hash {
     /// Iterate the sha256 algorithm to turn a sha256 hash into a sha256d hash
     #[must_use]
-    pub fn hash_again(&self) -> sha256d::Hash {
-        crate::Hash::from_byte_array(<Self as crate::GeneralHash>::hash(&self.0).0)
-    }
+    pub fn hash_again(&self) -> sha256d::Hash { sha256d::Hash::from_byte_array(hash(&self.0).0) }
 
     /// Computes hash from `bytes` in `const` context.
     ///
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index 11e2240580..be144f2f27 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -9,6 +9,18 @@ use core::marker::PhantomData;
 use crate::sha256::Midstate;
 use crate::{sha256, HashEngine as _};
 
+/// Hashes some bytes.
+pub fn hash<T>(data: &[u8]) -> Hash<T>
+where
+    T: Tag,
+{
+    use crate::HashEngine as _;
+
+    let mut engine = HashEngine::default();
+    engine.input(data);
+    engine.finalize()
+}
+
 /// Trait representing a tag that can be used as a context for SHA256t hashes.
 pub trait Tag {
     /// The [`Midstate`] after pre-tagging the hash engine.

From 2b6ef31469edd93d59655afa41f3130f3ab058ba Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Feb 2025 13:53:47 +1100
Subject: [PATCH 479/554] hashes: Add hash_byte_chunks function to modules

 Add a standalone `hash_byte_chunks` function that is a drop in
 replacement for `GeneralHash::hash_byte_chunks`. Do not add it to
 `hmac` - this is in parity with the current code because `Hmac` does
 not implement `GeneralHash::hash_byte_chunks`.
---
 hashes/src/internal_macros.rs | 17 ++++++++++++++++-
 hashes/src/sha256t/mod.rs     | 16 ++++++++++++++++
 2 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index 41ffab5937..fee359a9e4 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -80,6 +80,21 @@ macro_rules! general_hash_type {
             engine.finalize()
         }
 
+        /// Hashes all the byte slices retrieved from the iterator together.
+        pub fn hash_byte_chunks<B, I>(byte_slices: I) -> Hash
+        where
+            B: AsRef<[u8]>,
+            I: IntoIterator<Item = B>,
+        {
+            use crate::HashEngine as _;
+
+            let mut engine = Hash::engine();
+            for slice in byte_slices {
+                engine.input(slice.as_ref());
+            }
+            engine.finalize()
+        }
+
         $crate::internal_macros::hash_type_no_default!($bits, $reverse, $doc);
 
         impl Hash {
@@ -99,7 +114,7 @@ macro_rules! general_hash_type {
                 B: AsRef<[u8]>,
                 I: IntoIterator<Item = B>,
             {
-                <Self as $crate::GeneralHash>::hash_byte_chunks(byte_slices)
+                hash_byte_chunks(byte_slices)
             }
         }
     };
diff --git a/hashes/src/sha256t/mod.rs b/hashes/src/sha256t/mod.rs
index be144f2f27..d5acd5edfd 100644
--- a/hashes/src/sha256t/mod.rs
+++ b/hashes/src/sha256t/mod.rs
@@ -21,6 +21,22 @@ where
     engine.finalize()
 }
 
+/// Hashes all the byte slices retrieved from the iterator together.
+pub fn hash_byte_chunks<B, I, T>(byte_slices: I) -> Hash<T>
+where
+    B: AsRef<[u8]>,
+    I: IntoIterator<Item = B>,
+    T: Tag,
+{
+    use crate::HashEngine as _;
+
+    let mut engine = HashEngine::default();
+    for slice in byte_slices {
+        engine.input(slice.as_ref());
+    }
+    engine.finalize()
+}
+
 /// Trait representing a tag that can be used as a context for SHA256t hashes.
 pub trait Tag {
     /// The [`Midstate`] after pre-tagging the hash engine.

From 791501eabc4ba000d194301e816aa27f8cc6be5d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Feb 2025 13:29:05 +1100
Subject: [PATCH 480/554] io: Use function in place of GeneralHashExt

We would like to remove the `GeneralHash` trait but we want to keep the
`hash_reader` functionality.

Add a stand alone function (when `hashes` is enabled) `hash_reader`.
Remove the extension trait.
---
 io/src/hash.rs | 53 +++++++++++++++++++-------------------------------
 io/src/lib.rs  |  2 +-
 2 files changed, 21 insertions(+), 34 deletions(-)

diff --git a/io/src/hash.rs b/io/src/hash.rs
index 6a311b8fde..859f035b73 100644
--- a/io/src/hash.rs
+++ b/io/src/hash.rs
@@ -10,9 +10,11 @@
 use hashes::hmac::HmacEngine;
 use hashes::{
     hash160, ripemd160, sha1, sha256, sha256d, sha256t, sha384, sha512, sha512_256, siphash24,
-    GeneralHash, HashEngine as _,
+    HashEngine as _,
 };
 
+use crate::BufRead;
+
 macro_rules! impl_write {
     ($ty: ty, $write_fn: expr, $flush_fn: expr $(, $bounded_ty: ident : $bounds: path),*) => {
         // `std::io::Write` is implemented in `bitcoin_hashes` because of the orphan rule.
@@ -132,39 +134,24 @@ impl_write!(
 );
 
 /// Hashes data from a reader.
-///
-/// Adds functionality to a [`hashes::GeneralHash`] type to support hashing data read from a
-/// buffered reader.
-pub trait GeneralHashExt: GeneralHash + sealed::Sealed {
-    /// Hashes the entire contents of the `reader`.
-    fn hash_reader<R: crate::BufRead>(reader: &mut R) -> Result<Self, crate::Error>
-    where
-        Self::Engine: Default,
-    {
-        let mut engine = Self::engine(); // This calls `Self::Engine::default()`.
-        loop {
-            let bytes = reader.fill_buf()?;
-
-            let read = bytes.len();
-            // Empty slice means EOF.
-            if read == 0 {
-                break;
-            }
-
-            engine.input(bytes);
-            reader.consume(read);
+pub fn hash_reader<T>(reader: &mut impl BufRead) -> Result<T::Hash, crate::Error>
+where
+    T: hashes::HashEngine + Default,
+{
+    let mut engine = T::default();
+    loop {
+        let bytes = reader.fill_buf()?;
+
+        let read = bytes.len();
+        // Empty slice means EOF.
+        if read == 0 {
+            break;
         }
-        Ok(Self::from_engine(engine))
-    }
-}
-
-impl<T: GeneralHash> GeneralHashExt for T {}
 
-mod sealed {
-    /// Used to seal the `GeneralHashExt` trait.
-    pub trait Sealed {}
-
-    impl<T: hashes::GeneralHash> Sealed for T {}
+        engine.input(bytes);
+        reader.consume(read);
+    }
+    Ok(engine.finalize())
 }
 
 #[cfg(test)]
@@ -308,7 +295,7 @@ mod tests {
                     assert_eq!(got, $want);
 
                     let mut reader = Cursor::new(DATA);
-                    let hash_from_reader = $module::Hash::hash_reader(&mut reader).unwrap();
+                    let hash_from_reader = $crate::hash_reader::<$module::HashEngine>(&mut reader).unwrap();
                     assert_eq!(hash_from_reader, hash)
                 }
             )*
diff --git a/io/src/lib.rs b/io/src/lib.rs
index 0b7ee50939..8da2d108dc 100644
--- a/io/src/lib.rs
+++ b/io/src/lib.rs
@@ -46,7 +46,7 @@ pub use bridge::{FromStd, ToStd};
 #[rustfmt::skip]                // Keep public re-exports separate.
 pub use self::error::{Error, ErrorKind};
 #[cfg(feature = "hashes")]
-pub use self::hash::GeneralHashExt;
+pub use self::hash::hash_reader;
 
 /// Result type returned by functions in this crate.
 pub type Result<T> = core::result::Result<T, Error>;

From 6426e59c63074fa48a6508ef6687199b46143d44 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Feb 2025 13:47:51 +1100
Subject: [PATCH 481/554] Remove unused trait import

This import is not needed. Interesting that the linter does not catch
it.
---
 hashes/src/hash160/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hashes/src/hash160/mod.rs b/hashes/src/hash160/mod.rs
index bf03d1d1f1..3c457c1aac 100644
--- a/hashes/src/hash160/mod.rs
+++ b/hashes/src/hash160/mod.rs
@@ -132,7 +132,7 @@ mod tests {
 mod benches {
     use test::Bencher;
 
-    use crate::{hash160, GeneralHash as _, Hash as _, HashEngine};
+    use crate::{hash160, Hash as _, HashEngine};
 
     #[bench]
     pub fn hash160_10(bh: &mut Bencher) {

From 95ad91cdb64c8870d3eb992090bab7a70d1369b9 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Feb 2025 13:57:27 +1100
Subject: [PATCH 482/554] hashes: Remove the GeneralHash trait

Now that we are able to unambiguously go from a hash engine to its
associated hash type there is no longer any need for the `GeneralHash`
trait.

Please note that IMO this concept of a general hash type as opposed to
one where one can hash arbitrary data still exists in the codebase - it
is implicitly in the `hash_newtype` macro.

Remove the `GeneralHash` trait.
---
 hashes/src/internal_macros.rs |  6 -----
 hashes/src/lib.rs             | 46 -----------------------------------
 2 files changed, 52 deletions(-)

diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
index fee359a9e4..5e9599322a 100644
--- a/hashes/src/internal_macros.rs
+++ b/hashes/src/internal_macros.rs
@@ -26,12 +26,6 @@ macro_rules! hash_trait_impls {
         #[cfg(not(feature = "hex"))]
         $crate::impl_debug_only!(Hash, { $bits / 8 }, $reverse $(, $gen: $gent)*);
 
-        impl<$($gen: $gent),*> $crate::GeneralHash for Hash<$($gen),*> {
-            type Engine = HashEngine<$($gen),*>;
-
-            fn from_engine(e: Self::Engine) -> Hash<$($gen),*> { Self::from_engine(e) }
-        }
-
         #[cfg(feature = "serde")]
         $crate::serde_impl!(Hash, { $bits / 8} $(, $gen: $gent)*);
 
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
index 4201b0ea0e..b3962214ca 100644
--- a/hashes/src/lib.rs
+++ b/hashes/src/lib.rs
@@ -208,52 +208,6 @@ pub trait HashEngine: Clone {
     fn finalize(self) -> Self::Hash;
 }
 
-/// Trait describing hash digests which can be constructed by hashing arbitrary data.
-///
-/// Some methods have been bound to engines which implement Default, which is
-/// generally an unkeyed hash function.
-pub trait GeneralHash: Hash {
-    /// 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;
-
-    /// Constructs a new engine.
-    fn engine() -> Self::Engine
-    where
-        Self::Engine: Default,
-    {
-        Self::Engine::default()
-    }
-
-    /// Produces a hash from the current state of a given engine.
-    fn from_engine(e: Self::Engine) -> Self;
-
-    /// Hashes some bytes.
-    fn hash(data: &[u8]) -> Self
-    where
-        Self::Engine: Default,
-    {
-        let mut engine = Self::engine();
-        engine.input(data);
-        Self::from_engine(engine)
-    }
-
-    /// Hashes all the byte slices retrieved from the iterator together.
-    fn hash_byte_chunks<B, I>(byte_slices: I) -> Self
-    where
-        B: AsRef<[u8]>,
-        I: IntoIterator<Item = B>,
-        Self::Engine: Default,
-    {
-        let mut engine = Self::engine();
-        for slice in byte_slices {
-            engine.input(slice.as_ref());
-        }
-        Self::from_engine(engine)
-    }
-}
-
 /// Trait which applies to hashes of all types.
 pub trait Hash:
     Copy + Clone + PartialEq + Eq + PartialOrd + Ord + hash::Hash + convert::AsRef<[u8]>

From ae0ba6c1356505697fc5e841741ac488538e3407 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Tue, 4 Mar 2025 22:49:28 +0700
Subject: [PATCH 483/554] Take spent closure by value in count_witness_sigops
 and count_p2sh_sigops

This fixes issue #4141
Change count_witness_sigops and count_p2sh_sigops to take the spent
closure by value instead of &mut

- Changed both functions to accept S as a value (FnMut) instead of &mut S
- Removes need to annotate &mut when calling the function
---
 bitcoin/src/blockdata/transaction.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 9a3707d5d8..e1401eb725 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -414,7 +414,7 @@ impl TransactionExt for Transaction {
 
         // 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))
+        cost.saturating_add(self.count_witness_sigops(spent))
     }
 
     #[inline]
@@ -453,12 +453,12 @@ trait TransactionExtPriv {
     fn count_p2pk_p2pkh_sigops(&self) -> usize;
 
     /// Does not include wrapped SegWit (see `count_witness_sigops`).
-    fn count_p2sh_sigops<S>(&self, spent: &mut S) -> usize
+    fn count_p2sh_sigops<S>(&self, spent: S) -> usize
     where
         S: FnMut(&OutPoint) -> Option<TxOut>;
 
     /// Includes wrapped SegWit (returns 0 for Taproot spends).
-    fn count_witness_sigops<S>(&self, spent: &mut S) -> usize
+    fn count_witness_sigops<S>(&self, spent: S) -> usize
     where
         S: FnMut(&OutPoint) -> Option<TxOut>;
 
@@ -481,7 +481,7 @@ impl TransactionExtPriv for Transaction {
     }
 
     /// Does not include wrapped SegWit (see `count_witness_sigops`).
-    fn count_p2sh_sigops<S>(&self, spent: &mut S) -> usize
+    fn count_p2sh_sigops<S>(&self, mut spent: S) -> usize
     where
         S: FnMut(&OutPoint) -> Option<TxOut>,
     {
@@ -506,7 +506,7 @@ impl TransactionExtPriv for Transaction {
     }
 
     /// Includes wrapped SegWit (returns 0 for Taproot spends).
-    fn count_witness_sigops<S>(&self, spent: &mut S) -> usize
+    fn count_witness_sigops<S>(&self, mut spent: S) -> usize
     where
         S: FnMut(&OutPoint) -> Option<TxOut>,
     {

From a01370052715b6733f07011f28944105493bda63 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Tue, 4 Mar 2025 11:02:18 +0100
Subject: [PATCH 484/554] Replace uses of `chunks_exact` with `as_chunks`

In the past we've been using `chunks_exact` because const generics were
unstable but then, when they were stabilized we didn't use `as_chunks`
(or `array_chunks`) since they were unstable. But the instability was
only because Rust devs don't know how to handle `0` being passed in. The
function is perfectly implementable on stable. (With a tiny,
easy-to-understand `unsafe` block.) `core` doesn't want to make a
decision for all other crates yet but we can make it for our own crates
because we know that we simply never pass zero. (And even if we did, we
could just change the decision.)

It also turns out there's a hack to simulate `const {}` block in our
MSRV, so we can make compilation fail early.

This commit adds an extension trait to internals to provide the methods,
so we no longer have to use `chunks_exact`. It also cleans up the code
quite nicely.
---
 Cargo-minimal.lock                   |   1 +
 Cargo-recent.lock                    |   1 +
 bitcoin/src/taproot/merkle_branch.rs |  17 ++--
 hashes/Cargo.toml                    |   2 +-
 hashes/src/ripemd160/crypto.rs       |   5 +-
 hashes/src/ripemd160/mod.rs          |   6 +-
 hashes/src/sha1/crypto.rs            |   5 +-
 hashes/src/sha1/mod.rs               |   6 +-
 hashes/src/sha256/crypto.rs          |   5 +-
 hashes/src/sha256/mod.rs             |   9 ++-
 hashes/src/sha512/crypto.rs          |   5 +-
 hashes/src/sha512/mod.rs             |   6 +-
 internals/src/lib.rs                 |   1 +
 internals/src/slice.rs               | 117 +++++++++++++++++++++++++++
 14 files changed, 158 insertions(+), 28 deletions(-)
 create mode 100644 internals/src/slice.rs

diff --git a/Cargo-minimal.lock b/Cargo-minimal.lock
index 83c663c9cd..f1b5097fa9 100644
--- a/Cargo-minimal.lock
+++ b/Cargo-minimal.lock
@@ -146,6 +146,7 @@ dependencies = [
 name = "bitcoin_hashes"
 version = "0.16.0"
 dependencies = [
+ "bitcoin-internals",
  "hex-conservative 0.3.0",
  "serde",
  "serde_json",
diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index bb8ec5132d..558ade0a89 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -145,6 +145,7 @@ dependencies = [
 name = "bitcoin_hashes"
 version = "0.16.0"
 dependencies = [
+ "bitcoin-internals",
  "hex-conservative 0.3.0",
  "serde",
  "serde_json",
diff --git a/bitcoin/src/taproot/merkle_branch.rs b/bitcoin/src/taproot/merkle_branch.rs
index 10b2d0718c..33f0330fc4 100644
--- a/bitcoin/src/taproot/merkle_branch.rs
+++ b/bitcoin/src/taproot/merkle_branch.rs
@@ -45,18 +45,17 @@ impl TaprootMerkleBranch {
     /// The function returns an error if 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 {
+        use internals::slice::SliceExt;
+        let (node_hashes, remainder) = sl.bitcoin_as_chunks::<TAPROOT_CONTROL_NODE_SIZE>();
+        if !remainder.is_empty() {
             Err(InvalidMerkleBranchSizeError(sl.len()).into())
-        } else if sl.len() > TAPROOT_CONTROL_NODE_SIZE * TAPROOT_CONTROL_MAX_NODE_COUNT {
+        } else if node_hashes.len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
             Err(InvalidMerkleTreeDepthError(sl.len() / TAPROOT_CONTROL_NODE_SIZE).into())
         } else {
-            let inner = sl
-                .chunks_exact(TAPROOT_CONTROL_NODE_SIZE)
-                .map(|chunk| {
-                    let bytes = <[u8; 32]>::try_from(chunk)
-                        .expect("chunks_exact always returns the correct size");
-                    TapNodeHash::from_byte_array(bytes)
-                })
+            let inner = node_hashes
+                .iter()
+                .copied()
+                .map(TapNodeHash::from_byte_array)
                 .collect();
 
             Ok(TaprootMerkleBranch(inner))
diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
index 25e213790d..3e020d4b9a 100644
--- a/hashes/Cargo.toml
+++ b/hashes/Cargo.toml
@@ -22,7 +22,7 @@ serde = ["dep:serde", "hex"]
 small-hash = []
 
 [dependencies]
-
+internals = { package = "bitcoin-internals", version = "0.4.0" }
 hex = { package = "hex-conservative", version = "0.3.0", default-features = false, optional = true }
 serde = { version = "1.0", default-features = false, optional = true }
 
diff --git a/hashes/src/ripemd160/crypto.rs b/hashes/src/ripemd160/crypto.rs
index 4c62268929..178a2f441c 100644
--- a/hashes/src/ripemd160/crypto.rs
+++ b/hashes/src/ripemd160/crypto.rs
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
+use internals::slice::SliceExt;
 use super::{HashEngine, BLOCK_SIZE};
 
 #[cfg(feature = "small-hash")]
@@ -132,8 +133,8 @@ impl HashEngine {
         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"))
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.bitcoin_as_chunks().0) {
+            *w_val = u32::from_le_bytes(*buff_bytes)
         }
 
         process_block!(self.h, w,
diff --git a/hashes/src/ripemd160/mod.rs b/hashes/src/ripemd160/mod.rs
index e6be175370..c69b8ec39b 100644
--- a/hashes/src/ripemd160/mod.rs
+++ b/hashes/src/ripemd160/mod.rs
@@ -2,6 +2,8 @@
 
 //! RIPEMD160 implementation.
 
+use internals::slice::SliceExt;
+
 #[cfg(bench)]
 mod benches;
 mod crypto;
@@ -68,8 +70,8 @@ impl HashEngine {
     #[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());
+        for (val, ret_bytes) in self.h.iter().zip(ret.bitcoin_as_chunks_mut().0) {
+            *ret_bytes = val.to_le_bytes();
         }
         ret
     }
diff --git a/hashes/src/sha1/crypto.rs b/hashes/src/sha1/crypto.rs
index 6f8a3fd8a7..9076c91095 100644
--- a/hashes/src/sha1/crypto.rs
+++ b/hashes/src/sha1/crypto.rs
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
+use internals::slice::SliceExt;
 use super::{HashEngine, BLOCK_SIZE};
 
 impl HashEngine {
@@ -8,8 +9,8 @@ impl HashEngine {
         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 (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.bitcoin_as_chunks().0) {
+            *w_val = u32::from_be_bytes(*buff_bytes)
         }
         for i in 16..80 {
             w[i] = (w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]).rotate_left(1);
diff --git a/hashes/src/sha1/mod.rs b/hashes/src/sha1/mod.rs
index dc32d31dd1..420cc4602d 100644
--- a/hashes/src/sha1/mod.rs
+++ b/hashes/src/sha1/mod.rs
@@ -2,6 +2,8 @@
 
 //! SHA1 implementation.
 
+use internals::slice::SliceExt;
+
 #[cfg(bench)]
 mod benches;
 mod crypto;
@@ -60,8 +62,8 @@ impl HashEngine {
     #[cfg(not(hashes_fuzz))]
     pub(crate) 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())
+        for (val, ret_bytes) in self.h.iter().zip(ret.bitcoin_as_chunks_mut().0) {
+            *ret_bytes = val.to_be_bytes();
         }
         ret
     }
diff --git a/hashes/src/sha256/crypto.rs b/hashes/src/sha256/crypto.rs
index 210eb6e6e3..34e780d7b8 100644
--- a/hashes/src/sha256/crypto.rs
+++ b/hashes/src/sha256/crypto.rs
@@ -5,6 +5,7 @@ use core::arch::x86::*;
 #[cfg(all(feature = "std", target_arch = "x86_64"))]
 use core::arch::x86_64::*;
 
+use internals::slice::SliceExt;
 use super::{HashEngine, Midstate, BLOCK_SIZE};
 
 #[allow(non_snake_case)]
@@ -526,8 +527,8 @@ impl HashEngine {
         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"));
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.bitcoin_as_chunks().0) {
+            *w_val = u32::from_be_bytes(*buff_bytes);
         }
 
         let mut a = self.h[0];
diff --git a/hashes/src/sha256/mod.rs b/hashes/src/sha256/mod.rs
index 6ae83b879b..39624ae235 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -9,6 +9,7 @@ mod crypto;
 mod tests;
 
 use core::{cmp, convert, fmt};
+use internals::slice::SliceExt;
 
 use crate::{incomplete_block_len, sha256d, HashEngine as _};
 #[cfg(doc)]
@@ -79,8 +80,8 @@ impl HashEngine {
     /// Please see docs on [`Midstate`] before using this function.
     pub fn from_midstate(midstate: Midstate) -> HashEngine {
         let mut ret = [0; 8];
-        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate.as_ref().chunks_exact(4)) {
-            *ret_val = u32::from_be_bytes(midstate_bytes.try_into().expect("4 byte slice"));
+        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate.as_ref().bitcoin_as_chunks().0) {
+            *ret_val = u32::from_be_bytes(*midstate_bytes);
         }
 
         HashEngine { buffer: [0; BLOCK_SIZE], h: ret, bytes_hashed: midstate.bytes_hashed }
@@ -108,8 +109,8 @@ impl HashEngine {
     #[cfg(not(hashes_fuzz))]
     fn midstate_unchecked(&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());
+        for (val, ret_bytes) in self.h.iter().zip(ret.bitcoin_as_chunks_mut::<4>().0) {
+            *ret_bytes = val.to_be_bytes();
         }
         Midstate { bytes: ret, bytes_hashed: self.bytes_hashed }
     }
diff --git a/hashes/src/sha512/crypto.rs b/hashes/src/sha512/crypto.rs
index cbb1c82ab5..0a9d5b0da4 100644
--- a/hashes/src/sha512/crypto.rs
+++ b/hashes/src/sha512/crypto.rs
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
+use internals::slice::SliceExt;
 use super::{HashEngine, BLOCK_SIZE};
 
 #[allow(non_snake_case)]
@@ -75,8 +76,8 @@ impl HashEngine {
         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"));
+        for (w_val, buff_bytes) in w.iter_mut().zip(self.buffer.bitcoin_as_chunks().0) {
+            *w_val = u64::from_be_bytes(*buff_bytes);
         }
 
         let mut a = self.h[0];
diff --git a/hashes/src/sha512/mod.rs b/hashes/src/sha512/mod.rs
index 65bf75c18e..2ee451f468 100644
--- a/hashes/src/sha512/mod.rs
+++ b/hashes/src/sha512/mod.rs
@@ -2,6 +2,8 @@
 
 //! SHA512 implementation.
 
+use internals::slice::SliceExt;
+
 #[cfg(bench)]
 mod benches;
 mod crypto;
@@ -79,8 +81,8 @@ impl HashEngine {
     #[cfg(not(hashes_fuzz))]
     pub(crate) 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());
+        for (val, ret_bytes) in self.h.iter().zip(ret.bitcoin_as_chunks_mut().0) {
+            *ret_bytes = val.to_be_bytes();
         }
         ret
     }
diff --git a/internals/src/lib.rs b/internals/src/lib.rs
index 34fa682ae6..bed67bd2f1 100644
--- a/internals/src/lib.rs
+++ b/internals/src/lib.rs
@@ -42,6 +42,7 @@ pub mod error;
 pub mod macros;
 mod parse;
 pub mod script;
+pub mod slice;
 pub mod wrap_debug;
 #[cfg(feature = "serde")]
 #[macro_use]
diff --git a/internals/src/slice.rs b/internals/src/slice.rs
new file mode 100644
index 0000000000..38ac95878b
--- /dev/null
+++ b/internals/src/slice.rs
@@ -0,0 +1,117 @@
+//! Contains extensions related to slices.
+
+/// Extension trait for slice.
+pub trait SliceExt {
+    /// The item type the slice is storing.
+    type Item;
+
+    /// Splits up the slice into a slice of arrays and a remainder.
+    ///
+    /// Note that `N` must not be zero:
+    ///
+    /// ```compile_fail
+    /// let slice = [1, 2, 3];
+    /// let fail = slice.as_chunks::<0>();
+    /// ```
+    fn bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item]);
+
+    /// Splits up the slice into a slice of arrays and a remainder.
+    ///
+    /// Note that `N` must not be zero:
+    ///
+    /// ```compile_fail
+    /// let mut slice = [1, 2, 3];
+    /// let fail = slice.as_chunks_mut::<0>();
+    /// ```
+    fn bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item]);
+}
+
+impl<T> SliceExt for [T] {
+    type Item = T;
+
+    fn bitcoin_as_chunks<const N: usize>(&self) -> (&[[Self::Item; N]], &[Self::Item]) {
+        #[allow(clippy::let_unit_value)]
+        let _ = Hack::<N>::IS_NONZERO;
+
+        let chunks_count = self.len() / N;
+        let total_left_len = chunks_count * N;
+        let (left, right) = self.split_at(total_left_len);
+        // SAFETY: we've obtained the pointer from a slice that's still live
+        // we're merely casting, so no aliasing issues here
+        // arrays of T have same alignment as T
+        // the resulting slice points within the obtained slice as was computed above
+        let left = unsafe { core::slice::from_raw_parts(left.as_ptr().cast::<[Self::Item; N]>(), chunks_count) };
+        (left, right)
+    }
+
+    fn bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item]) {
+        #[allow(clippy::let_unit_value)]
+        let _ = Hack::<N>::IS_NONZERO;
+
+        let chunks_count = self.len() / N;
+        let total_left_len = chunks_count * N;
+        let (left, right) = self.split_at_mut(total_left_len);
+        // SAFETY: we've obtained the pointer from a slice that's still live
+        // we're merely casting, so no aliasing issues here
+        // arrays of T have same alignment as T
+        // the resulting slice points within the obtained slice as was computed above
+        let left = unsafe { core::slice::from_raw_parts_mut(left.as_mut_ptr().cast::<[Self::Item; N]>(), chunks_count) };
+        (left, right)
+    }
+}
+
+struct Hack<const N: usize>;
+
+impl<const N: usize> Hack<N> {
+    const IS_NONZERO: () = { assert!(N != 0); };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::SliceExt;
+
+    // some comparisons require type annotations
+    const EMPTY: &[i32] = &[];
+
+    #[test]
+    fn one_to_one() {
+        let slice = [1];
+        let (left, right) = slice.bitcoin_as_chunks::<1>();
+        assert_eq!(left, &[[1]]);
+        assert_eq!(right, EMPTY);
+    }
+
+    #[test]
+    fn one_to_two() {
+        const EMPTY_LEFT: &[[i32; 2]] = &[];
+
+        let slice = [1i32];
+        let (left, right) = slice.bitcoin_as_chunks::<2>();
+        assert_eq!(left, EMPTY_LEFT);
+        assert_eq!(right, &[1]);
+    }
+
+    #[test]
+    fn two_to_one() {
+        let slice = [1, 2];
+        let (left, right) = slice.bitcoin_as_chunks::<1>();
+        assert_eq!(left, &[[1], [2]]);
+        assert_eq!(right, EMPTY);
+    }
+
+    #[test]
+    fn two_to_two() {
+        let slice = [1, 2];
+        let (left, right) = slice.bitcoin_as_chunks::<2>();
+        assert_eq!(left, &[[1, 2]]);
+        assert_eq!(right, EMPTY);
+    }
+
+    #[test]
+    fn three_to_two() {
+        let slice = [1, 2, 3];
+        let (left, right) = slice.bitcoin_as_chunks::<2>();
+        assert_eq!(left, &[[1, 2]]);
+        assert_eq!(right, &[3]);
+    }
+}

From d1c758f5a472a4a67cf9c7afa9ef9c0d793a2e16 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 7 Mar 2025 13:35:49 +1100
Subject: [PATCH 485/554] Add fee_rate::serde re-export

When we added the `fee_rate::serde` module we forgot to re-export it.
This is needed so downstream can do specify serde attributes on struct
fields.

```rust
    #[serde(with = "bitcoin::fee_rate::serde::as_sat_per_kwu")]
    rate: FeeRate,
```
---
 bitcoin/src/blockdata/mod.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bitcoin/src/blockdata/mod.rs b/bitcoin/src/blockdata/mod.rs
index cc4b1ecb50..9916e56af5 100644
--- a/bitcoin/src/blockdata/mod.rs
+++ b/bitcoin/src/blockdata/mod.rs
@@ -23,6 +23,8 @@ pub use self::{
 pub mod fee_rate {
     /// Re-export everything from the [`units::fee_rate`] module.
     pub use units::fee_rate::FeeRate;
+    #[cfg(feature = "serde")]
+    pub use units::fee_rate::serde;
 }
 
 /// Provides absolute and relative locktimes.

From 2aac5a1f81a9bb217c4dfb7e45b96188ea60e35b Mon Sep 17 00:00:00 2001
From: NinaLua <iturf@sina.cn>
Date: Fri, 7 Mar 2025 17:03:58 +0800
Subject: [PATCH 486/554] Fix some comments

Signed-off-by: NinaLua <iturf@sina.cn>
---
 bitcoin/src/blockdata/transaction.rs | 2 +-
 bitcoin/src/crypto/key.rs            | 2 +-
 hashes/src/macros.rs                 | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 9a3707d5d8..b53e87bc84 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -433,7 +433,7 @@ impl TransactionExt for Transaction {
 }
 
 /// Iterates over transaction outputs and for each output yields the length of the scriptPubkey.
-// This exists to hardcode the type of the closure crated by `map`.
+// This exists to hardcode the type of the closure created by `map`.
 pub struct TxOutToScriptPubkeyLengthIter<'a> {
     inner: core::slice::Iter<'a, TxOut>,
 }
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index c1d67bb644..4581298b51 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -997,7 +997,7 @@ impl fmt::Display for FromWifError {
             InvalidBase58PayloadLength(ref e) =>
                 write_err!(f, "decoded base58 data was an invalid length"; e),
             InvalidAddressVersion(ref e) =>
-                write_err!(f, "decoded base58 data contained an invalid address version btye"; e),
+                write_err!(f, "decoded base58 data contained an invalid address version byte"; e),
             Secp256k1(ref e) => write_err!(f, "private key validation failed"; e),
             InvalidWifCompressionFlag(ref e) => write_err!(f, "invalid WIF compression flag";e),
         }
diff --git a/hashes/src/macros.rs b/hashes/src/macros.rs
index 9ff5371541..070b727281 100644
--- a/hashes/src/macros.rs
+++ b/hashes/src/macros.rs
@@ -193,7 +193,7 @@ macro_rules! hash_newtype {
     };
 }
 
-/// Implements string functions using hex for a new type crated with [`crate::hash_newtype`] macro.
+/// Implements string functions using hex for a new type created with [`crate::hash_newtype`] macro.
 ///
 /// Implements:
 ///
@@ -210,7 +210,7 @@ macro_rules! impl_hex_for_newtype {
     }
 }
 
-/// Implements `fmt::Debug` using hex for a new type crated with [`crate::hash_newtype`] macro.
+/// Implements `fmt::Debug` using hex for a new type created with [`crate::hash_newtype`] macro.
 ///
 /// This is provided in case you do not want to use the `hex` feature.
 #[macro_export]

From ddb6dd520ec173f199d7c0fc0e9baa1abd00e4f7 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 7 Mar 2025 15:44:50 +0000
Subject: [PATCH 487/554] Move module out of fuzz_target directory

The new module `fuzz_utils` in the `fuzz_targets/` directory causes
`verify-execution` to fail.

Move the module to the `src/` directory. Create a `lib.rs` file.
---
 fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs    | 3 +--
 fuzz/fuzz_targets/bitcoin/deserialize_script.rs  | 3 +--
 fuzz/{fuzz_targets/bitcoin => src}/fuzz_utils.rs | 4 ++++
 fuzz/src/lib.rs                                  | 5 +++++
 4 files changed, 11 insertions(+), 4 deletions(-)
 rename fuzz/{fuzz_targets/bitcoin => src}/fuzz_utils.rs (90%)
 create mode 100644 fuzz/src/lib.rs

diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs b/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
index b3fe54bbdd..043d195969 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
@@ -1,7 +1,6 @@
 use honggfuzz::fuzz;
 
-mod fuzz_utils;
-use fuzz_utils::consume_random_bytes;
+use bitcoin_fuzz::fuzz_utils::consume_random_bytes;
 
 fn do_test(data: &[u8]) {
     let mut new_data = data;
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
index e7c1191b40..0968b64f0e 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -4,8 +4,7 @@ use bitcoin::script::{self, ScriptExt as _};
 use bitcoin::{FeeRate, Network};
 use honggfuzz::fuzz;
 
-mod fuzz_utils;
-use fuzz_utils::{consume_random_bytes, consume_u64};
+use bitcoin_fuzz::fuzz_utils::{consume_random_bytes, consume_u64};
 
 fn do_test(data: &[u8]) {
     let mut new_data = data;
diff --git a/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs b/fuzz/src/fuzz_utils.rs
similarity index 90%
rename from fuzz/fuzz_targets/bitcoin/fuzz_utils.rs
rename to fuzz/src/fuzz_utils.rs
index aeaa11ae21..8a072db98b 100644
--- a/fuzz/fuzz_targets/bitcoin/fuzz_utils.rs
+++ b/fuzz/src/fuzz_utils.rs
@@ -1,3 +1,7 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Helper functions for fuzzing.
+
 pub fn consume_random_bytes<'a>(data: &mut &'a [u8]) -> &'a [u8] {
     if data.is_empty() {
         return &[];
diff --git a/fuzz/src/lib.rs b/fuzz/src/lib.rs
new file mode 100644
index 0000000000..1be440fab2
--- /dev/null
+++ b/fuzz/src/lib.rs
@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! # Fuzzing
+
+pub mod fuzz_utils;

From e2dee4900f19f20ed243deaeeb4d4f5be3f4f9e9 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 8 Mar 2025 08:24:46 +1100
Subject: [PATCH 488/554] Re-name Timestamp to BlockTime

We just added a `Timestamp` type without knowing that there was a push
by OpenTimestamps to also create a timestamp and that our new type may
lead to confusion. Our timestamp is explicitly for the `time` field in a
block so we can call it `BlockTime`. This name change makes the module
name stale but we will change that in a following patch to ease review.
---
 bitcoin/src/bip152.rs              |  4 ++--
 bitcoin/src/blockdata/block.rs     | 12 ++++++------
 bitcoin/src/blockdata/constants.rs | 18 +++++++++---------
 bitcoin/src/lib.rs                 |  2 +-
 bitcoin/src/pow.rs                 |  8 ++++----
 primitives/src/block.rs            |  6 +++---
 primitives/src/lib.rs              |  2 +-
 units/src/lib.rs                   |  2 +-
 units/src/timestamp.rs             | 18 +++++++++---------
 units/tests/api.rs                 | 14 +++++++-------
 10 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs
index c7b69526bf..e602a31338 100644
--- a/bitcoin/src/bip152.rs
+++ b/bitcoin/src/bip152.rs
@@ -413,7 +413,7 @@ mod test {
     use crate::merkle_tree::TxMerkleNode;
     use crate::transaction::OutPointExt;
     use crate::{
-        transaction, Amount, BlockChecked, CompactTarget, OutPoint, ScriptBuf, Sequence, Timestamp,
+        transaction, Amount, BlockChecked, CompactTarget, OutPoint, ScriptBuf, Sequence, BlockTime,
         TxIn, TxOut, Txid, Witness,
     };
 
@@ -437,7 +437,7 @@ mod test {
             version: block::Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0x99; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0x77; 32]),
-            time: Timestamp::from_u32(2),
+            time: BlockTime::from_u32(2),
             bits: CompactTarget::from_consensus(3),
             nonce: 4,
         };
diff --git a/bitcoin/src/blockdata/block.rs b/bitcoin/src/blockdata/block.rs
index dfd039e557..a8dae5e4ba 100644
--- a/bitcoin/src/blockdata/block.rs
+++ b/bitcoin/src/blockdata/block.rs
@@ -13,7 +13,7 @@ use core::fmt;
 use hashes::{sha256d, HashEngine};
 use internals::{compact_size, ToU64};
 use io::{BufRead, Write};
-use units::Timestamp;
+use units::BlockTime;
 
 use super::Weight;
 use crate::consensus::encode::WriteExt as _;
@@ -86,15 +86,15 @@ impl Decodable for Version {
     }
 }
 
-impl Encodable for Timestamp {
+impl Encodable for BlockTime {
     fn consensus_encode<W: Write + ?Sized>(&self, w: &mut W) -> Result<usize, io::Error> {
         self.to_u32().consensus_encode(w)
     }
 }
 
-impl Decodable for Timestamp {
+impl Decodable for BlockTime {
     fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-        Decodable::consensus_decode(r).map(Timestamp::from_u32)
+        Decodable::consensus_decode(r).map(BlockTime::from_u32)
     }
 }
 
@@ -609,7 +609,7 @@ mod tests {
             block::compute_merkle_root(&transactions).unwrap()
         );
         assert_eq!(serialize(&real_decode.header().merkle_root), merkle);
-        assert_eq!(real_decode.header().time, Timestamp::from_u32(1231965655));
+        assert_eq!(real_decode.header().time, BlockTime::from_u32(1231965655));
         assert_eq!(real_decode.header().bits, CompactTarget::from_consensus(486604799));
         assert_eq!(real_decode.header().nonce, 2067413810);
         assert_eq!(real_decode.header().work(), work);
@@ -660,7 +660,7 @@ mod tests {
             real_decode.header().merkle_root,
             block::compute_merkle_root(&transactions).unwrap()
         );
-        assert_eq!(real_decode.header().time, Timestamp::from_u32(1472004949));
+        assert_eq!(real_decode.header().time, BlockTime::from_u32(1472004949));
         assert_eq!(real_decode.header().bits, CompactTarget::from_consensus(0x1a06d450));
         assert_eq!(real_decode.header().nonce, 1879759182);
         assert_eq!(real_decode.header().work(), work);
diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 2c5cb4e193..3d8dc25610 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -16,7 +16,7 @@ use crate::opcodes::all::*;
 use crate::pow::CompactTarget;
 use crate::transaction::{self, OutPoint, Transaction, TxIn, TxOut};
 use crate::witness::Witness;
-use crate::{script, Amount, BlockHash, Sequence, TestnetVersion, Timestamp};
+use crate::{script, Amount, BlockHash, Sequence, TestnetVersion, BlockTime};
 
 /// How many seconds between blocks we expect on average.
 pub const TARGET_BLOCK_SPACING: u32 = 600;
@@ -132,7 +132,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: Timestamp::from_u32(1231006505),
+                time: BlockTime::from_u32(1231006505),
                 bits: CompactTarget::from_consensus(0x1d00ffff),
                 nonce: 2083236893,
             },
@@ -144,7 +144,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: Timestamp::from_u32(1296688602),
+                time: BlockTime::from_u32(1296688602),
                 bits: CompactTarget::from_consensus(0x1d00ffff),
                 nonce: 414098458,
             },
@@ -156,7 +156,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: Timestamp::from_u32(1714777860),
+                time: BlockTime::from_u32(1714777860),
                 bits: CompactTarget::from_consensus(0x1d00ffff),
                 nonce: 393743547,
             },
@@ -168,7 +168,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: Timestamp::from_u32(1598918400),
+                time: BlockTime::from_u32(1598918400),
                 bits: CompactTarget::from_consensus(0x1e0377ae),
                 nonce: 52613770,
             },
@@ -180,7 +180,7 @@ pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
                 version: block::Version::ONE,
                 prev_blockhash: BlockHash::GENESIS_PREVIOUS_BLOCK_HASH,
                 merkle_root,
-                time: Timestamp::from_u32(1296688602),
+                time: BlockTime::from_u32(1296688602),
                 bits: CompactTarget::from_consensus(0x207fffff),
                 nonce: 2,
             },
@@ -320,7 +320,7 @@ mod test {
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
 
-        assert_eq!(gen.header().time, Timestamp::from_u32(1231006505));
+        assert_eq!(gen.header().time, BlockTime::from_u32(1231006505));
         assert_eq!(gen.header().bits, CompactTarget::from_consensus(0x1d00ffff));
         assert_eq!(gen.header().nonce, 2083236893);
         assert_eq!(
@@ -338,7 +338,7 @@ mod test {
             gen.header().merkle_root.to_string(),
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
-        assert_eq!(gen.header().time, Timestamp::from_u32(1296688602));
+        assert_eq!(gen.header().time, BlockTime::from_u32(1296688602));
         assert_eq!(gen.header().bits, CompactTarget::from_consensus(0x1d00ffff));
         assert_eq!(gen.header().nonce, 414098458);
         assert_eq!(
@@ -356,7 +356,7 @@ mod test {
             gen.header().merkle_root.to_string(),
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"
         );
-        assert_eq!(gen.header().time, Timestamp::from_u32(1598918400));
+        assert_eq!(gen.header().time, BlockTime::from_u32(1598918400));
         assert_eq!(gen.header().bits, CompactTarget::from_consensus(0x1e0377ae));
         assert_eq!(gen.header().nonce, 52613770);
         assert_eq!(
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index 3082483131..e9505f8af2 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -135,7 +135,7 @@ pub use units::{
     amount::{Amount, Denomination, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::FeeRate,
-    timestamp::{self, Timestamp},
+    timestamp::{self, BlockTime},
     weight::Weight,
 };
 
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index 09929f64f1..bb59edb508 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -1078,7 +1078,7 @@ pub mod test_utils {
 mod tests {
     use super::*;
     use crate::pow::test_utils::{u128_to_work, u32_to_target, u64_to_target};
-    use crate::Timestamp;
+    use crate::BlockTime;
 
     impl U256 {
         fn bit_at(&self, index: usize) -> bool {
@@ -1763,7 +1763,7 @@ mod tests {
             version: Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0; 32]),
-            time: Timestamp::from_u32(1599332177),
+            time: BlockTime::from_u32(1599332177),
             bits: epoch_start.bits,
             nonce: epoch_start.nonce,
         };
@@ -1785,7 +1785,7 @@ mod tests {
             version: Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0; 32]),
-            time: Timestamp::from_u32(1599332844),
+            time: BlockTime::from_u32(1599332844),
             bits: starting_bits,
             nonce: 0,
         };
@@ -1795,7 +1795,7 @@ mod tests {
             version: Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0; 32]),
-            time: Timestamp::from_u32(1600591200),
+            time: BlockTime::from_u32(1600591200),
             bits: starting_bits,
             nonce: 0,
         };
diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index 88eefad960..18cbdc0918 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -14,7 +14,7 @@ use core::marker::PhantomData;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use hashes::{sha256d, HashEngine as _};
-use units::Timestamp;
+use units::BlockTime;
 
 use crate::merkle_tree::TxMerkleNode;
 #[cfg(feature = "alloc")]
@@ -180,7 +180,7 @@ pub struct Header {
     /// 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: Timestamp,
+    pub time: BlockTime,
     /// The target value below which the blockhash must lie.
     pub bits: CompactTarget,
     /// The nonce, selected to obtain a low enough blockhash.
@@ -402,7 +402,7 @@ mod tests {
             version: Version::ONE,
             prev_blockhash: BlockHash::from_byte_array([0x99; 32]),
             merkle_root: TxMerkleNode::from_byte_array([0x77; 32]),
-            time: Timestamp::from(2),
+            time: BlockTime::from(2),
             bits: CompactTarget::from_consensus(3),
             nonce: 4,
         };
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index abca776bea..b26727e0fe 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -58,7 +58,7 @@ pub use units::{
     amount::{self, Amount, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::{self, FeeRate},
-    timestamp::{self, Timestamp},
+    timestamp::{self, BlockTime},
     weight::{self, Weight},
 };
 
diff --git a/units/src/lib.rs b/units/src/lib.rs
index 7654d6723a..287005c455 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -43,6 +43,6 @@ pub use self::{
     amount::{Amount, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::FeeRate,
-    timestamp::Timestamp,
+    timestamp::BlockTime,
     weight::Weight
 };
diff --git a/units/src/timestamp.rs b/units/src/timestamp.rs
index 35e59d8be6..41faec706e 100644
--- a/units/src/timestamp.rs
+++ b/units/src/timestamp.rs
@@ -26,33 +26,33 @@ use serde::{Deserialize, Serialize};
 /// ref: <https://en.bitcoin.it/wiki/Block_timestamp>
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Timestamp(u32);
+pub struct BlockTime(u32);
 
-impl Timestamp {
-    /// Constructs a new [`Timestamp`] from an unsigned 32 bit integer value.
+impl BlockTime {
+    /// Constructs a new [`BlockTime`] from an unsigned 32 bit integer value.
     #[inline]
-    pub const fn from_u32(t: u32) -> Self { Timestamp(t) }
+    pub const fn from_u32(t: u32) -> Self { BlockTime(t) }
 
     /// Returns the inner `u32` value.
     #[inline]
     pub const fn to_u32(self) -> u32 { self.0 }
 }
 
-impl From<u32> for Timestamp {
+impl From<u32> for BlockTime {
     #[inline]
     fn from(t: u32) -> Self { Self::from_u32(t) }
 }
 
-impl From<Timestamp> for u32 {
+impl From<BlockTime> for u32 {
     #[inline]
-    fn from(t: Timestamp) -> Self { t.to_u32() }
+    fn from(t: BlockTime) -> Self { t.to_u32() }
 }
 
 #[cfg(feature = "arbitrary")]
-impl<'a> Arbitrary<'a> for Timestamp {
+impl<'a> Arbitrary<'a> for BlockTime {
     #[inline]
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let t: u32 = u.arbitrary()?;
-        Ok(Timestamp::from(t))
+        Ok(BlockTime::from(t))
     }
 }
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 97a20e2a65..9643fb8be6 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -15,7 +15,7 @@ use arbitrary::{Arbitrary, Unstructured};
 use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::Height`.
 use bitcoin_units::{
     amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, FeeRate,
-    SignedAmount, Timestamp, Weight,
+    SignedAmount, BlockTime, Weight,
 };
 
 /// A struct that includes all public non-error enums.
@@ -42,7 +42,7 @@ struct Structs {
     i: relative::Height,
     j: relative::Time,
     k: Weight,
-    l: Timestamp,
+    l: BlockTime,
 }
 
 impl Structs {
@@ -59,7 +59,7 @@ impl Structs {
             i: relative::Height::MAX,
             j: relative::Time::MAX,
             k: Weight::MAX,
-            l: Timestamp::from_u32(u32::MAX),
+            l: BlockTime::from_u32(u32::MAX),
         }
     }
 }
@@ -89,7 +89,7 @@ struct CommonTraits {
     i: relative::Height,
     j: relative::Time,
     k: Weight,
-    l: Timestamp,
+    l: BlockTime,
 }
 
 /// A struct that includes all types that implement `Default`.
@@ -147,7 +147,7 @@ fn api_can_use_modules_from_crate_root() {
 #[test]
 fn api_can_use_types_from_crate_root() {
     use bitcoin_units::{
-        Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, Timestamp, Weight,
+        Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, BlockTime, Weight,
     };
 }
 
@@ -190,7 +190,7 @@ fn api_can_use_all_types_from_module_parse() {
 
 #[test]
 fn api_can_use_all_types_from_module_timestamp() {
-    use bitcoin_units::timestamp::Timestamp;
+    use bitcoin_units::timestamp::BlockTime;
 }
 
 #[test]
@@ -295,7 +295,7 @@ impl<'a> Arbitrary<'a> for Structs {
             i: relative::Height::arbitrary(u)?,
             j: relative::Time::arbitrary(u)?,
             k: Weight::arbitrary(u)?,
-            l: Timestamp::arbitrary(u)?,
+            l: BlockTime::arbitrary(u)?,
         };
         Ok(a)
     }

From c707b959b72dd89ca6df581a6102f32daedb8368 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sat, 8 Mar 2025 08:30:10 +1100
Subject: [PATCH 489/554] Rename timestamp module to time

We just re-named `Timestamp` to `BlockTime`. We have a `units::block`
module but it currently holds abstractions (`BlockHeight` and
`BlockInterval`) that are not onchain abstractions and therefore
somewhat different from the `BlockTime`. Instead of making `block` a
block 'utils' module instead re-name the `timestamp` module to `time`.
---
 bitcoin/src/lib.rs                  | 2 +-
 primitives/src/lib.rs               | 2 +-
 units/src/lib.rs                    | 4 ++--
 units/src/{timestamp.rs => time.rs} | 0
 units/tests/api.rs                  | 6 +++---
 5 files changed, 7 insertions(+), 7 deletions(-)
 rename units/src/{timestamp.rs => time.rs} (100%)

diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index e9505f8af2..792f23df19 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -135,7 +135,7 @@ pub use units::{
     amount::{Amount, Denomination, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::FeeRate,
-    timestamp::{self, BlockTime},
+    time::{self, BlockTime},
     weight::Weight,
 };
 
diff --git a/primitives/src/lib.rs b/primitives/src/lib.rs
index b26727e0fe..31fb210a89 100644
--- a/primitives/src/lib.rs
+++ b/primitives/src/lib.rs
@@ -58,7 +58,7 @@ pub use units::{
     amount::{self, Amount, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::{self, FeeRate},
-    timestamp::{self, BlockTime},
+    time::{self, BlockTime},
     weight::{self, Weight},
 };
 
diff --git a/units/src/lib.rs b/units/src/lib.rs
index 287005c455..4a166ebb23 100644
--- a/units/src/lib.rs
+++ b/units/src/lib.rs
@@ -34,7 +34,7 @@ pub mod block;
 pub mod fee_rate;
 pub mod locktime;
 pub mod parse;
-pub mod timestamp;
+pub mod time;
 pub mod weight;
 
 #[doc(inline)]
@@ -43,6 +43,6 @@ pub use self::{
     amount::{Amount, SignedAmount},
     block::{BlockHeight, BlockInterval},
     fee_rate::FeeRate,
-    timestamp::BlockTime,
+    time::BlockTime,
     weight::Weight
 };
diff --git a/units/src/timestamp.rs b/units/src/time.rs
similarity index 100%
rename from units/src/timestamp.rs
rename to units/src/time.rs
diff --git a/units/tests/api.rs b/units/tests/api.rs
index 9643fb8be6..b8ec96c3ca 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -141,7 +141,7 @@ struct Errors {
 
 #[test]
 fn api_can_use_modules_from_crate_root() {
-    use bitcoin_units::{amount, block, fee_rate, locktime, parse, timestamp, weight};
+    use bitcoin_units::{amount, block, fee_rate, locktime, parse, time, weight};
 }
 
 #[test]
@@ -189,8 +189,8 @@ fn api_can_use_all_types_from_module_parse() {
 }
 
 #[test]
-fn api_can_use_all_types_from_module_timestamp() {
-    use bitcoin_units::timestamp::BlockTime;
+fn api_can_use_all_types_from_module_time() {
+    use bitcoin_units::time::BlockTime;
 }
 
 #[test]

From 02a9efddc47063ad9b81721b552d937185226bcc Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 8 Mar 2025 01:18:46 +0000
Subject: [PATCH 490/554] Automated update to Github CI to rustc
 nightly-2025-03-06

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 44b3e69d4a..a305832151 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-03-03
+nightly-2025-03-06

From 2f897e210950242f9855403b056af0e74276e2ab Mon Sep 17 00:00:00 2001
From: yancy <github@yancy.lol>
Date: Sat, 8 Mar 2025 10:36:56 -0600
Subject: [PATCH 491/554] Remove warning section

Since monadic handling has been introduced, panics have been replaced
with return errors.  Therefore this section is no longer applicable.
---
 units/src/amount/unsigned.rs | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index c52a8f2c54..89d7eb35ff 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -22,17 +22,6 @@ use super::{
 /// conversion to various denominations. The [`Amount`] type does not implement [`serde`] traits
 /// but we do provide modules for serializing as satoshis or bitcoin.
 ///
-/// 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.
-///
 /// # Examples
 ///
 /// ```

From a273814d23f7f804f60bc260e6939a75ed9f1790 Mon Sep 17 00:00:00 2001
From: yancy <github@yancy.lol>
Date: Fri, 7 Mar 2025 08:29:33 -0600
Subject: [PATCH 492/554] Replace underflow with overflow in doc comments

The use of underflow is misleading.  Adding one to MAX and
subtracting one from MIN are both considered an overflow.
---
 bitcoin/src/blockdata/script/instruction.rs | 2 +-
 bitcoin/src/taproot/serialized_signature.rs | 2 +-
 units/src/amount/mod.rs                     | 4 ++--
 units/src/amount/signed.rs                  | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/bitcoin/src/blockdata/script/instruction.rs b/bitcoin/src/blockdata/script/instruction.rs
index 575ba6311a..16cd1df458 100644
--- a/bitcoin/src/blockdata/script/instruction.rs
+++ b/bitcoin/src/blockdata/script/instruction.rs
@@ -231,7 +231,7 @@ impl<'a> InstructionIndices<'a> {
         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
+        // No overflow: 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;
diff --git a/bitcoin/src/taproot/serialized_signature.rs b/bitcoin/src/taproot/serialized_signature.rs
index 2bc849b846..be388e2c3c 100644
--- a/bitcoin/src/taproot/serialized_signature.rs
+++ b/bitcoin/src/taproot/serialized_signature.rs
@@ -217,7 +217,7 @@ mod into_iter {
 
         #[inline]
         fn size_hint(&self) -> (usize, Option<usize>) {
-            // can't underflow thanks to the invariant
+            // can't overflow thanks to the invariant
             let len = self.signature.len() - self.pos;
             (len, Some(len))
         }
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 8af21f0a1f..7fb8bc5356 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -588,8 +588,8 @@ enum DisplayStyle {
 
 /// Calculates the sum over the iterator using checked arithmetic.
 pub trait CheckedSum<R>: sealed::Sealed<R> {
-    /// Calculates the sum over the iterator using checked arithmetic. If an over or underflow would
-    /// happen it returns [`None`].
+    /// Calculates the sum over the iterator using checked arithmetic. If an
+    /// overflow happens it returns [`None`].
     fn checked_sum(self) -> Option<R>;
 }
 
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index f51be5570f..7551ac197a 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -25,10 +25,10 @@ use super::{
 /// Warning!
 ///
 /// This type implements several arithmetic operations from [`core::ops`].
-/// To prevent errors due to overflow or underflow when using these operations,
+/// To prevent errors due to an overflow 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 [`SignedAmount`]
-/// implements will panic when overflow or underflow occurs.
+/// implements will panic when an overflow occurs.
 ///
 /// # Examples
 ///

From 0428554585de668e2a59fa61e44b473f4085d717 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Sun, 9 Mar 2025 05:57:03 +1100
Subject: [PATCH 493/554] primitives: Feature gate import

Feature gate the `Infallible` import. Found with `clippy`.
---
 primitives/src/transaction.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 05210ee299..fce862f8f7 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -12,6 +12,7 @@
 
 #[cfg(feature = "alloc")]
 use core::cmp;
+#[cfg(feature = "alloc")]
 use core::convert::Infallible;
 use core::fmt;
 

From 08ced04d124440d6b18d5815fd378f4f301f6d7d Mon Sep 17 00:00:00 2001
From: wgyt <wgythe@gmail.com>
Date: Mon, 10 Mar 2025 09:04:59 +0800
Subject: [PATCH 494/554] fix typos

---
 README.md                       | 2 +-
 bitcoin/src/consensus/encode.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d51dcd37b7..109ec1dce4 100644
--- a/README.md
+++ b/README.md
@@ -132,7 +132,7 @@ or [`hashes/embedded`](https://github.com/rust-bitcoin/rust-bitcoin/tree/master/
 ### 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.
+your shell to see a list of available sub-commands.
 
 ### Building the docs
 
diff --git a/bitcoin/src/consensus/encode.rs b/bitcoin/src/consensus/encode.rs
index a8637c2c6f..c2a751a0fe 100644
--- a/bitcoin/src/consensus/encode.rs
+++ b/bitcoin/src/consensus/encode.rs
@@ -286,7 +286,7 @@ pub trait Decodable: Sized {
     ///
     /// ### Rules for trait implementations
     ///
-    /// * Simple types that that have a fixed size (own and member fields), don't have to overwrite
+    /// * Simple types that have a fixed size (own and member fields), don't have to overwrite
     ///   this method, or be concern with it.
     /// * Types that deserialize using externally provided length should implement it:
     ///   * Make `consensus_decode` forward to `consensus_decode_bytes_from_finite_reader` with the

From a824b79206edb79fc990ff0022e10f4a5ebe4cb3 Mon Sep 17 00:00:00 2001
From: RiceChuan <lc582041246@gmail.com>
Date: Mon, 10 Mar 2025 12:10:12 +0800
Subject: [PATCH 495/554] docs: The quotation marks are incorrect.

Signed-off-by: RiceChuan <lc582041246@gmail.com>
---
 io/src/error.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/io/src/error.rs b/io/src/error.rs
index 8148514b22..a79725cf2b 100644
--- a/io/src/error.rs
+++ b/io/src/error.rs
@@ -188,7 +188,7 @@ define_errorkind!(
     WriteZero,
     /// This operation was interrupted.
     Interrupted,
-    /// An error returned when an operation could not be completed because an “end of file” was reached prematurely.
+    /// An error returned when an operation could not be completed because an "end of file" was reached prematurely.
     UnexpectedEof,
     // Note: Any time we bump the MSRV any new error kinds should be added here!
     /// A custom error that does not fall under any other I/O error kind

From a65d1d8b95156e98c9645e89d11e15f45443bf60 Mon Sep 17 00:00:00 2001
From: AM <hones02_tunica@icloud.com>
Date: Mon, 10 Mar 2025 12:17:04 +0800
Subject: [PATCH 496/554] docs: Update README to replace use of mutagen with
 cargo-mutants

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index d51dcd37b7..e96b90ed16 100644
--- a/README.md
+++ b/README.md
@@ -149,7 +149,7 @@ Unit and integration tests are available for those interested, along with benchm
 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)
+- Mutation testing with [`cargo-mutants`](https://github.com/sourcefrog/cargo-mutants)
 - Code verification with [`Kani`](https://github.com/model-checking/kani)
 
 There are always more tests to write and more bugs to find, contributions to our testing efforts
@@ -167,9 +167,9 @@ 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`.
+We are doing mutation testing with [cargo-mutants](https://github.com/sourcefrog/cargo-mutants). To run
+these tests first install with `cargo install --locked cargo-mutants` then run with `cargo mutants --in-place --no-shuffle`.
+Note that running these mutation tests will take on the order of 10's of minutes.
 
 ### Code verification
 

From 199f57849acd9845902a8090ad6490a61ee03d24 Mon Sep 17 00:00:00 2001
From: AM <hones02_tunica@icloud.com>
Date: Mon, 10 Mar 2025 12:45:57 +0800
Subject: [PATCH 497/554] Remove references to cfg(mutate) from lint allow - no
 longer allowed

Also fix incorrect spelling of honggfuzz
---
 README.md             | 2 +-
 bitcoin/Cargo.toml    | 2 +-
 primitives/Cargo.toml | 3 ---
 3 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index e96b90ed16..635741aa2a 100644
--- a/README.md
+++ b/README.md
@@ -148,7 +148,7 @@ alias build-docs='RUSTDOCFLAGS="--cfg docsrs" cargo +nightly rustdoc --features=
 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)
+- Fuzz testing with [`Honggfuzz`](https://github.com/rust-fuzz/honggfuzz-rs)
 - Mutation testing with [`cargo-mutants`](https://github.com/sourcefrog/cargo-mutants)
 - Code verification with [`Kani`](https://github.com/model-checking/kani)
 
diff --git a/bitcoin/Cargo.toml b/bitcoin/Cargo.toml
index d792a3a7ec..7784efff71 100644
--- a/bitcoin/Cargo.toml
+++ b/bitcoin/Cargo.toml
@@ -95,4 +95,4 @@ name = "io"
 required-features = ["std"]
 
 [lints.rust]
-unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(fuzzing)', 'cfg(kani)', 'cfg(mutate)'] }
+unexpected_cfgs = { level = "deny", check-cfg = ['cfg(bench)', 'cfg(fuzzing)', 'cfg(kani)'] }
diff --git a/primitives/Cargo.toml b/primitives/Cargo.toml
index 3a7feefc9f..b8b0bdd4c5 100644
--- a/primitives/Cargo.toml
+++ b/primitives/Cargo.toml
@@ -38,9 +38,6 @@ bincode = "1.3.1"
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
-[lints.rust]
-unexpected_cfgs = { level = "deny", check-cfg = ['cfg(mutate)'] }
-
 [lints.clippy]
 # Exclude lints we don't think are valuable.
 needless_question_mark = "allow" # https://github.com/rust-bitcoin/rust-bitcoin/pull/2134

From 8f74b823ab8ef44bde7d003f8ba43fbe44dbef3e Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Mon, 10 Mar 2025 10:02:50 -0300
Subject: [PATCH 498/554] Add validation for private key format and master key
 constraints

This commit adds additional validation checks when decoding extended private keys:

1. Verifies that byte 45 is zero as required by BIP-32 specification
2. For master keys (depth=0), ensures parent fingerprint is zero
3. For master keys (depth=0), ensures child number is zero

These checks improve security by rejecting malformed keys that could
potentially lead to unexpected behavior. Added corresponding error types
and unit tests to verify each validation rule.
---
 bitcoin/src/bip32.rs | 69 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 5b83327e84..382d855543 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -518,6 +518,12 @@ pub enum Error {
     InvalidPublicKeyHexLength(usize),
     /// Base58 decoded data was an invalid length.
     InvalidBase58PayloadLength(InvalidBase58PayloadLengthError),
+    /// Invalid private key prefix (byte 45 must be 0)
+    InvalidPrivateKeyPrefix,
+    /// Non-zero parent fingerprint for a master key (depth 0)
+    NonZeroParentFingerprintForMasterKey,
+    /// Non-zero child number for a master key (depth 0)
+    NonZeroChildNumberForMasterKey,
 }
 
 impl From<Infallible> for Error {
@@ -544,6 +550,11 @@ impl fmt::Display for Error {
             InvalidPublicKeyHexLength(got) =>
                 write!(f, "PublicKey hex should be 66 or 130 digits long, got: {}", got),
             InvalidBase58PayloadLength(ref e) => write_err!(f, "base58 payload"; e),
+            InvalidPrivateKeyPrefix =>
+                f.write_str("invalid private key prefix, byte 45 must be 0 as required by BIP-32"),
+            NonZeroParentFingerprintForMasterKey =>
+                f.write_str("non-zero parent fingerprint in master key"),
+            NonZeroChildNumberForMasterKey => f.write_str("non-zero child number in master key"),
         }
     }
 }
@@ -565,6 +576,9 @@ impl std::error::Error for Error {
             | UnknownVersion(_)
             | WrongExtendedKeyLength(_)
             | InvalidPublicKeyHexLength(_) => None,
+            InvalidPrivateKeyPrefix => None,
+            NonZeroParentFingerprintForMasterKey => None,
+            NonZeroChildNumberForMasterKey => None,
         }
     }
 }
@@ -699,6 +713,23 @@ impl Xpriv {
             return Err(Error::UnknownVersion([b0, b1, b2, b3]));
         };
 
+        // Check that byte 45 is 0 as required by BIP-32 for private keys
+        if data[45] != 0 {
+            return Err(Error::InvalidPrivateKeyPrefix);
+        }
+
+        // For master keys (depth=0), both parent fingerprint and child number must be zero
+        let depth = data[4];
+        if depth == 0 {
+            if !data[5..9].iter().all(|&b| b == 0) {
+                return Err(Error::NonZeroParentFingerprintForMasterKey);
+            }
+
+            if !data[9..13].iter().all(|&b| b == 0) {
+                return Err(Error::NonZeroChildNumberForMasterKey);
+            }
+        }
+
         Ok(Xpriv {
             network,
             depth: data[4],
@@ -1235,6 +1266,44 @@ mod tests {
                   "xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y");
     }
 
+    #[test]
+    fn test_reject_xpriv_with_non_zero_byte_at_index_45() {
+        let mut xpriv = base58::decode_check("xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9").unwrap();
+
+        // Modify byte at index 45 to be non-zero (e.g., 1)
+        xpriv[45] = 1;
+
+        let result = Xpriv::decode(&xpriv);
+        assert!(result.is_err());
+
+        match result {
+            Err(Error::InvalidPrivateKeyPrefix) => {}
+            _ => panic!("Expected InvalidPrivateKeyPrefix error, got {:?}", result),
+        }
+    }
+
+    #[test]
+    fn test_reject_xpriv_with_zero_depth_and_non_zero_index() {
+        let result = "xprv9s21ZrQH4r4TsiLvyLXqM9P7k1K3EYhA1kkD6xuquB5i39AU8KF42acDyL3qsDbU9NmZn6MsGSUYZEsuoePmjzsB3eFKSUEh3Gu1N3cqVUN".parse::<Xpriv>();
+        assert!(result.is_err());
+
+        match result {
+            Err(Error::NonZeroChildNumberForMasterKey) => {}
+            _ => panic!("Expected NonZeroChildNumberForMasterKey error, got {:?}", result),
+        }
+    }
+
+    #[test]
+    fn test_reject_xpriv_with_zero_depth_and_non_zero_parent_fingerprint() {
+        let result = "xprv9s2SPatNQ9Vc6GTbVMFPFo7jsaZySyzk7L8n2uqKXJen3KUmvQNTuLh3fhZMBoG3G4ZW1N2kZuHEPY53qmbZzCHshoQnNf4GvELZfqTUrcv".parse::<Xpriv>();
+        assert!(result.is_err());
+
+        match result {
+            Err(Error::NonZeroParentFingerprintForMasterKey) => {}
+            _ => panic!("Expected NonZeroParentFingerprintForMasterKey error, got {:?}", result),
+        }
+    }
+
     #[test]
     #[cfg(feature = "serde")]
     pub fn encode_decode_childnumber() {

From 938461cc65c09a5237cc9b7245c4f503ec3977fe Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 31 Jan 2025 09:01:56 +1100
Subject: [PATCH 499/554] psbt: Use Amount::ZERO in unit test

We have a const for this, use it.

Internal change only.
---
 bitcoin/src/psbt/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index f10cbbb329..b2787d73e9 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -2283,7 +2283,7 @@ mod tests {
             version: transaction::Version::TWO,
             lock_time: absolute::LockTime::ZERO,
             input: vec![TxIn::EMPTY_COINBASE, TxIn::EMPTY_COINBASE],
-            output: vec![TxOut { value: Amount::from_sat(0), script_pubkey: ScriptBuf::new() }],
+            output: vec![TxOut { value: Amount::ZERO, script_pubkey: ScriptBuf::new() }],
         };
         let mut psbt = Psbt::from_unsigned_tx(unsigned_tx).unwrap();
 

From 8ecdc7c27512ea0ae91c955441c32d7074d5cd98 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 10:09:41 +1100
Subject: [PATCH 500/554] Use den_ prefix for local Denomination variable

Throughout the `amount::tests` module we use `sat` and `ssat` as aliases
to amount constructors but in on test we use them as `Denomination`
variables. To assist clarity and so we can introduce uniform usage of
the constructor aliases change the variable names to use the `den_`
prefix.

Internal change only, no logic changes.
---
 units/src/amount/tests.rs | 59 ++++++++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 25 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index d263623eb9..748cd38762 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -339,53 +339,62 @@ fn floating_point() {
 #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
 fn parsing() {
     use super::ParseAmountError as E;
-    let btc = Denomination::Bitcoin;
-    let sat = Denomination::Satoshi;
+    let den_btc = Denomination::Bitcoin;
+    let den_sat = Denomination::Satoshi;
     let p = Amount::from_str_in;
     let sp = SignedAmount::from_str_in;
 
-    assert_eq!(p("x", btc), Err(E::from(InvalidCharacterError { invalid_char: 'x', position: 0 })));
     assert_eq!(
-        p("-", btc),
+        p("x", den_btc),
+        Err(E::from(InvalidCharacterError { invalid_char: 'x', position: 0 }))
+    );
+    assert_eq!(
+        p("-", den_btc),
         Err(E::from(MissingDigitsError { kind: MissingDigitsKind::OnlyMinusSign }))
     );
     assert_eq!(
-        sp("-", btc),
+        sp("-", den_btc),
         Err(E::from(MissingDigitsError { kind: MissingDigitsKind::OnlyMinusSign }))
     );
     assert_eq!(
-        p("-1.0x", btc),
+        p("-1.0x", den_btc),
         Err(E::from(InvalidCharacterError { invalid_char: 'x', position: 4 }))
     );
     assert_eq!(
-        p("0.0 ", btc),
+        p("0.0 ", den_btc),
         Err(E::from(InvalidCharacterError { invalid_char: ' ', position: 3 }))
     );
     assert_eq!(
-        p("0.000.000", btc),
+        p("0.000.000", den_btc),
         Err(E::from(InvalidCharacterError { invalid_char: '.', position: 5 }))
     );
     #[cfg(feature = "alloc")]
     let more_than_max = format!("{}", Amount::MAX.to_sat() + 1);
     #[cfg(feature = "alloc")]
-    assert_eq!(p(&more_than_max, btc), Err(OutOfRangeError::too_big(false).into()));
-    assert_eq!(p("0.000000042", btc), Err(TooPreciseError { position: 10 }.into()));
-    assert_eq!(p("1.0000000", sat), Ok(Amount::from_sat_unchecked(1)));
-    assert_eq!(p("1.1", sat), Err(TooPreciseError { position: 2 }.into()));
-    assert_eq!(p("1000.1", sat), Err(TooPreciseError { position: 5 }.into()));
-    assert_eq!(p("1001.0000000", sat), Ok(Amount::from_sat_unchecked(1001)));
-    assert_eq!(p("1000.0000001", sat), Err(TooPreciseError { position: 11 }.into()));
-
-    assert_eq!(p("1", btc), Ok(Amount::from_sat_unchecked(1_000_000_00)));
-    assert_eq!(sp("-.5", btc), Ok(SignedAmount::from_sat_unchecked(-500_000_00)));
+    assert_eq!(p(&more_than_max, den_btc), Err(OutOfRangeError::too_big(false).into()));
+    assert_eq!(p("0.000000042", den_btc), Err(TooPreciseError { position: 10 }.into()));
+    assert_eq!(p("1.0000000", den_sat), Ok(Amount::from_sat_unchecked(1)));
+    assert_eq!(p("1.1", den_sat), Err(TooPreciseError { position: 2 }.into()));
+    assert_eq!(p("1000.1", den_sat), Err(TooPreciseError { position: 5 }.into()));
+    assert_eq!(p("1001.0000000", den_sat), Ok(Amount::from_sat_unchecked(1001)));
+    assert_eq!(p("1000.0000001", den_sat), Err(TooPreciseError { position: 11 }.into()));
+
+    assert_eq!(p("1", den_btc), Ok(Amount::from_sat_unchecked(1_000_000_00)));
+    assert_eq!(sp("-.5", den_btc), Ok(SignedAmount::from_sat_unchecked(-500_000_00)));
     #[cfg(feature = "alloc")]
-    assert_eq!(sp(&SignedAmount::MIN.to_sat().to_string(), sat), Ok(SignedAmount::MIN));
-    assert_eq!(p("1.1", btc), Ok(Amount::from_sat_unchecked(1_100_000_00)));
-    assert_eq!(p("100", sat), Ok(Amount::from_sat_unchecked(100)));
-    assert_eq!(p("55", sat), Ok(Amount::from_sat_unchecked(55)));
-    assert_eq!(p("2100000000000000", sat), Ok(Amount::from_sat_unchecked(21_000_000__000_000_00)));
-    assert_eq!(p("2100000000000000.", sat), Ok(Amount::from_sat_unchecked(21_000_000__000_000_00)));
-    assert_eq!(p("21000000", btc), Ok(Amount::from_sat_unchecked(21_000_000__000_000_00)));
+    assert_eq!(sp(&SignedAmount::MIN.to_sat().to_string(), den_sat), Ok(SignedAmount::MIN));
+    assert_eq!(p("1.1", den_btc), Ok(Amount::from_sat_unchecked(1_100_000_00)));
+    assert_eq!(p("100", den_sat), Ok(Amount::from_sat_unchecked(100)));
+    assert_eq!(p("55", den_sat), Ok(Amount::from_sat_unchecked(55)));
+    assert_eq!(
+        p("2100000000000000", den_sat),
+        Ok(Amount::from_sat_unchecked(21_000_000__000_000_00))
+    );
+    assert_eq!(
+        p("2100000000000000.", den_sat),
+        Ok(Amount::from_sat_unchecked(21_000_000__000_000_00))
+    );
+    assert_eq!(p("21000000", den_btc), Ok(Amount::from_sat_unchecked(21_000_000__000_000_00)));
 
     // exactly 50 chars.
     assert_eq!(

From ef0af8d62e28dad70cbe2f847769d4f839b3077e Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Sat, 8 Mar 2025 15:15:13 +0000
Subject: [PATCH 501/554] Use sat/ssat constructors throughout tests

There is an as yet unresolved discussion about the unchecked amount
constructor. In an effort to focus the amount of changes required later
and also to make the `tests` module uniform use the `sat` and `ssat`
constructor functions everywhere.

Internal change only, no logic changes.
---
 units/src/amount/tests.rs | 152 +++++++++++---------------------------
 1 file changed, 44 insertions(+), 108 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 748cd38762..af41eaf627 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -16,11 +16,11 @@ use super::*;
 #[cfg(feature = "alloc")]
 use crate::{FeeRate, Weight};
 
+fn sat(sat: u64) -> Amount { Amount::from_sat(sat) }
+fn ssat(ssat: i64) -> SignedAmount { SignedAmount::from_sat(ssat) }
+
 #[test]
 fn sanity_check() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!(ssat(-100).abs(), ssat(100));
     assert_eq!(ssat(i64::MIN + 1).checked_abs().unwrap(), ssat(i64::MAX));
     assert_eq!(ssat(-100).signum(), -1);
@@ -102,25 +102,22 @@ fn from_str_zero_without_denomination() {
 #[test]
 fn from_int_btc() {
     let amt = Amount::from_int_btc_const(2);
-    assert_eq!(Amount::from_sat_unchecked(200_000_000), amt);
+    assert_eq!(sat(200_000_000), amt);
 }
 
 #[test]
 fn amount_try_from_signed_amount() {
-    let sa_positive = SignedAmount::from_sat_unchecked(123);
+    let sa_positive = ssat(123);
     let ua_positive = Amount::try_from(sa_positive).unwrap();
-    assert_eq!(ua_positive, Amount::from_sat_unchecked(123));
+    assert_eq!(ua_positive, sat(123));
 
-    let sa_negative = SignedAmount::from_sat_unchecked(-123);
+    let sa_negative = ssat(-123);
     let result = Amount::try_from(sa_negative);
     assert_eq!(result, Err(OutOfRangeError { is_signed: false, is_greater_than_max: false }));
 }
 
 #[test]
 fn mul_div() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
     let op_result_sat = |sat| NumOpResult::Valid(Amount::from_sat(sat));
     let op_result_ssat = |sat| NumOpResult::Valid(SignedAmount::from_sat(sat));
 
@@ -141,17 +138,14 @@ fn neg() {
 #[cfg(feature = "std")]
 #[test]
 fn overflows() {
-    let result = Amount::MAX + Amount::from_sat_unchecked(1);
+    let result = Amount::MAX + sat(1);
     assert!(result.is_error());
-    let result = Amount::from_sat_unchecked(8_446_744_073_709_551_615) * 3;
+    let result = sat(8_446_744_073_709_551_615) * 3;
     assert!(result.is_error());
 }
 
 #[test]
 fn add() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
     assert!(sat(0) + sat(0) == sat(0).into());
     assert!(sat(127) + sat(179) == sat(306).into());
 
@@ -164,9 +158,6 @@ fn add() {
 
 #[test]
 fn sub() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
     assert!(sat(0) - sat(0) == sat(0).into());
     assert!(sat(179) - sat(127) == sat(52).into());
     assert!((sat(127) - sat(179)).is_error());
@@ -180,9 +171,6 @@ fn sub() {
 
 #[test]
 fn checked_arithmetic() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!(SignedAmount::MAX.checked_add(ssat(1)), None);
     assert_eq!(SignedAmount::MIN.checked_sub(ssat(1)), None);
     assert_eq!(Amount::MAX.checked_add(sat(1)), None);
@@ -195,9 +183,6 @@ fn checked_arithmetic() {
 #[test]
 #[allow(deprecated_in_future)]
 fn unchecked_arithmetic() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!(ssat(10).unchecked_add(ssat(20)), ssat(30));
     assert_eq!(ssat(50).unchecked_sub(ssat(10)), ssat(40));
     assert_eq!(sat(5).unchecked_add(sat(7)), sat(12));
@@ -206,8 +191,6 @@ fn unchecked_arithmetic() {
 
 #[test]
 fn positive_sub() {
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!(ssat(10).positive_sub(ssat(7)).unwrap(), ssat(3));
     assert!(ssat(-10).positive_sub(ssat(7)).is_none());
     assert!(ssat(10).positive_sub(ssat(-7)).is_none());
@@ -218,12 +201,12 @@ fn positive_sub() {
 #[test]
 fn amount_checked_div_by_weight_ceil() {
     let weight = Weight::from_kwu(1).unwrap();
-    let fee_rate = Amount::from_sat_unchecked(1).checked_div_by_weight_ceil(weight).unwrap();
+    let fee_rate = sat(1).checked_div_by_weight_ceil(weight).unwrap();
     // 1 sats / 1,000 wu = 1 sats/kwu
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(1));
 
     let weight = Weight::from_wu(381);
-    let fee_rate = Amount::from_sat_unchecked(329).checked_div_by_weight_ceil(weight).unwrap();
+    let fee_rate = sat(329).checked_div_by_weight_ceil(weight).unwrap();
     // 329 sats / 381 wu = 863.5 sats/kwu
     // round up to 864
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(864));
@@ -236,12 +219,12 @@ fn amount_checked_div_by_weight_ceil() {
 #[test]
 fn amount_checked_div_by_weight_floor() {
     let weight = Weight::from_kwu(1).unwrap();
-    let fee_rate = Amount::from_sat_unchecked(1).checked_div_by_weight_floor(weight).unwrap();
+    let fee_rate = sat(1).checked_div_by_weight_floor(weight).unwrap();
     // 1 sats / 1,000 wu = 1 sats/kwu
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(1));
 
     let weight = Weight::from_wu(381);
-    let fee_rate = Amount::from_sat_unchecked(329).checked_div_by_weight_floor(weight).unwrap();
+    let fee_rate = sat(329).checked_div_by_weight_floor(weight).unwrap();
     // 329 sats / 381 wu = 863.5 sats/kwu
     // round down to 863
     assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
@@ -253,7 +236,7 @@ fn amount_checked_div_by_weight_floor() {
 #[cfg(feature = "alloc")]
 #[test]
 fn amount_checked_div_by_fee_rate() {
-    let amount = Amount::from_sat_unchecked(1000);
+    let amount = sat(1000);
     let fee_rate = FeeRate::from_sat_per_kwu(2);
 
     // Test floor division
@@ -266,7 +249,7 @@ fn amount_checked_div_by_fee_rate() {
     assert_eq!(weight, Weight::from_wu(500_000)); // Same result for exact division
 
     // Test truncation behavior
-    let amount = Amount::from_sat_unchecked(1000);
+    let amount = sat(1000);
     let fee_rate = FeeRate::from_sat_per_kwu(3);
     let floor_weight = amount.checked_div_by_fee_rate_floor(fee_rate).unwrap();
     let ceil_weight = amount.checked_div_by_fee_rate_ceil(fee_rate).unwrap();
@@ -287,7 +270,7 @@ fn amount_checked_div_by_fee_rate() {
 
     // Test overflow case
     let tiny_fee_rate = FeeRate::from_sat_per_kwu(1);
-    let large_amount = Amount::from_sat(u64::MAX);
+    let large_amount = sat(u64::MAX);
     assert!(large_amount.checked_div_by_fee_rate_floor(tiny_fee_rate).is_none());
     assert!(large_amount.checked_div_by_fee_rate_ceil(tiny_fee_rate).is_none());
 }
@@ -298,8 +281,6 @@ 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(1_122_000_000)));
     assert_eq!(sf(-11.22, D::MilliBitcoin), Ok(ssat(-1_122_000)));
@@ -339,6 +320,7 @@ fn floating_point() {
 #[allow(clippy::inconsistent_digit_grouping)] // Group to show 100,000,000 sats per bitcoin.
 fn parsing() {
     use super::ParseAmountError as E;
+
     let den_btc = Denomination::Bitcoin;
     let den_sat = Denomination::Satoshi;
     let p = Amount::from_str_in;
@@ -373,28 +355,28 @@ fn parsing() {
     #[cfg(feature = "alloc")]
     assert_eq!(p(&more_than_max, den_btc), Err(OutOfRangeError::too_big(false).into()));
     assert_eq!(p("0.000000042", den_btc), Err(TooPreciseError { position: 10 }.into()));
-    assert_eq!(p("1.0000000", den_sat), Ok(Amount::from_sat_unchecked(1)));
+    assert_eq!(p("1.0000000", den_sat), Ok(sat(1)));
     assert_eq!(p("1.1", den_sat), Err(TooPreciseError { position: 2 }.into()));
     assert_eq!(p("1000.1", den_sat), Err(TooPreciseError { position: 5 }.into()));
-    assert_eq!(p("1001.0000000", den_sat), Ok(Amount::from_sat_unchecked(1001)));
+    assert_eq!(p("1001.0000000", den_sat), Ok(sat(1001)));
     assert_eq!(p("1000.0000001", den_sat), Err(TooPreciseError { position: 11 }.into()));
 
-    assert_eq!(p("1", den_btc), Ok(Amount::from_sat_unchecked(1_000_000_00)));
-    assert_eq!(sp("-.5", den_btc), Ok(SignedAmount::from_sat_unchecked(-500_000_00)));
+    assert_eq!(p("1", den_btc), Ok(sat(1_000_000_00)));
+    assert_eq!(sp("-.5", den_btc), Ok(ssat(-500_000_00)));
     #[cfg(feature = "alloc")]
     assert_eq!(sp(&SignedAmount::MIN.to_sat().to_string(), den_sat), Ok(SignedAmount::MIN));
-    assert_eq!(p("1.1", den_btc), Ok(Amount::from_sat_unchecked(1_100_000_00)));
-    assert_eq!(p("100", den_sat), Ok(Amount::from_sat_unchecked(100)));
-    assert_eq!(p("55", den_sat), Ok(Amount::from_sat_unchecked(55)));
+    assert_eq!(p("1.1", den_btc), Ok(sat(1_100_000_00)));
+    assert_eq!(p("100", den_sat), Ok(sat(100)));
+    assert_eq!(p("55", den_sat), Ok(sat(55)));
     assert_eq!(
         p("2100000000000000", den_sat),
-        Ok(Amount::from_sat_unchecked(21_000_000__000_000_00))
+        Ok(sat(21_000_000__000_000_00))
     );
     assert_eq!(
         p("2100000000000000.", den_sat),
-        Ok(Amount::from_sat_unchecked(21_000_000__000_000_00))
+        Ok(sat(21_000_000__000_000_00))
     );
-    assert_eq!(p("21000000", den_btc), Ok(Amount::from_sat_unchecked(21_000_000__000_000_00)));
+    assert_eq!(p("21000000", den_btc), Ok(sat(21_000_000__000_000_00)));
 
     // exactly 50 chars.
     assert_eq!(
@@ -417,15 +399,12 @@ fn to_string() {
     assert_eq!(format!("{:.8}", Amount::ONE_BTC.display_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_unchecked(-42).to_string_in(D::Bitcoin), "-0.00000042");
+    assert_eq!(ssat(-42).to_string_in(D::Bitcoin), "-0.00000042");
 
     assert_eq!(Amount::ONE_BTC.to_string_with_denomination(D::Bitcoin), "1 BTC");
     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_unchecked(-42).to_string_with_denomination(D::Bitcoin),
-        "-0.00000042 BTC"
-    );
+    assert_eq!(ssat(-42).to_string_with_denomination(D::Bitcoin), "-0.00000042 BTC");
 }
 
 // May help identify a problem sooner
@@ -602,8 +581,6 @@ check_format_non_negative_show_denom! {
 
 #[test]
 fn unsigned_signed_conversion() {
-    let ssat = SignedAmount::from_sat;
-    let sat = Amount::from_sat;
     let max_sats: u64 = Amount::MAX.to_sat();
 
     assert_eq!(sat(max_sats).to_signed(), ssat(max_sats as i64));
@@ -681,12 +658,12 @@ fn from_str() {
     case("21000001 BTC", Err(OutOfRangeError::too_big(false)));
     case("18446744073709551616 sat", Err(OutOfRangeError::too_big(false)));
 
-    ok_case(".5 bits", Amount::from_sat_unchecked(50));
-    ok_scase("-.5 bits", SignedAmount::from_sat_unchecked(-50));
-    ok_case("0.00253583 BTC", Amount::from_sat_unchecked(253_583));
-    ok_scase("-5 satoshi", SignedAmount::from_sat_unchecked(-5));
-    ok_case("0.10000000 BTC", Amount::from_sat_unchecked(100_000_00));
-    ok_scase("-100 bits", SignedAmount::from_sat_unchecked(-10_000));
+    ok_case(".5 bits", sat(50));
+    ok_scase("-.5 bits", ssat(-50));
+    ok_case("0.00253583 BTC", sat(253_583));
+    ok_scase("-5 satoshi", ssat(-5));
+    ok_case("0.10000000 BTC", sat(100_000_00));
+    ok_scase("-100 bits", ssat(-10_000));
     ok_case("21000000 BTC", Amount::MAX);
     ok_scase("21000000 BTC", SignedAmount::MAX);
     ok_scase("-21000000 BTC", SignedAmount::MIN);
@@ -776,7 +753,7 @@ fn to_string_with_denomination_from_str_roundtrip() {
 
     use super::Denomination as D;
 
-    let amt = Amount::from_sat_unchecked(42);
+    let amt = sat(42);
     let denom = Amount::to_string_with_denomination;
     assert_eq!(denom(amt, D::Bitcoin).parse::<Amount>(), Ok(amt));
     assert_eq!(denom(amt, D::CentiBitcoin).parse::<Amount>(), Ok(amt));
@@ -807,10 +784,7 @@ fn serde_as_sat() {
     }
 
     serde_test::assert_tokens(
-        &T {
-            amt: Amount::from_sat_unchecked(123_456_789),
-            samt: SignedAmount::from_sat_unchecked(-123_456_789),
-        },
+        &T { amt: sat(123_456_789), samt: ssat(-123_456_789) },
         &[
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::Str("amt"),
@@ -837,10 +811,7 @@ fn serde_as_btc() {
         pub samt: SignedAmount,
     }
 
-    let orig = T {
-        amt: Amount::from_sat_unchecked(20_000_000__000_000_01),
-        samt: SignedAmount::from_sat_unchecked(-20_000_000__000_000_01),
-    };
+    let orig = T { amt: sat(20_000_000__000_000_01), samt: ssat(-20_000_000__000_000_01) };
 
     let json = "{\"amt\": 20000000.00000001, \
                 \"samt\": -20000000.00000001}";
@@ -874,10 +845,7 @@ fn serde_as_str() {
     }
 
     serde_test::assert_tokens(
-        &T {
-            amt: Amount::from_sat_unchecked(123_456_789),
-            samt: SignedAmount::from_sat_unchecked(-123_456_789),
-        },
+        &T { amt: sat(123_456_789), samt: ssat(-123_456_789) },
         &[
             serde_test::Token::Struct { name: "T", len: 2 },
             serde_test::Token::String("amt"),
@@ -904,10 +872,7 @@ fn serde_as_btc_opt() {
         pub samt: Option<SignedAmount>,
     }
 
-    let with = T {
-        amt: Some(Amount::from_sat_unchecked(2_500_000_00)),
-        samt: Some(SignedAmount::from_sat_unchecked(-2_500_000_00)),
-    };
+    let with = T { amt: Some(sat(2_500_000_00)), samt: Some(ssat(-2_500_000_00)) };
     let without = T { amt: None, samt: None };
 
     // Test Roundtripping
@@ -946,10 +911,7 @@ fn serde_as_sat_opt() {
         pub samt: Option<SignedAmount>,
     }
 
-    let with = T {
-        amt: Some(Amount::from_sat_unchecked(2_500_000_00)),
-        samt: Some(SignedAmount::from_sat_unchecked(-2_500_000_00)),
-    };
+    let with = T { amt: Some(sat(2_500_000_00)), samt: Some(ssat(-2_500_000_00)) };
     let without = T { amt: None, samt: None };
 
     // Test Roundtripping
@@ -988,10 +950,7 @@ fn serde_as_str_opt() {
         pub samt: Option<SignedAmount>,
     }
 
-    let with = T {
-        amt: Some(Amount::from_sat_unchecked(123_456_789)),
-        samt: Some(SignedAmount::from_sat_unchecked(-123_456_789)),
-    };
+    let with = T { amt: Some(sat(123_456_789)), samt: Some(ssat(-123_456_789)) };
     let without = T { amt: None, samt: None };
 
     // Test Roundtripping
@@ -1018,9 +977,6 @@ fn serde_as_str_opt() {
 
 #[test]
 fn sum_amounts() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!([].iter().sum::<NumOpResult<Amount>>(), Amount::ZERO.into());
     assert_eq!([].iter().sum::<NumOpResult<SignedAmount>>(), SignedAmount::ZERO.into());
 
@@ -1053,9 +1009,6 @@ fn sum_amounts() {
 
 #[test]
 fn checked_sum_amounts() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!([].into_iter().checked_sum(), Some(Amount::ZERO));
     assert_eq!([].into_iter().checked_sum(), Some(SignedAmount::ZERO));
 
@@ -1121,8 +1074,6 @@ fn disallow_unknown_denomination() {
 #[test]
 #[cfg(feature = "alloc")]
 fn trailing_zeros_for_amount() {
-    let sat = Amount::from_sat;
-
     assert_eq!(format!("{}", sat(1_000_000)), "0.01 BTC");
     assert_eq!(format!("{}", Amount::ONE_SAT), "0.00000001 BTC");
     assert_eq!(format!("{}", Amount::ONE_BTC), "1 BTC");
@@ -1203,8 +1154,6 @@ fn add_sub_combos() {
 
 #[test]
 fn unsigned_addition() {
-    let sat = Amount::from_sat;
-
     assert_eq!(sat(0) + sat(0), NumOpResult::from(sat(0)));
     assert_eq!(sat(0) + sat(307), NumOpResult::from(sat(307)));
     assert_eq!(sat(307) + sat(0), NumOpResult::from(sat(307)));
@@ -1214,8 +1163,6 @@ fn unsigned_addition() {
 
 #[test]
 fn signed_addition() {
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!(ssat(0) + ssat(0), NumOpResult::from(ssat(0)));
     assert_eq!(ssat(0) + ssat(307), NumOpResult::from(ssat(307)));
     assert_eq!(ssat(307) + ssat(0), NumOpResult::from(ssat(307)));
@@ -1235,8 +1182,6 @@ fn signed_addition() {
 
 #[test]
 fn unsigned_subtraction() {
-    let sat = Amount::from_sat;
-
     assert_eq!(sat(0) - sat(0), NumOpResult::from(sat(0)));
     assert_eq!(sat(307) - sat(0), NumOpResult::from(sat(307)));
     assert_eq!(sat(461) - sat(307), NumOpResult::from(sat(154)));
@@ -1244,8 +1189,6 @@ fn unsigned_subtraction() {
 
 #[test]
 fn signed_subtraction() {
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!(ssat(0) - ssat(0), NumOpResult::from(ssat(0)));
     assert_eq!(ssat(0) - ssat(307), NumOpResult::from(ssat(-307)));
     assert_eq!(ssat(307) - ssat(0), NumOpResult::from(ssat(307)));
@@ -1261,11 +1204,8 @@ fn signed_subtraction() {
 
 #[test]
 fn op_int_combos() {
-    let sat = Amount::from_sat;
-    let ssat = SignedAmount::from_sat;
-
-    let res = |sat| NumOpResult::from(Amount::from_sat(sat));
-    let sres = |ssat| NumOpResult::from(SignedAmount::from_sat(ssat));
+    let res = |n_sat| NumOpResult::from(sat(n_sat));
+    let sres = |n_ssat| NumOpResult::from(ssat(n_ssat));
 
     assert_eq!(sat(23) * 31, res(713));
     assert_eq!(ssat(23) * 31, sres(713));
@@ -1304,8 +1244,6 @@ fn op_int_combos() {
 
 #[test]
 fn unsigned_amount_div_by_amount() {
-    let sat = Amount::from_sat;
-
     assert_eq!(sat(0) / sat(7), 0);
     assert_eq!(sat(1897) / sat(7), 271);
 }
@@ -1318,8 +1256,6 @@ fn unsigned_amount_div_by_amount_zero() {
 
 #[test]
 fn signed_amount_div_by_amount() {
-    let ssat = SignedAmount::from_sat;
-
     assert_eq!(ssat(0) / ssat(7), 0);
 
     assert_eq!(ssat(1897) / ssat(7), 271);

From e6f7b26d80a8f2680ca4732013d89e029bcb2abc Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 09:41:10 +1100
Subject: [PATCH 502/554] Use _unchecked in amount const types

We are about to start enforcing the MAX_MONEY invariant. Doing so will
change constructors to return an error type.

In preparation use the `_unchecked` constructor for all the consts.

Internal change only, no logic changes.
---
 units/src/amount/signed.rs   | 12 ++++++------
 units/src/amount/unsigned.rs | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 7551ac197a..d4c2d02271 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -50,17 +50,17 @@ pub struct SignedAmount(i64);
 
 impl SignedAmount {
     /// The zero amount.
-    pub const ZERO: Self = SignedAmount(0);
+    pub const ZERO: Self = SignedAmount::from_sat_unchecked(0);
     /// Exactly one satoshi.
-    pub const ONE_SAT: Self = SignedAmount(1);
+    pub const ONE_SAT: Self = SignedAmount::from_sat_unchecked(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Self = SignedAmount(100_000_000);
+    pub const ONE_BTC: Self = SignedAmount::from_sat_unchecked(100_000_000);
     /// Exactly fifty bitcoin.
-    pub const FIFTY_BTC: Self = Self::from_sat_unchecked(50 * 100_000_000);
+    pub const FIFTY_BTC: Self = SignedAmount::from_sat_unchecked(50 * 100_000_000);
     /// The maximum value allowed as an amount. Useful for sanity checking.
-    pub const MAX_MONEY: Self = SignedAmount(21_000_000 * 100_000_000);
+    pub const MAX_MONEY: Self = SignedAmount::from_sat_unchecked(21_000_000 * 100_000_000);
     /// The minimum value of an amount.
-    pub const MIN: Self = SignedAmount(-21_000_000 * 100_000_000);
+    pub const MIN: Self = SignedAmount::from_sat_unchecked(-21_000_000 * 100_000_000);
     /// The maximum value of an amount.
     pub const MAX: Self = SignedAmount::MAX_MONEY;
 
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 89d7eb35ff..71ee58de40 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -42,15 +42,15 @@ pub struct Amount(u64);
 
 impl Amount {
     /// The zero amount.
-    pub const ZERO: Self = Amount(0);
+    pub const ZERO: Self = Amount::from_sat_unchecked(0);
     /// Exactly one satoshi.
-    pub const ONE_SAT: Self = Amount(1);
+    pub const ONE_SAT: Self = Amount::from_sat_unchecked(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Self = Self::from_int_btc_const(1);
+    pub const ONE_BTC: Self = Amount::from_sat_unchecked(100_000_000);
     /// Exactly fifty bitcoin.
-    pub const FIFTY_BTC: Self = Self::from_sat_unchecked(50 * 100_000_000);
+    pub const FIFTY_BTC: Self = Amount::from_sat_unchecked(50 * 100_000_000);
     /// The maximum value allowed as an amount. Useful for sanity checking.
-    pub const MAX_MONEY: Self = Self::from_int_btc_const(21_000_000);
+    pub const MAX_MONEY: Self = Amount::from_sat_unchecked(21_000_000 * 100_000_000);
     /// The minimum value of an amount.
     pub const MIN: Self = Amount::ZERO;
     /// The maximum value of an amount.

From 6d70c77cf90a373041c93ac6e3a746f85a51b900 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 09:54:50 +1100
Subject: [PATCH 503/554] Enforce newtype sanity rules for amount types

The unchecked-should-be-unsafe conversation is out of scope for this
patch. We want to bite off small chunks so the constructors are left as
they currently are - we are just doing the encapsulation here. This is
in preparation for enforcing the MAX_MONEY invariant which is not
currently enforced.

As per the sanity rules policy outline in:

 https://github.com/rust-bitcoin/rust-bitcoin/discussions/4090

For both amount types create a private `encapsulate` module that
consists of exactly the type and a single constructor and a single
getter.
---
 units/src/amount/signed.rs   | 156 +++++++++++++++++++----------------
 units/src/amount/unsigned.rs | 126 ++++++++++++++++------------
 2 files changed, 156 insertions(+), 126 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index d4c2d02271..5e5b4c5a2b 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -16,37 +16,60 @@ use super::{
     DisplayStyle, OutOfRangeError, ParseAmountError, ParseError,
 };
 
-/// A signed amount.
-///
-/// The [`SignedAmount`] type can be used to express Bitcoin amounts that support arithmetic and
-/// conversion to various denominations. The [`SignedAmount`] type does not implement [`serde`]
-/// traits but we do provide modules for serializing as satoshis or bitcoin.
-///
-/// Warning!
-///
-/// This type implements several arithmetic operations from [`core::ops`].
-/// To prevent errors due to an overflow 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 [`SignedAmount`]
-/// implements will panic when an overflow occurs.
-///
-/// # Examples
-///
-/// ```
-/// # #[cfg(feature = "serde")] {
-/// use serde::{Serialize, Deserialize};
-/// use bitcoin_units::SignedAmount;
-///
-/// #[derive(Serialize, Deserialize)]
-/// struct Foo {
-///     // If you are using `rust-bitcoin` then `bitcoin::amount::serde::as_sat` also works.
-///     #[serde(with = "bitcoin_units::amount::serde::as_sat")]  // Also `serde::as_btc`.
-///     amount: SignedAmount,
-/// }
-/// # }
-/// ```
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct SignedAmount(i64);
+mod encapsulate {
+    /// A signed amount.
+    ///
+    /// The [`SignedAmount`] type can be used to express Bitcoin amounts that support arithmetic and
+    /// conversion to various denominations. The [`SignedAmount`] type does not implement [`serde`]
+    /// traits but we do provide modules for serializing as satoshis or bitcoin.
+    ///
+    /// Warning!
+    ///
+    /// This type implements several arithmetic operations from [`core::ops`].
+    /// To prevent errors due to an overflow 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 [`SignedAmount`]
+    /// implements will panic when an overflow occurs.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[cfg(feature = "serde")] {
+    /// use serde::{Serialize, Deserialize};
+    /// use bitcoin_units::SignedAmount;
+    ///
+    /// #[derive(Serialize, Deserialize)]
+    /// struct Foo {
+    ///     // If you are using `rust-bitcoin` then `bitcoin::amount::serde::as_sat` also works.
+    ///     #[serde(with = "bitcoin_units::amount::serde::as_sat")]  // Also `serde::as_btc`.
+    ///     amount: SignedAmount,
+    /// }
+    /// # }
+    /// ```
+    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct SignedAmount(i64);
+
+    impl SignedAmount {
+        /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
+        ///
+        /// Caller to guarantee that `satoshi` is within valid range.
+        ///
+        /// See [`Self::MIN`] and [`Self::MAX_MONEY`].
+        pub const fn from_sat_unchecked(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
+
+        /// Gets the number of satoshis in this [`SignedAmount`].
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// # use bitcoin_units::SignedAmount;
+        /// assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);
+        /// ```
+        pub const fn to_sat(self) -> i64 { self.0 }
+    }
+}
+#[doc(inline)]
+pub use encapsulate::SignedAmount;
 
 impl SignedAmount {
     /// The zero amount.
@@ -73,24 +96,9 @@ impl SignedAmount {
     /// let amount = SignedAmount::from_sat(-100_000);
     /// assert_eq!(amount.to_sat(), -100_000);
     /// ```
-    pub const fn from_sat(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
-
-    /// Gets the number of satoshis in this [`SignedAmount`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_units::SignedAmount;
-    /// assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);
-    /// ```
-    pub const fn to_sat(self) -> i64 { self.0 }
-
-    /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
-    ///
-    /// Caller to guarantee that `satoshi` is within valid range.
-    ///
-    /// See [`Self::MIN`] and [`Self::MAX_MONEY`].
-    pub const fn from_sat_unchecked(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
+    pub const fn from_sat(satoshi: i64) -> SignedAmount {
+        SignedAmount::from_sat_unchecked(satoshi)
+    }
 
     /// Converts from a value expressing a decimal number of bitcoin to a [`SignedAmount`].
     ///
@@ -153,11 +161,11 @@ impl SignedAmount {
             (false, sat) if sat > SignedAmount::MAX.to_sat() as u64 => Err(ParseAmountError(
                 ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_big(true)),
             )),
-            (false, sat) => Ok(SignedAmount(sat as i64)), // Cast ok, value in this arm does not wrap.
+            (false, sat) => Ok(SignedAmount::from_sat(sat as i64)), // Cast ok, value in this arm does not wrap.
             (true, sat) if sat > SignedAmount::MIN.to_sat().unsigned_abs() => Err(
                 ParseAmountError(ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_small())),
             ),
-            (true, sat) => Ok(SignedAmount(-(sat as i64))), // Cast ok, value in this arm does not wrap.
+            (true, sat) => Ok(SignedAmount::from_sat(-(sat as i64))), // Cast ok, value in this arm does not wrap.
         }
     }
 
@@ -300,11 +308,11 @@ impl SignedAmount {
 
     /// Gets the absolute value of this [`SignedAmount`].
     #[must_use]
-    pub fn abs(self) -> SignedAmount { SignedAmount(self.0.abs()) }
+    pub fn abs(self) -> SignedAmount { SignedAmount::from_sat(self.to_sat().abs()) }
 
     /// Gets the absolute value of this [`SignedAmount`] returning [`Amount`].
     #[must_use]
-    pub fn unsigned_abs(self) -> Amount { Amount::from_sat(self.0.unsigned_abs()) }
+    pub fn unsigned_abs(self) -> Amount { Amount::from_sat(self.to_sat().unsigned_abs()) }
 
     /// Returns a number representing sign of this [`SignedAmount`].
     ///
@@ -312,19 +320,19 @@ impl SignedAmount {
     /// - `1` if the amount is positive
     /// - `-1` if the amount is negative
     #[must_use]
-    pub fn signum(self) -> i64 { self.0.signum() }
+    pub fn signum(self) -> i64 { self.to_sat().signum() }
 
     /// Checks if this [`SignedAmount`] is positive.
     ///
     /// 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() }
+    pub fn is_positive(self) -> bool { self.to_sat().is_positive() }
 
     /// Checks if this [`SignedAmount`] is negative.
     ///
     /// 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() }
+    pub fn is_negative(self) -> bool { self.to_sat().is_negative() }
 
     /// Returns the absolute value of this [`SignedAmount`].
     ///
@@ -334,8 +342,8 @@ impl SignedAmount {
     #[must_use]
     pub const fn checked_abs(self) -> Option<SignedAmount> {
         // No `map()` in const context.
-        match self.0.checked_abs() {
-            Some(res) => Some(SignedAmount(res)),
+        match self.to_sat().checked_abs() {
+            Some(res) => Some(SignedAmount::from_sat(res)),
             None => None,
         }
     }
@@ -346,8 +354,8 @@ impl SignedAmount {
     #[must_use]
     pub const fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
-        match self.0.checked_add(rhs.0) {
-            Some(res) => SignedAmount(res).check_min_max(),
+        match self.to_sat().checked_add(rhs.to_sat()) {
+            Some(res) => SignedAmount::from_sat(res).check_min_max(),
             None => None,
         }
     }
@@ -359,8 +367,8 @@ impl SignedAmount {
     #[must_use]
     pub const fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
-        match self.0.checked_sub(rhs.0) {
-            Some(res) => SignedAmount(res).check_min_max(),
+        match self.to_sat().checked_sub(rhs.to_sat()) {
+            Some(res) => SignedAmount::from_sat(res).check_min_max(),
             None => None,
         }
     }
@@ -372,8 +380,8 @@ impl SignedAmount {
     #[must_use]
     pub const fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
-        match self.0.checked_mul(rhs) {
-            Some(res) => SignedAmount(res).check_min_max(),
+        match self.to_sat().checked_mul(rhs) {
+            Some(res) => SignedAmount::from_sat(res).check_min_max(),
             None => None,
         }
     }
@@ -386,8 +394,8 @@ impl SignedAmount {
     #[must_use]
     pub const fn checked_div(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
-        match self.0.checked_div(rhs) {
-            Some(res) => Some(SignedAmount(res)),
+        match self.to_sat().checked_div(rhs) {
+            Some(res) => Some(SignedAmount::from_sat(res)),
             None => None,
         }
     }
@@ -398,8 +406,8 @@ impl SignedAmount {
     #[must_use]
     pub const fn checked_rem(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
-        match self.0.checked_rem(rhs) {
-            Some(res) => Some(SignedAmount(res)),
+        match self.to_sat().checked_rem(rhs) {
+            Some(res) => Some(SignedAmount::from_sat(res)),
             None => None,
         }
     }
@@ -413,7 +421,9 @@ impl SignedAmount {
     /// On overflow, panics in debug mode, wraps in release mode.
     #[must_use]
     #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
-    pub fn unchecked_add(self, rhs: SignedAmount) -> SignedAmount { Self(self.0 + rhs.0) }
+    pub fn unchecked_add(self, rhs: SignedAmount) -> SignedAmount {
+        Self::from_sat(self.to_sat() + rhs.to_sat())
+    }
 
     /// Unchecked subtraction.
     ///
@@ -424,7 +434,9 @@ impl SignedAmount {
     /// On overflow, panics in debug mode, wraps in release mode.
     #[must_use]
     #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
-    pub fn unchecked_sub(self, rhs: SignedAmount) -> SignedAmount { Self(self.0 - rhs.0) }
+    pub fn unchecked_sub(self, rhs: SignedAmount) -> SignedAmount {
+        Self::from_sat(self.to_sat() - rhs.to_sat())
+    }
 
     /// Subtraction that doesn't allow negative [`SignedAmount`]s.
     ///
@@ -453,7 +465,7 @@ impl SignedAmount {
 
     /// Checks the amount is within the allowed range.
     const fn check_min_max(self) -> Option<SignedAmount> {
-        if self.0 < Self::MIN.0 || self.0 > Self::MAX.0 {
+        if self.to_sat() < Self::MIN.to_sat() || self.to_sat() > Self::MAX.to_sat() {
             None
         } else {
             Some(self)
@@ -514,6 +526,6 @@ impl From<Amount> for SignedAmount {
 impl<'a> Arbitrary<'a> for SignedAmount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let s = i64::arbitrary(u)?;
-        Ok(Self(s))
+        Ok(Self::from_sat(s))
     }
 }
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 71ee58de40..ae9c3f5c24 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -16,29 +16,58 @@ use super::{
     OutOfRangeError, ParseAmountError, ParseError, SignedAmount,
 };
 
-/// An amount.
-///
-/// The [`Amount`] type can be used to express Bitcoin amounts that support arithmetic and
-/// conversion to various denominations. The [`Amount`] type does not implement [`serde`] traits
-/// but we do provide modules for serializing as satoshis or bitcoin.
-///
-/// # Examples
-///
-/// ```
-/// # #[cfg(feature = "serde")] {
-/// use serde::{Serialize, Deserialize};
-/// use bitcoin_units::Amount;
-///
-/// #[derive(Serialize, Deserialize)]
-/// struct Foo {
-///     // If you are using `rust-bitcoin` then `bitcoin::amount::serde::as_sat` also works.
-///     #[serde(with = "bitcoin_units::amount::serde::as_sat")]  // Also `serde::as_btc`.
-///     amount: Amount,
-/// }
-/// # }
-/// ```
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Amount(u64);
+mod encapsulate {
+    /// An amount.
+    ///
+    /// The [`Amount`] type can be used to express Bitcoin amounts that support arithmetic and
+    /// conversion to various denominations. The [`Amount`] type does not implement [`serde`] traits
+    /// but we do provide modules for serializing as satoshis or bitcoin.
+    ///
+    /// Warning!
+    ///
+    /// This type implements several arithmetic operations from [`core::ops`].
+    /// To prevent errors due to an overflow 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 an overflow occurs.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[cfg(feature = "serde")] {
+    /// use serde::{Serialize, Deserialize};
+    /// use bitcoin_units::Amount;
+    ///
+    /// #[derive(Serialize, Deserialize)]
+    /// struct Foo {
+    ///     // If you are using `rust-bitcoin` then `bitcoin::amount::serde::as_sat` also works.
+    ///     #[serde(with = "bitcoin_units::amount::serde::as_sat")]  // Also `serde::as_btc`.
+    ///     amount: Amount,
+    /// }
+    /// # }
+    /// ```
+    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct Amount(u64);
+
+    impl Amount {
+        /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
+        ///
+        /// Caller to guarantee that `satoshi` is within valid range. See [`Self::MAX_MONEY`].
+        pub const fn from_sat_unchecked(satoshi: u64) -> Amount { Self(satoshi) }
+
+        /// Gets the number of satoshis in this [`Amount`].
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// # use bitcoin_units::Amount;
+        /// assert_eq!(Amount::ONE_BTC.to_sat(), 100_000_000);
+        /// ```
+        pub const fn to_sat(self) -> u64 { self.0 }
+    }
+}
+#[doc(inline)]
+pub use encapsulate::Amount;
 
 impl Amount {
     /// The zero amount.
@@ -67,22 +96,7 @@ impl Amount {
     /// let amount = Amount::from_sat(100_000);
     /// assert_eq!(amount.to_sat(), 100_000);
     /// ```
-    pub const fn from_sat(satoshi: u64) -> Amount { Amount(satoshi) }
-
-    /// Gets the number of satoshis in this [`Amount`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_units::Amount;
-    /// assert_eq!(Amount::ONE_BTC.to_sat(), 100_000_000);
-    /// ```
-    pub const fn to_sat(self) -> u64 { self.0 }
-
-    /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
-    ///
-    /// Caller to guarantee that `satoshi` is within valid range. See [`Self::MAX_MONEY`].
-    pub const fn from_sat_unchecked(satoshi: u64) -> Amount { Self(satoshi) }
+    pub const fn from_sat(satoshi: u64) -> Amount { Amount::from_sat_unchecked(satoshi) }
 
     /// Converts from a value expressing a decimal number of bitcoin to an [`Amount`].
     ///
@@ -148,7 +162,7 @@ impl Amount {
                 OutOfRangeError::negative(),
             )));
         }
-        if sats > Self::MAX.0 {
+        if sats > Self::MAX.to_sat() {
             return Err(ParseAmountError(ParseAmountErrorInner::OutOfRange(
                 OutOfRangeError::too_big(false),
             )));
@@ -299,8 +313,8 @@ impl Amount {
     #[must_use]
     pub const fn checked_add(self, rhs: Amount) -> Option<Amount> {
         // No `map()` in const context.
-        match self.0.checked_add(rhs.0) {
-            Some(res) => Amount(res).check_max(),
+        match self.to_sat().checked_add(rhs.to_sat()) {
+            Some(res) => Amount::from_sat(res).check_max(),
             None => None,
         }
     }
@@ -311,8 +325,8 @@ impl Amount {
     #[must_use]
     pub const fn checked_sub(self, rhs: Amount) -> Option<Amount> {
         // No `map()` in const context.
-        match self.0.checked_sub(rhs.0) {
-            Some(res) => Some(Amount(res)),
+        match self.to_sat().checked_sub(rhs.to_sat()) {
+            Some(res) => Some(Amount::from_sat(res)),
             None => None,
         }
     }
@@ -323,8 +337,8 @@ impl Amount {
     #[must_use]
     pub const fn checked_mul(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
-        match self.0.checked_mul(rhs) {
-            Some(res) => Amount(res).check_max(),
+        match self.to_sat().checked_mul(rhs) {
+            Some(res) => Amount::from_sat(res).check_max(),
             None => None,
         }
     }
@@ -337,8 +351,8 @@ impl Amount {
     #[must_use]
     pub const fn checked_div(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
-        match self.0.checked_div(rhs) {
-            Some(res) => Some(Amount(res)),
+        match self.to_sat().checked_div(rhs) {
+            Some(res) => Some(Amount::from_sat(res)),
             None => None,
         }
     }
@@ -349,8 +363,8 @@ impl Amount {
     #[must_use]
     pub const fn checked_rem(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
-        match self.0.checked_rem(rhs) {
-            Some(res) => Some(Amount(res)),
+        match self.to_sat().checked_rem(rhs) {
+            Some(res) => Some(Amount::from_sat(res)),
             None => None,
         }
     }
@@ -364,7 +378,9 @@ impl Amount {
     /// On overflow, panics in debug mode, wraps in release mode.
     #[must_use]
     #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
-    pub fn unchecked_add(self, rhs: Amount) -> Amount { Self(self.0 + rhs.0) }
+    pub fn unchecked_add(self, rhs: Amount) -> Amount {
+        Self::from_sat(self.to_sat() + rhs.to_sat())
+    }
 
     /// Unchecked subtraction.
     ///
@@ -375,7 +391,9 @@ impl Amount {
     /// On overflow, panics in debug mode, wraps in release mode.
     #[must_use]
     #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
-    pub fn unchecked_sub(self, rhs: Amount) -> Amount { Self(self.0 - rhs.0) }
+    pub fn unchecked_sub(self, rhs: Amount) -> Amount {
+        Self::from_sat(self.to_sat() - rhs.to_sat())
+    }
 
     /// Converts to a signed amount.
     #[rustfmt::skip] // Moves code comments to the wrong line.
@@ -385,7 +403,7 @@ impl Amount {
 
     /// Checks if the amount is below the maximum value. Returns `None` if it is above.
     const fn check_max(self) -> Option<Amount> {
-        if self.0 > Self::MAX.0 {
+        if self.to_sat() > Self::MAX.to_sat() {
             None
         } else {
             Some(self)
@@ -445,6 +463,6 @@ impl TryFrom<SignedAmount> for Amount {
 impl<'a> Arbitrary<'a> for Amount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
         let a = u64::arbitrary(u)?;
-        Ok(Self(a))
+        Ok(Self::from_sat(a))
     }
 }

From ac7168020274f2240aa6376b3aa12efc11c0aa57 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 10:21:15 +1100
Subject: [PATCH 504/554] Pick one - MAX or MAX_MONEY

Just use MAX everywhere in this codebase.

After discussion in PR consensus was to just use MAX throughout the
codebase.

ref: https://github.com/rust-bitcoin/rust-bitcoin/pull/4164#discussion_r1979441438
---
 bitcoin/tests/serde.rs       |  2 +-
 units/src/amount/signed.rs   |  2 +-
 units/src/amount/tests.rs    | 31 ++++++++++++++++++++++---------
 units/src/amount/unsigned.rs |  2 +-
 units/tests/str.rs           |  4 ++--
 5 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
index 807f838a6e..dff93b0c50 100644
--- a/bitcoin/tests/serde.rs
+++ b/bitcoin/tests/serde.rs
@@ -110,7 +110,7 @@ fn serde_regression_txin() {
 #[test]
 fn serde_regression_txout() {
     let txout =
-        TxOut { value: Amount::MAX_MONEY, script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]) };
+        TxOut { value: Amount::MAX, script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]) };
     let got = serialize(&txout).unwrap();
     let want = include_bytes!("data/serde/txout_bincode") as &[_];
     assert_eq!(got, want)
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 5e5b4c5a2b..bdabfefde0 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -54,7 +54,7 @@ mod encapsulate {
         ///
         /// Caller to guarantee that `satoshi` is within valid range.
         ///
-        /// See [`Self::MIN`] and [`Self::MAX_MONEY`].
+        /// See [`Self::MIN`] and [`Self::MAX`].
         pub const fn from_sat_unchecked(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
 
         /// Gets the number of satoshis in this [`SignedAmount`].
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index af41eaf627..a692ca6506 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -725,15 +725,28 @@ fn to_from_string_in() {
     assert_eq!(ua_str(&ua_sat(21_000_000).to_string_in(D::Bit), D::Bit), Ok(ua_sat(21_000_000)));
     assert_eq!(ua_str(&ua_sat(0).to_string_in(D::Satoshi), D::Satoshi), Ok(ua_sat(0)));
 
-    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Bitcoin), D::Bitcoin).is_ok());
-    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::CentiBitcoin), D::CentiBitcoin)
-        .is_ok());
-    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MilliBitcoin), D::MilliBitcoin)
-        .is_ok());
-    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MicroBitcoin), D::MicroBitcoin)
-        .is_ok());
+    assert!(
+        ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Bitcoin), D::Bitcoin).is_ok()
+    );
+    assert!(ua_str(
+        &ua_sat(Amount::MAX.to_sat()).to_string_in(D::CentiBitcoin),
+        D::CentiBitcoin
+    )
+    .is_ok());
+    assert!(ua_str(
+        &ua_sat(Amount::MAX.to_sat()).to_string_in(D::MilliBitcoin),
+        D::MilliBitcoin
+    )
+    .is_ok());
+    assert!(ua_str(
+        &ua_sat(Amount::MAX.to_sat()).to_string_in(D::MicroBitcoin),
+        D::MicroBitcoin
+    )
+    .is_ok());
     assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Bit), D::Bit).is_ok());
-    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Satoshi), D::Satoshi).is_ok());
+    assert!(
+        ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Satoshi), D::Satoshi).is_ok()
+    );
 
     assert_eq!(
         sa_str(&SignedAmount::MAX.to_string_in(D::Satoshi), D::MicroBitcoin),
@@ -1276,7 +1289,7 @@ fn check_const() {
     assert_eq!(Amount::ONE_BTC.to_sat(), 100_000_000);
     assert_eq!(SignedAmount::FIFTY_BTC.to_sat(), SignedAmount::ONE_BTC.to_sat() * 50);
     assert_eq!(Amount::FIFTY_BTC.to_sat(), Amount::ONE_BTC.to_sat() * 50);
-    assert_eq!(Amount::MAX_MONEY.to_sat() as i64, SignedAmount::MAX_MONEY.to_sat());
+    assert_eq!(Amount::MAX.to_sat() as i64, SignedAmount::MAX.to_sat());
 }
 
 // Sanity check than stdlib supports the set of reference combinations for the ops we want.
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index ae9c3f5c24..27435fba07 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -52,7 +52,7 @@ mod encapsulate {
     impl Amount {
         /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
         ///
-        /// Caller to guarantee that `satoshi` is within valid range. See [`Self::MAX_MONEY`].
+        /// Caller to guarantee that `satoshi` is within valid range. See [`Self::MAX`].
         pub const fn from_sat_unchecked(satoshi: u64) -> Amount { Self(satoshi) }
 
         /// Gets the number of satoshis in this [`Amount`].
diff --git a/units/tests/str.rs b/units/tests/str.rs
index 89068bf9b3..0b365af201 100644
--- a/units/tests/str.rs
+++ b/units/tests/str.rs
@@ -22,10 +22,10 @@ macro_rules! check {
 
 check! {
     amount_unsigned_one_sat, Amount, Amount::ONE_SAT, "0.00000001 BTC";
-    amount_unsigned_max_money, Amount, Amount::MAX_MONEY, "21000000 BTC";
+    amount_unsigned_max_money, Amount, Amount::MAX, "21000000 BTC";
 
     amount_signed_one_sat, SignedAmount, SignedAmount::ONE_SAT, "0.00000001 BTC";
-    amount_signed_max_money, SignedAmount, SignedAmount::MAX_MONEY, "21000000 BTC";
+    amount_signed_max_money, SignedAmount, SignedAmount::MAX, "21000000 BTC";
 
     block_height_min, BlockHeight, BlockHeight::MIN, "0";
     block_height_max, BlockHeight, BlockHeight::MAX, "4294967295";

From 13595fbe7d5ddcab0492445169297e009b6d6cc7 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 10:45:34 +1100
Subject: [PATCH 505/554] Fix amount whole bitcoin constructors

I royally botched the recent effort to make const amount constructors
use a smaller type. I left in an  unnecessary panic and forgot to do
both of them.

Note these function return values will change again very shortly when we
start enforcing the MAX_MONEY invariant. However the 64 to 32 bit change
is unrelated to that and is easier to review if done separately.

Whole bitcoin can not in any sane environment be greater than 21,000,000
which fits in 32 bits so we can take a 32 bit integer in the whole
bitcoin constructors without loss of utility. Doing so removes the
potential panic.

This is a breaking API change. We elect not to deprecate because we want
to keep the same function names.
---
 units/src/amount/signed.rs   | 26 ++++++++------------------
 units/src/amount/unsigned.rs | 23 ++++++-----------------
 2 files changed, 14 insertions(+), 35 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index bdabfefde0..df9aa18f31 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -121,29 +121,19 @@ impl SignedAmount {
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`].
-    ///
-    /// # Errors
-    ///
-    /// The function errors if the argument multiplied by the number of sats
-    /// per bitcoin overflows an `i64` type.
-    pub fn from_int_btc<T: Into<i64>>(whole_bitcoin: T) -> Result<SignedAmount, OutOfRangeError> {
-        match whole_bitcoin.into().checked_mul(100_000_000) {
-            Some(amount) => Ok(Self::from_sat(amount)),
-            None => Err(OutOfRangeError { is_signed: true, is_greater_than_max: true }),
-        }
+    #[allow(clippy::missing_panics_doc)]
+    pub fn from_int_btc<T: Into<i32>>(whole_bitcoin: T) -> SignedAmount {
+        SignedAmount::from_int_btc_const(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`]
     /// in const context.
-    ///
-    /// # Panics
-    ///
-    /// The function panics if the argument multiplied by the number of sats
-    /// per bitcoin overflows an `i64` type.
-    pub const fn from_int_btc_const(whole_bitcoin: i64) -> SignedAmount {
-        match whole_bitcoin.checked_mul(100_000_000) {
+    #[allow(clippy::missing_panics_doc)]
+    pub const fn from_int_btc_const(whole_bitcoin: i32) -> SignedAmount {
+        let btc = whole_bitcoin as i64; // Can't call `into` in const context.
+        match btc.checked_mul(100_000_000) {
             Some(amount) => SignedAmount::from_sat(amount),
-            None => panic!("checked_mul overflowed"),
+            None => panic!("cannot overflow in i64"),
         }
     }
 
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 27435fba07..167ad85f30 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -119,30 +119,19 @@ impl Amount {
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`].
-    ///
-    /// # Errors
-    ///
-    /// The function errors if the argument multiplied by the number of sats
-    /// per bitcoin overflows a `u64` type.
-    pub fn from_int_btc<T: Into<u64>>(whole_bitcoin: T) -> Result<Amount, OutOfRangeError> {
-        match whole_bitcoin.into().checked_mul(100_000_000) {
-            Some(amount) => Ok(Self::from_sat(amount)),
-            None => Err(OutOfRangeError { is_signed: false, is_greater_than_max: true }),
-        }
+    #[allow(clippy::missing_panics_doc)]
+    pub fn from_int_btc<T: Into<u32>>(whole_bitcoin: T) -> Amount {
+        Amount::from_int_btc_const(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`]
     /// in const context.
-    ///
-    /// # Panics
-    ///
-    /// The function panics if the argument multiplied by the number of sats
-    /// per bitcoin overflows a `u64` type.
+    #[allow(clippy::missing_panics_doc)]
     pub const fn from_int_btc_const(whole_bitcoin: u32) -> Amount {
-        let btc = whole_bitcoin as u64; // Can't call u64::from in const context.
+        let btc = whole_bitcoin as u64; // Can't call `into` in const context.
         match btc.checked_mul(100_000_000) {
             Some(amount) => Amount::from_sat(amount),
-            None => panic!("checked_mul overflowed"),
+            None => panic!("cannot overflow a u64"),
         }
     }
 

From f9eb3079537ebc6d4a43121f7de839ba5b5018dc Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 12:04:18 +1100
Subject: [PATCH 506/554] Remove panic in dust value functions

Calculating the minimum non-dust fee currently panics if either the
script is really big or the dust fee rate is really big.

Harden the API by returning an `Option` instead of panicing.
---
 bitcoin/src/blockdata/script/borrowed.rs | 13 ++++++-------
 bitcoin/src/blockdata/script/tests.rs    |  8 ++++----
 bitcoin/src/blockdata/transaction.rs     |  8 ++++----
 3 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs
index 624feb3b54..4ae5c9ce1d 100644
--- a/bitcoin/src/blockdata/script/borrowed.rs
+++ b/bitcoin/src/blockdata/script/borrowed.rs
@@ -261,7 +261,7 @@ crate::internal_macros::define_extension_trait! {
         /// Returns the minimum value an output with this script should have in order to be
         /// broadcastable on today’s Bitcoin network.
         #[deprecated(since = "0.32.0", note = "use `minimal_non_dust` etc. instead")]
-        fn dust_value(&self) -> Amount { self.minimal_non_dust() }
+        fn dust_value(&self) -> Option<Amount> { self.minimal_non_dust() }
 
         /// Returns the minimum value an output with this script should have in order to be
         /// broadcastable on today's Bitcoin network.
@@ -272,7 +272,7 @@ crate::internal_macros::define_extension_trait! {
         /// To use a custom value, use [`minimal_non_dust_custom`].
         ///
         /// [`minimal_non_dust_custom`]: Script::minimal_non_dust_custom
-        fn minimal_non_dust(&self) -> Amount {
+        fn minimal_non_dust(&self) -> Option<Amount> {
             self.minimal_non_dust_internal(DUST_RELAY_TX_FEE.into())
         }
 
@@ -287,7 +287,7 @@ crate::internal_macros::define_extension_trait! {
         /// To use the default Bitcoin Core value, use [`minimal_non_dust`].
         ///
         /// [`minimal_non_dust`]: Script::minimal_non_dust
-        fn minimal_non_dust_custom(&self, dust_relay_fee: FeeRate) -> Amount {
+        fn minimal_non_dust_custom(&self, dust_relay_fee: FeeRate) -> Option<Amount> {
             self.minimal_non_dust_internal(dust_relay_fee.to_sat_per_kwu() * 4)
         }
 
@@ -394,7 +394,7 @@ mod sealed {
 
 crate::internal_macros::define_extension_trait! {
     pub(crate) trait ScriptExtPriv impl for Script {
-        fn minimal_non_dust_internal(&self, dust_relay_fee: u64) -> Amount {
+        fn minimal_non_dust_internal(&self, dust_relay_fee: u64) -> Option<Amount> {
             // This must never be lower than Bitcoin Core's GetDustThreshold() (as of v0.21) as it may
             // otherwise allow users to create transactions which likely can never be broadcast/confirmed.
             let sats = dust_relay_fee
@@ -408,13 +408,12 @@ crate::internal_macros::define_extension_trait! {
                     32 + 4 + 1 + 107 + 4 + // The spend cost copied from Core
                     8 + // The serialized size of the TxOut's amount field
                     self.consensus_encode(&mut sink()).expect("sinks don't error").to_u64() // The serialized size of this script_pubkey
-                })
-                .expect("dust_relay_fee or script length should not be absurdly large")
+                })?
                 / 1000; // divide by 1000 like in Core to get value as it cancels out DEFAULT_MIN_RELAY_TX_FEE
                         // Note: We ensure the division happens at the end, since Core performs the division at the end.
                         //       This will make sure none of the implicit floor operations mess with the value.
 
-            Amount::from_sat(sats)
+            Some(Amount::from_sat(sats))
         }
 
         fn count_sigops_internal(&self, accurate: bool) -> usize {
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 9b47ef6528..4443645b1b 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -684,10 +684,10 @@ fn default_dust_value() {
     // well-known scriptPubKey types.
     let script_p2wpkh = Builder::new().push_int_unchecked(0).push_slice([42; 20]).into_script();
     assert!(script_p2wpkh.is_p2wpkh());
-    assert_eq!(script_p2wpkh.minimal_non_dust(), Amount::from_sat_unchecked(294));
+    assert_eq!(script_p2wpkh.minimal_non_dust(), Some(Amount::from_sat_unchecked(294)));
     assert_eq!(
         script_p2wpkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
-        Amount::from_sat_unchecked(588)
+        Some(Amount::from_sat_unchecked(588))
     );
 
     let script_p2pkh = Builder::new()
@@ -698,10 +698,10 @@ fn default_dust_value() {
         .push_opcode(OP_CHECKSIG)
         .into_script();
     assert!(script_p2pkh.is_p2pkh());
-    assert_eq!(script_p2pkh.minimal_non_dust(), Amount::from_sat_unchecked(546));
+    assert_eq!(script_p2pkh.minimal_non_dust(), Some(Amount::from_sat_unchecked(546)));
     assert_eq!(
         script_p2pkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
-        Amount::from_sat_unchecked(1092)
+        Some(Amount::from_sat_unchecked(1092))
     );
 }
 
diff --git a/bitcoin/src/blockdata/transaction.rs b/bitcoin/src/blockdata/transaction.rs
index 4510c465d3..0c60d3c654 100644
--- a/bitcoin/src/blockdata/transaction.rs
+++ b/bitcoin/src/blockdata/transaction.rs
@@ -183,8 +183,8 @@ crate::internal_macros::define_extension_trait! {
         /// To use a custom value, use [`minimal_non_dust_custom`].
         ///
         /// [`minimal_non_dust_custom`]: TxOut::minimal_non_dust_custom
-        fn minimal_non_dust(script_pubkey: ScriptBuf) -> Self {
-            TxOut { value: script_pubkey.minimal_non_dust(), script_pubkey }
+        fn minimal_non_dust(script_pubkey: ScriptBuf) -> Option<TxOut> {
+            Some(TxOut { value: script_pubkey.minimal_non_dust()?, script_pubkey })
         }
 
         /// Constructs a new `TxOut` with given script and the smallest possible `value` that is **not** dust
@@ -198,8 +198,8 @@ crate::internal_macros::define_extension_trait! {
         /// To use the default Bitcoin Core value, use [`minimal_non_dust`].
         ///
         /// [`minimal_non_dust`]: TxOut::minimal_non_dust
-        fn minimal_non_dust_custom(script_pubkey: ScriptBuf, dust_relay_fee: FeeRate) -> Self {
-            TxOut { value: script_pubkey.minimal_non_dust_custom(dust_relay_fee), script_pubkey }
+        fn minimal_non_dust_custom(script_pubkey: ScriptBuf, dust_relay_fee: FeeRate) -> Option<TxOut> {
+            Some(TxOut { value: script_pubkey.minimal_non_dust_custom(dust_relay_fee)?, script_pubkey })
         }
     }
 }

From 76a2d70b2866c9a9e2e24c1d71a9630a57559737 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 12:17:57 +1100
Subject: [PATCH 507/554] Make mul weight by fee return NumOpResult

Now that we have the `NumOpResult<Amount>` type that is used to show a
math calculation returned a valid amount we can use it when multiplying
weight and fee rates thus removing panics.
---
 units/src/amount/mod.rs    |  1 +
 units/src/amount/result.rs |  5 ++---
 units/src/fee.rs           | 13 ++++++-------
 3 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 7fb8bc5356..940b9a5a80 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -39,6 +39,7 @@ pub use self::{
     signed::SignedAmount,
     unsigned::Amount,
 };
+pub(crate) use self::result::OptionExt;
 
 /// A set of denominations in which amounts can be expressed.
 ///
diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index ae1c6e12d1..4b78d00800 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Provides a monodic numeric result type that is used to return the result of
-//! doing mathematical operations (`core::ops`) on amount types.
+//! Provides a monodic type used when mathematical operations (`core::ops`) return an amount type.
 
 use core::{fmt, ops};
 
@@ -378,7 +377,7 @@ impl<'a> core::iter::Sum<&'a NumOpResult<SignedAmount>> for NumOpResult<SignedAm
     }
 }
 
-pub(in crate::amount) trait OptionExt<T> {
+pub(crate) trait OptionExt<T> {
     fn valid_or_error(self) -> NumOpResult<T>;
 }
 
diff --git a/units/src/fee.rs b/units/src/fee.rs
index 1bb3b9b665..39dff63b07 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -13,6 +13,7 @@
 
 use core::ops;
 
+use crate::amount::{NumOpResult, OptionExt};
 use crate::{Amount, FeeRate, Weight};
 
 impl Amount {
@@ -160,17 +161,15 @@ impl FeeRate {
 
 /// Computes the ceiling so that the fee computation is conservative.
 impl ops::Mul<FeeRate> for Weight {
-    type Output = Amount;
+    type Output = NumOpResult<Amount>;
 
-    fn mul(self, rhs: FeeRate) -> Self::Output {
-        Amount::from_sat((rhs.to_sat_per_kwu() * self.to_wu() + 999) / 1000)
-    }
+    fn mul(self, rhs: FeeRate) -> Self::Output { rhs.checked_mul_by_weight(self).valid_or_error() }
 }
 
 impl ops::Mul<Weight> for FeeRate {
-    type Output = Amount;
+    type Output = NumOpResult<Amount>;
 
-    fn mul(self, rhs: Weight) -> Self::Output { rhs * self }
+    fn mul(self, rhs: Weight) -> Self::Output { self.checked_mul_by_weight(rhs).valid_or_error() }
 }
 
 impl ops::Div<Weight> for Amount {
@@ -265,7 +264,7 @@ mod tests {
         let three = Weight::from_vb(3).unwrap();
         let six = Amount::from_sat_unchecked(6);
 
-        assert_eq!(two * three, six);
+        assert_eq!(two * three, six.into());
     }
 
     #[test]

From 5d851f1c3e98d7d426e5897b2d734b77a299ccfb Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 13:02:38 +1100
Subject: [PATCH 508/554] Remove deprecated amount methods

When we enforce the MAX_MONEY invariant these functions would require
the function signature changing - might as well just delete them.
---
 units/src/amount/signed.rs   | 26 --------------------------
 units/src/amount/tests.rs    |  9 ---------
 units/src/amount/unsigned.rs | 26 --------------------------
 3 files changed, 61 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index df9aa18f31..a04795de6e 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -402,32 +402,6 @@ impl SignedAmount {
         }
     }
 
-    /// Unchecked addition.
-    ///
-    /// Computes `self + rhs`.
-    ///
-    /// # Panics
-    ///
-    /// On overflow, panics in debug mode, wraps in release mode.
-    #[must_use]
-    #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
-    pub fn unchecked_add(self, rhs: SignedAmount) -> SignedAmount {
-        Self::from_sat(self.to_sat() + rhs.to_sat())
-    }
-
-    /// Unchecked subtraction.
-    ///
-    /// Computes `self - rhs`.
-    ///
-    /// # Panics
-    ///
-    /// On overflow, panics in debug mode, wraps in release mode.
-    #[must_use]
-    #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
-    pub fn unchecked_sub(self, rhs: SignedAmount) -> SignedAmount {
-        Self::from_sat(self.to_sat() - rhs.to_sat())
-    }
-
     /// Subtraction that doesn't allow negative [`SignedAmount`]s.
     ///
     /// Returns [`None`] if either `self`, `rhs` or the result is strictly negative.
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index a692ca6506..2d3b5e1c62 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -180,15 +180,6 @@ fn checked_arithmetic() {
     assert_eq!(ssat(-6).checked_div(2), Some(ssat(-3)));
 }
 
-#[test]
-#[allow(deprecated_in_future)]
-fn unchecked_arithmetic() {
-    assert_eq!(ssat(10).unchecked_add(ssat(20)), ssat(30));
-    assert_eq!(ssat(50).unchecked_sub(ssat(10)), ssat(40));
-    assert_eq!(sat(5).unchecked_add(sat(7)), sat(12));
-    assert_eq!(sat(10).unchecked_sub(sat(7)), sat(3));
-}
-
 #[test]
 fn positive_sub() {
     assert_eq!(ssat(10).positive_sub(ssat(7)).unwrap(), ssat(3));
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 167ad85f30..c3488dfafa 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -358,32 +358,6 @@ impl Amount {
         }
     }
 
-    /// Unchecked addition.
-    ///
-    /// Computes `self + rhs`.
-    ///
-    /// # Panics
-    ///
-    /// On overflow, panics in debug mode, wraps in release mode.
-    #[must_use]
-    #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
-    pub fn unchecked_add(self, rhs: Amount) -> Amount {
-        Self::from_sat(self.to_sat() + rhs.to_sat())
-    }
-
-    /// Unchecked subtraction.
-    ///
-    /// Computes `self - rhs`.
-    ///
-    /// # Panics
-    ///
-    /// On overflow, panics in debug mode, wraps in release mode.
-    #[must_use]
-    #[deprecated(since = "TBD", note = "consider converting to u64 using `to_sat`")]
-    pub fn unchecked_sub(self, rhs: Amount) -> Amount {
-        Self::from_sat(self.to_sat() - rhs.to_sat())
-    }
-
     /// Converts to a signed amount.
     #[rustfmt::skip] // Moves code comments to the wrong line.
     pub fn to_signed(self) -> SignedAmount {

From e4513bf9250799bc18a10728af184d6c86a561a4 Mon Sep 17 00:00:00 2001
From: ChrisCho-H <c.hyunhum@gmail.com>
Date: Tue, 11 Mar 2025 10:04:13 +0900
Subject: [PATCH 509/554] feat: add MAX_BLOCK_SERIALIZED_SIZE existing in core

---
 bitcoin/src/blockdata/constants.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 2c5cb4e193..ae0d48df8f 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -52,6 +52,8 @@ pub const SUBSIDY_HALVING_INTERVAL: u32 = 210_000;
 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;
+/// The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
+pub const MAX_BLOCK_SERIALIZED_SIZE: usize = 4_000_000;
 
 // This is the 65 byte (uncompressed) pubkey used as the one-and-only output of the genesis transaction.
 //

From 968406cb95d7490869de9f23022f5c77a3665de8 Mon Sep 17 00:00:00 2001
From: planetBoy <140164174+Guayaba221@users.noreply.github.com>
Date: Tue, 11 Mar 2025 15:43:09 +0100
Subject: [PATCH 510/554] Update ecdsa-psbt.rs

---
 bitcoin/examples/ecdsa-psbt.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/examples/ecdsa-psbt.rs b/bitcoin/examples/ecdsa-psbt.rs
index 54ae34767c..e6bbaf1e66 100644
--- a/bitcoin/examples/ecdsa-psbt.rs
+++ b/bitcoin/examples/ecdsa-psbt.rs
@@ -54,7 +54,7 @@ const INPUT_UTXO_TXID: &str = "295f06639cde6039bf0c3dbf4827f0e3f2b2c2b476408e2f9
 const INPUT_UTXO_VOUT: u32 = 0;
 const INPUT_UTXO_SCRIPT_PUBKEY: &str = "00149891eeb8891b3e80a2a1ade180f143add23bf5de";
 const INPUT_UTXO_VALUE: &str = "50 BTC";
-// Get this from the desciptor,
+// Get this from the descriptor,
 // "wpkh([97f17dca/0'/0'/0']02749483607dafb30c66bd93ece4474be65745ce538c2d70e8e246f17e7a4e0c0c)#m9n56cx0".
 const INPUT_UTXO_DERIVATION_PATH: &str = "0h/0h/0h";
 

From c0e20dbf2e1406a3f3df5538d1397b233078cd7c Mon Sep 17 00:00:00 2001
From: Bruno Garcia <brunoely.gc@gmail.com>
Date: Tue, 11 Mar 2025 18:24:16 -0300
Subject: [PATCH 511/554] test: add coverage for ServiceFlags::P2P_V2

---
 bitcoin/src/p2p/mod.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/p2p/mod.rs b/bitcoin/src/p2p/mod.rs
index b594a6693d..cb9c1f5a86 100644
--- a/bitcoin/src/p2p/mod.rs
+++ b/bitcoin/src/p2p/mod.rs
@@ -405,6 +405,7 @@ mod tests {
             ServiceFlags::WITNESS,
             ServiceFlags::COMPACT_FILTERS,
             ServiceFlags::NETWORK_LIMITED,
+            ServiceFlags::P2P_V2,
         ];
 
         let mut flags = ServiceFlags::NONE;
@@ -430,8 +431,12 @@ mod tests {
         // 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());
+        assert_eq!("ServiceFlags(P2P_V2)", ServiceFlags::P2P_V2.to_string());
+        let flag = ServiceFlags::WITNESS
+            | ServiceFlags::BLOOM
+            | ServiceFlags::NETWORK
+            | ServiceFlags::P2P_V2;
+        assert_eq!("ServiceFlags(NETWORK|BLOOM|WITNESS|P2P_V2)", flag.to_string());
         let flag = ServiceFlags::WITNESS | 0xf0.into();
         assert_eq!("ServiceFlags(WITNESS|COMPACT_FILTERS|0xb0)", flag.to_string());
     }

From 61e7226299fbfb13f34ba27e45042019a92b050d Mon Sep 17 00:00:00 2001
From: kevincatty <zhanshanmao@outlook.com>
Date: Wed, 12 Mar 2025 16:51:55 +0800
Subject: [PATCH 512/554] chore: add missing backquotes

Signed-off-by: kevincatty <zhanshanmao@outlook.com>
---
 bitcoin/src/address/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 72a3ec7db6..a4588617aa 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -938,7 +938,7 @@ impl<V: NetworkValidation> fmt::Debug for Address<V> {
 /// Address can be parsed only with `NetworkUnchecked`.
 ///
 /// Only SegWit bech32 addresses prefixed with `bc`, `bcrt` or `tb` and legacy base58 addresses
-/// prefixed with `1`, `2, `3`, `m` or `n` are supported.
+/// prefixed with `1`, `2`, `3`, `m` or `n` are supported.
 ///
 /// # Errors
 ///

From 3e750d7ba1469540e057ad763b31b6a725a6f397 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 7 Mar 2025 16:04:10 +0000
Subject: [PATCH 513/554] Create test helper function to create a header

Move the header creation to the helper function so it can be used in
further tests.
---
 primitives/src/block.rs | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index 3b49256100..3ac68ad744 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -361,6 +361,17 @@ impl<'a> Arbitrary<'a> for Version {
 mod tests {
     use super::*;
 
+    fn dummy_header() -> Header {
+        Header {
+            version: Version::ONE,
+            prev_blockhash: BlockHash::from_byte_array([0x99; 32]),
+            merkle_root: TxMerkleNode::from_byte_array([0x77; 32]),
+            time: Timestamp::from(2),
+            bits: CompactTarget::from_consensus(3),
+            nonce: 4,
+        }
+    }
+
     #[test]
     fn version_is_not_signalling_with_invalid_bit() {
         let arbitrary_version = Version::from_consensus(1_234_567_890);
@@ -398,14 +409,7 @@ mod tests {
     // Check that the size of the header consensus serialization matches the const SIZE value
     #[test]
     fn header_size() {
-        let header = Header {
-            version: Version::ONE,
-            prev_blockhash: BlockHash::from_byte_array([0x99; 32]),
-            merkle_root: TxMerkleNode::from_byte_array([0x77; 32]),
-            time: Timestamp::from(2),
-            bits: CompactTarget::from_consensus(3),
-            nonce: 4,
-        };
+        let header = dummy_header();
 
         // Calculate the size of the block header in bytes from the sum of the serialized lengths
         // it's fields: version, prev_blockhash, merkle_root, time, bits, nonce.

From c1ea20b958f448a5a35073ce3d5bd5394918eb9b Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Fri, 7 Mar 2025 16:33:19 +0000
Subject: [PATCH 514/554] Increase test coverage in block.rs

Add tests to `primitive::block` module to increase test coverage.
---
 primitives/src/block.rs | 110 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)

diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index 3ac68ad744..56673fa414 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -406,6 +406,12 @@ mod tests {
         assert_eq!(version.to_consensus(), 1_234_567_890);
     }
 
+    #[test]
+    fn version_default() {
+        let version = Version::default();
+        assert_eq!(version.to_consensus(), Version::NO_SOFT_FORK_SIGNALLING.to_consensus());
+    }
+
     // Check that the size of the header consensus serialization matches the const SIZE value
     #[test]
     fn header_size() {
@@ -422,4 +428,108 @@ mod tests {
 
         assert_eq!(header_size, Header::SIZE);
     }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_new_unchecked() {
+        let header = dummy_header();
+        let transactions = vec![];
+        let block = Block::new_unchecked(header, transactions.clone());
+        assert_eq!(block.header, header);
+        assert_eq!(block.transactions, transactions);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_assume_checked() {
+        let header = dummy_header();
+        let transactions = vec![];
+        let block = Block::new_unchecked(header, transactions.clone());
+        let witness_root = Some(WitnessMerkleNode::from_byte_array([0x88; 32]));
+        let checked_block = block.assume_checked(witness_root);
+        assert_eq!(checked_block.header(), &header);
+        assert_eq!(checked_block.transactions(), &transactions);
+        assert_eq!(checked_block.cached_witness_root(), witness_root);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_into_parts() {
+        let header = dummy_header();
+        let transactions = vec![];
+        let block = Block::new_unchecked(header, transactions.clone());
+        let (block_header, block_transactions) = block.into_parts();
+        assert_eq!(block_header, header);
+        assert_eq!(block_transactions, transactions);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_cached_witness_root() {
+        let header = dummy_header();
+        let transactions = vec![];
+        let block = Block::new_unchecked(header, transactions);
+        let witness_root = Some(WitnessMerkleNode::from_byte_array([0x88; 32]));
+        let checked_block = block.assume_checked(witness_root);
+        assert_eq!(checked_block.cached_witness_root(), witness_root);
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_block_hash() {
+        let header = dummy_header();
+        let transactions = vec![];
+        let block = Block::new_unchecked(header, transactions);
+        assert_eq!(block.block_hash(), header.block_hash());
+    }
+
+    #[test]
+    fn block_hash_from_header() {
+        let header = dummy_header();
+        let block_hash = header.block_hash();
+        assert_eq!(block_hash, BlockHash::from(header));
+    }
+
+    #[test]
+    fn block_hash_from_header_ref() {
+        let header = dummy_header();
+        let block_hash: BlockHash = BlockHash::from(&header);
+        assert_eq!(block_hash, header.block_hash());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_hash_from_block() {
+        let header = dummy_header();
+        let transactions = vec![];
+        let block = Block::new_unchecked(header, transactions);
+        let block_hash: BlockHash = BlockHash::from(block);
+        assert_eq!(block_hash, header.block_hash());
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn block_hash_from_block_ref() {
+        let header = dummy_header();
+        let transactions = vec![];
+        let block = Block::new_unchecked(header, transactions);
+        let block_hash: BlockHash = BlockHash::from(&block);
+        assert_eq!(block_hash, header.block_hash());
+    }
+
+    #[test]
+    fn header_debug() {
+        let header = dummy_header();
+        let expected = format!(
+            "Header {{ block_hash: {:?}, version: {:?}, prev_blockhash: {:?}, merkle_root: {:?}, time: {:?}, bits: {:?}, nonce: {:?} }}",
+            header.block_hash(),
+            header.version,
+            header.prev_blockhash,
+            header.merkle_root,
+            header.time,
+            header.bits,
+            header.nonce
+        );
+        assert_eq!(format!("{:?}", header), expected);
+    }
 }

From 93c6c8cef59ceed56932d62daeb212c2b40fc4a1 Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Wed, 12 Mar 2025 15:14:52 -0300
Subject: [PATCH 515/554] Use impl_op_for_references macro in fee module

This commit replaces the individual operator implementations in the fee
module with the impl_op_for_references macro to handle reference operations.
This removes the need to manually implement reference combinations for
operands, simplifying the code and improving consistency.

The change:
- Replaces direct implementations of operators with macro usage
- Adds tests to verify that reference operations work correctly
- Maintains the same semantics as the original implementation
---
 units/src/fee.rs | 68 +++++++++++++++++++++++++++---------------------
 1 file changed, 38 insertions(+), 30 deletions(-)

diff --git a/units/src/fee.rs b/units/src/fee.rs
index 39dff63b07..c8dbc900c0 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -159,42 +159,36 @@ impl FeeRate {
     }
 }
 
-/// Computes the ceiling so that the fee computation is conservative.
-impl ops::Mul<FeeRate> for Weight {
-    type Output = NumOpResult<Amount>;
-
-    fn mul(self, rhs: FeeRate) -> Self::Output { rhs.checked_mul_by_weight(self).valid_or_error() }
-}
-
-impl ops::Mul<Weight> for FeeRate {
-    type Output = NumOpResult<Amount>;
+crate::internal_macros::impl_op_for_references! {
+    impl ops::Mul<FeeRate> for Weight {
+        type Output = NumOpResult<Amount>;
+        fn mul(self, rhs: FeeRate) -> Self::Output {
+            rhs.checked_mul_by_weight(self).valid_or_error()
+        }
+    }
 
-    fn mul(self, rhs: Weight) -> Self::Output { self.checked_mul_by_weight(rhs).valid_or_error() }
-}
+    impl ops::Mul<Weight> for FeeRate {
+        type Output = NumOpResult<Amount>;
+        fn mul(self, rhs: Weight) -> Self::Output {
+            self.checked_mul_by_weight(rhs).valid_or_error()
+        }
+    }
 
-impl ops::Div<Weight> for Amount {
-    type Output = FeeRate;
+    impl ops::Div<Weight> for Amount {
+        type Output = FeeRate;
 
-    /// Truncating integer division.
-    ///
-    /// This is likely the wrong thing for a user dividing an amount by a weight. Consider using
-    /// `checked_div_by_weight` instead.
-    fn div(self, rhs: Weight) -> Self::Output {
-        FeeRate::from_sat_per_kwu(self.to_sat() * 1000 / rhs.to_wu())
+        fn div(self, rhs: Weight) -> Self::Output {
+            FeeRate::from_sat_per_kwu(self.to_sat() * 1000 / rhs.to_wu())
+        }
     }
-}
 
-impl ops::Div<FeeRate> for Amount {
-    type Output = Weight;
+    impl ops::Div<FeeRate> for Amount {
+        type Output = Weight;
 
-    /// Truncating integer division.
-    ///
-    /// # Panics
-    ///
-    /// This operation will panic if `fee_rate` is zero or the division results in overflow.
-    ///
-    /// Note: This uses floor division. For ceiling division use [`Amount::checked_div_by_fee_rate_ceil`].
-    fn div(self, rhs: FeeRate) -> Self::Output { self.checked_div_by_fee_rate_floor(rhs).unwrap() }
+        fn div(self, rhs: FeeRate) -> Self::Output {
+            self.checked_div_by_fee_rate_floor(rhs).unwrap()
+        }
+    }
 }
 
 impl Weight {
@@ -265,9 +259,15 @@ mod tests {
         let six = Amount::from_sat_unchecked(6);
 
         assert_eq!(two * three, six.into());
+
+        // Test reference operators
+        assert_eq!(&two * three, six.into());
+        assert_eq!(two * &three, six.into());
+        assert_eq!(&two * &three, six.into());
     }
 
     #[test]
+    #[allow(clippy::op_ref)]
     fn amount_div_by_fee_rate() {
         // Test exact division
         let amount = Amount::from_sat_unchecked(1000);
@@ -275,6 +275,14 @@ mod tests {
         let weight = amount / fee_rate;
         assert_eq!(weight, Weight::from_wu(500_000));
 
+        // Test reference division
+        let weight_ref = &amount / fee_rate;
+        assert_eq!(weight_ref, Weight::from_wu(500_000));
+        let weight_ref2 = amount / &fee_rate;
+        assert_eq!(weight_ref2, Weight::from_wu(500_000));
+        let weight_ref3 = &amount / &fee_rate;
+        assert_eq!(weight_ref3, Weight::from_wu(500_000));
+
         // Test truncation behavior
         let amount = Amount::from_sat_unchecked(1000);
         let fee_rate = FeeRate::from_sat_per_kwu(3);

From ab4ea7c13d08411044bd5f9c17457e926c80ed4d Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 28 Feb 2025 13:08:33 +1100
Subject: [PATCH 516/554] Enforce the MAX_MONEY invariant in amount types

Enforcing the MAX_MONEY invariant is quite involved because it means
multiple things:

- Constructing amounts is now fallible
- Converting from unsigned to signed is now infallible
- Taking the absolute value is now infallible
- Integer overflow is illuminated in various places

Details:

- Update from_sat to check the invariant
- Fix all docs including examples
- Use the unchecked constructor in test code
- Comment any other use of the unchecked constructor
- Deprecate unchecked_abs
- Fail serde (using the horrible string error variant)
- Try not to use the unchecked constructor in rustdocs, no need to encourage unsuspecting users to use it.
- Use ? in rustdoc examples (required by Rust API guidlines)
- Remove TryFrom<Amount> for SignedAmount because the conversion is now infallible. Add a From impl.
- Fix the arbitrary impls
- Maintain correct formatting
- Remove private check_max function as its no longer needed
---
 bitcoin/src/blockdata/script/borrowed.rs |   2 +-
 bitcoin/src/lib.rs                       |   6 +-
 bitcoin/src/psbt/mod.rs                  |   4 +-
 bitcoin/tests/psbt-sign-taproot.rs       |   8 +-
 primitives/src/transaction.rs            |   4 +-
 units/src/amount/mod.rs                  |   5 +-
 units/src/amount/result.rs               |   4 +-
 units/src/amount/serde.rs                |   6 +-
 units/src/amount/signed.rs               | 153 ++++++++++++++---------
 units/src/amount/tests.rs                |  62 ++++-----
 units/src/amount/unsigned.rs             | 123 +++++++++++-------
 units/src/amount/verification.rs         |  46 +++----
 units/src/fee.rs                         |  10 +-
 13 files changed, 250 insertions(+), 183 deletions(-)

diff --git a/bitcoin/src/blockdata/script/borrowed.rs b/bitcoin/src/blockdata/script/borrowed.rs
index 4ae5c9ce1d..c048ba3670 100644
--- a/bitcoin/src/blockdata/script/borrowed.rs
+++ b/bitcoin/src/blockdata/script/borrowed.rs
@@ -413,7 +413,7 @@ crate::internal_macros::define_extension_trait! {
                         // Note: We ensure the division happens at the end, since Core performs the division at the end.
                         //       This will make sure none of the implicit floor operations mess with the value.
 
-            Some(Amount::from_sat(sats))
+            Amount::from_sat(sats).ok()
         }
 
         fn count_sigops_internal(&self, accurate: bool) -> usize {
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index 3082483131..29fe224838 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -198,7 +198,7 @@ pub mod amount {
     //! This module mainly introduces the [`Amount`] and [`SignedAmount`] types.
     //! We refer to the documentation on the types for more information.
 
-    use crate::consensus::{encode, Decodable, Encodable};
+    use crate::consensus::{self, encode, Decodable, Encodable};
     use crate::io::{BufRead, Write};
 
     #[rustfmt::skip]            // Keep public re-exports separate.
@@ -215,7 +215,9 @@ pub mod amount {
     impl Decodable for Amount {
         #[inline]
         fn consensus_decode<R: BufRead + ?Sized>(r: &mut R) -> Result<Self, encode::Error> {
-            Ok(Amount::from_sat(Decodable::consensus_decode(r)?))
+            Amount::from_sat(Decodable::consensus_decode(r)?).map_err(|_| {
+                consensus::parse_failed_error("amount is greater than Amount::MAX_MONEY")
+            })
         }
     }
 
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index b2787d73e9..bfe5282586 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -1268,7 +1268,7 @@ mod tests {
                     witness: Witness::default(),
                 }],
                 output: vec![TxOut {
-                    value: Amount::from_sat(output),
+                    value: Amount::from_sat(output).unwrap(),
                     script_pubkey: ScriptBuf::from_hex(
                         "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
                     )
@@ -1282,7 +1282,7 @@ mod tests {
 
             inputs: vec![Input {
                 witness_utxo: Some(TxOut {
-                    value: Amount::from_sat(input),
+                    value: Amount::from_sat(input).unwrap(),
                     script_pubkey: ScriptBuf::from_hex(
                         "a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587",
                     )
diff --git a/bitcoin/tests/psbt-sign-taproot.rs b/bitcoin/tests/psbt-sign-taproot.rs
index 89611e7995..0f8cf5933c 100644
--- a/bitcoin/tests/psbt-sign-taproot.rs
+++ b/bitcoin/tests/psbt-sign-taproot.rs
@@ -205,7 +205,7 @@ fn create_psbt_for_taproot_key_path_spend(
 ) -> Psbt {
     let send_value = 6400;
     let out_puts = vec![TxOut {
-        value: Amount::from_sat(send_value),
+        value: Amount::from_sat(send_value).unwrap(),
         script_pubkey: to_address.script_pubkey(),
     }];
     let prev_tx_id = "06980ca116f74c7845a897461dd0e1d15b114130176de5004957da516b4dee3a";
@@ -243,7 +243,7 @@ fn create_psbt_for_taproot_key_path_spend(
     let mut input = Input {
         witness_utxo: {
             let script_pubkey = from_address.script_pubkey();
-            Some(TxOut { value: Amount::from_sat(utxo_value), script_pubkey })
+            Some(TxOut { value: Amount::from_sat(utxo_value).unwrap(), script_pubkey })
         },
         tap_key_origins: origins,
         ..Default::default()
@@ -283,7 +283,7 @@ fn create_psbt_for_taproot_script_path_spend(
     let mfp = "73c5da0a";
 
     let out_puts = vec![TxOut {
-        value: Amount::from_sat(send_value),
+        value: Amount::from_sat(send_value).unwrap(),
         script_pubkey: to_address.script_pubkey(),
     }];
     let prev_tx_id = "9d7c6770fca57285babab60c51834cfcfd10ad302119cae842d7216b4ac9a376";
@@ -322,7 +322,7 @@ fn create_psbt_for_taproot_script_path_spend(
     let mut input = Input {
         witness_utxo: {
             let script_pubkey = from_address.script_pubkey();
-            Some(TxOut { value: Amount::from_sat(utxo_value), script_pubkey })
+            Some(TxOut { value: Amount::from_sat(utxo_value).unwrap(), script_pubkey })
         },
         tap_key_origins: origins,
         tap_scripts,
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 6dfef80a82..bb2f815229 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -670,7 +670,7 @@ mod tests {
             witness: Witness::new(),
         };
 
-        let txout = TxOut { value: Amount::from_sat(123_456_789), script_pubkey: ScriptBuf::new() };
+        let txout = TxOut { value: Amount::from_sat(123_456_789).unwrap(), script_pubkey: ScriptBuf::new() };
 
         let tx_orig = Transaction {
             version: Version::ONE,
@@ -682,7 +682,7 @@ mod tests {
         // Test changing the transaction
         let mut tx = tx_orig.clone();
         tx.inputs_mut()[0].previous_output.txid = Txid::from_byte_array([0xFF; 32]);
-        tx.outputs_mut()[0].value = Amount::from_sat(987_654_321);
+        tx.outputs_mut()[0].value = Amount::from_sat(987_654_321).unwrap();
         assert_eq!(tx.inputs()[0].previous_output.txid.to_byte_array(), [0xFF; 32]);
         assert_eq!(tx.outputs()[0].value.to_sat(), 987_654_321);
 
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 940b9a5a80..9333b87e6c 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -59,7 +59,7 @@ pub(crate) use self::result::OptionExt;
 /// # Examples
 ///
 /// ```
-/// # use bitcoin_units::Amount;
+/// # use bitcoin_units::{amount, Amount};
 ///
 /// let equal = [
 ///     ("1 BTC", 100_000_000),
@@ -72,9 +72,10 @@ pub(crate) use self::result::OptionExt;
 /// for (string, sats) in equal {
 ///     assert_eq!(
 ///         string.parse::<Amount>().expect("valid bitcoin amount string"),
-///         Amount::from_sat(sats),
+///         Amount::from_sat(sats)?,
 ///     )
 /// }
+/// # Ok::<_, amount::OutOfRangeError>(())
 /// ```
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 #[non_exhaustive]
diff --git a/units/src/amount/result.rs b/units/src/amount/result.rs
index 4b78d00800..ab06f207fc 100644
--- a/units/src/amount/result.rs
+++ b/units/src/amount/result.rs
@@ -328,7 +328,9 @@ crate::internal_macros::impl_op_for_references! {
 impl ops::Neg for SignedAmount {
     type Output = Self;
 
-    fn neg(self) -> Self::Output { Self::from_sat(self.to_sat().neg()) }
+    fn neg(self) -> Self::Output {
+        Self::from_sat(self.to_sat().neg()).expect("all +ve and -ve values are valid")
+    }
 }
 
 impl core::iter::Sum<NumOpResult<Amount>> for NumOpResult<Amount> {
diff --git a/units/src/amount/serde.rs b/units/src/amount/serde.rs
index 4754d6cb2e..1db2e9eea2 100644
--- a/units/src/amount/serde.rs
+++ b/units/src/amount/serde.rs
@@ -92,7 +92,8 @@ impl SerdeAmount for Amount {
         u64::serialize(&self.to_sat(), s)
     }
     fn des_sat<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
-        Ok(Amount::from_sat(u64::deserialize(d)?))
+        use serde::de::Error;
+        Amount::from_sat(u64::deserialize(d)?).map_err(D::Error::custom)
     }
     #[cfg(feature = "alloc")]
     fn ser_btc<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
@@ -137,7 +138,8 @@ impl SerdeAmount for SignedAmount {
         i64::serialize(&self.to_sat(), s)
     }
     fn des_sat<'d, D: Deserializer<'d>>(d: D, _: private::Token) -> Result<Self, D::Error> {
-        Ok(SignedAmount::from_sat(i64::deserialize(d)?))
+        use serde::de::Error;
+        SignedAmount::from_sat(i64::deserialize(d)?).map_err(D::Error::custom)
     }
     #[cfg(feature = "alloc")]
     fn ser_btc<S: Serializer>(self, s: S, _: private::Token) -> Result<S::Ok, S::Error> {
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index a04795de6e..3f7927b47b 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -87,17 +87,29 @@ impl SignedAmount {
     /// The maximum value of an amount.
     pub const MAX: Self = SignedAmount::MAX_MONEY;
 
-    /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
+    /// Constructs a new [`SignedAmount`] from the given number of satoshis.
+    ///
+    /// # Errors
+    ///
+    /// If `satoshi` is outside of valid range (see [`Self::MAX_MONEY`]).
     ///
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::SignedAmount;
-    /// let amount = SignedAmount::from_sat(-100_000);
-    /// assert_eq!(amount.to_sat(), -100_000);
+    /// # use bitcoin_units::{amount, SignedAmount};
+    /// # let sat = -100_000;
+    /// let amount = SignedAmount::from_sat(sat)?;
+    /// assert_eq!(amount.to_sat(), sat);
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
-    pub const fn from_sat(satoshi: i64) -> SignedAmount {
-        SignedAmount::from_sat_unchecked(satoshi)
+    pub const fn from_sat(satoshi: i64) -> Result<SignedAmount, OutOfRangeError> {
+        if satoshi < Self::MIN.to_sat() {
+            Err(OutOfRangeError { is_signed: true, is_greater_than_max: false })
+        } else if satoshi > Self::MAX_MONEY.to_sat() {
+            Err(OutOfRangeError { is_signed: true, is_greater_than_max: true })
+        } else {
+            Ok(SignedAmount::from_sat_unchecked(satoshi))
+        }
     }
 
     /// Converts from a value expressing a decimal number of bitcoin to a [`SignedAmount`].
@@ -111,9 +123,10 @@ impl SignedAmount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::SignedAmount;
-    /// let amount = SignedAmount::from_btc(-0.01).expect("we know 0.01 is valid");
+    /// # use bitcoin_units::{amount, SignedAmount};
+    /// let amount = SignedAmount::from_btc(-0.01)?;
     /// assert_eq!(amount.to_sat(), -1_000_000);
+    /// # Ok::<_, amount::ParseAmountError>(())
     /// ```
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<SignedAmount, ParseAmountError> {
@@ -121,15 +134,23 @@ impl SignedAmount {
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`].
+    ///
+    /// # Errors
+    ///
+    /// If `whole_bitcoin` is greater than `21_000_000`.
     #[allow(clippy::missing_panics_doc)]
-    pub fn from_int_btc<T: Into<i32>>(whole_bitcoin: T) -> SignedAmount {
+    pub fn from_int_btc<T: Into<i32>>(whole_bitcoin: T) -> Result<SignedAmount, OutOfRangeError> {
         SignedAmount::from_int_btc_const(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`]
     /// in const context.
+    ///
+    /// # Errors
+    ///
+    /// If `whole_bitcoin` is greater than `21_000_000`.
     #[allow(clippy::missing_panics_doc)]
-    pub const fn from_int_btc_const(whole_bitcoin: i32) -> SignedAmount {
+    pub const fn from_int_btc_const(whole_bitcoin: i32) -> Result<SignedAmount, OutOfRangeError> {
         let btc = whole_bitcoin as i64; // Can't call `into` in const context.
         match btc.checked_mul(100_000_000) {
             Some(amount) => SignedAmount::from_sat(amount),
@@ -151,11 +172,11 @@ impl SignedAmount {
             (false, sat) if sat > SignedAmount::MAX.to_sat() as u64 => Err(ParseAmountError(
                 ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_big(true)),
             )),
-            (false, sat) => Ok(SignedAmount::from_sat(sat as i64)), // Cast ok, value in this arm does not wrap.
+            (false, sat) => Ok(SignedAmount::from_sat_unchecked(sat as i64)), // Cast ok, value in this arm does not wrap.
             (true, sat) if sat > SignedAmount::MIN.to_sat().unsigned_abs() => Err(
                 ParseAmountError(ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_small())),
             ),
-            (true, sat) => Ok(SignedAmount::from_sat(-(sat as i64))), // Cast ok, value in this arm does not wrap.
+            (true, sat) => Ok(SignedAmount::from_sat_unchecked(-(sat as i64))), // Cast ok, value in this arm does not wrap.
         }
     }
 
@@ -173,7 +194,7 @@ impl SignedAmount {
     /// ```
     /// # use bitcoin_units::{amount, SignedAmount};
     /// let amount = SignedAmount::from_str_with_denomination("0.1 BTC")?;
-    /// assert_eq!(amount, SignedAmount::from_sat(10_000_000));
+    /// assert_eq!(amount, SignedAmount::from_sat(10_000_000)?);
     /// # Ok::<_, amount::ParseError>(())
     /// ```
     pub fn from_str_with_denomination(s: &str) -> Result<SignedAmount, ParseError> {
@@ -188,9 +209,10 @@ impl SignedAmount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
-    /// let amount = SignedAmount::from_sat(100_000);
-    /// assert_eq!(amount.to_float_in(Denomination::Bitcoin), 0.001)
+    /// # use bitcoin_units::amount::{self, SignedAmount, Denomination};
+    /// let amount = SignedAmount::from_sat(100_000)?;
+    /// assert_eq!(amount.to_float_in(Denomination::Bitcoin), 0.001);
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[cfg(feature = "alloc")]
     #[allow(clippy::missing_panics_doc)]
@@ -205,9 +227,10 @@ impl SignedAmount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
-    /// let amount = SignedAmount::from_sat(100_000);
-    /// assert_eq!(amount.to_btc(), amount.to_float_in(Denomination::Bitcoin))
+    /// # use bitcoin_units::amount::{self, SignedAmount, Denomination};
+    /// let amount = SignedAmount::from_sat(100_000)?;
+    /// assert_eq!(amount.to_btc(), amount.to_float_in(Denomination::Bitcoin));
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[cfg(feature = "alloc")]
     pub fn to_btc(self) -> f64 { self.to_float_in(Denomination::Bitcoin) }
@@ -236,13 +259,13 @@ impl SignedAmount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
+    /// # use bitcoin_units::amount::{self, SignedAmount, Denomination};
     /// # use std::fmt::Write;
-    /// let amount = SignedAmount::from_sat(10_000_000);
+    /// let amount = SignedAmount::from_sat(10_000_000)?;
     /// let mut output = String::new();
-    /// write!(&mut output, "{}", amount.display_in(Denomination::Bitcoin))?;
+    /// let _ = write!(&mut output, "{}", amount.display_in(Denomination::Bitcoin));
     /// assert_eq!(output, "0.1");
-    /// # Ok::<(), std::fmt::Error>(())
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
@@ -274,9 +297,10 @@ impl SignedAmount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
-    /// let amount = SignedAmount::from_sat(10_000_000);
-    /// assert_eq!(amount.to_string_in(Denomination::Bitcoin), "0.1")
+    /// # use bitcoin_units::amount::{self, SignedAmount, Denomination};
+    /// let amount = SignedAmount::from_sat(10_000_000)?;
+    /// assert_eq!(amount.to_string_in(Denomination::Bitcoin), "0.1");
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[cfg(feature = "alloc")]
     pub fn to_string_in(self, denom: Denomination) -> String { self.display_in(denom).to_string() }
@@ -287,9 +311,10 @@ impl SignedAmount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{SignedAmount, Denomination};
-    /// let amount = SignedAmount::from_sat(10_000_000);
-    /// assert_eq!(amount.to_string_with_denomination(Denomination::Bitcoin), "0.1 BTC")
+    /// # use bitcoin_units::amount::{self, SignedAmount, Denomination};
+    /// let amount = SignedAmount::from_sat(10_000_000)?;
+    /// assert_eq!(amount.to_string_with_denomination(Denomination::Bitcoin), "0.1 BTC");
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[cfg(feature = "alloc")]
     pub fn to_string_with_denomination(self, denom: Denomination) -> String {
@@ -297,12 +322,23 @@ impl SignedAmount {
     }
 
     /// Gets the absolute value of this [`SignedAmount`].
+    ///
+    /// This function never overflows or panics, unlike `i64::abs()`.
     #[must_use]
-    pub fn abs(self) -> SignedAmount { SignedAmount::from_sat(self.to_sat().abs()) }
+    pub const fn abs(self) -> SignedAmount {
+        // `i64::abs()` can never overflow because SignedAmount::MIN == -MAX_MONEY.
+        match Self::from_sat(self.to_sat().abs()) {
+            Ok(amount) => amount,
+            Err(_) => panic!("a positive signed amount is always valid"),
+        }
+    }
 
     /// Gets the absolute value of this [`SignedAmount`] returning [`Amount`].
     #[must_use]
-    pub fn unsigned_abs(self) -> Amount { Amount::from_sat(self.to_sat().unsigned_abs()) }
+    #[allow(clippy::missing_panics_doc)]
+    pub fn unsigned_abs(self) -> Amount {
+        self.abs().to_unsigned().expect("a positive signed amount is always valid")
+    }
 
     /// Returns a number representing sign of this [`SignedAmount`].
     ///
@@ -330,13 +366,9 @@ impl SignedAmount {
     ///
     /// Returns [`None`] if overflow occurred. (`self == i64::MIN`)
     #[must_use]
-    pub const fn checked_abs(self) -> Option<SignedAmount> {
-        // No `map()` in const context.
-        match self.to_sat().checked_abs() {
-            Some(res) => Some(SignedAmount::from_sat(res)),
-            None => None,
-        }
-    }
+    #[deprecated(since = "TBD", note = "Never returns none, use `abs()` instead")]
+    #[allow(clippy::unnecessary_wraps)] // To match stdlib function definition.
+    pub const fn checked_abs(self) -> Option<SignedAmount> { Some(self.abs()) }
 
     /// Checked addition.
     ///
@@ -345,7 +377,10 @@ impl SignedAmount {
     pub const fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.to_sat().checked_add(rhs.to_sat()) {
-            Some(res) => SignedAmount::from_sat(res).check_min_max(),
+            Some(res) => match SignedAmount::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None,
+            },
             None => None,
         }
     }
@@ -358,7 +393,10 @@ impl SignedAmount {
     pub const fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.to_sat().checked_sub(rhs.to_sat()) {
-            Some(res) => SignedAmount::from_sat(res).check_min_max(),
+            Some(res) => match Self::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None,
+            },
             None => None,
         }
     }
@@ -371,7 +409,10 @@ impl SignedAmount {
     pub const fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.to_sat().checked_mul(rhs) {
-            Some(res) => SignedAmount::from_sat(res).check_min_max(),
+            Some(res) => match Self::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None,
+            },
             None => None,
         }
     }
@@ -385,7 +426,10 @@ impl SignedAmount {
     pub const fn checked_div(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.to_sat().checked_div(rhs) {
-            Some(res) => Some(SignedAmount::from_sat(res)),
+            Some(res) => match Self::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None, // Unreachable because of checked_div above.
+            },
             None => None,
         }
     }
@@ -397,7 +441,10 @@ impl SignedAmount {
     pub const fn checked_rem(self, rhs: i64) -> Option<SignedAmount> {
         // No `map()` in const context.
         match self.to_sat().checked_rem(rhs) {
-            Some(res) => Some(SignedAmount::from_sat(res)),
+            Some(res) => match Self::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None, // Unreachable because of checked_rem above.
+            },
             None => None,
         }
     }
@@ -419,20 +466,14 @@ impl SignedAmount {
     /// # Errors
     ///
     /// If the amount is negative.
+    #[allow(clippy::missing_panics_doc)]
     pub fn to_unsigned(self) -> Result<Amount, OutOfRangeError> {
         if self.is_negative() {
             Err(OutOfRangeError::negative())
         } else {
-            Ok(Amount::from_sat(self.to_sat() as u64)) // Cast ok, checked not negative above.
-        }
-    }
-
-    /// Checks the amount is within the allowed range.
-    const fn check_min_max(self) -> Option<SignedAmount> {
-        if self.to_sat() < Self::MIN.to_sat() || self.to_sat() > Self::MAX.to_sat() {
-            None
-        } else {
-            Some(self)
+            // Cast ok, checked not negative above.
+            Ok(Amount::from_sat(self.to_sat() as u64)
+                .expect("a positive signed amount is always valid"))
         }
     }
 }
@@ -482,14 +523,14 @@ impl FromStr for SignedAmount {
 impl From<Amount> for SignedAmount {
     fn from(value: Amount) -> Self {
         let v = value.to_sat() as i64; // Cast ok, signed amount and amount share positive range.
-        Self::from_sat_unchecked(v)
+        Self::from_sat(v).expect("all amounts are valid signed amounts")
     }
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for SignedAmount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let s = i64::arbitrary(u)?;
-        Ok(Self::from_sat(s))
+        let sats = u.int_in_range(Self::MIN.to_sat()..=Self::MAX.to_sat())?;
+        Ok(Self::from_sat(sats).expect("range is valid"))
     }
 }
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 2d3b5e1c62..b9d5518eb3 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -16,18 +16,19 @@ use super::*;
 #[cfg(feature = "alloc")]
 use crate::{FeeRate, Weight};
 
-fn sat(sat: u64) -> Amount { Amount::from_sat(sat) }
-fn ssat(ssat: i64) -> SignedAmount { SignedAmount::from_sat(ssat) }
+#[track_caller]
+fn sat(sat: u64) -> Amount { Amount::from_sat(sat).unwrap() }
+
+#[track_caller]
+fn ssat(ssat: i64) -> SignedAmount { SignedAmount::from_sat(ssat).unwrap() }
 
 #[test]
 fn sanity_check() {
     assert_eq!(ssat(-100).abs(), ssat(100));
-    assert_eq!(ssat(i64::MIN + 1).checked_abs().unwrap(), ssat(i64::MAX));
     assert_eq!(ssat(-100).signum(), -1);
     assert_eq!(ssat(0).signum(), 0);
     assert_eq!(ssat(100).signum(), 1);
     assert_eq!(SignedAmount::from(sat(100)), ssat(100));
-    assert!(ssat(i64::MIN).checked_abs().is_none());
     assert!(!ssat(-100).is_positive());
     assert!(ssat(100).is_positive());
 
@@ -101,7 +102,7 @@ fn from_str_zero_without_denomination() {
 
 #[test]
 fn from_int_btc() {
-    let amt = Amount::from_int_btc_const(2);
+    let amt = Amount::from_int_btc_const(2).unwrap();
     assert_eq!(sat(200_000_000), amt);
 }
 
@@ -118,8 +119,8 @@ fn amount_try_from_signed_amount() {
 
 #[test]
 fn mul_div() {
-    let op_result_sat = |sat| NumOpResult::Valid(Amount::from_sat(sat));
-    let op_result_ssat = |sat| NumOpResult::Valid(SignedAmount::from_sat(sat));
+    let op_result_sat = |a| NumOpResult::Valid(sat(a));
+    let op_result_ssat = |a| NumOpResult::Valid(ssat(a));
 
     assert_eq!(sat(14) * 3, op_result_sat(42));
     assert_eq!(sat(14) / 2, op_result_sat(7));
@@ -131,19 +132,10 @@ fn mul_div() {
 
 #[test]
 fn neg() {
-    let amount = -SignedAmount::from_sat_unchecked(2);
+    let amount = -ssat(2);
     assert_eq!(amount.to_sat(), -2);
 }
 
-#[cfg(feature = "std")]
-#[test]
-fn overflows() {
-    let result = Amount::MAX + sat(1);
-    assert!(result.is_error());
-    let result = sat(8_446_744_073_709_551_615) * 3;
-    assert!(result.is_error());
-}
-
 #[test]
 fn add() {
     assert!(sat(0) + sat(0) == sat(0).into());
@@ -258,12 +250,6 @@ fn amount_checked_div_by_fee_rate() {
     let weight = max_amount.checked_div_by_fee_rate_floor(small_fee_rate).unwrap();
     // 21_000_000_0000_0000 sats / (1 sat/kwu) = 2_100_000_000_000_000_000 wu
     assert_eq!(weight, Weight::from_wu(2_100_000_000_000_000_000));
-
-    // Test overflow case
-    let tiny_fee_rate = FeeRate::from_sat_per_kwu(1);
-    let large_amount = sat(u64::MAX);
-    assert!(large_amount.checked_div_by_fee_rate_floor(tiny_fee_rate).is_none());
-    assert!(large_amount.checked_div_by_fee_rate_ceil(tiny_fee_rate).is_none());
 }
 
 #[cfg(feature = "alloc")]
@@ -417,8 +403,8 @@ macro_rules! check_format_non_negative {
             #[test]
             #[cfg(feature = "alloc")]
             fn $test_name() {
-                assert_eq!(format!($format_string, Amount::from_sat($val).display_in(Denomination::$denom)), $expected);
-                assert_eq!(format!($format_string, SignedAmount::from_sat($val as i64).display_in(Denomination::$denom)), $expected);
+                assert_eq!(format!($format_string, sat($val).display_in(Denomination::$denom)), $expected);
+                assert_eq!(format!($format_string, ssat($val as i64).display_in(Denomination::$denom)), $expected);
             }
         )*
     }
@@ -430,8 +416,8 @@ macro_rules! check_format_non_negative_show_denom {
             #[test]
             #[cfg(feature = "alloc")]
             fn $test_name() {
-                assert_eq!(format!($format_string, Amount::from_sat($val).display_in(Denomination::$denom).show_denomination()), concat!($expected, $denom_suffix));
-                assert_eq!(format!($format_string, SignedAmount::from_sat($val as i64).display_in(Denomination::$denom).show_denomination()), concat!($expected, $denom_suffix));
+                assert_eq!(format!($format_string, sat($val).display_in(Denomination::$denom).show_denomination()), concat!($expected, $denom_suffix));
+                assert_eq!(format!($format_string, ssat($val as i64).display_in(Denomination::$denom).show_denomination()), concat!($expected, $denom_suffix));
             }
         )*
     }
@@ -1020,7 +1006,7 @@ fn checked_sum_amounts() {
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(sum, Some(sat(1400)));
 
-    let amounts = [sat(u64::MAX), sat(1337), sat(21)];
+    let amounts = [Amount::MAX_MONEY, sat(1337), sat(21)];
     let sum = amounts.into_iter().checked_sum();
     assert_eq!(sum, None);
 
@@ -1119,7 +1105,7 @@ fn add_sub_combos() {
     macro_rules! check_res {
         ($($amount:ident, $op:tt, $lhs:literal, $rhs:literal, $ans:literal);* $(;)?) => {
             $(
-                let amt = |sat| $amount::from_sat(sat);
+                let amt = |sat| $amount::from_sat(sat).unwrap();
 
                 let sat_lhs = amt($lhs);
                 let sat_rhs = amt($rhs);
@@ -1255,7 +1241,7 @@ fn unsigned_amount_div_by_amount() {
 #[test]
 #[should_panic(expected = "attempt to divide by zero")]
 fn unsigned_amount_div_by_amount_zero() {
-    let _ = Amount::from_sat(1897) / Amount::ZERO;
+    let _ = sat(1897) / Amount::ZERO;
 }
 
 #[test]
@@ -1271,7 +1257,7 @@ fn signed_amount_div_by_amount() {
 #[test]
 #[should_panic(expected = "attempt to divide by zero")]
 fn signed_amount_div_by_amount_zero() {
-    let _ = SignedAmount::from_sat(1897) / SignedAmount::ZERO;
+    let _ = ssat(1897) / SignedAmount::ZERO;
 }
 
 #[test]
@@ -1307,8 +1293,8 @@ fn sanity_all_ops() {
 #[test]
 #[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
 fn num_op_result_ops() {
-    let sat = Amount::from_sat(1);
-    let ssat = SignedAmount::from_sat(1);
+    let sat = Amount::from_sat(1).unwrap();
+    let ssat = SignedAmount::from_sat(1).unwrap();
 
     // Explicit type as sanity check.
     let res: NumOpResult<Amount> = sat + sat;
@@ -1358,8 +1344,8 @@ fn num_op_result_ops() {
 #[test]
 #[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
 fn num_op_result_ops_integer() {
-    let sat = Amount::from_sat(1);
-    let ssat = SignedAmount::from_sat(1);
+    let sat = Amount::from_sat(1).unwrap();
+    let ssat = SignedAmount::from_sat(1).unwrap();
 
     // Explicit type as sanity check.
     let res: NumOpResult<Amount> = sat + sat;
@@ -1401,8 +1387,8 @@ fn num_op_result_ops_integer() {
 fn amount_op_result_neg() {
     // TODO: Implement Neg all round.
 
-    // let sat = Amount::from_sat(1);
-    let ssat = SignedAmount::from_sat(1);
+    // let sat = Amount::from_sat(1).unwrap();
+    let ssat = SignedAmount::from_sat(1).unwrap();
 
     // let _ = -sat;
     let _ = -ssat;
@@ -1413,7 +1399,7 @@ fn amount_op_result_neg() {
 // Verify we have implemented all `Sum` for the `NumOpResult` type.
 #[test]
 fn amount_op_result_sum() {
-    let res = Amount::from_sat(1) + Amount::from_sat(1);
+    let res = Amount::from_sat(1).unwrap() + Amount::from_sat(1).unwrap();
     let amounts = [res, res];
     let amount_refs = [&res, &res];
 
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index c3488dfafa..1b328f9645 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -87,31 +87,44 @@ impl Amount {
     /// The number of bytes that an amount contributes to the size of a transaction.
     pub const SIZE: usize = 8; // Serialized length of a u64.
 
-    /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
+    /// Constructs a new [`Amount`] from the given number of satoshis.
+    ///
+    /// # Errors
+    ///
+    /// If `satoshi` is outside of valid range (greater than [`Self::MAX_MONEY`]).
     ///
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::Amount;
-    /// let amount = Amount::from_sat(100_000);
-    /// assert_eq!(amount.to_sat(), 100_000);
+    /// # use bitcoin_units::{amount, Amount};
+    /// # let sat = 100_000;
+    /// let amount = Amount::from_sat(sat)?;
+    /// assert_eq!(amount.to_sat(), sat);
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
-    pub const fn from_sat(satoshi: u64) -> Amount { Amount::from_sat_unchecked(satoshi) }
+    pub const fn from_sat(satoshi: u64) -> Result<Amount, OutOfRangeError> {
+        if satoshi > Self::MAX_MONEY.to_sat() {
+            Err(OutOfRangeError { is_signed: false, is_greater_than_max: true })
+        } else {
+            Ok(Self::from_sat_unchecked(satoshi))
+        }
+    }
 
     /// Converts from a value expressing a decimal number of bitcoin to an [`Amount`].
     ///
     /// # Errors
     ///
-    /// If the amount is too big, too precise or negative.
+    /// If the amount is too precise, negative, or greater than 21,000,000.
     ///
     /// Please be aware of the risk of using floating-point numbers.
     ///
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::Amount;
-    /// let amount = Amount::from_btc(0.01).expect("we know 0.01 is valid");
+    /// # use bitcoin_units::{amount, Amount};
+    /// let amount = Amount::from_btc(0.01)?;
     /// assert_eq!(amount.to_sat(), 1_000_000);
+    /// # Ok::<_, amount::ParseAmountError>(())
     /// ```
     #[cfg(feature = "alloc")]
     pub fn from_btc(btc: f64) -> Result<Amount, ParseAmountError> {
@@ -119,15 +132,23 @@ impl Amount {
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`].
+    ///
+    /// # Errors
+    ///
+    /// If `whole_bitcoin` is greater than `21_000_000`.
     #[allow(clippy::missing_panics_doc)]
-    pub fn from_int_btc<T: Into<u32>>(whole_bitcoin: T) -> Amount {
+    pub fn from_int_btc<T: Into<u32>>(whole_bitcoin: T) -> Result<Amount, OutOfRangeError> {
         Amount::from_int_btc_const(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`]
     /// in const context.
+    ///
+    /// # Errors
+    ///
+    /// If `whole_bitcoin` is greater than `21_000_000`.
     #[allow(clippy::missing_panics_doc)]
-    pub const fn from_int_btc_const(whole_bitcoin: u32) -> Amount {
+    pub const fn from_int_btc_const(whole_bitcoin: u32) -> Result<Amount, OutOfRangeError> {
         let btc = whole_bitcoin as u64; // Can't call `into` in const context.
         match btc.checked_mul(100_000_000) {
             Some(amount) => Amount::from_sat(amount),
@@ -142,7 +163,7 @@ impl Amount {
     ///
     /// # Errors
     ///
-    /// If the amount is too big, too precise or negative.
+    /// If the amount is too precise, negative, or greater than 21,000,000.
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<Amount, ParseAmountError> {
         let (negative, sats) =
             parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(false))?;
@@ -156,7 +177,7 @@ impl Amount {
                 OutOfRangeError::too_big(false),
             )));
         }
-        Ok(Self::from_sat(sats))
+        Ok(Self::from_sat_unchecked(sats))
     }
 
     /// Parses amounts with denomination suffix as produced by [`Self::to_string_with_denomination`]
@@ -173,7 +194,7 @@ impl Amount {
     /// ```
     /// # use bitcoin_units::{amount, Amount};
     /// let amount = Amount::from_str_with_denomination("0.1 BTC")?;
-    /// assert_eq!(amount, Amount::from_sat(10_000_000));
+    /// assert_eq!(amount, Amount::from_sat(10_000_000)?);
     /// # Ok::<_, amount::ParseError>(())
     /// ```
     pub fn from_str_with_denomination(s: &str) -> Result<Amount, ParseError> {
@@ -188,9 +209,10 @@ impl Amount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{Amount, Denomination};
-    /// let amount = Amount::from_sat(100_000);
-    /// assert_eq!(amount.to_float_in(Denomination::Bitcoin), 0.001)
+    /// # use bitcoin_units::amount::{self, Amount, Denomination};
+    /// let amount = Amount::from_sat(100_000)?;
+    /// assert_eq!(amount.to_float_in(Denomination::Bitcoin), 0.001);
+    /// # Ok::<_, amount::ParseError>(())
     /// ```
     #[cfg(feature = "alloc")]
     #[allow(clippy::missing_panics_doc)]
@@ -205,9 +227,10 @@ impl Amount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{Amount, Denomination};
-    /// let amount = Amount::from_sat(100_000);
-    /// assert_eq!(amount.to_btc(), amount.to_float_in(Denomination::Bitcoin))
+    /// # use bitcoin_units::amount::{self, Amount, Denomination};
+    /// let amount = Amount::from_sat(100_000)?;
+    /// assert_eq!(amount.to_btc(), amount.to_float_in(Denomination::Bitcoin));
+    /// # Ok::<_, amount::ParseError>(())
     /// ```
     #[cfg(feature = "alloc")]
     pub fn to_btc(self) -> f64 { self.to_float_in(Denomination::Bitcoin) }
@@ -236,13 +259,13 @@ impl Amount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{Amount, Denomination};
+    /// # use bitcoin_units::amount::{self, Amount, Denomination};
     /// # use std::fmt::Write;
-    /// let amount = Amount::from_sat(10_000_000);
+    /// let amount = Amount::from_sat(10_000_000)?;
     /// let mut output = String::new();
-    /// write!(&mut output, "{}", amount.display_in(Denomination::Bitcoin))?;
+    /// let _ = write!(&mut output, "{}", amount.display_in(Denomination::Bitcoin));
     /// assert_eq!(output, "0.1");
-    /// # Ok::<(), std::fmt::Error>(())
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[must_use]
     pub fn display_in(self, denomination: Denomination) -> Display {
@@ -274,9 +297,10 @@ impl Amount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{Amount, Denomination};
-    /// let amount = Amount::from_sat(10_000_000);
-    /// assert_eq!(amount.to_string_in(Denomination::Bitcoin), "0.1")
+    /// # use bitcoin_units::amount::{self, Amount, Denomination};
+    /// let amount = Amount::from_sat(10_000_000)?;
+    /// assert_eq!(amount.to_string_in(Denomination::Bitcoin), "0.1");
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[cfg(feature = "alloc")]
     pub fn to_string_in(self, denom: Denomination) -> String { self.display_in(denom).to_string() }
@@ -287,9 +311,10 @@ impl Amount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::amount::{Amount, Denomination};
-    /// let amount = Amount::from_sat(10_000_000);
-    /// assert_eq!(amount.to_string_with_denomination(Denomination::Bitcoin), "0.1 BTC")
+    /// # use bitcoin_units::amount::{self, Amount, Denomination};
+    /// let amount = Amount::from_sat(10_000_000)?;
+    /// assert_eq!(amount.to_string_with_denomination(Denomination::Bitcoin), "0.1 BTC");
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[cfg(feature = "alloc")]
     pub fn to_string_with_denomination(self, denom: Denomination) -> String {
@@ -302,9 +327,10 @@ impl Amount {
     #[must_use]
     pub const fn checked_add(self, rhs: Amount) -> Option<Amount> {
         // No `map()` in const context.
-        match self.to_sat().checked_add(rhs.to_sat()) {
-            Some(res) => Amount::from_sat(res).check_max(),
-            None => None,
+        // Unchecked add ok, adding two values less than `MAX_MONEY` cannot overflow an `i64`.
+        match Self::from_sat(self.to_sat() + rhs.to_sat()) {
+            Ok(amount) => Some(amount),
+            Err(_) => None,
         }
     }
 
@@ -315,7 +341,10 @@ impl Amount {
     pub const fn checked_sub(self, rhs: Amount) -> Option<Amount> {
         // No `map()` in const context.
         match self.to_sat().checked_sub(rhs.to_sat()) {
-            Some(res) => Some(Amount::from_sat(res)),
+            Some(res) => match Self::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None, // Unreachable because of checked_sub above.
+            },
             None => None,
         }
     }
@@ -327,7 +356,10 @@ impl Amount {
     pub const fn checked_mul(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
         match self.to_sat().checked_mul(rhs) {
-            Some(res) => Amount::from_sat(res).check_max(),
+            Some(res) => match Self::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None,
+            },
             None => None,
         }
     }
@@ -341,7 +373,10 @@ impl Amount {
     pub const fn checked_div(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
         match self.to_sat().checked_div(rhs) {
-            Some(res) => Some(Amount::from_sat(res)),
+            Some(res) => match Self::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None, // Unreachable because of checked_div above.
+            },
             None => None,
         }
     }
@@ -353,7 +388,10 @@ impl Amount {
     pub const fn checked_rem(self, rhs: u64) -> Option<Amount> {
         // No `map()` in const context.
         match self.to_sat().checked_rem(rhs) {
-            Some(res) => Some(Amount::from_sat(res)),
+            Some(res) => match Self::from_sat(res) {
+                Ok(amount) => Some(amount),
+                Err(_) => None, // Unreachable because of checked_div above.
+            },
             None => None,
         }
     }
@@ -363,15 +401,6 @@ impl Amount {
     pub fn to_signed(self) -> SignedAmount {
         SignedAmount::from_sat_unchecked(self.to_sat() as i64) // Cast ok, signed amount and amount share positive range.
     }
-
-    /// Checks if the amount is below the maximum value. Returns `None` if it is above.
-    const fn check_max(self) -> Option<Amount> {
-        if self.to_sat() > Self::MAX.to_sat() {
-            None
-        } else {
-            Some(self)
-        }
-    }
 }
 
 impl default::Default for Amount {
@@ -425,7 +454,7 @@ impl TryFrom<SignedAmount> for Amount {
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Amount {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        let a = u64::arbitrary(u)?;
-        Ok(Self::from_sat(a))
+        let sats = u.int_in_range(Self::MIN.to_sat()..=Self::MAX.to_sat())?;
+        Ok(Self::from_sat(sats).expect("range is valid"))
     }
 }
diff --git a/units/src/amount/verification.rs b/units/src/amount/verification.rs
index ecf35d2173..f8c988608a 100644
--- a/units/src/amount/verification.rs
+++ b/units/src/amount/verification.rs
@@ -23,17 +23,21 @@ use super::*;
 fn u_amount_homomorphic() {
     let n1 = kani::any::<u64>();
     let n2 = kani::any::<u64>();
-    // Assume we don't overflow in the actual tests.
-    kani::assume(n1.checked_add(n2).is_some()); // Adding u64s doesn't overflow.
-    let a1 = Amount::from_sat(n1); // TODO: If from_sat enforces invariant assume this `is_ok()`.
-    let a2 = Amount::from_sat(n2);
-    kani::assume(a1.checked_add(a2).is_some()); // Adding amounts doesn't overflow.
 
-    assert_eq!(Amount::from_sat(n1) + Amount::from_sat(n2), Amount::from_sat(n1 + n2).into());
+    // Assume the values are within range.
+    kani::assume(Amount::from_sat(n1).is_ok());
+    kani::assume(Amount::from_sat(n2).is_ok());
+
+    let sat = |sat| Amount::from_sat(sat).unwrap();
+
+    // Assume sum is within range.
+    kani::assume(sat(n1).checked_add(sat(n2)).is_some());
+
+    assert_eq!(sat(n1) + sat(n2), sat(n1 + n2).into());
 
     let max = cmp::max(n1, n2);
     let min = cmp::min(n1, n2);
-    assert_eq!(Amount::from_sat(max) - Amount::from_sat(min), Amount::from_sat(max - min).into());
+    assert_eq!(sat(max) - sat(min), sat(max - min).into());
 }
 
 #[kani::unwind(4)]
@@ -41,20 +45,16 @@ fn u_amount_homomorphic() {
 fn s_amount_homomorphic() {
     let n1 = kani::any::<i64>();
     let n2 = kani::any::<i64>();
-    // Assume we don't overflow in the actual tests.
-    kani::assume(n1.checked_add(n2).is_some()); // Adding i64s doesn't overflow.
-    kani::assume(n1.checked_sub(n2).is_some()); // Subbing i64s doesn't overflow.
-    let a1 = SignedAmount::from_sat(n1); // TODO: If from_sat enforces invariant assume this `is_ok()`.
-    let a2 = SignedAmount::from_sat(n2);
-    kani::assume(a1.checked_add(a2).is_some()); // Adding amounts doesn't overflow.
-    kani::assume(a1.checked_sub(a2).is_some()); // Subbing amounts doesn't overflow.
-
-    assert_eq!(
-        SignedAmount::from_sat(n1) + SignedAmount::from_sat(n2),
-        SignedAmount::from_sat(n1 + n2).into()
-    );
-    assert_eq!(
-        SignedAmount::from_sat(n1) - SignedAmount::from_sat(n2),
-        SignedAmount::from_sat(n1 - n2).into()
-    );
+
+    // Assume the values are within range.
+    kani::assume(SignedAmount::from_sat(n1).is_ok());
+    kani::assume(SignedAmount::from_sat(n2).is_ok());
+
+    let ssat = |ssat| SignedAmount::from_sat(ssat).unwrap();
+
+    kani::assume(ssat(n1).checked_add(ssat(n2)).is_some()); // Adding amounts doesn't overflow.
+    kani::assume(ssat(n1).checked_sub(ssat(n2)).is_some()); // Subbing amounts doesn't overflow.
+
+    assert_eq!(ssat(n1) + ssat(n2), ssat(n1 + n2).into());
+    assert_eq!(ssat(n1) - ssat(n2), ssat(n1 - n2).into());
 }
diff --git a/units/src/fee.rs b/units/src/fee.rs
index 39dff63b07..569d6d6627 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -28,11 +28,12 @@ impl Amount {
     /// # Examples
     ///
     /// ```
-    /// # use bitcoin_units::{Amount, FeeRate, Weight};
-    /// let amount = Amount::from_sat(10);
+    /// # use bitcoin_units::{amount, Amount, FeeRate, Weight};
+    /// let amount = Amount::from_sat(10)?;
     /// let weight = Weight::from_wu(300);
     /// let fee_rate = amount.checked_div_by_weight_ceil(weight).expect("Division by weight failed");
     /// assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(34));
+    /// # Ok::<_, amount::OutOfRangeError>(())
     /// ```
     #[must_use]
     pub const fn checked_div_by_weight_ceil(self, weight: Weight) -> Option<FeeRate> {
@@ -151,7 +152,10 @@ impl FeeRate {
         // No `?` operator in const context.
         match self.to_sat_per_kwu().checked_mul(weight.to_wu()) {
             Some(mul_res) => match mul_res.checked_add(999) {
-                Some(add_res) => Some(Amount::from_sat(add_res / 1000)),
+                Some(add_res) => match Amount::from_sat(add_res / 1000) {
+                    Ok(fee) => Some(fee),
+                    Err(_) => None,
+                },
                 None => None,
             },
             None => None,

From cacf734ccf89e049bafc4f6bc73b6254881e2574 Mon Sep 17 00:00:00 2001
From: Update cargo-semver-checks Bot <bot@example.com>
Date: Sat, 15 Mar 2025 01:07:34 +0000
Subject: [PATCH 517/554] Automated update to Github CI to cargo-semver-checks
 version-0.40.0

---
 .github/workflows/cargo-semver-checks-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/cargo-semver-checks-version b/.github/workflows/cargo-semver-checks-version
index 4ef2eb086f..9b0025a785 100644
--- a/.github/workflows/cargo-semver-checks-version
+++ b/.github/workflows/cargo-semver-checks-version
@@ -1 +1 @@
-0.39.0
+0.40.0

From 058e8285f07dea1b416b2a71501e0a28f3e71619 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 15 Mar 2025 01:44:24 +0000
Subject: [PATCH 518/554] Automated update to Github CI to rustc
 nightly-2025-03-14

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index a305832151..79656d4c37 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-03-06
+nightly-2025-03-14

From a74e08a53df42a822b3e4840f37bf72b24418fe1 Mon Sep 17 00:00:00 2001
From: Fmt Bot <bot@example.com>
Date: Sun, 16 Mar 2025 01:25:25 +0000
Subject: [PATCH 519/554] 2025-03-16 automated rustfmt nightly

---
 bitcoin/src/bip152.rs                         |  2 +-
 bitcoin/src/blockdata/constants.rs            |  2 +-
 bitcoin/src/blockdata/mod.rs                  |  4 +-
 bitcoin/src/blockdata/script/tests.rs         |  2 +-
 bitcoin/src/crypto/key.rs                     |  2 +-
 bitcoin/src/lib.rs                            |  4 +-
 bitcoin/src/psbt/mod.rs                       |  8 +--
 bitcoin/src/psbt/serialize.rs                 |  6 +-
 bitcoin/src/taproot/merkle_branch.rs          |  6 +-
 bitcoin/tests/serde.rs                        |  3 +-
 fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs |  3 +-
 .../bitcoin/deserialize_script.rs             |  3 +-
 hashes/src/ripemd160/crypto.rs                |  1 +
 hashes/src/sha1/crypto.rs                     |  1 +
 hashes/src/sha256/crypto.rs                   |  1 +
 hashes/src/sha256/mod.rs                      |  4 +-
 hashes/src/sha512/crypto.rs                   |  1 +
 internals/src/slice.rs                        | 23 +++++--
 primitives/src/opcodes.rs                     |  2 +-
 primitives/src/transaction.rs                 |  5 +-
 primitives/src/witness.rs                     | 24 ++++----
 units/src/amount/mod.rs                       |  4 +-
 units/src/amount/tests.rs                     | 61 +++++++------------
 units/tests/api.rs                            |  6 +-
 24 files changed, 87 insertions(+), 91 deletions(-)

diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs
index e602a31338..979dabc5e5 100644
--- a/bitcoin/src/bip152.rs
+++ b/bitcoin/src/bip152.rs
@@ -413,7 +413,7 @@ mod test {
     use crate::merkle_tree::TxMerkleNode;
     use crate::transaction::OutPointExt;
     use crate::{
-        transaction, Amount, BlockChecked, CompactTarget, OutPoint, ScriptBuf, Sequence, BlockTime,
+        transaction, Amount, BlockChecked, BlockTime, CompactTarget, OutPoint, ScriptBuf, Sequence,
         TxIn, TxOut, Txid, Witness,
     };
 
diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 8d48609aa3..6e8ef036e9 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -16,7 +16,7 @@ use crate::opcodes::all::*;
 use crate::pow::CompactTarget;
 use crate::transaction::{self, OutPoint, Transaction, TxIn, TxOut};
 use crate::witness::Witness;
-use crate::{script, Amount, BlockHash, Sequence, TestnetVersion, BlockTime};
+use crate::{script, Amount, BlockHash, BlockTime, Sequence, TestnetVersion};
 
 /// How many seconds between blocks we expect on average.
 pub const TARGET_BLOCK_SPACING: u32 = 600;
diff --git a/bitcoin/src/blockdata/mod.rs b/bitcoin/src/blockdata/mod.rs
index 9916e56af5..a6f39ba9a8 100644
--- a/bitcoin/src/blockdata/mod.rs
+++ b/bitcoin/src/blockdata/mod.rs
@@ -21,10 +21,10 @@ pub use self::{
 
 /// Implements `FeeRate` and assoctiated features.
 pub mod fee_rate {
-    /// Re-export everything from the [`units::fee_rate`] module.
-    pub use units::fee_rate::FeeRate;
     #[cfg(feature = "serde")]
     pub use units::fee_rate::serde;
+    /// Re-export everything from the [`units::fee_rate`] module.
+    pub use units::fee_rate::FeeRate;
 }
 
 /// Provides absolute and relative locktimes.
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 4443645b1b..110faa10f8 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -8,7 +8,7 @@ use crate::address::script_pubkey::{
 };
 use crate::consensus::encode::{deserialize, serialize};
 use crate::crypto::key::{PublicKey, XOnlyPublicKey};
-use crate::{Amount, FeeRate, opcodes};
+use crate::{opcodes, Amount, FeeRate};
 
 #[test]
 #[rustfmt::skip]
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 4581298b51..862ed1fc79 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -462,7 +462,7 @@ impl PrivateKey {
     /// Deserializes a private key from a byte array.
     pub fn from_byte_array(
         data: [u8; 32],
-        network: impl Into<NetworkKind>
+        network: impl Into<NetworkKind>,
     ) -> Result<PrivateKey, secp256k1::Error> {
         Ok(PrivateKey::new(secp256k1::SecretKey::from_byte_array(&data)?, network))
     }
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index ffb70ba54b..545604397b 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -164,9 +164,7 @@ pub use crate::{
     blockdata::script::witness_program::{self, WitnessProgram},
     blockdata::script::witness_version::{self, WitnessVersion},
     // These modules also re-export all the respective `primitives` types.
-    blockdata::{
-        block, constants, fee_rate, locktime, script, transaction, weight, witness,
-    },
+    blockdata::{block, constants, fee_rate, locktime, script, transaction, weight, witness},
 };
 
 #[rustfmt::skip]
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index bfe5282586..ffba04ea9d 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -135,7 +135,7 @@ impl Psbt {
     /// An alias for [`extract_tx_fee_rate_limit`].
     ///
     /// [`extract_tx_fee_rate_limit`]: Psbt::extract_tx_fee_rate_limit
-    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
+    #[allow(clippy::result_large_err)] // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx(self) -> Result<Transaction, ExtractTxError> {
         self.internal_extract_tx_with_fee_rate_limit(Self::DEFAULT_MAX_FEE_RATE)
     }
@@ -147,7 +147,7 @@ impl Psbt {
     /// [`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.
-    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
+    #[allow(clippy::result_large_err)] // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx_fee_rate_limit(self) -> Result<Transaction, ExtractTxError> {
         self.internal_extract_tx_with_fee_rate_limit(Self::DEFAULT_MAX_FEE_RATE)
     }
@@ -159,7 +159,7 @@ impl Psbt {
     /// See [`extract_tx`].
     ///
     /// [`extract_tx`]: Psbt::extract_tx
-    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
+    #[allow(clippy::result_large_err)] // The PSBT returned in `SendingToomuch` is large.
     pub fn extract_tx_with_fee_rate_limit(
         self,
         max_fee_rate: FeeRate,
@@ -187,7 +187,7 @@ impl Psbt {
     }
 
     #[inline]
-    #[allow(clippy::result_large_err)]  // The PSBT returned in `SendingToomuch` is large.
+    #[allow(clippy::result_large_err)] // The PSBT returned in `SendingToomuch` is large.
     fn internal_extract_tx_with_fee_rate_limit(
         self,
         max_fee_rate: FeeRate,
diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
index 89de08dcb0..a087bcbb55 100644
--- a/bitcoin/src/psbt/serialize.rs
+++ b/bitcoin/src/psbt/serialize.rs
@@ -260,10 +260,8 @@ impl Serialize for XOnlyPublicKey {
 
 impl Deserialize for XOnlyPublicKey {
     fn deserialize(bytes: &[u8]) -> Result<Self, Error> {
-        XOnlyPublicKey::from_byte_array(
-            bytes.try_into().map_err(|_| Error::InvalidXOnlyPublicKey)?,
-        )
-        .map_err(|_| Error::InvalidXOnlyPublicKey)
+        XOnlyPublicKey::from_byte_array(bytes.try_into().map_err(|_| Error::InvalidXOnlyPublicKey)?)
+            .map_err(|_| Error::InvalidXOnlyPublicKey)
     }
 }
 
diff --git a/bitcoin/src/taproot/merkle_branch.rs b/bitcoin/src/taproot/merkle_branch.rs
index 33f0330fc4..5ad08cbc1a 100644
--- a/bitcoin/src/taproot/merkle_branch.rs
+++ b/bitcoin/src/taproot/merkle_branch.rs
@@ -52,11 +52,7 @@ impl TaprootMerkleBranch {
         } else if node_hashes.len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
             Err(InvalidMerkleTreeDepthError(sl.len() / TAPROOT_CONTROL_NODE_SIZE).into())
         } else {
-            let inner = node_hashes
-                .iter()
-                .copied()
-                .map(TapNodeHash::from_byte_array)
-                .collect();
+            let inner = node_hashes.iter().copied().map(TapNodeHash::from_byte_array).collect();
 
             Ok(TaprootMerkleBranch(inner))
         }
diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
index dff93b0c50..66ffc63b0b 100644
--- a/bitcoin/tests/serde.rs
+++ b/bitcoin/tests/serde.rs
@@ -109,8 +109,7 @@ fn serde_regression_txin() {
 
 #[test]
 fn serde_regression_txout() {
-    let txout =
-        TxOut { value: Amount::MAX, script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]) };
+    let txout = TxOut { value: Amount::MAX, script_pubkey: ScriptBuf::from(vec![0u8, 1u8, 2u8]) };
     let got = serialize(&txout).unwrap();
     let want = include_bytes!("data/serde/txout_bincode") as &[_];
     assert_eq!(got, want)
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs b/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
index 043d195969..7b36cf6975 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_psbt.rs
@@ -1,6 +1,5 @@
-use honggfuzz::fuzz;
-
 use bitcoin_fuzz::fuzz_utils::consume_random_bytes;
+use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
     let mut new_data = data;
diff --git a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
index 0968b64f0e..41ef804933 100644
--- a/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
+++ b/fuzz/fuzz_targets/bitcoin/deserialize_script.rs
@@ -2,9 +2,8 @@ use bitcoin::address::Address;
 use bitcoin::consensus::encode;
 use bitcoin::script::{self, ScriptExt as _};
 use bitcoin::{FeeRate, Network};
-use honggfuzz::fuzz;
-
 use bitcoin_fuzz::fuzz_utils::{consume_random_bytes, consume_u64};
+use honggfuzz::fuzz;
 
 fn do_test(data: &[u8]) {
     let mut new_data = data;
diff --git a/hashes/src/ripemd160/crypto.rs b/hashes/src/ripemd160/crypto.rs
index 178a2f441c..70e92f66d6 100644
--- a/hashes/src/ripemd160/crypto.rs
+++ b/hashes/src/ripemd160/crypto.rs
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use internals::slice::SliceExt;
+
 use super::{HashEngine, BLOCK_SIZE};
 
 #[cfg(feature = "small-hash")]
diff --git a/hashes/src/sha1/crypto.rs b/hashes/src/sha1/crypto.rs
index 9076c91095..70d04f506c 100644
--- a/hashes/src/sha1/crypto.rs
+++ b/hashes/src/sha1/crypto.rs
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use internals::slice::SliceExt;
+
 use super::{HashEngine, BLOCK_SIZE};
 
 impl HashEngine {
diff --git a/hashes/src/sha256/crypto.rs b/hashes/src/sha256/crypto.rs
index 34e780d7b8..eea9ff7a04 100644
--- a/hashes/src/sha256/crypto.rs
+++ b/hashes/src/sha256/crypto.rs
@@ -6,6 +6,7 @@ use core::arch::x86::*;
 use core::arch::x86_64::*;
 
 use internals::slice::SliceExt;
+
 use super::{HashEngine, Midstate, BLOCK_SIZE};
 
 #[allow(non_snake_case)]
diff --git a/hashes/src/sha256/mod.rs b/hashes/src/sha256/mod.rs
index ac11002c71..a45eb0bfee 100644
--- a/hashes/src/sha256/mod.rs
+++ b/hashes/src/sha256/mod.rs
@@ -9,6 +9,7 @@ mod crypto;
 mod tests;
 
 use core::{cmp, convert, fmt};
+
 use internals::slice::SliceExt;
 
 use crate::{incomplete_block_len, sha256d, HashEngine as _};
@@ -80,7 +81,8 @@ impl HashEngine {
     /// Please see docs on [`Midstate`] before using this function.
     pub fn from_midstate(midstate: Midstate) -> HashEngine {
         let mut ret = [0; 8];
-        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate.as_ref().bitcoin_as_chunks().0) {
+        for (ret_val, midstate_bytes) in ret.iter_mut().zip(midstate.as_ref().bitcoin_as_chunks().0)
+        {
             *ret_val = u32::from_be_bytes(*midstate_bytes);
         }
 
diff --git a/hashes/src/sha512/crypto.rs b/hashes/src/sha512/crypto.rs
index 0a9d5b0da4..6bf4f5ce26 100644
--- a/hashes/src/sha512/crypto.rs
+++ b/hashes/src/sha512/crypto.rs
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
 use internals::slice::SliceExt;
+
 use super::{HashEngine, BLOCK_SIZE};
 
 #[allow(non_snake_case)]
diff --git a/internals/src/slice.rs b/internals/src/slice.rs
index 38ac95878b..4c32126d06 100644
--- a/internals/src/slice.rs
+++ b/internals/src/slice.rs
@@ -23,7 +23,9 @@ pub trait SliceExt {
     /// let mut slice = [1, 2, 3];
     /// let fail = slice.as_chunks_mut::<0>();
     /// ```
-    fn bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item]);
+    fn bitcoin_as_chunks_mut<const N: usize>(
+        &mut self,
+    ) -> (&mut [[Self::Item; N]], &mut [Self::Item]);
 }
 
 impl<T> SliceExt for [T] {
@@ -40,11 +42,15 @@ impl<T> SliceExt for [T] {
         // we're merely casting, so no aliasing issues here
         // arrays of T have same alignment as T
         // the resulting slice points within the obtained slice as was computed above
-        let left = unsafe { core::slice::from_raw_parts(left.as_ptr().cast::<[Self::Item; N]>(), chunks_count) };
+        let left = unsafe {
+            core::slice::from_raw_parts(left.as_ptr().cast::<[Self::Item; N]>(), chunks_count)
+        };
         (left, right)
     }
 
-    fn bitcoin_as_chunks_mut<const N: usize>(&mut self) -> (&mut [[Self::Item; N]], &mut [Self::Item]) {
+    fn bitcoin_as_chunks_mut<const N: usize>(
+        &mut self,
+    ) -> (&mut [[Self::Item; N]], &mut [Self::Item]) {
         #[allow(clippy::let_unit_value)]
         let _ = Hack::<N>::IS_NONZERO;
 
@@ -55,7 +61,12 @@ impl<T> SliceExt for [T] {
         // we're merely casting, so no aliasing issues here
         // arrays of T have same alignment as T
         // the resulting slice points within the obtained slice as was computed above
-        let left = unsafe { core::slice::from_raw_parts_mut(left.as_mut_ptr().cast::<[Self::Item; N]>(), chunks_count) };
+        let left = unsafe {
+            core::slice::from_raw_parts_mut(
+                left.as_mut_ptr().cast::<[Self::Item; N]>(),
+                chunks_count,
+            )
+        };
         (left, right)
     }
 }
@@ -63,7 +74,9 @@ impl<T> SliceExt for [T] {
 struct Hack<const N: usize>;
 
 impl<const N: usize> Hack<N> {
-    const IS_NONZERO: () = { assert!(N != 0); };
+    const IS_NONZERO: () = {
+        assert!(N != 0);
+    };
 }
 
 #[cfg(test)]
diff --git a/primitives/src/opcodes.rs b/primitives/src/opcodes.rs
index 3a3bce70f6..8438445569 100644
--- a/primitives/src/opcodes.rs
+++ b/primitives/src/opcodes.rs
@@ -6,7 +6,7 @@
 //! all of the opcodes for that language.
 
 #![allow(non_camel_case_types)]
-#![allow(dead_code)]            // This module is private and is duplicated in `bitcoin`.
+#![allow(dead_code)] // This module is private and is duplicated in `bitcoin`.
 
 use core::fmt;
 
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index bb2f815229..764ed68c64 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -670,7 +670,10 @@ mod tests {
             witness: Witness::new(),
         };
 
-        let txout = TxOut { value: Amount::from_sat(123_456_789).unwrap(), script_pubkey: ScriptBuf::new() };
+        let txout = TxOut {
+            value: Amount::from_sat(123_456_789).unwrap(),
+            script_pubkey: ScriptBuf::new(),
+        };
 
         let tx_orig = Transaction {
             version: Version::ONE,
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index d5cf272250..bf2a8f9f8c 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -355,8 +355,7 @@ impl<'de> serde::Deserialize<'de> for Witness {
                 self,
                 mut a: A,
             ) -> Result<Self::Value, A::Error> {
-                use hex::FromHex;
-                use hex::HexToBytesError as E;
+                use hex::{FromHex, HexToBytesError as E};
                 use serde::de::{self, Unexpected};
 
                 let mut ret = match a.size_hint() {
@@ -366,16 +365,17 @@ impl<'de> serde::Deserialize<'de> for Witness {
 
                 while let Some(elem) = a.next_element::<String>()? {
                     let vec = Vec::<u8>::from_hex(&elem).map_err(|e| match e {
-                        E::InvalidChar(ref e) => match core::char::from_u32(e.invalid_char().into()) {
-                            Some(c) => de::Error::invalid_value(
-                                Unexpected::Char(c),
-                                &"a valid hex character",
-                            ),
-                            None => de::Error::invalid_value(
-                                Unexpected::Unsigned(e.invalid_char().into()),
-                                &"a valid hex character",
-                            ),
-                        },
+                        E::InvalidChar(ref e) =>
+                            match core::char::from_u32(e.invalid_char().into()) {
+                                Some(c) => de::Error::invalid_value(
+                                    Unexpected::Char(c),
+                                    &"a valid hex character",
+                                ),
+                                None => de::Error::invalid_value(
+                                    Unexpected::Unsigned(e.invalid_char().into()),
+                                    &"a valid hex character",
+                                ),
+                            },
                         E::OddLengthString(ref e) =>
                             de::Error::invalid_length(e.length(), &"an even length string"),
                     })?;
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 9333b87e6c..98e2137a8c 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -115,7 +115,7 @@ impl Denomination {
             Denomination::MicroBitcoin => -2,
             Denomination::Bit => -2,
             Denomination::Satoshi => 0,
-            Denomination::_DoNotUse(infallible) => match infallible {}
+            Denomination::_DoNotUse(infallible) => match infallible {},
         }
     }
 
@@ -128,7 +128,7 @@ impl Denomination {
             Denomination::MicroBitcoin => "uBTC",
             Denomination::Bit => "bits",
             Denomination::Satoshi => "satoshi",
-            Denomination::_DoNotUse(infallible) => match infallible {}
+            Denomination::_DoNotUse(infallible) => match infallible {},
         }
     }
 
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index b9d5518eb3..fedeb78cd6 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -345,14 +345,8 @@ fn parsing() {
     assert_eq!(p("1.1", den_btc), Ok(sat(1_100_000_00)));
     assert_eq!(p("100", den_sat), Ok(sat(100)));
     assert_eq!(p("55", den_sat), Ok(sat(55)));
-    assert_eq!(
-        p("2100000000000000", den_sat),
-        Ok(sat(21_000_000__000_000_00))
-    );
-    assert_eq!(
-        p("2100000000000000.", den_sat),
-        Ok(sat(21_000_000__000_000_00))
-    );
+    assert_eq!(p("2100000000000000", den_sat), Ok(sat(21_000_000__000_000_00)));
+    assert_eq!(p("2100000000000000.", den_sat), Ok(sat(21_000_000__000_000_00)));
     assert_eq!(p("21000000", den_btc), Ok(sat(21_000_000__000_000_00)));
 
     // exactly 50 chars.
@@ -702,28 +696,15 @@ fn to_from_string_in() {
     assert_eq!(ua_str(&ua_sat(21_000_000).to_string_in(D::Bit), D::Bit), Ok(ua_sat(21_000_000)));
     assert_eq!(ua_str(&ua_sat(0).to_string_in(D::Satoshi), D::Satoshi), Ok(ua_sat(0)));
 
-    assert!(
-        ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Bitcoin), D::Bitcoin).is_ok()
-    );
-    assert!(ua_str(
-        &ua_sat(Amount::MAX.to_sat()).to_string_in(D::CentiBitcoin),
-        D::CentiBitcoin
-    )
-    .is_ok());
-    assert!(ua_str(
-        &ua_sat(Amount::MAX.to_sat()).to_string_in(D::MilliBitcoin),
-        D::MilliBitcoin
-    )
-    .is_ok());
-    assert!(ua_str(
-        &ua_sat(Amount::MAX.to_sat()).to_string_in(D::MicroBitcoin),
-        D::MicroBitcoin
-    )
-    .is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Bitcoin), D::Bitcoin).is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::CentiBitcoin), D::CentiBitcoin)
+        .is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MilliBitcoin), D::MilliBitcoin)
+        .is_ok());
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::MicroBitcoin), D::MicroBitcoin)
+        .is_ok());
     assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Bit), D::Bit).is_ok());
-    assert!(
-        ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Satoshi), D::Satoshi).is_ok()
-    );
+    assert!(ua_str(&ua_sat(Amount::MAX.to_sat()).to_string_in(D::Satoshi), D::Satoshi).is_ok());
 
     assert_eq!(
         sa_str(&SignedAmount::MAX.to_string_in(D::Satoshi), D::MicroBitcoin),
@@ -970,11 +951,19 @@ fn sum_amounts() {
     assert_eq!([].iter().sum::<NumOpResult<Amount>>(), Amount::ZERO.into());
     assert_eq!([].iter().sum::<NumOpResult<SignedAmount>>(), SignedAmount::ZERO.into());
 
-    let results = [NumOpResult::Valid(sat(42)), NumOpResult::Valid(sat(1337)), NumOpResult::Valid(sat(21))];
+    let results =
+        [NumOpResult::Valid(sat(42)), NumOpResult::Valid(sat(1337)), NumOpResult::Valid(sat(21))];
     assert_eq!(results.iter().sum::<NumOpResult<Amount>>(), NumOpResult::Valid(sat(1400)));
 
-    let signed_results = [NumOpResult::Valid(ssat(42)), NumOpResult::Valid(ssat(1337)), NumOpResult::Valid(ssat(21))];
-    assert_eq!(signed_results.iter().sum::<NumOpResult<SignedAmount>>(), NumOpResult::Valid(ssat(1400)));
+    let signed_results = [
+        NumOpResult::Valid(ssat(42)),
+        NumOpResult::Valid(ssat(1337)),
+        NumOpResult::Valid(ssat(21)),
+    ];
+    assert_eq!(
+        signed_results.iter().sum::<NumOpResult<SignedAmount>>(),
+        NumOpResult::Valid(ssat(1400))
+    );
 
     let amounts = [sat(42), sat(1337), sat(21)];
     assert_eq!(
@@ -1240,9 +1229,7 @@ fn unsigned_amount_div_by_amount() {
 
 #[test]
 #[should_panic(expected = "attempt to divide by zero")]
-fn unsigned_amount_div_by_amount_zero() {
-    let _ = sat(1897) / Amount::ZERO;
-}
+fn unsigned_amount_div_by_amount_zero() { let _ = sat(1897) / Amount::ZERO; }
 
 #[test]
 fn signed_amount_div_by_amount() {
@@ -1256,9 +1243,7 @@ fn signed_amount_div_by_amount() {
 
 #[test]
 #[should_panic(expected = "attempt to divide by zero")]
-fn signed_amount_div_by_amount_zero() {
-    let _ = ssat(1897) / SignedAmount::ZERO;
-}
+fn signed_amount_div_by_amount_zero() { let _ = ssat(1897) / SignedAmount::ZERO; }
 
 #[test]
 fn check_const() {
diff --git a/units/tests/api.rs b/units/tests/api.rs
index b8ec96c3ca..e3b89fed0f 100644
--- a/units/tests/api.rs
+++ b/units/tests/api.rs
@@ -14,8 +14,8 @@ use arbitrary::{Arbitrary, Unstructured};
 // These imports test "typical" usage by user code.
 use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::Height`.
 use bitcoin_units::{
-    amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, FeeRate,
-    SignedAmount, BlockTime, Weight,
+    amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval,
+    BlockTime, FeeRate, SignedAmount, Weight,
 };
 
 /// A struct that includes all public non-error enums.
@@ -147,7 +147,7 @@ fn api_can_use_modules_from_crate_root() {
 #[test]
 fn api_can_use_types_from_crate_root() {
     use bitcoin_units::{
-        Amount, BlockHeight, BlockInterval, FeeRate, SignedAmount, BlockTime, Weight,
+        Amount, BlockHeight, BlockInterval, BlockTime, FeeRate, SignedAmount, Weight,
     };
 }
 

From 427bfb82d75cdc98d31ec270c2011d6f6d75bcd4 Mon Sep 17 00:00:00 2001
From: healthyyyoung <healthyoung@proton.me>
Date: Sun, 16 Mar 2025 07:23:18 +0000
Subject: [PATCH 520/554] chore: spellchecker

---
 bitcoin/src/blockdata/script/tests.rs | 2 +-
 bitcoin/src/pow.rs                    | 2 +-
 bitcoin/src/psbt/serialize.rs         | 2 +-
 chacha20_poly1305/src/chacha20.rs     | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 4443645b1b..bbc0c43b0e 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -494,7 +494,7 @@ fn script_asm() {
     assert_eq!(ScriptBuf::from_hex("0047304402202457e78cc1b7f50d0543863c27de75d07982bde8359b9e3316adec0aec165f2f02200203fd331c4e4a4a02f48cf1c291e2c0d6b2f7078a784b5b3649fca41f8794d401004cf1552103244e602b46755f24327142a0517288cebd159eccb6ccf41ea6edf1f601e9af952103bbbacc302d19d29dbfa62d23f37944ae19853cf260c745c2bea739c95328fcb721039227e83246bd51140fe93538b2301c9048be82ef2fb3c7fc5d78426ed6f609ad210229bf310c379b90033e2ecb07f77ecf9b8d59acb623ab7be25a0caed539e2e6472103703e2ed676936f10b3ce9149fa2d4a32060fb86fa9a70a4efe3f21d7ab90611921031e9b7c6022400a6bb0424bbcde14cff6c016b91ee3803926f3440abf5c146d05210334667f975f55a8455d515a2ef1c94fdfa3315f12319a14515d2a13d82831f62f57ae").unwrap().to_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.
+    // which triggered overflow bugs on 32-bit machines in script formatting in the past.
     assert_eq!(ScriptBuf::from_hex("01").unwrap().to_string(), "OP_PUSHBYTES_1 <push past end>");
     assert_eq!(ScriptBuf::from_hex("0201").unwrap().to_string(), "OP_PUSHBYTES_2 <push past end>");
     assert_eq!(ScriptBuf::from_hex("4c").unwrap().to_string(), "<unexpected end>");
diff --git a/bitcoin/src/pow.rs b/bitcoin/src/pow.rs
index bb59edb508..ae295a3b7d 100644
--- a/bitcoin/src/pow.rs
+++ b/bitcoin/src/pow.rs
@@ -253,7 +253,7 @@ impl Target {
     /// [max]: Target::max
     /// [target]: crate::block::HeaderExt::target
     pub fn difficulty(&self, params: impl AsRef<Params>) -> u128 {
-        // Panic here may be eaiser to debug than during the actual division.
+        // Panic here may be easier to debug than during the actual division.
         assert_ne!(self.0, U256::ZERO, "divide by zero");
 
         let max = params.as_ref().max_attainable_target;
diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
index 89de08dcb0..abe0853f27 100644
--- a/bitcoin/src/psbt/serialize.rs
+++ b/bitcoin/src/psbt/serialize.rs
@@ -368,7 +368,7 @@ impl Serialize for TapTree {
         for leaf_info in self.script_leaves() {
             // # Cast Safety:
             //
-            // TaprootMerkleBranch can only have len atmost 128(TAPROOT_CONTROL_MAX_NODE_COUNT).
+            // TaprootMerkleBranch can only have len at most 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());
diff --git a/chacha20_poly1305/src/chacha20.rs b/chacha20_poly1305/src/chacha20.rs
index bf0013192f..0f332fbaba 100644
--- a/chacha20_poly1305/src/chacha20.rs
+++ b/chacha20_poly1305/src/chacha20.rs
@@ -243,7 +243,7 @@ pub struct ChaCha20 {
     nonce: Nonce,
     /// Internal block index of keystream.
     block_count: u32,
-    /// Interal byte offset index of the block_count.
+    /// Internal byte offset index of the block_count.
     seek_offset_bytes: usize,
 }
 

From dd6687d9929557618226145802e0db5f5eb398b7 Mon Sep 17 00:00:00 2001
From: planetBoy <140164174+Guayaba221@users.noreply.github.com>
Date: Sun, 16 Mar 2025 16:13:21 +0100
Subject: [PATCH 521/554] Update sighash.rs

---
 bitcoin/examples/sighash.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index e4bf819efc..0878ea4390 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -57,7 +57,7 @@ fn compute_sighash_p2wpkh(raw_tx: &[u8], inp_idx: usize, amount: Amount) {
 /// # Parameters
 ///
 /// * `raw_tx` - spending tx hex
-/// * `inp_idx` - spending tx input inde
+/// * `inp_idx` - spending tx input index
 /// * `script_pubkey_bytes_opt` - Option with scriptPubKey bytes. If None, it's p2sh case, i.e., reftx output's scriptPubKey.type is "scripthash". In this case scriptPubkey is extracted from the spending transaction's scriptSig. If Some(), it's p2ms case, i.e., reftx output's scriptPubKey.type is "multisig", and the scriptPubkey is supplied from the referenced output.
 fn compute_sighash_legacy(raw_tx: &[u8], inp_idx: usize, script_pubkey_bytes_opt: Option<&[u8]>) {
     let tx: Transaction = consensus::deserialize(raw_tx).unwrap();

From 441e173792fa97fb6f8bf991e6c195da8d8f1a51 Mon Sep 17 00:00:00 2001
From: planetBoy <140164174+Guayaba221@users.noreply.github.com>
Date: Sun, 16 Mar 2025 16:14:13 +0100
Subject: [PATCH 522/554] Update owned.rs

---
 bitcoin/src/blockdata/script/owned.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bitcoin/src/blockdata/script/owned.rs b/bitcoin/src/blockdata/script/owned.rs
index ccc82ca894..8b8b73e385 100644
--- a/bitcoin/src/blockdata/script/owned.rs
+++ b/bitcoin/src/blockdata/script/owned.rs
@@ -203,7 +203,7 @@ impl<'a> Extend<Instruction<'a>> for ScriptBuf {
 /// Pretends that this is a mutable reference to [`ScriptBuf`]'s internal buffer.
 ///
 /// In reality the backing `Vec<u8>` is swapped with an empty one and this is holding both the
-/// reference and the vec. The vec is put back when this drops so it also covers paics. (But not
+/// reference and the vec. The vec is put back when this drops so it also covers panics. (But not
 /// leaks, which is OK since we never leak.)
 pub(crate) struct ScriptBufAsVec<'a>(&'a mut ScriptBuf, Vec<u8>);
 

From f4f79f88eb2c6c80c46c95c69fcc43b17d306be2 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Mon, 17 Mar 2025 11:40:02 +1100
Subject: [PATCH 523/554] Enable getting the network kind from an address

Users may wish to ask of an address 'what kind of address is this?' We
have the `NetworkKind` struct that abstracts over the answer but
currently no API to ask the question.

The address may have been parsed or constructed and weather the network
has been checked already is immaterial. Hence we add the function for
both `NetworkChecked` and `NetworkUnchecked` addresses.

Fix: #4247
---
 bitcoin/src/address/mod.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index a4588617aa..36b6a553c4 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -273,6 +273,16 @@ impl From<Network> for KnownHrp {
     fn from(n: Network) -> Self { Self::from_network(n) }
 }
 
+impl From<KnownHrp> for NetworkKind {
+    fn from(hrp: KnownHrp) -> Self {
+        match hrp {
+            KnownHrp::Mainnet => NetworkKind::Main,
+            KnownHrp::Testnets => NetworkKind::Test,
+            KnownHrp::Regtest => NetworkKind::Test,
+        }
+    }
+}
+
 /// The data encoded by an `Address`.
 ///
 /// This is the data used to encumber an output that pays to this address i.e., it is the address
@@ -450,6 +460,16 @@ impl<V: NetworkValidation> Address<V> {
 
     /// Marks the network of this address as unchecked.
     pub fn into_unchecked(self) -> Address<NetworkUnchecked> { Address(self.0, PhantomData) }
+
+    /// Returns the [`NetworkKind`] of this address.
+    pub fn network_kind(&self) -> NetworkKind {
+        use AddressInner::*;
+        match self.0 {
+            P2pkh { hash: _, ref network } => *network,
+            P2sh { hash: _, ref network } => *network,
+            Segwit { program: _, ref hrp } => NetworkKind::from(*hrp),
+        }
+    }
 }
 
 /// Methods and functions that can be called only on `Address<NetworkChecked>`.

From c97bebdcba1b69c68f3f356b8f96c44940bd0b39 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Mar 2025 14:41:41 +0000
Subject: [PATCH 524/554] Increase test coverage in absolute.rs

Modify existing tests and add new ones to increase test coverage in
`locktime/absolute.rs`.
---
 primitives/src/locktime/absolute.rs | 67 +++++++++++++++++++----------
 1 file changed, 45 insertions(+), 22 deletions(-)

diff --git a/primitives/src/locktime/absolute.rs b/primitives/src/locktime/absolute.rs
index 8d90cf2548..ad03f5102b 100644
--- a/primitives/src/locktime/absolute.rs
+++ b/primitives/src/locktime/absolute.rs
@@ -405,12 +405,25 @@ mod tests {
 
     #[test]
     fn display_and_alternate() {
+        let lock_by_height = LockTime::from_height(741_521).unwrap();
+        let lock_by_time = LockTime::from_time(1_653_195_600).unwrap(); // May 22nd 2022, 5am UTC.
+
+        assert_eq!(format!("{}", lock_by_height), "741521");
+        assert_eq!(format!("{:#}", lock_by_height), "block-height 741521");
+        assert!(!format!("{:?}", lock_by_height).is_empty());
+
+        assert_eq!(format!("{}", lock_by_time), "1653195600");
+        assert_eq!(format!("{:#}", lock_by_time), "block-time 1653195600 (seconds since epoch)");
+        assert!(!format!("{:?}", lock_by_time).is_empty());
+    }
+
+    #[test]
+    fn roundtrips() {
         let lock_by_height = LockTime::from_consensus(741_521);
-        let s = format!("{}", lock_by_height);
-        assert_eq!(&s, "741521");
+        let lock_by_time = LockTime::from_consensus(1_653_195_600);
 
-        let got = format!("{:#}", lock_by_height);
-        assert_eq!(got, "block-height 741521");
+        assert_eq!(lock_by_height.to_consensus_u32(), 741_521);
+        assert_eq!(lock_by_time.to_consensus_u32(), 1_653_195_600);
     }
 
     #[test]
@@ -438,10 +451,20 @@ mod tests {
     }
 
     #[test]
-    fn lock_time_from_invalid_hex_should_err() {
-        let hex = "0xzb93";
-        let result = LockTime::from_hex(hex);
-        assert!(result.is_err());
+    fn invalid_hex() {
+        assert!(LockTime::from_hex("0xzb93").is_err());
+        assert!(LockTime::from_unprefixed_hex("zb93").is_err());
+    }
+
+    #[test]
+    fn invalid_locktime_type() {
+        assert!(LockTime::from_height(499_999_999).is_ok()); // Below the threshold.
+        assert!(LockTime::from_height(500_000_000).is_err()); // The threshold.
+        assert!(LockTime::from_height(500_000_001).is_err()); // Above the threshold.
+
+        assert!(LockTime::from_time(499_999_999).is_err()); // Below the threshold.
+        assert!(LockTime::from_time(500_000_000).is_ok()); // The threshold.
+        assert!(LockTime::from_time(500_000_001).is_ok()); // Above the threshold.
     }
 
     #[test]
@@ -466,33 +489,33 @@ mod tests {
 
     #[test]
     fn satisfied_by_height() {
-        let lock_by_height = LockTime::from_consensus(750_000);
+        let height_below = Height::from_consensus(700_000).unwrap();
+        let height = Height::from_consensus(750_000).unwrap();
+        let height_above = Height::from_consensus(800_000).unwrap();
 
-        let height_same = Height::from_consensus(750_000).expect("failed to parse height");
-        let height_above = Height::from_consensus(800_000).expect("failed to parse height");
-        let height_below = Height::from_consensus(700_000).expect("failed to parse height");
+        let lock_by_height = LockTime::from(height);
 
         let t: u32 = 1_653_195_600; // May 22nd, 5am UTC.
-        let time = Time::from_consensus(t).expect("invalid time value");
+        let time = Time::from_consensus(t).unwrap();
 
-        assert!(lock_by_height.is_satisfied_by(height_same, time));
-        assert!(lock_by_height.is_satisfied_by(height_above, time));
         assert!(!lock_by_height.is_satisfied_by(height_below, time));
+        assert!(lock_by_height.is_satisfied_by(height, time));
+        assert!(lock_by_height.is_satisfied_by(height_above, time));
     }
 
     #[test]
     fn satisfied_by_time() {
-        let lock_by_time = LockTime::from_consensus(1_653_195_600); // May 22nd 2022, 5am UTC.
+        let time_before = Time::from_consensus(1_653_109_200).unwrap(); // "May 21th 2022, 5am UTC.
+        let time = Time::from_consensus(1_653_195_600).unwrap(); // "May 22nd 2022, 5am UTC.
+        let time_after = Time::from_consensus(1_653_282_000).unwrap(); // "May 23rd 2022, 5am UTC.
 
-        let time_same = Time::from_consensus(1_653_195_600).expect("May 22nd 2022, 5am UTC");
-        let time_after = Time::from_consensus(1_653_282_000).expect("May 23rd 2022, 5am UTC");
-        let time_before = Time::from_consensus(1_653_109_200).expect("May 21th 2022, 5am UTC");
+        let lock_by_time = LockTime::from(time);
 
-        let height = Height::from_consensus(800_000).expect("failed to parse height");
+        let height = Height::from_consensus(800_000).unwrap();
 
-        assert!(lock_by_time.is_satisfied_by(height, time_same));
-        assert!(lock_by_time.is_satisfied_by(height, time_after));
         assert!(!lock_by_time.is_satisfied_by(height, time_before));
+        assert!(lock_by_time.is_satisfied_by(height, time));
+        assert!(lock_by_time.is_satisfied_by(height, time_after));
     }
 
     #[test]

From 7b114e38935f9c688c1259793e7ffda822f25c57 Mon Sep 17 00:00:00 2001
From: "Jamil Lambert, PhD" <Jamil.Lambert@proton.me>
Date: Tue, 11 Mar 2025 16:01:53 +0000
Subject: [PATCH 525/554] Increase test coverage in relative.rs

Increase test coverage in `locktime/relative.rs`
---
 primitives/src/locktime/relative.rs | 67 +++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/primitives/src/locktime/relative.rs b/primitives/src/locktime/relative.rs
index 8c03a9459b..000adb0784 100644
--- a/primitives/src/locktime/relative.rs
+++ b/primitives/src/locktime/relative.rs
@@ -470,6 +470,36 @@ impl std::error::Error for IncompatibleTimeError {}
 mod tests {
     use super::*;
 
+    #[test]
+    fn display_and_alternate() {
+        let lock_by_height = LockTime::from_height(10);
+        let lock_by_time = LockTime::from_512_second_intervals(70);
+
+        assert_eq!(format!("{}", lock_by_height), "10");
+        assert_eq!(format!("{:#}", lock_by_height), "block-height 10");
+        assert!(!format!("{:?}", lock_by_height).is_empty());
+
+        assert_eq!(format!("{}", lock_by_time), "70");
+        assert_eq!(format!("{:#}", lock_by_time), "block-time 70 (512 second intervals)");
+        assert!(!format!("{:?}", lock_by_time).is_empty());
+    }
+
+    #[test]
+    fn from_seconds_ceil_and_floor() {
+        let time = 70*512+1;
+        let lock_by_time = LockTime::from_seconds_ceil(time).unwrap();
+        assert_eq!(lock_by_time, LockTime::from_512_second_intervals(71));
+
+        let lock_by_time = LockTime::from_seconds_floor(time).unwrap();
+        assert_eq!(lock_by_time, LockTime::from_512_second_intervals(70));
+
+        let mut max_time = 0xffff * 512;
+        assert_eq!(LockTime::from_seconds_ceil(max_time),LockTime::from_seconds_floor(max_time));
+        max_time += 512;
+        assert!(LockTime::from_seconds_ceil(max_time).is_err());
+        assert!(LockTime::from_seconds_floor(max_time).is_err());
+    }
+
     #[test]
     fn parses_correctly_to_height_or_time() {
         let height1 = Height::from(10);
@@ -555,6 +585,10 @@ mod tests {
 
         assert!(lock_by_time.is_implied_by_sequence(seq_time));
         assert!(!lock_by_time.is_implied_by_sequence(seq_height));
+
+        let disabled_sequence = Sequence::from_consensus(1 << 31);
+        assert!(!lock_by_height.is_implied_by_sequence(disabled_sequence));
+        assert!(!lock_by_time.is_implied_by_sequence(disabled_sequence));
     }
 
     #[test]
@@ -587,4 +621,37 @@ mod tests {
             assert_eq!(LockTime::from_sequence(seq).unwrap().to_sequence(), seq);
         }
     }
+
+    #[test]
+    fn disabled_locktime_error() {
+        let disabled_sequence = Sequence::from_consensus(1 << 31);
+        let err = LockTime::try_from(disabled_sequence).unwrap_err();
+
+        assert_eq!(err.disabled_locktime_value(), 1 << 31);
+        assert!(!format!("{}", err).is_empty());
+    }
+
+    #[test]
+    fn incompatible_height_error() {
+        let height = Height::from(10);
+        let time = Time::from_512_second_intervals(70);
+        let lock_by_time = LockTime::from(time);
+        let err = lock_by_time.is_satisfied_by_height(height).unwrap_err();
+
+        assert_eq!(err.incompatible(), height);
+        assert_eq!(err.expected(), time);
+        assert!(!format!("{}", err).is_empty());
+    }
+
+    #[test]
+    fn incompatible_time_error() {
+        let height = Height::from(10);
+        let time = Time::from_512_second_intervals(70);
+        let lock_by_height = LockTime::from(height);
+        let err = lock_by_height.is_satisfied_by_time(time).unwrap_err();
+
+        assert_eq!(err.incompatible(), time);
+        assert_eq!(err.expected(), height);
+        assert!(!format!("{}", err).is_empty());
+    }
 }

From 2ec1c2a0448c92bf12eb56d8c6bcf2d96b8bcf53 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Tue, 18 Mar 2025 09:37:10 +1100
Subject: [PATCH 526/554] units: Make from_int_btc_const take a 16 bit integer

The `from_int_btc_const` constructors are specifically designed for
easily creating amount types in const context but currently they return
an error which is annoying to handle in const context. If we make the
`whole_bitcoin` parameter a 16 bit integer this gives us a nicer const
constructor with the downside that it can only create values upto a
maximum of

- unsigned: 65_536
- signed: 32_767

That is plenty high enough for most use cases.

Then use the new `from_int_btc_const` in associated consts.

Note that because `from_sat` checks max (and min) values we must
define max and min from sats directly.
---
 units/src/amount/signed.rs   | 24 +++++++++---------------
 units/src/amount/tests.rs    |  2 +-
 units/src/amount/unsigned.rs | 24 +++++++++---------------
 3 files changed, 19 insertions(+), 31 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 3f7927b47b..2119f488db 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -77,9 +77,9 @@ impl SignedAmount {
     /// Exactly one satoshi.
     pub const ONE_SAT: Self = SignedAmount::from_sat_unchecked(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Self = SignedAmount::from_sat_unchecked(100_000_000);
+    pub const ONE_BTC: Self = SignedAmount::from_int_btc_const(1);
     /// Exactly fifty bitcoin.
-    pub const FIFTY_BTC: Self = SignedAmount::from_sat_unchecked(50 * 100_000_000);
+    pub const FIFTY_BTC: Self = SignedAmount::from_int_btc_const(50);
     /// The maximum value allowed as an amount. Useful for sanity checking.
     pub const MAX_MONEY: Self = SignedAmount::from_sat_unchecked(21_000_000 * 100_000_000);
     /// The minimum value of an amount.
@@ -134,27 +134,21 @@ impl SignedAmount {
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`].
-    ///
-    /// # Errors
-    ///
-    /// If `whole_bitcoin` is greater than `21_000_000`.
     #[allow(clippy::missing_panics_doc)]
-    pub fn from_int_btc<T: Into<i32>>(whole_bitcoin: T) -> Result<SignedAmount, OutOfRangeError> {
+    pub fn from_int_btc<T: Into<i16>>(whole_bitcoin: T) -> SignedAmount {
         SignedAmount::from_int_btc_const(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`]
     /// in const context.
-    ///
-    /// # Errors
-    ///
-    /// If `whole_bitcoin` is greater than `21_000_000`.
     #[allow(clippy::missing_panics_doc)]
-    pub const fn from_int_btc_const(whole_bitcoin: i32) -> Result<SignedAmount, OutOfRangeError> {
+    pub const fn from_int_btc_const(whole_bitcoin: i16) -> SignedAmount {
         let btc = whole_bitcoin as i64; // Can't call `into` in const context.
-        match btc.checked_mul(100_000_000) {
-            Some(amount) => SignedAmount::from_sat(amount),
-            None => panic!("cannot overflow in i64"),
+        let sats = btc * 100_000_000;
+
+        match SignedAmount::from_sat(sats) {
+            Ok(amount) => amount,
+            Err(_) => panic!("unreachable - 65536 BTC is within range"),
         }
     }
 
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index fedeb78cd6..5fc4955889 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -102,7 +102,7 @@ fn from_str_zero_without_denomination() {
 
 #[test]
 fn from_int_btc() {
-    let amt = Amount::from_int_btc_const(2).unwrap();
+    let amt = Amount::from_int_btc_const(2);
     assert_eq!(sat(200_000_000), amt);
 }
 
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 1b328f9645..ab1abb9c37 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -75,9 +75,9 @@ impl Amount {
     /// Exactly one satoshi.
     pub const ONE_SAT: Self = Amount::from_sat_unchecked(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Self = Amount::from_sat_unchecked(100_000_000);
+    pub const ONE_BTC: Self = Amount::from_int_btc_const(1);
     /// Exactly fifty bitcoin.
-    pub const FIFTY_BTC: Self = Amount::from_sat_unchecked(50 * 100_000_000);
+    pub const FIFTY_BTC: Self = Amount::from_int_btc_const(50);
     /// The maximum value allowed as an amount. Useful for sanity checking.
     pub const MAX_MONEY: Self = Amount::from_sat_unchecked(21_000_000 * 100_000_000);
     /// The minimum value of an amount.
@@ -132,27 +132,21 @@ impl Amount {
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`].
-    ///
-    /// # Errors
-    ///
-    /// If `whole_bitcoin` is greater than `21_000_000`.
     #[allow(clippy::missing_panics_doc)]
-    pub fn from_int_btc<T: Into<u32>>(whole_bitcoin: T) -> Result<Amount, OutOfRangeError> {
+    pub fn from_int_btc<T: Into<u16>>(whole_bitcoin: T) -> Amount {
         Amount::from_int_btc_const(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`]
     /// in const context.
-    ///
-    /// # Errors
-    ///
-    /// If `whole_bitcoin` is greater than `21_000_000`.
     #[allow(clippy::missing_panics_doc)]
-    pub const fn from_int_btc_const(whole_bitcoin: u32) -> Result<Amount, OutOfRangeError> {
+    pub const fn from_int_btc_const(whole_bitcoin: u16) -> Amount {
         let btc = whole_bitcoin as u64; // Can't call `into` in const context.
-        match btc.checked_mul(100_000_000) {
-            Some(amount) => Amount::from_sat(amount),
-            None => panic!("cannot overflow a u64"),
+        let sats = btc * 100_000_000;
+
+        match Amount::from_sat(sats) {
+            Ok(amount) => amount,
+            Err(_) => panic!("unreachable - 65536 BTC is within range"),
         }
     }
 

From 277045bad7c4e9339d55e57ec425b0d0b46a5b58 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sat, 15 Mar 2025 19:28:43 +0100
Subject: [PATCH 527/554] Add `Buf` suffix to `TaprootMerkleBranch`

This type actually contains a `Vec` but we would prefer to have an
unsized type. Rename it first so that we can reuse the name later.
---
 bitcoin/src/taproot/merkle_branch.rs | 42 ++++++++++++++--------------
 bitcoin/src/taproot/mod.rs           | 22 +++++++--------
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/bitcoin/src/taproot/merkle_branch.rs b/bitcoin/src/taproot/merkle_branch.rs
index 5ad08cbc1a..6a523ba8dd 100644
--- a/bitcoin/src/taproot/merkle_branch.rs
+++ b/bitcoin/src/taproot/merkle_branch.rs
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
-//! Contains `TaprootMerkleBranch` and its associated types.
+//! Contains `TaprootMerkleBranchBuf` and its associated types.
 
 use hashes::Hash;
 
@@ -15,9 +15,9 @@ use crate::prelude::{Borrow, BorrowMut, Box, Vec};
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(into = "Vec<TapNodeHash>"))]
 #[cfg_attr(feature = "serde", serde(try_from = "Vec<TapNodeHash>"))]
-pub struct TaprootMerkleBranch(Vec<TapNodeHash>);
+pub struct TaprootMerkleBranchBuf(Vec<TapNodeHash>);
 
-impl TaprootMerkleBranch {
+impl TaprootMerkleBranchBuf {
     /// Returns a reference to the slice of hashes.
     #[deprecated(since = "0.32.0", note = "use `as_slice` instead")]
     #[inline]
@@ -54,7 +54,7 @@ impl TaprootMerkleBranch {
         } else {
             let inner = node_hashes.iter().copied().map(TapNodeHash::from_byte_array).collect();
 
-            Ok(TaprootMerkleBranch(inner))
+            Ok(TaprootMerkleBranchBuf(inner))
         }
     }
 
@@ -70,7 +70,7 @@ impl TaprootMerkleBranch {
         if collection.as_ref().len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
             Err(InvalidMerkleTreeDepthError(collection.as_ref().len()))
         } else {
-            Ok(TaprootMerkleBranch(collection.into()))
+            Ok(TaprootMerkleBranchBuf(collection.into()))
         }
     }
 
@@ -113,7 +113,7 @@ impl TaprootMerkleBranch {
 
 macro_rules! impl_try_from {
     ($from:ty) => {
-        impl TryFrom<$from> for TaprootMerkleBranch {
+        impl TryFrom<$from> for TaprootMerkleBranchBuf {
             type Error = InvalidMerkleTreeDepthError;
 
             /// Constructs a new Merkle proof from list of hashes.
@@ -123,7 +123,7 @@ macro_rules! impl_try_from {
             /// If inner proof length is more than [`TAPROOT_CONTROL_MAX_NODE_COUNT`] (128).
             #[inline]
             fn try_from(v: $from) -> Result<Self, Self::Error> {
-                TaprootMerkleBranch::from_collection(v)
+                TaprootMerkleBranchBuf::from_collection(v)
             }
         }
     };
@@ -135,7 +135,7 @@ impl_try_from!(Box<[TapNodeHash]>);
 macro_rules! impl_try_from_array {
     ($($len:expr),* $(,)?) => {
         $(
-            impl From<[TapNodeHash; $len]> for TaprootMerkleBranch {
+            impl From<[TapNodeHash; $len]> for TaprootMerkleBranchBuf {
                 #[inline]
                 fn from(a: [TapNodeHash; $len]) -> Self {
                     Self(a.to_vec())
@@ -146,7 +146,7 @@ macro_rules! impl_try_from_array {
 }
 // Implement for all values [0, 128] inclusive.
 //
-// The reason zero is included is that `TaprootMerkleBranch` doesn't contain the hash of the node
+// The reason zero is included is that `TaprootMerkleBranchBuf` 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,
@@ -157,12 +157,12 @@ impl_try_from_array!(
     117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128
 );
 
-impl From<TaprootMerkleBranch> for Vec<TapNodeHash> {
+impl From<TaprootMerkleBranchBuf> for Vec<TapNodeHash> {
     #[inline]
-    fn from(branch: TaprootMerkleBranch) -> Self { branch.0 }
+    fn from(branch: TaprootMerkleBranchBuf) -> Self { branch.0 }
 }
 
-impl IntoIterator for TaprootMerkleBranch {
+impl IntoIterator for TaprootMerkleBranchBuf {
     type IntoIter = IntoIter;
     type Item = TapNodeHash;
 
@@ -170,7 +170,7 @@ impl IntoIterator for TaprootMerkleBranch {
     fn into_iter(self) -> Self::IntoIter { IntoIter(self.0.into_iter()) }
 }
 
-impl<'a> IntoIterator for &'a TaprootMerkleBranch {
+impl<'a> IntoIterator for &'a TaprootMerkleBranchBuf {
     type IntoIter = core::slice::Iter<'a, TapNodeHash>;
     type Item = &'a TapNodeHash;
 
@@ -178,7 +178,7 @@ impl<'a> IntoIterator for &'a TaprootMerkleBranch {
     fn into_iter(self) -> Self::IntoIter { self.0.iter() }
 }
 
-impl<'a> IntoIterator for &'a mut TaprootMerkleBranch {
+impl<'a> IntoIterator for &'a mut TaprootMerkleBranchBuf {
     type IntoIter = core::slice::IterMut<'a, TapNodeHash>;
     type Item = &'a mut TapNodeHash;
 
@@ -186,41 +186,41 @@ impl<'a> IntoIterator for &'a mut TaprootMerkleBranch {
     fn into_iter(self) -> Self::IntoIter { self.0.iter_mut() }
 }
 
-impl core::ops::Deref for TaprootMerkleBranch {
+impl core::ops::Deref for TaprootMerkleBranchBuf {
     type Target = [TapNodeHash];
 
     #[inline]
     fn deref(&self) -> &Self::Target { &self.0 }
 }
 
-impl core::ops::DerefMut for TaprootMerkleBranch {
+impl core::ops::DerefMut for TaprootMerkleBranchBuf {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
 }
 
-impl AsRef<[TapNodeHash]> for TaprootMerkleBranch {
+impl AsRef<[TapNodeHash]> for TaprootMerkleBranchBuf {
     #[inline]
     fn as_ref(&self) -> &[TapNodeHash] { &self.0 }
 }
 
-impl AsMut<[TapNodeHash]> for TaprootMerkleBranch {
+impl AsMut<[TapNodeHash]> for TaprootMerkleBranchBuf {
     #[inline]
     fn as_mut(&mut self) -> &mut [TapNodeHash] { &mut self.0 }
 }
 
-impl Borrow<[TapNodeHash]> for TaprootMerkleBranch {
+impl Borrow<[TapNodeHash]> for TaprootMerkleBranchBuf {
     #[inline]
     fn borrow(&self) -> &[TapNodeHash] { &self.0 }
 }
 
-impl BorrowMut<[TapNodeHash]> for TaprootMerkleBranch {
+impl BorrowMut<[TapNodeHash]> for TaprootMerkleBranchBuf {
     #[inline]
     fn borrow_mut(&mut self) -> &mut [TapNodeHash] { &mut self.0 }
 }
 
 /// Iterator over node hashes within Taproot Merkle branch.
 ///
-/// This is created by `into_iter` method on `TaprootMerkleBranch` (via `IntoIterator` trait).
+/// This is created by `into_iter` method on `TaprootMerkleBranchBuf` (via `IntoIterator` trait).
 #[derive(Clone, Debug)]
 pub struct IntoIter(alloc::vec::IntoIter<TapNodeHash>);
 
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 78616db365..2c0a29096d 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -27,7 +27,7 @@ use crate::{Script, ScriptBuf};
 #[doc(inline)]
 pub use crate::crypto::taproot::{SigFromSliceError, Signature};
 #[doc(inline)]
-pub use merkle_branch::TaprootMerkleBranch;
+pub use merkle_branch::TaprootMerkleBranchBuf;
 
 // Taproot test vectors from BIP-341 state the hashes without any reversing
 sha256t_tag! {
@@ -190,7 +190,7 @@ pub struct LeafScript<S> {
 }
 
 // type alias for versioned tap script corresponding Merkle proof
-type ScriptMerkleProofMap = BTreeMap<(ScriptBuf, LeafVersion), BTreeSet<TaprootMerkleBranch>>;
+type ScriptMerkleProofMap = BTreeMap<(ScriptBuf, LeafVersion), BTreeSet<TaprootMerkleBranchBuf>>;
 
 /// Represents Taproot spending information.
 ///
@@ -221,7 +221,7 @@ pub struct TaprootSpendInfo {
     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
+    /// Map from (script, leaf_version) to (sets of) [`TaprootMerkleBranchBuf`]. 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.
@@ -1037,7 +1037,7 @@ pub struct LeafNode {
     /// The [`TapLeaf`]
     leaf: TapLeaf,
     /// The Merkle proof (hashing partners) to get this node.
-    merkle_branch: TaprootMerkleBranch,
+    merkle_branch: TaprootMerkleBranchBuf,
 }
 
 impl LeafNode {
@@ -1091,9 +1091,9 @@ impl LeafNode {
     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`].
+    /// node in form of [`TaprootMerkleBranchBuf`].
     #[inline]
-    pub fn merkle_branch(&self) -> &TaprootMerkleBranch { &self.merkle_branch }
+    pub fn merkle_branch(&self) -> &TaprootMerkleBranchBuf { &self.merkle_branch }
 
     /// Returns a reference to the leaf of this [`ScriptLeaf`].
     #[inline]
@@ -1109,7 +1109,7 @@ pub struct ScriptLeaf<'leaf> {
     /// The script.
     script: &'leaf Script,
     /// The Merkle proof (hashing partners) to get this node.
-    merkle_branch: &'leaf TaprootMerkleBranch,
+    merkle_branch: &'leaf TaprootMerkleBranchBuf,
 }
 
 impl<'leaf> ScriptLeaf<'leaf> {
@@ -1120,7 +1120,7 @@ impl<'leaf> ScriptLeaf<'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 }
+    pub fn merkle_branch(&self) -> &TaprootMerkleBranchBuf { 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> {
@@ -1140,7 +1140,7 @@ pub struct ControlBlock {
     /// The internal key.
     pub internal_key: UntweakedPublicKey,
     /// The Merkle proof of a script associated with this leaf.
-    pub merkle_branch: TaprootMerkleBranch,
+    pub merkle_branch: TaprootMerkleBranchBuf,
 }
 
 impl ControlBlock {
@@ -1172,7 +1172,7 @@ impl ControlBlock {
             &sl[1..TAPROOT_CONTROL_BASE_SIZE].try_into().expect("Slice should be exactly 32 bytes"),
         )
         .map_err(TaprootError::InvalidInternalKey)?;
-        let merkle_branch = TaprootMerkleBranch::decode(&sl[TAPROOT_CONTROL_BASE_SIZE..])?;
+        let merkle_branch = TaprootMerkleBranchBuf::decode(&sl[TAPROOT_CONTROL_BASE_SIZE..])?;
         Ok(ControlBlock { leaf_version, output_key_parity, internal_key, merkle_branch })
     }
 
@@ -1923,7 +1923,7 @@ mod test {
                 .unwrap()
                 .to_byte_array(),
         );
-        let merkle_branch = TaprootMerkleBranch::from([hash1, hash2]);
+        let merkle_branch = TaprootMerkleBranchBuf::from([hash1, hash2]);
         // use serde_test to test serialization and deserialization
         serde_test::assert_tokens(
             &merkle_branch.readable(),

From 33d75659dac697a9ffdb684fbd202ebcaf21505c Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sat, 15 Mar 2025 19:38:48 +0100
Subject: [PATCH 528/554] Push `merkle_branch` module one level deeper.

This moves the content of the module into `buf` submodule making future
changes clearer.
---
 .../taproot/{merkle_branch.rs => merkle_branch/buf.rs}   | 2 +-
 bitcoin/src/taproot/merkle_branch/mod.rs                 | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)
 rename bitcoin/src/taproot/{merkle_branch.rs => merkle_branch/buf.rs} (98%)
 create mode 100644 bitcoin/src/taproot/merkle_branch/mod.rs

diff --git a/bitcoin/src/taproot/merkle_branch.rs b/bitcoin/src/taproot/merkle_branch/buf.rs
similarity index 98%
rename from bitcoin/src/taproot/merkle_branch.rs
rename to bitcoin/src/taproot/merkle_branch/buf.rs
index 6a523ba8dd..d89559fcc3 100644
--- a/bitcoin/src/taproot/merkle_branch.rs
+++ b/bitcoin/src/taproot/merkle_branch/buf.rs
@@ -92,7 +92,7 @@ impl TaprootMerkleBranchBuf {
     }
 
     /// Appends elements to proof.
-    pub(super) fn push(&mut self, h: TapNodeHash) -> Result<(), InvalidMerkleTreeDepthError> {
+    pub(in super::super) fn push(&mut self, h: TapNodeHash) -> Result<(), InvalidMerkleTreeDepthError> {
         if self.len() >= TAPROOT_CONTROL_MAX_NODE_COUNT {
             Err(InvalidMerkleTreeDepthError(self.0.len()))
         } else {
diff --git a/bitcoin/src/taproot/merkle_branch/mod.rs b/bitcoin/src/taproot/merkle_branch/mod.rs
new file mode 100644
index 0000000000..838fe0b6e1
--- /dev/null
+++ b/bitcoin/src/taproot/merkle_branch/mod.rs
@@ -0,0 +1,9 @@
+//! Contains `TaprootMerkleBranchBuf` and its associated types.
+
+mod buf;
+
+pub use buf::TaprootMerkleBranchBuf;
+use super::{
+    InvalidMerkleBranchSizeError, InvalidMerkleTreeDepthError, TapNodeHash, TaprootError,
+    TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE,
+};

From 370c2597c61c2a4ba9b688df4cef9464bd473dd8 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sun, 16 Mar 2025 10:17:49 +0100
Subject: [PATCH 529/554] Add `as_mut_slice` to `TaprootMerkleBranchBuf`

`TaprootMerkleBranchBuf` already had `as_slice` method and `DerefMut`
but was missing `as_slice_mut`, so this change adds it.
---
 bitcoin/src/taproot/merkle_branch/buf.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/bitcoin/src/taproot/merkle_branch/buf.rs b/bitcoin/src/taproot/merkle_branch/buf.rs
index d89559fcc3..657929cd31 100644
--- a/bitcoin/src/taproot/merkle_branch/buf.rs
+++ b/bitcoin/src/taproot/merkle_branch/buf.rs
@@ -27,6 +27,10 @@ impl TaprootMerkleBranchBuf {
     #[inline]
     pub fn as_slice(&self) -> &[TapNodeHash] { &self.0 }
 
+    /// Returns a mutable reference to the slice of hashes.
+    #[inline]
+    pub fn as_mut_slice(&mut self) -> &mut [TapNodeHash] { &mut self.0 }
+
     /// Returns the number of nodes in this Merkle proof.
     #[inline]
     pub fn len(&self) -> usize { self.0.len() }

From 04a4efbe639a3546d31c777eb1e0d0176f05b573 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sun, 16 Mar 2025 11:02:41 +0100
Subject: [PATCH 530/554] Introduce unsized `TaprootMerkleBranch`

`TaprootMerkleBranchBuf` being a vec introduced intermediate allocation
when creating or decoding `Witness`. However the representation on the
wire is the same as in-memory (aside from `#[repr(transparent)]`) so
this allocation wasn't really needed.

This commit introduces `TaprootMerkleBranch` type which is unsized and
can be used in place of `TaprootMerkleBranchBuf` within `ControlBlock`.
Aside from removing the intermediate allocation, this improves the API a
bit: the conversion from array to other type is no longer needed because
it's performed by `ControlBlock` in its methods. Thus, consumers who
have an array can simply set it as `merkle_branch` field and then encode
the `ControlBlock` into witness. A convenience method is also provided
to push the `ControlBlock` along with other parts at the end of the
`Witness`.
---
 bitcoin/src/blockdata/witness.rs              |  13 +-
 bitcoin/src/taproot/merkle_branch/borrowed.rs | 290 ++++++++++++++++++
 bitcoin/src/taproot/merkle_branch/buf.rs      |  22 +-
 bitcoin/src/taproot/merkle_branch/mod.rs      |  58 ++++
 bitcoin/src/taproot/mod.rs                    |  37 ++-
 5 files changed, 397 insertions(+), 23 deletions(-)
 create mode 100644 bitcoin/src/taproot/merkle_branch/borrowed.rs

diff --git a/bitcoin/src/blockdata/witness.rs b/bitcoin/src/blockdata/witness.rs
index 89b9980816..fd57da387d 100644
--- a/bitcoin/src/blockdata/witness.rs
+++ b/bitcoin/src/blockdata/witness.rs
@@ -14,8 +14,8 @@ use crate::prelude::Vec;
 #[cfg(doc)]
 use crate::script::ScriptExt as _;
 use crate::taproot::{
-    self, LeafScript, LeafVersion, TAPROOT_ANNEX_PREFIX, TAPROOT_CONTROL_BASE_SIZE,
-    TAPROOT_LEAF_MASK,
+    self, ControlBlock, LeafScript, LeafVersion, TAPROOT_ANNEX_PREFIX, TAPROOT_CONTROL_BASE_SIZE,
+    TAPROOT_LEAF_MASK, TaprootMerkleBranch,
 };
 use crate::Script;
 
@@ -135,6 +135,15 @@ crate::internal_macros::define_extension_trait! {
             witness
         }
 
+        /// Finishes constructing the P2TR script spend witness by pushing the required items.
+        fn push_p2tr_script_spend(&mut self, script: &Script, control_block: &ControlBlock<impl AsRef<TaprootMerkleBranch>>, annex: Option<&[u8]>) {
+            self.push(script.as_bytes());
+            self.push(&*control_block.encode_to_arrayvec());
+            if let Some(annex) = annex {
+                self.push(annex);
+            }
+        }
+
         /// Pushes, as a new element on the witness, an ECDSA signature.
         ///
         /// Pushes the DER encoded signature + sighash_type, requires an allocation.
diff --git a/bitcoin/src/taproot/merkle_branch/borrowed.rs b/bitcoin/src/taproot/merkle_branch/borrowed.rs
new file mode 100644
index 0000000000..58538f09d2
--- /dev/null
+++ b/bitcoin/src/taproot/merkle_branch/borrowed.rs
@@ -0,0 +1,290 @@
+use core::borrow::{Borrow, BorrowMut};
+use internals::slice::SliceExt;
+
+use super::{DecodeError, InvalidMerkleBranchSizeError, InvalidMerkleTreeDepthError, TaprootMerkleBranchBuf, TapNodeHash, TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE};
+
+pub use privacy_boundary::TaprootMerkleBranch;
+
+/// Makes sure only the allowed conversions are accessible to external code.
+mod privacy_boundary {
+    use super::*;
+
+    /// The Merkle proof for inclusion of a tree in a Taproot tree hash.
+    #[repr(transparent)]
+    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    pub struct TaprootMerkleBranch([TapNodeHash]);
+
+    impl TaprootMerkleBranch {
+        /// Returns a reference to the slice of hashes.
+        #[inline]
+        pub const fn as_slice(&self) -> &[TapNodeHash] { &self.0 }
+
+        /// Returns a reference to the mutable slice of hashes.
+        #[inline]
+        pub fn as_mut_slice(&mut self) -> &mut [TapNodeHash] { &mut self.0 }
+
+        pub(super) const fn from_hashes_unchecked(hashes: &[TapNodeHash]) -> &Self {
+            unsafe {
+                &*(hashes as *const _ as *const Self)
+            }
+        }
+
+        pub(super) fn from_mut_hashes_unchecked(hashes: &mut [TapNodeHash]) -> &mut Self {
+            unsafe {
+                &mut *(hashes as *mut _ as *mut Self)
+            }
+        }
+    }
+}
+
+impl TaprootMerkleBranch {
+    /// Returns an empty branch.
+    pub const fn new() -> &'static Self {
+        Self::from_hashes_unchecked(&[])
+    }
+
+    /// Returns the number of nodes in this Merkle proof.
+    #[inline]
+    pub fn len(&self) -> usize { self.as_slice().len() }
+
+    /// Checks if this Merkle proof is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool { self.as_slice().is_empty() }
+
+    /// Creates an iterator over the node hashes.
+    #[inline]
+    pub fn iter(&self) -> core::slice::Iter<'_, TapNodeHash> { self.into_iter() }
+
+    /// Creates an iterator over the mutable node hashes.
+    #[inline]
+    pub fn iter_mut(&mut self) -> core::slice::IterMut<'_, TapNodeHash> { self.into_iter() }
+
+    /// Casts `TaprootMerkleBranch` to a byte slice.
+    pub(crate) fn as_bytes(&self) -> &[u8] {
+        let ptr = self.as_slice().as_ptr();
+        let num_bytes = self.len() * TAPROOT_CONTROL_NODE_SIZE;
+        // SAFETY:
+        // The pointer points to memory that's borrowed and the returned slice has the same
+        // lifetime. The alignment is of the types is the same (as checked in the test), the
+        // length is within the bounds - as computed above by multiplication.
+        unsafe { core::slice::from_raw_parts(ptr.cast::<u8>(), num_bytes) }
+    }
+
+    /// Serializes to a writer.
+    ///
+    /// # Returns
+    ///
+    /// The number of bytes written to the writer.
+    pub fn encode<Write: io::Write + ?Sized>(&self, writer: &mut Write) -> io::Result<usize> {
+        let bytes = self.as_bytes();
+        writer.write_all(bytes)?;
+        Ok(bytes.len())
+    }
+
+    /// Zero-copy decodes `bytes` as Taproot Merkle branch.
+    ///
+    /// Note that "decoding" is quite trivial: it only performs appropriate bound checks and casts
+    /// the reference.
+    pub fn decode(bytes: &[u8]) -> Result<&Self, DecodeError> {
+        let (nodes, remainder) = bytes.bitcoin_as_chunks();
+        if remainder.is_empty() {
+            Self::decode_exact(nodes).map_err(Into::into)
+        } else {
+            Err(InvalidMerkleBranchSizeError(bytes.len()).into())
+        }
+    }
+
+    /// Decodes a byte slice that is statically known to be multiple of 32.
+    ///
+    /// This can be used as a building block for other ways of decoding.
+    fn decode_exact(nodes: &[[u8; TAPROOT_CONTROL_NODE_SIZE]]) -> Result<&Self, InvalidMerkleTreeDepthError> {
+        // SAFETY:
+        // The lifetime of the returned reference is the same as the lifetime of the input
+        // reference, the size of `TapNodeHash` is equal to `TAPROOT_CONTROL_NODE_SIZE` and the
+        // alignment of `TapNodeHash` is equal to the alignment of `u8` (see tests below).
+        Self::from_hashes(unsafe { &*(nodes as *const _ as *const [TapNodeHash]) })
+    }
+
+    fn from_hashes(nodes: &[TapNodeHash]) -> Result<&Self, InvalidMerkleTreeDepthError>{
+        if nodes.len() <= TAPROOT_CONTROL_MAX_NODE_COUNT {
+            Ok(Self::from_hashes_unchecked(nodes))
+        } else {
+            Err(InvalidMerkleTreeDepthError(nodes.len()))
+        }
+    }
+}
+
+impl Default for &'_ TaprootMerkleBranch {
+    fn default() -> Self {
+        TaprootMerkleBranch::new()
+    }
+}
+
+impl AsRef<TaprootMerkleBranch> for TaprootMerkleBranch {
+    fn as_ref(&self) -> &TaprootMerkleBranch {
+        self
+    }
+}
+
+impl AsMut<TaprootMerkleBranch> for TaprootMerkleBranch {
+    fn as_mut(&mut self) -> &mut TaprootMerkleBranch {
+        self
+    }
+}
+
+impl AsRef<TaprootMerkleBranch> for TaprootMerkleBranchBuf {
+    fn as_ref(&self) -> &TaprootMerkleBranch {
+        // TaprootMerkleBranchBuf maintains the invariant that the node count is in range.
+        TaprootMerkleBranch::from_hashes_unchecked(self.as_slice())
+    }
+}
+
+impl AsMut<TaprootMerkleBranch> for TaprootMerkleBranchBuf {
+    fn as_mut(&mut self) -> &mut TaprootMerkleBranch {
+        // TaprootMerkleBranchBuf maintains the invariant that the node count is in range.
+        TaprootMerkleBranch::from_mut_hashes_unchecked(self.as_mut_slice())
+    }
+}
+
+impl Borrow<TaprootMerkleBranch> for TaprootMerkleBranchBuf {
+    #[inline]
+    fn borrow(&self) -> &TaprootMerkleBranch { self.as_ref() }
+}
+
+impl BorrowMut<TaprootMerkleBranch> for TaprootMerkleBranchBuf {
+    #[inline]
+    fn borrow_mut(&mut self) -> &mut TaprootMerkleBranch { self.as_mut() }
+}
+
+impl<'a> TryFrom<&'a [TapNodeHash]> for &'a TaprootMerkleBranch {
+    type Error = InvalidMerkleTreeDepthError;
+
+    fn try_from(value: &'a [TapNodeHash]) -> Result<Self, Self::Error> {
+        TaprootMerkleBranch::from_hashes(value)
+    }
+}
+
+macro_rules! impl_from_array {
+    ($($len:expr),* $(,)?) => {
+        $(
+            impl AsRef<TaprootMerkleBranch> for [TapNodeHash; $len] {
+                fn as_ref(&self) -> &TaprootMerkleBranch {
+                    #[allow(unused_comparisons)]
+                    const _: () = { assert!($len <= TAPROOT_CONTROL_MAX_NODE_COUNT) };
+                    // There's a static check to ensure correct macro usage above.
+                    TaprootMerkleBranch::from_hashes_unchecked(self)
+                }
+            }
+
+            impl AsMut<TaprootMerkleBranch> for [TapNodeHash; $len] {
+                fn as_mut(&mut self) -> &mut TaprootMerkleBranch {
+                    #[allow(unused_comparisons)]
+                    const _: () = { assert!($len <= TAPROOT_CONTROL_MAX_NODE_COUNT) };
+                    // There's a static check to ensure correct macro usage above.
+                    TaprootMerkleBranch::from_mut_hashes_unchecked(self)
+                }
+            }
+
+            impl Borrow<TaprootMerkleBranch> for [TapNodeHash; $len] {
+                fn borrow(&self) -> &TaprootMerkleBranch {
+                    self.as_ref()
+                }
+            }
+
+            impl BorrowMut<TaprootMerkleBranch> for [TapNodeHash; $len] {
+                fn borrow_mut(&mut self) -> &mut TaprootMerkleBranch {
+                    self.as_mut()
+                }
+            }
+
+            impl<'a> From<&'a [TapNodeHash; $len]> for &'a TaprootMerkleBranch {
+                #[inline]
+                fn from(branch: &'a [TapNodeHash; $len]) -> Self {
+                    branch.as_ref()
+                }
+            }
+
+            impl<'a> From<&'a mut [TapNodeHash; $len]> for &'a mut TaprootMerkleBranch {
+                #[inline]
+                fn from(branch: &'a mut [TapNodeHash; $len]) -> Self {
+                    branch.as_mut()
+                }
+            }
+        )*
+    }
+}
+
+// Implement for all values [0, 128] inclusive.
+//
+// The reason zero is included is that `TaprootMerkleBranchBuf` 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_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 AsRef<[TapNodeHash]> for TaprootMerkleBranch {
+    #[inline]
+    fn as_ref(&self) -> &[TapNodeHash] { self.as_slice() }
+}
+
+impl AsMut<[TapNodeHash]> for TaprootMerkleBranch {
+    #[inline]
+    fn as_mut(&mut self) -> &mut [TapNodeHash] { self.as_mut_slice() }
+}
+
+impl Borrow<[TapNodeHash]> for TaprootMerkleBranch {
+    #[inline]
+    fn borrow(&self) -> &[TapNodeHash] { self.as_ref() }
+}
+
+impl BorrowMut<[TapNodeHash]> for TaprootMerkleBranch {
+    #[inline]
+    fn borrow_mut(&mut self) -> &mut [TapNodeHash] { self.as_mut() }
+}
+
+impl alloc::borrow::ToOwned for TaprootMerkleBranch {
+    // It could be argued that this should've been a stack-allocated type.
+    // However such type would be huge and this trait interacts with `Cow`.
+    // If someone wants to pass it around they're better off just always copying rather than using
+    // `Cow`.
+    type Owned = TaprootMerkleBranchBuf;
+
+    fn to_owned(&self) -> Self::Owned {
+        self.into()
+    }
+}
+
+impl<'a> IntoIterator for &'a TaprootMerkleBranch {
+    type IntoIter = core::slice::Iter<'a, TapNodeHash>;
+    type Item = &'a TapNodeHash;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.as_slice().iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a mut TaprootMerkleBranch {
+    type IntoIter = core::slice::IterMut<'a, TapNodeHash>;
+    type Item = &'a mut TapNodeHash;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter { self.as_mut_slice().iter_mut() }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn alignment() {
+        assert!(core::mem::align_of_val(super::TaprootMerkleBranch::new()) == core::mem::align_of::<u8>());
+    }
+
+    const _: () = {
+        assert!(core::mem::size_of::<super::TapNodeHash>() == super::TAPROOT_CONTROL_NODE_SIZE);
+        assert!(core::mem::align_of::<super::TapNodeHash>() == core::mem::align_of::<u8>());
+    };
+}
diff --git a/bitcoin/src/taproot/merkle_branch/buf.rs b/bitcoin/src/taproot/merkle_branch/buf.rs
index 657929cd31..1902d9b2ab 100644
--- a/bitcoin/src/taproot/merkle_branch/buf.rs
+++ b/bitcoin/src/taproot/merkle_branch/buf.rs
@@ -5,8 +5,8 @@
 use hashes::Hash;
 
 use super::{
-    InvalidMerkleBranchSizeError, InvalidMerkleTreeDepthError, TapNodeHash, TaprootError,
-    TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE,
+    InvalidMerkleTreeDepthError, TapNodeHash, TaprootError, TaprootMerkleBranch,
+    TAPROOT_CONTROL_MAX_NODE_COUNT,
 };
 use crate::prelude::{Borrow, BorrowMut, Box, Vec};
 
@@ -49,17 +49,7 @@ impl TaprootMerkleBranchBuf {
     /// The function returns an error if 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> {
-        use internals::slice::SliceExt;
-        let (node_hashes, remainder) = sl.bitcoin_as_chunks::<TAPROOT_CONTROL_NODE_SIZE>();
-        if !remainder.is_empty() {
-            Err(InvalidMerkleBranchSizeError(sl.len()).into())
-        } else if node_hashes.len() > TAPROOT_CONTROL_MAX_NODE_COUNT {
-            Err(InvalidMerkleTreeDepthError(sl.len() / TAPROOT_CONTROL_NODE_SIZE).into())
-        } else {
-            let inner = node_hashes.iter().copied().map(TapNodeHash::from_byte_array).collect();
-
-            Ok(TaprootMerkleBranchBuf(inner))
-        }
+        TaprootMerkleBranch::decode(sl).map(alloc::borrow::ToOwned::to_owned).map_err(Into::into)
     }
 
     /// Constructs a new Merkle proof from list of hashes.
@@ -222,6 +212,12 @@ impl BorrowMut<[TapNodeHash]> for TaprootMerkleBranchBuf {
     fn borrow_mut(&mut self) -> &mut [TapNodeHash] { &mut self.0 }
 }
 
+impl<'a> From<&'a TaprootMerkleBranch> for TaprootMerkleBranchBuf {
+    fn from(value: &'a TaprootMerkleBranch) -> Self {
+        Self(value.as_slice().into())
+    }
+}
+
 /// Iterator over node hashes within Taproot Merkle branch.
 ///
 /// This is created by `into_iter` method on `TaprootMerkleBranchBuf` (via `IntoIterator` trait).
diff --git a/bitcoin/src/taproot/merkle_branch/mod.rs b/bitcoin/src/taproot/merkle_branch/mod.rs
index 838fe0b6e1..0fd32c2594 100644
--- a/bitcoin/src/taproot/merkle_branch/mod.rs
+++ b/bitcoin/src/taproot/merkle_branch/mod.rs
@@ -1,9 +1,67 @@
 //! Contains `TaprootMerkleBranchBuf` and its associated types.
 
 mod buf;
+mod borrowed;
 
 pub use buf::TaprootMerkleBranchBuf;
+pub use borrowed::TaprootMerkleBranch;
+
+use core::fmt;
 use super::{
     InvalidMerkleBranchSizeError, InvalidMerkleTreeDepthError, TapNodeHash, TaprootError,
     TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE,
 };
+
+/// Returned when decoding of merkle branch fails.
+#[derive(Debug)]
+pub struct DecodeError {
+    /// Represents the invalid number of bytes. It may be invalid in two ways: it might not be a
+    /// multiple of 32, in which case it is guaranteed to be wrong for that reason;
+    /// only if it is a multiple of 32 do we check that it does not exceed 32 * 128, in which case
+    /// it is wrong for that reason.
+    ///
+    /// This error type is used in `Result<&TaprootMerkleBranch, DecodeError>`, so by keeping its
+    /// size down to a single `usize` (by not using enum) and considering the niche optimization on
+    /// the *fat reference* `&TaprootMerkleBranch`, the `Result` will have the same size as just
+    /// `&TaprootMerkleBranch`.
+    num_bytes: usize,
+}
+
+impl From<InvalidMerkleBranchSizeError> for DecodeError {
+    fn from(value: InvalidMerkleBranchSizeError) -> Self {
+        Self {
+            num_bytes: value.0,
+        }
+    }
+}
+
+impl From<InvalidMerkleTreeDepthError> for DecodeError {
+    fn from(value: InvalidMerkleTreeDepthError) -> Self {
+        Self {
+            num_bytes: value.0 * TAPROOT_CONTROL_NODE_SIZE,
+        }
+    }
+}
+
+impl fmt::Display for DecodeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.num_bytes % TAPROOT_CONTROL_NODE_SIZE == 0 {
+            write!(f, "the Merkle branch has {} nodes which is more than the limit {}", self.num_bytes / TAPROOT_CONTROL_NODE_SIZE, TAPROOT_CONTROL_MAX_NODE_COUNT)
+        } else {
+            write!(f, "the Merkle branch is {} bytes long which is not an integer multiple of {}", self.num_bytes, TAPROOT_CONTROL_NODE_SIZE)
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DecodeError {}
+
+impl From<DecodeError> for TaprootError {
+    fn from(value: DecodeError) -> Self {
+        if value.num_bytes % TAPROOT_CONTROL_NODE_SIZE == 0 {
+            InvalidMerkleTreeDepthError(value.num_bytes / TAPROOT_CONTROL_NODE_SIZE).into()
+        } else {
+            InvalidMerkleBranchSizeError(value.num_bytes).into()
+        }
+    }
+}
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 2c0a29096d..619f5edc89 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -28,6 +28,10 @@ use crate::{Script, ScriptBuf};
 pub use crate::crypto::taproot::{SigFromSliceError, Signature};
 #[doc(inline)]
 pub use merkle_branch::TaprootMerkleBranchBuf;
+#[doc(inline)]
+pub use merkle_branch::TaprootMerkleBranch;
+
+type ControlBlockArrayVec = internals::array_vec::ArrayVec<u8, TAPROOT_CONTROL_MAX_SIZE>;
 
 // Taproot test vectors from BIP-341 state the hashes without any reversing
 sha256t_tag! {
@@ -53,6 +57,7 @@ hash_newtype! {
     /// Tagged hash used in Taproot trees.
     ///
     /// See BIP-340 for tagging rules.
+    #[repr(transparent)]
     pub struct TapNodeHash(sha256t::Hash<TapBranchTag>);
 }
 
@@ -1132,7 +1137,7 @@ impl<'leaf> ScriptLeaf<'leaf> {
 /// Control block data structure used in Tapscript satisfaction.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct ControlBlock {
+pub struct ControlBlock<Branch = TaprootMerkleBranchBuf> where Branch: ?Sized {
     /// The tapleaf version.
     pub leaf_version: LeafVersion,
     /// The parity of the output key (NOT THE INTERNAL KEY WHICH IS ALWAYS XONLY).
@@ -1140,7 +1145,7 @@ pub struct ControlBlock {
     /// The internal key.
     pub internal_key: UntweakedPublicKey,
     /// The Merkle proof of a script associated with this leaf.
-    pub merkle_branch: TaprootMerkleBranchBuf,
+    pub merkle_branch: Branch,
 }
 
 impl ControlBlock {
@@ -1175,11 +1180,13 @@ impl ControlBlock {
         let merkle_branch = TaprootMerkleBranchBuf::decode(&sl[TAPROOT_CONTROL_BASE_SIZE..])?;
         Ok(ControlBlock { leaf_version, output_key_parity, internal_key, merkle_branch })
     }
+}
 
+impl<Branch: AsRef<TaprootMerkleBranch> + ?Sized> ControlBlock<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.len()
+        TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * self.merkle_branch.as_ref().len()
     }
 
     /// Serializes to a writer.
@@ -1188,12 +1195,26 @@ impl ControlBlock {
     ///
     /// The number of bytes written to the writer.
     pub fn encode<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<usize> {
+        self.encode_inner(move |bytes| writer.write_all(bytes))?;
+        Ok(self.size())
+    }
+
+    pub(crate) fn encode_to_arrayvec(&self) -> ControlBlockArrayVec {
+        let mut result = ControlBlockArrayVec::new();
+        self.encode_inner(|bytes| -> Result<(), core::convert::Infallible> {
+            result.extend_from_slice(bytes);
+            Ok(())
+        }).unwrap_or_else(|never| match never {});
+        result
+    }
+
+    fn encode_inner<E>(&self, mut write: impl FnMut(&[u8]) -> Result<(), E>) -> Result<(), E> {
         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(writer)?;
-        Ok(self.size())
+        write(&[first_byte])?;
+        write(&self.internal_key.serialize())?;
+        write(self.merkle_branch.as_ref().as_bytes())?;
+        Ok(())
     }
 
     /// Serializes the control block.
@@ -1221,7 +1242,7 @@ impl ControlBlock {
         // 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 {
+        for elem in self.merkle_branch.as_ref() {
             // Recalculate the curr hash as parent hash
             curr_hash = TapNodeHash::from_node_hashes(curr_hash, *elem);
         }

From c528f52894ed0e769aff3dd13bc0fee4087d47c1 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sun, 16 Mar 2025 20:00:21 +0100
Subject: [PATCH 531/554] Change `Deref::Target` of `TaprootMerkleBranchBuf`

`TaprootMerkleBranchBuf` previously derefed to a slice which lost the
information about length being valid. This commit changes the type
which, while API-breaking, is not disruptive because the type has API
very similar to slice.
---
 bitcoin/src/taproot/merkle_branch/buf.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bitcoin/src/taproot/merkle_branch/buf.rs b/bitcoin/src/taproot/merkle_branch/buf.rs
index 1902d9b2ab..d06ffcadf3 100644
--- a/bitcoin/src/taproot/merkle_branch/buf.rs
+++ b/bitcoin/src/taproot/merkle_branch/buf.rs
@@ -181,15 +181,15 @@ impl<'a> IntoIterator for &'a mut TaprootMerkleBranchBuf {
 }
 
 impl core::ops::Deref for TaprootMerkleBranchBuf {
-    type Target = [TapNodeHash];
+    type Target = TaprootMerkleBranch;
 
     #[inline]
-    fn deref(&self) -> &Self::Target { &self.0 }
+    fn deref(&self) -> &Self::Target { self.as_ref() }
 }
 
 impl core::ops::DerefMut for TaprootMerkleBranchBuf {
     #[inline]
-    fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
+    fn deref_mut(&mut self) -> &mut Self::Target { self.as_mut() }
 }
 
 impl AsRef<[TapNodeHash]> for TaprootMerkleBranchBuf {

From 9ea2e9262fbc04ea6fad33047de0fc1ead999dc7 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sun, 16 Mar 2025 20:06:57 +0100
Subject: [PATCH 532/554] Don't use references to `TaprootMerkleBranchBuf`

The new unsized type is more flexible and so are the references to it.
Just like we pass around `&str` instead of `&String` we should be
passing `&TaprootMerkleBranch` instead of `&TaprootMerkleBranchBuf`.
---
 bitcoin/src/taproot/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index 619f5edc89..a3358964ae 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -1096,9 +1096,9 @@ impl LeafNode {
     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 [`TaprootMerkleBranchBuf`].
+    /// node in form of [`TaprootMerkleBranch`].
     #[inline]
-    pub fn merkle_branch(&self) -> &TaprootMerkleBranchBuf { &self.merkle_branch }
+    pub fn merkle_branch(&self) -> &TaprootMerkleBranch { &self.merkle_branch }
 
     /// Returns a reference to the leaf of this [`ScriptLeaf`].
     #[inline]
@@ -1114,7 +1114,7 @@ pub struct ScriptLeaf<'leaf> {
     /// The script.
     script: &'leaf Script,
     /// The Merkle proof (hashing partners) to get this node.
-    merkle_branch: &'leaf TaprootMerkleBranchBuf,
+    merkle_branch: &'leaf TaprootMerkleBranch,
 }
 
 impl<'leaf> ScriptLeaf<'leaf> {
@@ -1125,7 +1125,7 @@ impl<'leaf> ScriptLeaf<'leaf> {
     pub fn script(&self) -> &Script { self.script }
 
     /// Obtains a reference to the Merkle proof of the leaf.
-    pub fn merkle_branch(&self) -> &TaprootMerkleBranchBuf { self.merkle_branch }
+    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> {

From 82d9d1aeea6c29a239a069045c20d2f65f97ac7e Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Mar 2025 13:24:54 +0000
Subject: [PATCH 533/554] amount: rename `from_int_btc_const` unctions to
 hungarian ones

We have `from_int_btc_const` on both `Amount` and `SignedAmount` because
the "real" `from_int_btc` is generic over the integer type it accepts,
which means that it cannot be a constfn. But we do want a constfn.

However, just because `from_int_btc_const` exists for the sake of
constfn doesn't mean that that's what it *is*. So rename these methods
to reflect what they *are*.
---
 units/src/amount/signed.rs   | 8 ++++----
 units/src/amount/tests.rs    | 4 +++-
 units/src/amount/unsigned.rs | 8 ++++----
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 2119f488db..4639828959 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -77,9 +77,9 @@ impl SignedAmount {
     /// Exactly one satoshi.
     pub const ONE_SAT: Self = SignedAmount::from_sat_unchecked(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Self = SignedAmount::from_int_btc_const(1);
+    pub const ONE_BTC: Self = SignedAmount::from_btc_i16(1);
     /// Exactly fifty bitcoin.
-    pub const FIFTY_BTC: Self = SignedAmount::from_int_btc_const(50);
+    pub const FIFTY_BTC: Self = SignedAmount::from_btc_i16(50);
     /// The maximum value allowed as an amount. Useful for sanity checking.
     pub const MAX_MONEY: Self = SignedAmount::from_sat_unchecked(21_000_000 * 100_000_000);
     /// The minimum value of an amount.
@@ -136,13 +136,13 @@ impl SignedAmount {
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`].
     #[allow(clippy::missing_panics_doc)]
     pub fn from_int_btc<T: Into<i16>>(whole_bitcoin: T) -> SignedAmount {
-        SignedAmount::from_int_btc_const(whole_bitcoin.into())
+        SignedAmount::from_btc_i16(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`]
     /// in const context.
     #[allow(clippy::missing_panics_doc)]
-    pub const fn from_int_btc_const(whole_bitcoin: i16) -> SignedAmount {
+    pub const fn from_btc_i16(whole_bitcoin: i16) -> SignedAmount {
         let btc = whole_bitcoin as i64; // Can't call `into` in const context.
         let sats = btc * 100_000_000;
 
diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 5fc4955889..60676f6052 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -102,8 +102,10 @@ fn from_str_zero_without_denomination() {
 
 #[test]
 fn from_int_btc() {
-    let amt = Amount::from_int_btc_const(2);
+    let amt = Amount::from_btc_u16(2);
     assert_eq!(sat(200_000_000), amt);
+    let amt = SignedAmount::from_btc_i16(-2);
+    assert_eq!(ssat(-200_000_000), amt);
 }
 
 #[test]
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index ab1abb9c37..9f6215d081 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -75,9 +75,9 @@ impl Amount {
     /// Exactly one satoshi.
     pub const ONE_SAT: Self = Amount::from_sat_unchecked(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Self = Amount::from_int_btc_const(1);
+    pub const ONE_BTC: Self = Amount::from_btc_u16(1);
     /// Exactly fifty bitcoin.
-    pub const FIFTY_BTC: Self = Amount::from_int_btc_const(50);
+    pub const FIFTY_BTC: Self = Amount::from_btc_u16(50);
     /// The maximum value allowed as an amount. Useful for sanity checking.
     pub const MAX_MONEY: Self = Amount::from_sat_unchecked(21_000_000 * 100_000_000);
     /// The minimum value of an amount.
@@ -134,13 +134,13 @@ impl Amount {
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`].
     #[allow(clippy::missing_panics_doc)]
     pub fn from_int_btc<T: Into<u16>>(whole_bitcoin: T) -> Amount {
-        Amount::from_int_btc_const(whole_bitcoin.into())
+        Amount::from_btc_u16(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`]
     /// in const context.
     #[allow(clippy::missing_panics_doc)]
-    pub const fn from_int_btc_const(whole_bitcoin: u16) -> Amount {
+    pub const fn from_btc_u16(whole_bitcoin: u16) -> Amount {
         let btc = whole_bitcoin as u64; // Can't call `into` in const context.
         let sats = btc * 100_000_000;
 

From beaa2db7e523ca1ac2bb6c5eaf22f8c42db67f5c Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Mar 2025 13:36:15 +0000
Subject: [PATCH 534/554] amount: add from_sat_i32 and from_sat_u32 methods for
 small constants

We have a ton of calls to `from_sat_unchecked` for small constants which
were clearly in range, e.g. in fee.rs. Add a new constfn for these
cases. Don't bother making a generic Into<u32>/Into<u16> variant because
there isn't an obvious name for it.

There are 7 instances where we're using this method with values that are
out of range, which we leave as from_sat_unchecked for now.
---
 bitcoin/examples/ecdsa-psbt-simple.rs   |  8 ++++----
 bitcoin/examples/sighash.rs             |  4 ++--
 bitcoin/examples/sign-tx-segwit-v0.rs   |  6 +++---
 bitcoin/examples/sign-tx-taproot.rs     |  6 +++---
 bitcoin/examples/taproot-psbt-simple.rs |  8 ++++----
 bitcoin/examples/taproot-psbt.rs        |  2 +-
 bitcoin/src/blockdata/script/tests.rs   | 10 +++++-----
 bitcoin/src/crypto/sighash.rs           |  6 +++---
 bitcoin/src/psbt/mod.rs                 | 26 ++++++++++++-------------
 units/src/amount/signed.rs              | 12 ++++++++++--
 units/src/amount/unsigned.rs            | 12 ++++++++++--
 units/src/fee.rs                        | 16 +++++++--------
 12 files changed, 66 insertions(+), 50 deletions(-)

diff --git a/bitcoin/examples/ecdsa-psbt-simple.rs b/bitcoin/examples/ecdsa-psbt-simple.rs
index 024f71c56f..ac5d84b43e 100644
--- a/bitcoin/examples/ecdsa-psbt-simple.rs
+++ b/bitcoin/examples/ecdsa-psbt-simple.rs
@@ -47,12 +47,12 @@ const BIP84_DERIVATION_PATH: &str = "m/84'/0'/0'";
 const MASTER_FINGERPRINT: &str = "9680603f";
 
 // The dummy UTXO amounts we are spending.
-const DUMMY_UTXO_AMOUNT_INPUT_1: Amount = Amount::from_sat_unchecked(20_000_000);
-const DUMMY_UTXO_AMOUNT_INPUT_2: Amount = Amount::from_sat_unchecked(10_000_000);
+const DUMMY_UTXO_AMOUNT_INPUT_1: Amount = Amount::from_sat_u32(20_000_000);
+const DUMMY_UTXO_AMOUNT_INPUT_2: Amount = Amount::from_sat_u32(10_000_000);
 
 // The amounts we are sending to someone, and receiving back as change.
-const SPEND_AMOUNT: Amount = Amount::from_sat_unchecked(25_000_000);
-const CHANGE_AMOUNT: Amount = Amount::from_sat_unchecked(4_990_000); // 10_000 sat fee.
+const SPEND_AMOUNT: Amount = Amount::from_sat_u32(25_000_000);
+const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(4_990_000); // 10_000 sat fee.
 
 // Derive the external address xpriv.
 fn get_external_address_xpriv<C: Signing>(
diff --git a/bitcoin/examples/sighash.rs b/bitcoin/examples/sighash.rs
index 0878ea4390..1055a52f7e 100644
--- a/bitcoin/examples/sighash.rs
+++ b/bitcoin/examples/sighash.rs
@@ -148,7 +148,7 @@ fn sighash_p2wpkh() {
     let inp_idx = 0;
     //output value from the referenced vout:0 from the referenced tx:
     //bitcoin-cli getrawtransaction 752d675b9cc0bd14e0bd23969effee0005ad6d7e550dcc832f0216c7ffd4e15c  3
-    let ref_out_value = Amount::from_sat_unchecked(200000000);
+    let ref_out_value = Amount::from_sat_u32(200000000);
 
     println!("\nsighash_p2wpkh:");
     compute_sighash_p2wpkh(&raw_tx, inp_idx, ref_out_value);
@@ -178,7 +178,7 @@ fn sighash_p2wsh_multisig_2x2() {
     //For the witness transaction sighash computation, we need its referenced output's value from the original transaction:
     //bitcoin-cli getrawtransaction 2845399a8cd7a52733f9f9d0e0b8b6c5d1c88aea4cee09f8d8fa762912b49e1b  3
     //we need vout 0 value in sats:
-    let ref_out_value = Amount::from_sat_unchecked(968240);
+    let ref_out_value = Amount::from_sat_u32(968240);
 
     println!("\nsighash_p2wsh_multisig_2x2:");
     compute_sighash_p2wsh(&raw_tx, 0, ref_out_value);
diff --git a/bitcoin/examples/sign-tx-segwit-v0.rs b/bitcoin/examples/sign-tx-segwit-v0.rs
index a30c02d939..b163a24b08 100644
--- a/bitcoin/examples/sign-tx-segwit-v0.rs
+++ b/bitcoin/examples/sign-tx-segwit-v0.rs
@@ -13,9 +13,9 @@ use bitcoin::{
     Txid, Witness,
 };
 
-const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_unchecked(20_000_000);
-const SPEND_AMOUNT: Amount = Amount::from_sat_unchecked(5_000_000);
-const CHANGE_AMOUNT: Amount = Amount::from_sat_unchecked(14_999_000); // 1000 sat fee.
+const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_u32(20_000_000);
+const SPEND_AMOUNT: Amount = Amount::from_sat_u32(5_000_000);
+const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(14_999_000); // 1000 sat fee.
 
 fn main() {
     let secp = Secp256k1::new();
diff --git a/bitcoin/examples/sign-tx-taproot.rs b/bitcoin/examples/sign-tx-taproot.rs
index df7532cbd8..06a3fab162 100644
--- a/bitcoin/examples/sign-tx-taproot.rs
+++ b/bitcoin/examples/sign-tx-taproot.rs
@@ -13,9 +13,9 @@ use bitcoin::{
     Txid, Witness,
 };
 
-const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_unchecked(20_000_000);
-const SPEND_AMOUNT: Amount = Amount::from_sat_unchecked(5_000_000);
-const CHANGE_AMOUNT: Amount = Amount::from_sat_unchecked(14_999_000); // 1000 sat fee.
+const DUMMY_UTXO_AMOUNT: Amount = Amount::from_sat_u32(20_000_000);
+const SPEND_AMOUNT: Amount = Amount::from_sat_u32(5_000_000);
+const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(14_999_000); // 1000 sat fee.
 
 fn main() {
     let secp = Secp256k1::new();
diff --git a/bitcoin/examples/taproot-psbt-simple.rs b/bitcoin/examples/taproot-psbt-simple.rs
index 8671032c10..8181573a27 100644
--- a/bitcoin/examples/taproot-psbt-simple.rs
+++ b/bitcoin/examples/taproot-psbt-simple.rs
@@ -45,12 +45,12 @@ const BIP86_DERIVATION_PATH: &str = "m/86'/0'/0'";
 const MASTER_FINGERPRINT: &str = "9680603f";
 
 // The dummy UTXO amounts we are spending.
-const DUMMY_UTXO_AMOUNT_INPUT_1: Amount = Amount::from_sat_unchecked(20_000_000);
-const DUMMY_UTXO_AMOUNT_INPUT_2: Amount = Amount::from_sat_unchecked(10_000_000);
+const DUMMY_UTXO_AMOUNT_INPUT_1: Amount = Amount::from_sat_u32(20_000_000);
+const DUMMY_UTXO_AMOUNT_INPUT_2: Amount = Amount::from_sat_u32(10_000_000);
 
 // The amounts we are sending to someone, and receiving back as change.
-const SPEND_AMOUNT: Amount = Amount::from_sat_unchecked(25_000_000);
-const CHANGE_AMOUNT: Amount = Amount::from_sat_unchecked(4_990_000); // 10_000 sat fee.
+const SPEND_AMOUNT: Amount = Amount::from_sat_u32(25_000_000);
+const CHANGE_AMOUNT: Amount = Amount::from_sat_u32(4_990_000); // 10_000 sat fee.
 
 // Derive the external address xpriv.
 fn get_external_address_xpriv<C: Signing>(
diff --git a/bitcoin/examples/taproot-psbt.rs b/bitcoin/examples/taproot-psbt.rs
index c5bb6d34ed..92af851561 100644
--- a/bitcoin/examples/taproot-psbt.rs
+++ b/bitcoin/examples/taproot-psbt.rs
@@ -40,7 +40,7 @@ const UTXO_SCRIPT_PUBKEY: &str =
     "5120be27fa8b1f5278faf82cab8da23e8761f8f9bd5d5ebebbb37e0e12a70d92dd16";
 const UTXO_PUBKEY: &str = "a6ac32163539c16b6b5dbbca01b725b8e8acaa5f821ba42c80e7940062140d19";
 const UTXO_MASTER_FINGERPRINT: &str = "e61b318f";
-const ABSOLUTE_FEES: Amount = Amount::from_sat_unchecked(1_000);
+const ABSOLUTE_FEES: Amount = Amount::from_sat_u32(1_000);
 
 // UTXO_1 will be used for spending example 1
 const UTXO_1: P2trUtxo = P2trUtxo {
diff --git a/bitcoin/src/blockdata/script/tests.rs b/bitcoin/src/blockdata/script/tests.rs
index 3f4d56aea3..27dcd32ea3 100644
--- a/bitcoin/src/blockdata/script/tests.rs
+++ b/bitcoin/src/blockdata/script/tests.rs
@@ -675,7 +675,7 @@ fn bitcoinconsensus() {
     let spent_bytes = hex!("0020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d");
     let spent = Script::from_bytes(&spent_bytes);
     let spending = hex!("010000000001011f97548fbbe7a0db7588a66e18d803d0089315aa7d4cc28360b6ec50ef36718a0100000000ffffffff02df1776000000000017a9146c002a686959067f4866b8fb493ad7970290ab728757d29f0000000000220020701a8d401c84fb13e6baf169d59684e17abd9fa216c8cc5b9fc63d622ff8c58d04004730440220565d170eed95ff95027a69b313758450ba84a01224e1f7f130dda46e94d13f8602207bdd20e307f062594022f12ed5017bbf4a055a06aea91c10110a0e3bb23117fc014730440220647d2dc5b15f60bc37dc42618a370b2a1490293f9e5c8464f53ec4fe1dfe067302203598773895b4b16d37485cbe21b337f4e4b650739880098c592553add7dd4355016952210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae00000000");
-    spent.verify(0, Amount::from_sat_unchecked(18393430), &spending).unwrap();
+    spent.verify(0, Amount::from_sat_u32(18393430), &spending).unwrap();
 }
 
 #[test]
@@ -684,10 +684,10 @@ fn default_dust_value() {
     // well-known scriptPubKey types.
     let script_p2wpkh = Builder::new().push_int_unchecked(0).push_slice([42; 20]).into_script();
     assert!(script_p2wpkh.is_p2wpkh());
-    assert_eq!(script_p2wpkh.minimal_non_dust(), Some(Amount::from_sat_unchecked(294)));
+    assert_eq!(script_p2wpkh.minimal_non_dust(), Some(Amount::from_sat_u32(294)));
     assert_eq!(
         script_p2wpkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
-        Some(Amount::from_sat_unchecked(588))
+        Some(Amount::from_sat_u32(588))
     );
 
     let script_p2pkh = Builder::new()
@@ -698,10 +698,10 @@ fn default_dust_value() {
         .push_opcode(OP_CHECKSIG)
         .into_script();
     assert!(script_p2pkh.is_p2pkh());
-    assert_eq!(script_p2pkh.minimal_non_dust(), Some(Amount::from_sat_unchecked(546)));
+    assert_eq!(script_p2pkh.minimal_non_dust(), Some(Amount::from_sat_u32(546)));
     assert_eq!(
         script_p2pkh.minimal_non_dust_custom(FeeRate::from_sat_per_vb_unchecked(6)),
-        Some(Amount::from_sat_unchecked(1092))
+        Some(Amount::from_sat_u32(1092))
     );
 }
 
diff --git a/bitcoin/src/crypto/sighash.rs b/bitcoin/src/crypto/sighash.rs
index 0fbe05a7da..8ef0047d4e 100644
--- a/bitcoin/src/crypto/sighash.rs
+++ b/bitcoin/src/crypto/sighash.rs
@@ -2089,7 +2089,7 @@ mod tests {
         ).unwrap();
 
         let spk = ScriptBuf::from_hex("00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1").unwrap();
-        let value = Amount::from_sat_unchecked(600_000_000);
+        let value = Amount::from_sat_u32(600_000_000);
 
         let mut cache = SighashCache::new(&tx);
         assert_eq!(
@@ -2130,7 +2130,7 @@ mod tests {
 
         let redeem_script =
             ScriptBuf::from_hex("001479091972186c449eb1ded22b78e40d009bdf0089").unwrap();
-        let value = Amount::from_sat_unchecked(1_000_000_000);
+        let value = Amount::from_sat_u32(1_000_000_000);
 
         let mut cache = SighashCache::new(&tx);
         assert_eq!(
@@ -2180,7 +2180,7 @@ mod tests {
         )
         .unwrap();
 
-        let value = Amount::from_sat_unchecked(987_654_321);
+        let value = Amount::from_sat_u32(987_654_321);
         (tx, witness_script, value)
     }
 
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index ffba04ea9d..6de7387790 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -1429,14 +1429,14 @@ mod tests {
                 }],
                 output: vec![
                     TxOut {
-                        value: Amount::from_sat_unchecked(99_999_699),
+                        value: Amount::from_sat_u32(99_999_699),
                         script_pubkey: ScriptBuf::from_hex(
                             "76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac",
                         )
                         .unwrap(),
                     },
                     TxOut {
-                        value: Amount::from_sat_unchecked(100_000_000),
+                        value: Amount::from_sat_u32(100_000_000),
                         script_pubkey: ScriptBuf::from_hex(
                             "a9143545e6e33b832c47050f24d3eeb93c9c03948bc787",
                         )
@@ -1678,11 +1678,11 @@ mod tests {
                     ],
                     output: vec![
                         TxOut {
-                            value: Amount::from_sat_unchecked(99_999_699),
+                            value: Amount::from_sat_u32(99_999_699),
                             script_pubkey: ScriptBuf::from_hex("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
                         },
                         TxOut {
-                            value: Amount::from_sat_unchecked(100_000_000),
+                            value: Amount::from_sat_u32(100_000_000),
                             script_pubkey: ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
                         },
                     ],
@@ -1725,7 +1725,7 @@ mod tests {
                             ],
                             output: vec![
                                 TxOut {
-                                    value: Amount::from_sat_unchecked(200_000_000),
+                                    value: Amount::from_sat_u32(200_000_000),
                                     script_pubkey: ScriptBuf::from_hex("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
                                 },
                                 TxOut {
@@ -2011,11 +2011,11 @@ mod tests {
                 ],
                 output: vec![
                     TxOut {
-                        value: Amount::from_sat_unchecked(99_999_699),
+                        value: Amount::from_sat_u32(99_999_699),
                         script_pubkey: ScriptBuf::from_hex("76a914d0c59903c5bac2868760e90fd521a4665aa7652088ac").unwrap(),
                     },
                     TxOut {
-                        value: Amount::from_sat_unchecked(100_000_000),
+                        value: Amount::from_sat_u32(100_000_000),
                         script_pubkey: ScriptBuf::from_hex("a9143545e6e33b832c47050f24d3eeb93c9c03948bc787").unwrap(),
                     },
                 ],
@@ -2058,7 +2058,7 @@ mod tests {
                         ],
                         output: vec![
                             TxOut {
-                                value: Amount::from_sat_unchecked(200_000_000),
+                                value: Amount::from_sat_u32(200_000_000),
                                 script_pubkey: ScriptBuf::from_hex("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
                             },
                             TxOut {
@@ -2171,9 +2171,9 @@ mod tests {
 
     #[test]
     fn fee() {
-        let output_0_val = Amount::from_sat_unchecked(99_999_699);
-        let output_1_val = Amount::from_sat_unchecked(100_000_000);
-        let prev_output_val = Amount::from_sat_unchecked(200_000_000);
+        let output_0_val = Amount::from_sat_u32(99_999_699);
+        let output_1_val = Amount::from_sat_u32(100_000_000);
+        let prev_output_val = Amount::from_sat_u32(200_000_000);
 
         let t = Psbt {
             unsigned_tx: Transaction {
@@ -2296,7 +2296,7 @@ mod tests {
 
         // First input we can spend. See comment above on key_map for why we use defaults here.
         let txout_wpkh = TxOut {
-            value: Amount::from_sat_unchecked(10),
+            value: Amount::from_sat_u32(10),
             script_pubkey: ScriptBuf::new_p2wpkh(pk.wpubkey_hash().unwrap()),
         };
         psbt.inputs[0].witness_utxo = Some(txout_wpkh);
@@ -2308,7 +2308,7 @@ mod tests {
         // Second input is unspendable by us e.g., from another wallet that supports future upgrades.
         let unknown_prog = WitnessProgram::new(WitnessVersion::V4, &[0xaa; 34]).unwrap();
         let txout_unknown_future = TxOut {
-            value: Amount::from_sat_unchecked(10),
+            value: Amount::from_sat_u32(10),
             script_pubkey: ScriptBuf::new_witness_program(&unknown_prog),
         };
         psbt.inputs[1].witness_utxo = Some(txout_unknown_future);
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 4639828959..cf633d4a49 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -57,6 +57,14 @@ mod encapsulate {
         /// See [`Self::MIN`] and [`Self::MAX`].
         pub const fn from_sat_unchecked(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
 
+        /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
+        ///
+        /// Accepts an `i32` which is guaranteed to be in range for the type, but which can only
+        /// represent roughly -21.47 to 21.47 BTC.
+        pub const fn from_sat_i32(satoshi: i32) -> SignedAmount {
+            SignedAmount(satoshi as i64) // cannot use i64::from in a constfn
+        }
+
         /// Gets the number of satoshis in this [`SignedAmount`].
         ///
         /// # Examples
@@ -73,9 +81,9 @@ pub use encapsulate::SignedAmount;
 
 impl SignedAmount {
     /// The zero amount.
-    pub const ZERO: Self = SignedAmount::from_sat_unchecked(0);
+    pub const ZERO: Self = SignedAmount::from_sat_i32(0);
     /// Exactly one satoshi.
-    pub const ONE_SAT: Self = SignedAmount::from_sat_unchecked(1);
+    pub const ONE_SAT: Self = SignedAmount::from_sat_i32(1);
     /// Exactly one bitcoin.
     pub const ONE_BTC: Self = SignedAmount::from_btc_i16(1);
     /// Exactly fifty bitcoin.
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 9f6215d081..b4191fe892 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -55,6 +55,14 @@ mod encapsulate {
         /// Caller to guarantee that `satoshi` is within valid range. See [`Self::MAX`].
         pub const fn from_sat_unchecked(satoshi: u64) -> Amount { Self(satoshi) }
 
+        /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
+        ///
+        /// Accepts an `u32` which is guaranteed to be in range for the type, but which can only
+        /// represent roughly 0 to 42.95 BTC.
+        pub const fn from_sat_u32(satoshi: u32) -> Amount {
+            Amount(satoshi as u64) // cannot use u64::from in a constfn
+        }
+
         /// Gets the number of satoshis in this [`Amount`].
         ///
         /// # Examples
@@ -71,9 +79,9 @@ pub use encapsulate::Amount;
 
 impl Amount {
     /// The zero amount.
-    pub const ZERO: Self = Amount::from_sat_unchecked(0);
+    pub const ZERO: Self = Amount::from_sat_u32(0);
     /// Exactly one satoshi.
-    pub const ONE_SAT: Self = Amount::from_sat_unchecked(1);
+    pub const ONE_SAT: Self = Amount::from_sat_u32(1);
     /// Exactly one bitcoin.
     pub const ONE_BTC: Self = Amount::from_btc_u16(1);
     /// Exactly fifty bitcoin.
diff --git a/units/src/fee.rs b/units/src/fee.rs
index 73c53b817e..21d223c9c5 100644
--- a/units/src/fee.rs
+++ b/units/src/fee.rs
@@ -216,7 +216,7 @@ mod tests {
 
     #[test]
     fn fee_rate_div_by_weight() {
-        let fee_rate = Amount::from_sat_unchecked(329) / Weight::from_wu(381);
+        let fee_rate = Amount::from_sat_u32(329) / Weight::from_wu(381);
         assert_eq!(fee_rate, FeeRate::from_sat_per_kwu(863));
     }
 
@@ -227,7 +227,7 @@ mod tests {
 
         let fee_rate = FeeRate::from_sat_per_vb(2).unwrap();
         let weight = Weight::from_vb(3).unwrap();
-        assert_eq!(fee_rate.to_fee(weight).unwrap(), Amount::from_sat_unchecked(6));
+        assert_eq!(fee_rate.to_fee(weight).unwrap(), Amount::from_sat_u32(6));
     }
 
     #[test]
@@ -237,7 +237,7 @@ mod tests {
             .unwrap()
             .checked_mul_by_weight(weight)
             .expect("expected Amount");
-        assert_eq!(Amount::from_sat_unchecked(100), fee);
+        assert_eq!(Amount::from_sat_u32(100), fee);
 
         let fee = FeeRate::from_sat_per_kwu(10).checked_mul_by_weight(Weight::MAX);
         assert!(fee.is_none());
@@ -245,14 +245,14 @@ mod tests {
         let weight = Weight::from_vb(3).unwrap();
         let fee_rate = FeeRate::from_sat_per_vb(3).unwrap();
         let fee = fee_rate.checked_mul_by_weight(weight).unwrap();
-        assert_eq!(Amount::from_sat_unchecked(9), fee);
+        assert_eq!(Amount::from_sat_u32(9), fee);
 
         let weight = Weight::from_wu(381);
         let fee_rate = FeeRate::from_sat_per_kwu(864);
         let fee = weight.checked_mul_by_fee_rate(fee_rate).unwrap();
         // 381 * 0.864 yields 329.18.
         // The result is then rounded up to 330.
-        assert_eq!(fee, Amount::from_sat_unchecked(330));
+        assert_eq!(fee, Amount::from_sat_u32(330));
     }
 
     #[test]
@@ -260,7 +260,7 @@ mod tests {
     fn multiply() {
         let two = FeeRate::from_sat_per_vb(2).unwrap();
         let three = Weight::from_vb(3).unwrap();
-        let six = Amount::from_sat_unchecked(6);
+        let six = Amount::from_sat_u32(6);
 
         assert_eq!(two * three, six.into());
 
@@ -274,7 +274,7 @@ mod tests {
     #[allow(clippy::op_ref)]
     fn amount_div_by_fee_rate() {
         // Test exact division
-        let amount = Amount::from_sat_unchecked(1000);
+        let amount = Amount::from_sat_u32(1000);
         let fee_rate = FeeRate::from_sat_per_kwu(2);
         let weight = amount / fee_rate;
         assert_eq!(weight, Weight::from_wu(500_000));
@@ -288,7 +288,7 @@ mod tests {
         assert_eq!(weight_ref3, Weight::from_wu(500_000));
 
         // Test truncation behavior
-        let amount = Amount::from_sat_unchecked(1000);
+        let amount = Amount::from_sat_u32(1000);
         let fee_rate = FeeRate::from_sat_per_kwu(3);
         let weight = amount / fee_rate;
         // 1000 * 1000 = 1,000,000 msats

From 05c8b043ff7b4389ef0dc899091033347a44c420 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Mar 2025 14:47:44 +0000
Subject: [PATCH 535/554] tests: replace Amount::from_sat_unchecked with
 from_sat.unwrap

There are only 7 instances of this so just call .unwrap() on each one.
---
 bitcoin/src/psbt/mod.rs | 10 +++++-----
 bitcoin/tests/serde.rs  |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 6de7387790..1f582cfa1b 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -1502,7 +1502,7 @@ mod tests {
                 )]),
             }],
             output: vec![TxOut {
-                value: Amount::from_sat_unchecked(190_303_501_938),
+                value: Amount::from_sat(190_303_501_938).unwrap(),
                 script_pubkey: ScriptBuf::from_hex(
                     "a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587",
                 )
@@ -1553,7 +1553,7 @@ mod tests {
                 Input {
                     non_witness_utxo: Some(tx),
                     witness_utxo: Some(TxOut {
-                        value: Amount::from_sat_unchecked(190_303_501_938),
+                        value: Amount::from_sat(190_303_501_938).unwrap(),
                         script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                     }),
                     sighash_type: Some("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY".parse::<PsbtSighashType>().unwrap()),
@@ -1729,7 +1729,7 @@ mod tests {
                                     script_pubkey: ScriptBuf::from_hex("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
                                 },
                                 TxOut {
-                                    value: Amount::from_sat_unchecked(190_303_501_938),
+                                    value: Amount::from_sat(190_303_501_938).unwrap(),
                                     script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                                 },
                             ],
@@ -2062,7 +2062,7 @@ mod tests {
                                 script_pubkey: ScriptBuf::from_hex("76a91485cff1097fd9e008bb34af709c62197b38978a4888ac").unwrap(),
                             },
                             TxOut {
-                                value: Amount::from_sat_unchecked(190_303_501_938),
+                                value: Amount::from_sat(190_303_501_938).unwrap(),
                                 script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
                             },
                         ],
@@ -2234,7 +2234,7 @@ mod tests {
                                 script_pubkey:  ScriptBuf::new()
                             },
                             TxOut {
-                                value: Amount::from_sat_unchecked(190_303_501_938),
+                                value: Amount::from_sat(190_303_501_938).unwrap(),
                                 script_pubkey:  ScriptBuf::new()
                             },
                         ],
diff --git a/bitcoin/tests/serde.rs b/bitcoin/tests/serde.rs
index 66ffc63b0b..25c89306c0 100644
--- a/bitcoin/tests/serde.rs
+++ b/bitcoin/tests/serde.rs
@@ -235,7 +235,7 @@ fn serde_regression_psbt() {
             .unwrap()]),
         }],
         output: vec![TxOut {
-            value: Amount::from_sat_unchecked(190_303_501_938),
+            value: Amount::from_sat(190_303_501_938).unwrap(),
             script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587")
                 .unwrap(),
         }],
@@ -282,7 +282,7 @@ fn serde_regression_psbt() {
         inputs: vec![Input {
             non_witness_utxo: Some(tx),
             witness_utxo: Some(TxOut {
-                value: Amount::from_sat_unchecked(190_303_501_938),
+                value: Amount::from_sat(190_303_501_938).unwrap(),
                 script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
             }),
             sighash_type: Some(PsbtSighashType::from("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY".parse::<EcdsaSighashType>().unwrap())),

From 3370c14d745423cf2fb5ba01e08eee55d9bf31d4 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Mar 2025 13:38:36 +0000
Subject: [PATCH 536/554] amount: stop using from_sat_unchecked in tests

There is no need for this. It's a 2-line diff to change it.
---
 units/src/amount/tests.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/units/src/amount/tests.rs b/units/src/amount/tests.rs
index 60676f6052..127e7566c4 100644
--- a/units/src/amount/tests.rs
+++ b/units/src/amount/tests.rs
@@ -648,9 +648,9 @@ fn from_str() {
 fn to_from_string_in() {
     use super::Denomination as D;
     let ua_str = Amount::from_str_in;
-    let ua_sat = Amount::from_sat_unchecked;
+    let ua_sat = |n| Amount::from_sat(n).unwrap();
     let sa_str = SignedAmount::from_str_in;
-    let sa_sat = SignedAmount::from_sat_unchecked;
+    let sa_sat = |n| SignedAmount::from_sat(n).unwrap();
 
     assert_eq!("0.5", ua_sat(50).to_string_in(D::Bit));
     assert_eq!("-0.5", sa_sat(-50).to_string_in(D::Bit));

From 004d07318465c73da9f302e13cbd50cfbe6fda35 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Mar 2025 14:26:20 +0000
Subject: [PATCH 537/554] amount: return i64 from parse_signed_to_satoshi

This private function is used for string-parsing an amount. It returns a
sign boolean and a u64, but its surrounding logic can be simplified if
it just returns a i64 (which is OK now since the range of `Amount` fits
into the range of i64).

Along the way we eliminate some instances of from_sat_unchecked.

Annoyingly we still need the bool to distinguish -0 from +0; when
parsing Amount we reject -0 (and we have tests for this).

This causes a couple error constructors to no longer be used outside of
unit tests. May be worth looking at whether we need them, or whether we
should be using them in parse_signed_to_satoshi.
---
 units/src/amount/error.rs    |  2 ++
 units/src/amount/mod.rs      | 21 ++++++++++++++-------
 units/src/amount/signed.rs   | 16 ++++------------
 units/src/amount/unsigned.rs | 11 +++--------
 4 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/units/src/amount/error.rs b/units/src/amount/error.rs
index 62e03a3062..992d7e543f 100644
--- a/units/src/amount/error.rs
+++ b/units/src/amount/error.rs
@@ -182,8 +182,10 @@ impl OutOfRangeError {
     /// Returns true if the input value was smaller than the minimum allowed value.
     pub fn is_below_min(self) -> bool { !self.is_greater_than_max }
 
+    #[cfg(test)]
     pub(crate) fn too_big(is_signed: bool) -> Self { Self { is_signed, is_greater_than_max: true } }
 
+    #[cfg(test)]
     pub(crate) fn too_small() -> Self {
         Self {
             // implied - negative() is used for the other
diff --git a/units/src/amount/mod.rs b/units/src/amount/mod.rs
index 98e2137a8c..8928cea9dc 100644
--- a/units/src/amount/mod.rs
+++ b/units/src/amount/mod.rs
@@ -202,10 +202,12 @@ const INPUT_STRING_LEN_LIMIT: usize = 50;
 
 /// Parses a decimal string in the given denomination into a satoshi value and a
 /// [`bool`] indicator for a negative amount.
+///
+/// The `bool` is only needed to distinguish -0 from 0.
 fn parse_signed_to_satoshi(
     mut s: &str,
     denom: Denomination,
-) -> Result<(bool, u64), InnerParseError> {
+) -> Result<(bool, SignedAmount), InnerParseError> {
     if s.is_empty() {
         return Err(InnerParseError::MissingDigits(MissingDigitsError {
             kind: MissingDigitsKind::Empty,
@@ -237,7 +239,7 @@ fn parse_signed_to_satoshi(
             let last_n = precision_diff.unsigned_abs().into();
             if let Some(position) = is_too_precise(s, last_n) {
                 match s.parse::<i64>() {
-                    Ok(0) => return Ok((is_negative, 0)),
+                    Ok(0) => return Ok((is_negative, SignedAmount::ZERO)),
                     _ =>
                         return Err(InnerParseError::TooPrecise(TooPreciseError {
                             position: position + usize::from(is_negative),
@@ -252,14 +254,14 @@ fn parse_signed_to_satoshi(
     };
 
     let mut decimals = None;
-    let mut value: u64 = 0; // as satoshis
+    let mut value: i64 = 0; // as satoshis
     for (i, c) in s.char_indices() {
         match c {
             '0'..='9' => {
                 // Do `value = 10 * value + digit`, catching overflows.
-                match 10_u64.checked_mul(value) {
+                match 10_i64.checked_mul(value) {
                     None => return Err(InnerParseError::Overflow { is_negative }),
-                    Some(val) => match val.checked_add(u64::from(c as u8 - b'0')) {
+                    Some(val) => match val.checked_add(i64::from(c as u8 - b'0')) {
                         None => return Err(InnerParseError::Overflow { is_negative }),
                         Some(val) => value = val,
                     },
@@ -295,13 +297,18 @@ fn parse_signed_to_satoshi(
     // 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) {
+        value = match 10_i64.checked_mul(value) {
             Some(v) => v,
             None => return Err(InnerParseError::Overflow { is_negative }),
         };
     }
 
-    Ok((is_negative, value))
+    let mut ret =
+        SignedAmount::from_sat(value).map_err(|_| InnerParseError::Overflow { is_negative })?;
+    if is_negative {
+        ret = -ret;
+    }
+    Ok((is_negative, ret))
 }
 
 #[derive(Debug)]
diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index cf633d4a49..262106673a 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -10,7 +10,7 @@ use core::{default, fmt};
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 
-use super::error::{ParseAmountErrorInner, ParseErrorInner};
+use super::error::ParseErrorInner;
 use super::{
     parse_signed_to_satoshi, split_amount_and_denomination, Amount, Denomination, Display,
     DisplayStyle, OutOfRangeError, ParseAmountError, ParseError,
@@ -169,17 +169,9 @@ impl SignedAmount {
     ///
     /// If the amount is too big (positive or negative) or too precise.
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
-        match parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(true))? {
-            // (negative, amount)
-            (false, sat) if sat > SignedAmount::MAX.to_sat() as u64 => Err(ParseAmountError(
-                ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_big(true)),
-            )),
-            (false, sat) => Ok(SignedAmount::from_sat_unchecked(sat as i64)), // Cast ok, value in this arm does not wrap.
-            (true, sat) if sat > SignedAmount::MIN.to_sat().unsigned_abs() => Err(
-                ParseAmountError(ParseAmountErrorInner::OutOfRange(OutOfRangeError::too_small())),
-            ),
-            (true, sat) => Ok(SignedAmount::from_sat_unchecked(-(sat as i64))), // Cast ok, value in this arm does not wrap.
-        }
+        parse_signed_to_satoshi(s, denom)
+            .map(|(_, amount)| amount)
+            .map_err(|error| error.convert(true))
     }
 
     /// Parses amounts with denomination suffix as produced by [`Self::to_string_with_denomination`]
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index b4191fe892..25533675ff 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -167,19 +167,14 @@ impl Amount {
     ///
     /// If the amount is too precise, negative, or greater than 21,000,000.
     pub fn from_str_in(s: &str, denom: Denomination) -> Result<Amount, ParseAmountError> {
-        let (negative, sats) =
+        let (is_neg, amount) =
             parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(false))?;
-        if negative {
+        if is_neg {
             return Err(ParseAmountError(ParseAmountErrorInner::OutOfRange(
                 OutOfRangeError::negative(),
             )));
         }
-        if sats > Self::MAX.to_sat() {
-            return Err(ParseAmountError(ParseAmountErrorInner::OutOfRange(
-                OutOfRangeError::too_big(false),
-            )));
-        }
-        Ok(Self::from_sat_unchecked(sats))
+        Self::try_from(amount).map_err(|e| ParseAmountError(ParseAmountErrorInner::OutOfRange(e)))
     }
 
     /// Parses amounts with denomination suffix as produced by [`Self::to_string_with_denomination`]

From d0d7a156047b1567bc065abba1454fd52a3d32d6 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Mar 2025 14:28:18 +0000
Subject: [PATCH 538/554] amount: move MIN/MAX constants and constructors
 inside the privacy boundary

It's conceptually a bit tortured to have an `Amount` type defined in a
private module, with an _unchecked method allowing you to set values out
of range, which needs to be used outside of the module to *define* the
range and the constructors that check it.

Move the constants and constructors inside the privacy module, where they
can be written directly. This is easier to understand and eliminates a couple
_unchecked calls.
---
 units/src/amount/signed.rs   | 63 +++++++++++++++++++-----------------
 units/src/amount/unsigned.rs | 59 +++++++++++++++++----------------
 2 files changed, 64 insertions(+), 58 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 262106673a..069eceee0d 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -17,6 +17,8 @@ use super::{
 };
 
 mod encapsulate {
+    use super::OutOfRangeError;
+
     /// A signed amount.
     ///
     /// The [`SignedAmount`] type can be used to express Bitcoin amounts that support arithmetic and
@@ -50,6 +52,11 @@ mod encapsulate {
     pub struct SignedAmount(i64);
 
     impl SignedAmount {
+        /// The maximum value of an amount.
+        pub const MAX: Self = Self(21_000_000 * 100_000_000);
+        /// The minimum value of an amount.
+        pub const MIN: Self = Self(-21_000_000 * 100_000_000);
+
         /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
         ///
         /// Caller to guarantee that `satoshi` is within valid range.
@@ -74,6 +81,31 @@ mod encapsulate {
         /// assert_eq!(SignedAmount::ONE_BTC.to_sat(), 100_000_000);
         /// ```
         pub const fn to_sat(self) -> i64 { self.0 }
+
+        /// Constructs a new [`SignedAmount`] from the given number of satoshis.
+        ///
+        /// # Errors
+        ///
+        /// If `satoshi` is outside of valid range (see [`Self::MAX_MONEY`]).
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// # use bitcoin_units::{amount, SignedAmount};
+        /// # let sat = -100_000;
+        /// let amount = SignedAmount::from_sat(sat)?;
+        /// assert_eq!(amount.to_sat(), sat);
+        /// # Ok::<_, amount::OutOfRangeError>(())
+        /// ```
+        pub const fn from_sat(satoshi: i64) -> Result<SignedAmount, OutOfRangeError> {
+            if satoshi < Self::MIN.to_sat() {
+                Err(OutOfRangeError { is_signed: true, is_greater_than_max: false })
+            } else if satoshi > Self::MAX_MONEY.to_sat() {
+                Err(OutOfRangeError { is_signed: true, is_greater_than_max: true })
+            } else {
+                Ok(Self(satoshi))
+            }
+        }
     }
 }
 #[doc(inline)]
@@ -89,36 +121,7 @@ impl SignedAmount {
     /// Exactly fifty bitcoin.
     pub const FIFTY_BTC: Self = SignedAmount::from_btc_i16(50);
     /// The maximum value allowed as an amount. Useful for sanity checking.
-    pub const MAX_MONEY: Self = SignedAmount::from_sat_unchecked(21_000_000 * 100_000_000);
-    /// The minimum value of an amount.
-    pub const MIN: Self = SignedAmount::from_sat_unchecked(-21_000_000 * 100_000_000);
-    /// The maximum value of an amount.
-    pub const MAX: Self = SignedAmount::MAX_MONEY;
-
-    /// Constructs a new [`SignedAmount`] from the given number of satoshis.
-    ///
-    /// # Errors
-    ///
-    /// If `satoshi` is outside of valid range (see [`Self::MAX_MONEY`]).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_units::{amount, SignedAmount};
-    /// # let sat = -100_000;
-    /// let amount = SignedAmount::from_sat(sat)?;
-    /// assert_eq!(amount.to_sat(), sat);
-    /// # Ok::<_, amount::OutOfRangeError>(())
-    /// ```
-    pub const fn from_sat(satoshi: i64) -> Result<SignedAmount, OutOfRangeError> {
-        if satoshi < Self::MIN.to_sat() {
-            Err(OutOfRangeError { is_signed: true, is_greater_than_max: false })
-        } else if satoshi > Self::MAX_MONEY.to_sat() {
-            Err(OutOfRangeError { is_signed: true, is_greater_than_max: true })
-        } else {
-            Ok(SignedAmount::from_sat_unchecked(satoshi))
-        }
-    }
+    pub const MAX_MONEY: Self = Self::MAX;
 
     /// Converts from a value expressing a decimal number of bitcoin to a [`SignedAmount`].
     ///
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 25533675ff..d82c3f8816 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -17,6 +17,8 @@ use super::{
 };
 
 mod encapsulate {
+    use super::OutOfRangeError;
+
     /// An amount.
     ///
     /// The [`Amount`] type can be used to express Bitcoin amounts that support arithmetic and
@@ -50,6 +52,11 @@ mod encapsulate {
     pub struct Amount(u64);
 
     impl Amount {
+        /// The maximum value of an amount.
+        pub const MAX: Self = Self(21_000_000 * 100_000_000);
+        /// The minimum value of an amount.
+        pub const MIN: Self = Self(0);
+
         /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
         ///
         /// Caller to guarantee that `satoshi` is within valid range. See [`Self::MAX`].
@@ -72,6 +79,29 @@ mod encapsulate {
         /// assert_eq!(Amount::ONE_BTC.to_sat(), 100_000_000);
         /// ```
         pub const fn to_sat(self) -> u64 { self.0 }
+
+        /// Constructs a new [`Amount`] from the given number of satoshis.
+        ///
+        /// # Errors
+        ///
+        /// If `satoshi` is outside of valid range (greater than [`Self::MAX_MONEY`]).
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// # use bitcoin_units::{amount, Amount};
+        /// # let sat = 100_000;
+        /// let amount = Amount::from_sat(sat)?;
+        /// assert_eq!(amount.to_sat(), sat);
+        /// # Ok::<_, amount::OutOfRangeError>(())
+        /// ```
+        pub const fn from_sat(satoshi: u64) -> Result<Amount, OutOfRangeError> {
+            if satoshi > Self::MAX_MONEY.to_sat() {
+                Err(OutOfRangeError { is_signed: false, is_greater_than_max: true })
+            } else {
+                Ok(Self(satoshi))
+            }
+        }
     }
 }
 #[doc(inline)]
@@ -87,37 +117,10 @@ impl Amount {
     /// Exactly fifty bitcoin.
     pub const FIFTY_BTC: Self = Amount::from_btc_u16(50);
     /// The maximum value allowed as an amount. Useful for sanity checking.
-    pub const MAX_MONEY: Self = Amount::from_sat_unchecked(21_000_000 * 100_000_000);
-    /// The minimum value of an amount.
-    pub const MIN: Self = Amount::ZERO;
-    /// The maximum value of an amount.
-    pub const MAX: Self = Amount::MAX_MONEY;
+    pub const MAX_MONEY: Self = Amount::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.
 
-    /// Constructs a new [`Amount`] from the given number of satoshis.
-    ///
-    /// # Errors
-    ///
-    /// If `satoshi` is outside of valid range (greater than [`Self::MAX_MONEY`]).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bitcoin_units::{amount, Amount};
-    /// # let sat = 100_000;
-    /// let amount = Amount::from_sat(sat)?;
-    /// assert_eq!(amount.to_sat(), sat);
-    /// # Ok::<_, amount::OutOfRangeError>(())
-    /// ```
-    pub const fn from_sat(satoshi: u64) -> Result<Amount, OutOfRangeError> {
-        if satoshi > Self::MAX_MONEY.to_sat() {
-            Err(OutOfRangeError { is_signed: false, is_greater_than_max: true })
-        } else {
-            Ok(Self::from_sat_unchecked(satoshi))
-        }
-    }
-
     /// Converts from a value expressing a decimal number of bitcoin to an [`Amount`].
     ///
     /// # Errors

From 2958521117e6ec3db98ec42c490b3dfea60f7ab3 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Tue, 18 Mar 2025 14:34:44 +0000
Subject: [PATCH 539/554] amount: remove from_sat_unchecked

Turns out we don't even need this. It is only used in one place now and
we can just stick an .expect there.
---
 units/src/amount/signed.rs   | 7 -------
 units/src/amount/unsigned.rs | 9 +++------
 2 files changed, 3 insertions(+), 13 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index 069eceee0d..cc16fb8eef 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -57,13 +57,6 @@ mod encapsulate {
         /// The minimum value of an amount.
         pub const MIN: Self = Self(-21_000_000 * 100_000_000);
 
-        /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
-        ///
-        /// Caller to guarantee that `satoshi` is within valid range.
-        ///
-        /// See [`Self::MIN`] and [`Self::MAX`].
-        pub const fn from_sat_unchecked(satoshi: i64) -> SignedAmount { SignedAmount(satoshi) }
-
         /// Constructs a new [`SignedAmount`] with satoshi precision and the given number of satoshis.
         ///
         /// Accepts an `i32` which is guaranteed to be in range for the type, but which can only
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index d82c3f8816..1ff3637b64 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -57,11 +57,6 @@ mod encapsulate {
         /// The minimum value of an amount.
         pub const MIN: Self = Self(0);
 
-        /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
-        ///
-        /// Caller to guarantee that `satoshi` is within valid range. See [`Self::MAX`].
-        pub const fn from_sat_unchecked(satoshi: u64) -> Amount { Self(satoshi) }
-
         /// Constructs a new [`Amount`] with satoshi precision and the given number of satoshis.
         ///
         /// Accepts an `u32` which is guaranteed to be in range for the type, but which can only
@@ -398,8 +393,10 @@ impl Amount {
 
     /// Converts to a signed amount.
     #[rustfmt::skip] // Moves code comments to the wrong line.
+    #[allow(clippy::missing_panics_doc)]
     pub fn to_signed(self) -> SignedAmount {
-        SignedAmount::from_sat_unchecked(self.to_sat() as i64) // Cast ok, signed amount and amount share positive range.
+        SignedAmount::from_sat(self.to_sat() as i64) // Cast ok, signed amount and amount share positive range.
+            .expect("range of Amount is within range of SignedAmount")
     }
 }
 

From 5dd0c9253d207facc954a9b7f30ec7b2a7f410d8 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Wed, 5 Mar 2025 11:45:38 +0100
Subject: [PATCH 540/554] Remove a bunch of `try_into().expect()`

Previously we've used `try_into().expect()` because const generics were
unavailable. Then they became available but we didn't realize we could
already convert a bunch of code to not use panicking conversions. But we
can (and could for a while).

This adds an extension trait for arrays to provide basic non-panicking
operations returning arrays, so they can be composed with other
functions accepting arrays without any conversions. It also refactors a
bunch of code to use the non-panicking constructs but it's certainly not
all of it. That could be done later. This just aims at removing the
ugliest offenders and demonstrate the usefulness of this approach.

Aside from this, to avoid a bunch of duplicated work, this refactors
BIP32 key parsing to use a common method where xpub and xpriv are
encoded the same. Not doing this already led to a mistake where xpriv
implemented some additional checks that were missing in xpub. Thus this
change also indirectly fixes that bug.
---
 base58/src/lib.rs                    |  16 ++-
 bitcoin/src/address/mod.rs           |   8 +-
 bitcoin/src/address/script_pubkey.rs |  19 ++--
 bitcoin/src/bip152.rs                |   6 +-
 bitcoin/src/bip158.rs                |  10 +-
 bitcoin/src/bip32.rs                 | 147 ++++++++++++++++-----------
 bitcoin/src/crypto/key.rs            |  27 +++--
 bitcoin/src/crypto/taproot.rs        |  33 +++---
 bitcoin/src/lib.rs                   |   1 +
 bitcoin/src/psbt/serialize.rs        |  10 +-
 bitcoin/src/taproot/mod.rs           |  26 ++---
 internals/src/array.rs               | 105 +++++++++++++++++++
 internals/src/lib.rs                 |   1 +
 internals/src/slice.rs               |  40 ++++++++
 primitives/src/witness.rs            |   8 +-
 15 files changed, 309 insertions(+), 148 deletions(-)
 create mode 100644 internals/src/array.rs

diff --git a/base58/src/lib.rs b/base58/src/lib.rs
index 312e9c5644..13db9fd1f1 100644
--- a/base58/src/lib.rs
+++ b/base58/src/lib.rs
@@ -20,6 +20,7 @@
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
+#![allow(clippy::incompatible_msrv)] // Has FPs and we're testing it which is more reliable anyway.
 
 extern crate alloc;
 
@@ -40,7 +41,10 @@ use core::fmt;
 pub use std::{string::String, vec::Vec};
 
 use hashes::sha256d;
+use internals::array::ArrayExt;
 use internals::array_vec::ArrayVec;
+#[allow(unused)] // MSRV polyfill
+use internals::slice::SliceExt;
 
 use crate::error::{IncorrectChecksumError, TooShortError};
 
@@ -109,15 +113,9 @@ pub fn decode(data: &str) -> Result<Vec<u8>, InvalidCharacterError> {
 /// 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(TooShortError { length: ret.len() }.into());
-    }
-    let check_start = ret.len() - 4;
+    let (remaining, &data_check) = ret.split_last_chunk::<4>().ok_or(TooShortError { length: ret.len() })?;
 
-    let hash_check = sha256d::Hash::hash(&ret[..check_start]).as_byte_array()[..4]
-        .try_into()
-        .expect("4 byte slice");
-    let data_check = ret[check_start..].try_into().expect("4 byte slice");
+    let hash_check = *sha256d::Hash::hash(remaining).as_byte_array().sub_array::<0, 4>();
 
     let expected = u32::from_le_bytes(hash_check);
     let actual = u32::from_le_bytes(data_check);
@@ -126,7 +124,7 @@ pub fn decode_check(data: &str) -> Result<Vec<u8>, Error> {
         return Err(IncorrectChecksumError { incorrect: actual, expected }.into());
     }
 
-    ret.truncate(check_start);
+    ret.truncate(remaining.len());
     Ok(ret)
 }
 
diff --git a/bitcoin/src/address/mod.rs b/bitcoin/src/address/mod.rs
index 36b6a553c4..93bc290d87 100644
--- a/bitcoin/src/address/mod.rs
+++ b/bitcoin/src/address/mod.rs
@@ -49,6 +49,7 @@ use core::str::FromStr;
 use bech32::primitives::gf32::Fe32;
 use bech32::primitives::hrp::Hrp;
 use hashes::{hash160, HashEngine};
+use internals::array::ArrayExt;
 use secp256k1::{Secp256k1, Verification, XOnlyPublicKey};
 
 use crate::address::script_pubkey::ScriptBufExt as _;
@@ -902,12 +903,9 @@ impl Address<NetworkUnchecked> {
             return Err(LegacyAddressTooLongError { length: s.len() }.into());
         }
         let data = base58::decode_check(s)?;
-        if data.len() != 21 {
-            return Err(InvalidBase58PayloadLengthError { length: s.len() }.into());
-        }
+        let data: &[u8; 21] = (&*data).try_into().map_err(|_| InvalidBase58PayloadLengthError { length: s.len() })?;
 
-        let (prefix, data) = data.split_first().expect("length checked above");
-        let data: [u8; 20] = data.try_into().expect("length checked above");
+        let (prefix, &data) = data.split_first();
 
         let inner = match *prefix {
             PUBKEY_ADDRESS_PREFIX_MAIN => {
diff --git a/bitcoin/src/address/script_pubkey.rs b/bitcoin/src/address/script_pubkey.rs
index 7c048680e9..b89008ca33 100644
--- a/bitcoin/src/address/script_pubkey.rs
+++ b/bitcoin/src/address/script_pubkey.rs
@@ -2,6 +2,7 @@
 
 //! Bitcoin scriptPubkey script extensions.
 
+use internals::array::ArrayExt;
 use secp256k1::{Secp256k1, Verification};
 
 use crate::internal_macros::define_extension_trait;
@@ -99,14 +100,16 @@ define_extension_trait! {
     pub(crate) trait ScriptExtPrivate impl for Script {
         /// Returns the bytes of the (possibly invalid) public key if this script is P2PK.
         fn p2pk_pubkey_bytes(&self) -> Option<&[u8]> {
-            match self.len() {
-                67 if self.as_bytes()[0] == OP_PUSHBYTES_65.to_u8()
-                    && self.as_bytes()[66] == OP_CHECKSIG.to_u8() =>
-                    Some(&self.as_bytes()[1..66]),
-                35 if self.as_bytes()[0] == OP_PUSHBYTES_33.to_u8()
-                    && self.as_bytes()[34] == OP_CHECKSIG.to_u8() =>
-                    Some(&self.as_bytes()[1..34]),
-                _ => None,
+            if let Ok(bytes) = <&[u8; 67]>::try_from(self.as_bytes()) {
+                let (&first, bytes) = bytes.split_first::<66>();
+                let (&last, pubkey) = bytes.split_last::<65>();
+                (first == OP_PUSHBYTES_65.to_u8() && last == OP_CHECKSIG.to_u8()).then_some(pubkey)
+            } else if let Ok(bytes) = <&[u8; 35]>::try_from(self.as_bytes()) {
+                let (&first, bytes) = bytes.split_first::<34>();
+                let (&last, pubkey) = bytes.split_last::<33>();
+                (first == OP_PUSHBYTES_33.to_u8() && last == OP_CHECKSIG.to_u8()).then_some(pubkey)
+            } else {
+                None
             }
         }
     }
diff --git a/bitcoin/src/bip152.rs b/bitcoin/src/bip152.rs
index 979dabc5e5..bb25066d18 100644
--- a/bitcoin/src/bip152.rs
+++ b/bitcoin/src/bip152.rs
@@ -10,7 +10,7 @@ use core::{convert, fmt, mem};
 use std::error;
 
 use hashes::{sha256, siphash24};
-use internals::ToU64 as _;
+use internals::{ToU64 as _, array::ArrayExt as _};
 use io::{BufRead, Write};
 
 use crate::consensus::encode::{self, Decodable, Encodable, ReadExt, WriteExt};
@@ -117,8 +117,8 @@ impl 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.
         (
-            u64::from_le_bytes(h.as_byte_array()[0..8].try_into().expect("8 byte slice")),
-            u64::from_le_bytes(h.as_byte_array()[8..16].try_into().expect("8 byte slice")),
+            u64::from_le_bytes(*h.as_byte_array().sub_array::<0, 8>()),
+            u64::from_le_bytes(*h.as_byte_array().sub_array::<8, 8>()),
         )
     }
 
diff --git a/bitcoin/src/bip158.rs b/bitcoin/src/bip158.rs
index a0d57c1a87..abdde2a9c2 100644
--- a/bitcoin/src/bip158.rs
+++ b/bitcoin/src/bip158.rs
@@ -42,7 +42,7 @@ use core::convert::Infallible;
 use core::fmt;
 
 use hashes::{sha256d, siphash24, HashEngine as _};
-use internals::{write_err, ToU64 as _};
+use internals::{write_err, ToU64 as _, array::ArrayExt as _};
 use io::{BufRead, Write};
 
 use crate::block::{Block, BlockHash, Checked};
@@ -195,8 +195,8 @@ impl<'a, W: Write> BlockFilterWriter<'a, W> {
     /// Constructs a new [`BlockFilterWriter`] from `block`.
     pub fn new(writer: &'a mut W, block: &'a Block<Checked>) -> BlockFilterWriter<'a, W> {
         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 k0 = u64::from_le_bytes(*block_hash_as_int.sub_array::<0, 8>());
+        let k1 = u64::from_le_bytes(*block_hash_as_int.sub_array::<8, 8>());
         let writer = GcsFilterWriter::new(writer, k0, k1, M, P);
         BlockFilterWriter { block, writer }
     }
@@ -250,8 +250,8 @@ impl BlockFilterReader {
     /// Constructs 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"));
+        let k0 = u64::from_le_bytes(*block_hash_as_int.sub_array::<0, 8>());
+        let k1 = u64::from_le_bytes(*block_hash_as_int.sub_array::<8, 8>());
         BlockFilterReader { reader: GcsFilterReader::new(k0, k1, M, P) }
     }
 
diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 382d855543..057efe4513 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -10,7 +10,8 @@ use core::ops::Index;
 use core::str::FromStr;
 use core::{fmt, slice};
 
-use hashes::{hash160, hash_newtype, sha512, HashEngine, Hmac, HmacEngine};
+use hashes::{hash160, hash_newtype, sha512, Hash, HashEngine, Hmac, HmacEngine};
+use internals::array::ArrayExt;
 use internals::write_err;
 use secp256k1::{Secp256k1, XOnlyPublicKey};
 
@@ -44,7 +45,7 @@ impl_array_newtype_stringify!(ChainCode, 32);
 
 impl ChainCode {
     fn from_hmac(hmac: Hmac<sha512::Hash>) -> Self {
-        hmac.as_ref()[32..].try_into().expect("half of hmac is guaranteed to be 32 bytes")
+        ChainCode(*hmac.as_byte_array().split_array::<32, 32>().1)
     }
 }
 
@@ -608,7 +609,7 @@ impl Xpriv {
             parent_fingerprint: Default::default(),
             child_number: ChildNumber::ZERO_NORMAL,
             private_key: secp256k1::SecretKey::from_byte_array(
-                &hmac.as_ref()[..32].try_into().expect("Slice should be exactly 32 bytes"),
+                hmac.as_byte_array().split_array::<32, 32>().0,
             )?,
             chain_code: ChainCode::from_hmac(hmac),
         })
@@ -682,7 +683,7 @@ impl Xpriv {
         engine.input(&u32::from(i).to_be_bytes());
         let hmac: Hmac<sha512::Hash> = engine.finalize();
         let sk = secp256k1::SecretKey::from_byte_array(
-            &hmac.as_ref()[..32].try_into().expect("statistically impossible to hit"),
+            hmac.as_byte_array().split_array::<32, 32>().0,
         )
         .expect("statistically impossible to hit");
         let tweaked =
@@ -700,49 +701,33 @@ impl Xpriv {
 
     /// 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 Common {
+            network,
+            depth,
+            parent_fingerprint,
+            child_number,
+            chain_code,
+            key,
+        } = Common::decode(data)?;
 
-        let network = if data.starts_with(&VERSION_BYTES_MAINNET_PRIVATE) {
-            NetworkKind::Main
-        } else if data.starts_with(&VERSION_BYTES_TESTNETS_PRIVATE) {
-            NetworkKind::Test
-        } else {
-            let (b0, b1, b2, b3) = (data[0], data[1], data[2], data[3]);
-            return Err(Error::UnknownVersion([b0, b1, b2, b3]));
+        let network = match network {
+            VERSION_BYTES_MAINNET_PRIVATE => NetworkKind::Main,
+            VERSION_BYTES_TESTNETS_PRIVATE => NetworkKind::Test,
+            unknown => return Err(Error::UnknownVersion(unknown)),
         };
 
-        // Check that byte 45 is 0 as required by BIP-32 for private keys
-        if data[45] != 0 {
+        let (&zero, private_key) = key.split_first();
+        if zero != 0 {
             return Err(Error::InvalidPrivateKeyPrefix);
         }
 
-        // For master keys (depth=0), both parent fingerprint and child number must be zero
-        let depth = data[4];
-        if depth == 0 {
-            if !data[5..9].iter().all(|&b| b == 0) {
-                return Err(Error::NonZeroParentFingerprintForMasterKey);
-            }
-
-            if !data[9..13].iter().all(|&b| b == 0) {
-                return Err(Error::NonZeroChildNumberForMasterKey);
-            }
-        }
-
         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_byte_array(
-                &data[46..78].try_into().expect("Slice should be exactly 32 bytes"),
-            )?,
+            depth,
+            parent_fingerprint,
+            child_number,
+            chain_code,
+            private_key: secp256k1::SecretKey::from_byte_array(private_key)?,
         })
     }
 
@@ -769,7 +754,7 @@ impl Xpriv {
 
     /// Returns the first four bytes of the identifier
     pub fn fingerprint<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> Fingerprint {
-        self.identifier(secp).as_byte_array()[0..4].try_into().expect("4 is the fingerprint length")
+        self.identifier(secp).as_byte_array().sub_array::<0, 4>().into()
     }
 }
 
@@ -849,7 +834,7 @@ impl Xpub {
 
                 let hmac = engine.finalize();
                 let private_key = secp256k1::SecretKey::from_byte_array(
-                    &hmac.as_ref()[..32].try_into().expect("Slice should be exactly 32 bytes"),
+                    hmac.as_byte_array().split_array::<32, 32>().0
                 )?;
                 let chain_code = ChainCode::from_hmac(hmac);
                 Ok((private_key, chain_code))
@@ -878,30 +863,28 @@ impl Xpub {
 
     /// 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 Common {
+            network,
+            depth,
+            parent_fingerprint,
+            child_number,
+            chain_code,
+            key,
+        } = Common::decode(data)?;
 
-        let network = if data.starts_with(&VERSION_BYTES_MAINNET_PUBLIC) {
-            NetworkKind::Main
-        } else if data.starts_with(&VERSION_BYTES_TESTNETS_PUBLIC) {
-            NetworkKind::Test
-        } else {
-            let (b0, b1, b2, b3) = (data[0], data[1], data[2], data[3]);
-            return Err(Error::UnknownVersion([b0, b1, b2, b3]));
+        let network = match network {
+            VERSION_BYTES_MAINNET_PUBLIC => NetworkKind::Main,
+            VERSION_BYTES_TESTNETS_PUBLIC => NetworkKind::Test,
+            unknown => return Err(Error::UnknownVersion(unknown)),
         };
 
         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])?,
+            depth,
+            parent_fingerprint,
+            child_number,
+            chain_code,
+            public_key: secp256k1::PublicKey::from_slice(&key)?,
         })
     }
 
@@ -927,7 +910,7 @@ impl Xpub {
 
     /// Returns the first four bytes of the identifier
     pub fn fingerprint(&self) -> Fingerprint {
-        self.identifier().as_byte_array()[0..4].try_into().expect("4 is the fingerprint length")
+        self.identifier().as_byte_array().sub_array::<0, 4>().into()
     }
 }
 
@@ -1004,6 +987,48 @@ impl fmt::Display for InvalidBase58PayloadLengthError {
 #[cfg(feature = "std")]
 impl std::error::Error for InvalidBase58PayloadLengthError {}
 
+// Helps unify decoding
+struct Common {
+    network: [u8; 4],
+    depth: u8,
+    parent_fingerprint: Fingerprint,
+    child_number: ChildNumber,
+    chain_code: ChainCode,
+    // public key (compressed) or 0 byte followed by a private key 
+    key: [u8; 33],
+}
+
+impl Common {
+    fn decode(data: &[u8]) -> Result<Self, Error> {
+        let data: &[u8; 78] = data.try_into().map_err(|_| Error::WrongExtendedKeyLength(data.len()))?;
+
+        let (&network, data) = data.split_array::<4, 74>();
+        let (&depth, data) = data.split_first::<73>();
+        let (&parent_fingerprint, data) = data.split_array::<4, 69>();
+        let (&child_number, data) = data.split_array::<4, 65>();
+        let (&chain_code, &key) = data.split_array::<32, 33>();
+
+        if depth == 0 {
+            if parent_fingerprint != [0u8; 4] {
+                return Err(Error::NonZeroParentFingerprintForMasterKey);
+            }
+
+            if child_number != [0u8; 4] {
+                return Err(Error::NonZeroChildNumberForMasterKey);
+            }
+        }
+
+        Ok(Common {
+            network,
+            depth,
+            parent_fingerprint: parent_fingerprint.into(),
+            child_number: u32::from_be_bytes(child_number).into(),
+            chain_code: chain_code.into(),
+            key,
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use hex::test_hex_unwrap as hex;
diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 862ed1fc79..1c4dc32ae8 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -12,6 +12,7 @@ use core::str::FromStr;
 
 use hashes::hash160;
 use hex::{FromHex, HexToArrayError};
+use internals::array::ArrayExt;
 use internals::array_vec::ArrayVec;
 use internals::{impl_to_hex_from_lower_hex, write_err};
 use io::{Read, Write};
@@ -505,20 +506,20 @@ impl PrivateKey {
     pub fn from_wif(wif: &str) -> Result<PrivateKey, FromWifError> {
         let data = base58::decode_check(wif)?;
 
-        let compressed = match data.len() {
-            33 => false,
-            34 => {
-                if data[33] != 1 {
-                    return Err(InvalidWifCompressionFlagError { invalid: data[33] }.into());
-                }
-                true
-            }
-            length => {
-                return Err(InvalidBase58PayloadLengthError { length }.into());
+        let (compressed, data) = if let Ok(data) = <&[u8; 33]>::try_from(&*data) {
+            (false, data)
+        } else if let Ok(data) = <&[u8; 34]>::try_from(&*data) {
+            let (compressed_flag, data) = data.split_last::<33>();
+            if *compressed_flag != 1 {
+                return Err(InvalidWifCompressionFlagError { invalid: *compressed_flag }.into());
             }
+            (true, data)
+        } else {
+            return Err(InvalidBase58PayloadLengthError { length: data.len() }.into());
         };
 
-        let network = match data[0] {
+        let (network, key) = data.split_first();
+        let network = match *network {
             128 => NetworkKind::Main,
             239 => NetworkKind::Test,
             invalid => {
@@ -529,9 +530,7 @@ impl PrivateKey {
         Ok(PrivateKey {
             compressed,
             network,
-            inner: secp256k1::SecretKey::from_byte_array(
-                &data[1..33].try_into().expect("Slice should be exactly 32 bytes"),
-            )?,
+            inner: secp256k1::SecretKey::from_byte_array(key)?,
         })
     }
 }
diff --git a/bitcoin/src/crypto/taproot.rs b/bitcoin/src/crypto/taproot.rs
index 7a19f579ff..fe66028b87 100644
--- a/bitcoin/src/crypto/taproot.rs
+++ b/bitcoin/src/crypto/taproot.rs
@@ -10,6 +10,7 @@ use core::fmt;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use internals::write_err;
+use internals::array::ArrayExt;
 use io::Write;
 
 use crate::prelude::Vec;
@@ -29,23 +30,17 @@ pub struct Signature {
 impl Signature {
     /// Deserializes the signature from a slice.
     pub fn from_slice(sl: &[u8]) -> Result<Self, SigFromSliceError> {
-        match sl.len() {
-            64 => {
-                // default type
-                let signature = secp256k1::schnorr::Signature::from_byte_array(
-                    sl[0..64].try_into().expect("Slice should be exactly 64 bytes"),
-                );
-                Ok(Signature { signature, sighash_type: TapSighashType::Default })
-            }
-            65 => {
-                let (sighash_type, signature) = sl.split_last().expect("slice len checked == 65");
-                let sighash_type = TapSighashType::from_consensus_u8(*sighash_type)?;
-                let signature = secp256k1::schnorr::Signature::from_byte_array(
-                    signature[0..64].try_into().expect("Slice should be exactly 64 bytes"),
-                );
-                Ok(Signature { signature, sighash_type })
-            }
-            len => Err(SigFromSliceError::InvalidSignatureSize(len)),
+        if let Ok(signature) = <[u8; 64]>::try_from(sl) {
+            // default type
+            let signature = secp256k1::schnorr::Signature::from_byte_array(signature);
+            Ok(Signature { signature, sighash_type: TapSighashType::Default })
+        } else if let Ok(signature) = <[u8; 65]>::try_from(sl) {
+            let (sighash_type, signature) = signature.split_last();
+            let sighash_type = TapSighashType::from_consensus_u8(*sighash_type)?;
+            let signature = secp256k1::schnorr::Signature::from_byte_array(*signature);
+            Ok(Signature { signature, sighash_type })
+        } else {
+            Err(SigFromSliceError::InvalidSignatureSize(sl.len()))
         }
     }
 
@@ -144,9 +139,7 @@ impl<'a> Arbitrary<'a> for Signature {
         let arbitrary_bytes: [u8; secp256k1::constants::SCHNORR_SIGNATURE_SIZE] = u.arbitrary()?;
 
         Ok(Signature {
-            signature: secp256k1::schnorr::Signature::from_byte_array(
-                arbitrary_bytes[0..64].try_into().expect("Slice should be exactly 64 bytes"),
-            ),
+            signature: secp256k1::schnorr::Signature::from_byte_array(arbitrary_bytes),
             sighash_type: TapSighashType::arbitrary(u)?,
         })
     }
diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs
index 545604397b..ed14a8bad0 100644
--- a/bitcoin/src/lib.rs
+++ b/bitcoin/src/lib.rs
@@ -38,6 +38,7 @@
 // Exclude lints we don't think are valuable.
 #![allow(clippy::needless_question_mark)] // https://github.com/rust-bitcoin/rust-bitcoin/pull/2134
 #![allow(clippy::manual_range_contains)] // More readable than clippy's format.
+#![allow(clippy::incompatible_msrv)] // Has FPs and we're testing it which is more reliable anyway.
 
 // We only support machines with index size of 4 bytes or more.
 //
diff --git a/bitcoin/src/psbt/serialize.rs b/bitcoin/src/psbt/serialize.rs
index 34086afab0..4c2b0f4815 100644
--- a/bitcoin/src/psbt/serialize.rs
+++ b/bitcoin/src/psbt/serialize.rs
@@ -7,6 +7,8 @@
 
 use hashes::{hash160, ripemd160, sha256, sha256d};
 use internals::compact_size;
+#[allow(unused)] // MSRV polyfill
+use internals::slice::SliceExt;
 use secp256k1::XOnlyPublicKey;
 
 use super::map::{Input, Map, Output, PsbtSighashType};
@@ -214,14 +216,12 @@ impl Serialize for KeySource {
 
 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 (fingerprint, mut d) = bytes.split_first_chunk::<4>()
+            .ok_or(io::Error::from(io::ErrorKind::UnexpectedEof))?;
 
-        let fprint: Fingerprint = bytes[0..4].try_into().expect("4 is the fingerprint length");
+        let fprint: Fingerprint = fingerprint.into();
         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()),
diff --git a/bitcoin/src/taproot/mod.rs b/bitcoin/src/taproot/mod.rs
index a3358964ae..b14264f249 100644
--- a/bitcoin/src/taproot/mod.rs
+++ b/bitcoin/src/taproot/mod.rs
@@ -13,7 +13,11 @@ use core::fmt;
 use core::iter::FusedIterator;
 
 use hashes::{hash_newtype, sha256t, sha256t_tag, HashEngine};
+use internals::array::ArrayExt;
 use internals::{impl_to_hex_from_lower_hex, write_err};
+#[allow(unused)] // MSRV polyfill
+use internals::slice::SliceExt;
+
 use io::Write;
 use secp256k1::{Scalar, Secp256k1};
 
@@ -1162,22 +1166,20 @@ impl ControlBlock {
     /// - [`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(InvalidControlBlockSizeError(sl.len()).into());
-        }
-        let output_key_parity = match sl[0] & 1 {
+        let (base, merkle_branch) = sl.split_first_chunk::<TAPROOT_CONTROL_BASE_SIZE>()
+            .ok_or(InvalidControlBlockSizeError(sl.len()))?;
+
+        let (&first, internal_key) = base.split_first();
+
+        let output_key_parity = match first & 1 {
             0 => secp256k1::Parity::Even,
             _ => secp256k1::Parity::Odd,
         };
 
-        let leaf_version = LeafVersion::from_consensus(sl[0] & TAPROOT_LEAF_MASK)?;
-        let internal_key = UntweakedPublicKey::from_byte_array(
-            &sl[1..TAPROOT_CONTROL_BASE_SIZE].try_into().expect("Slice should be exactly 32 bytes"),
-        )
-        .map_err(TaprootError::InvalidInternalKey)?;
-        let merkle_branch = TaprootMerkleBranchBuf::decode(&sl[TAPROOT_CONTROL_BASE_SIZE..])?;
+        let leaf_version = LeafVersion::from_consensus(first & TAPROOT_LEAF_MASK)?;
+        let internal_key = UntweakedPublicKey::from_byte_array(internal_key)
+            .map_err(TaprootError::InvalidInternalKey)?;
+        let merkle_branch = TaprootMerkleBranchBuf::decode(merkle_branch)?;
         Ok(ControlBlock { leaf_version, output_key_parity, internal_key, merkle_branch })
     }
 }
diff --git a/internals/src/array.rs b/internals/src/array.rs
new file mode 100644
index 0000000000..becbf6b64c
--- /dev/null
+++ b/internals/src/array.rs
@@ -0,0 +1,105 @@
+//! Contains extensions related to arrays.
+
+/// Extension trait for arrays.
+pub trait ArrayExt {
+    /// The item type the array is storing.
+    type Item;
+
+    /// Just like the slicing operation, this returns an array `LEN` items long at position
+    /// `OFFSET`.
+    ///
+    /// The correctness of this operation is compile-time checked.
+    ///
+    /// Note that unlike slicing where the second number is the end index, here the second number
+    /// is array length!
+    fn sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN];
+
+    /// Returns an item at given statically-known index.
+    ///
+    /// This is just like normal indexing except the check happens at compile time.
+    fn get_static<const INDEX: usize>(&self) -> &Self::Item {
+        &self.sub_array::<INDEX, 1>()[0]
+    }
+
+    /// Returns the first item in an array.
+    ///
+    /// Fails to compile if the array is empty.
+    ///
+    /// Note that this method's name is intentionally shadowing the `std`'s `first` method which
+    /// returns `Option`. The rationale is that given the known length of the array, we always know
+    /// that this will not return `None` so trying to keep the `std` method around is pointless.
+    /// Importing the trait will also cause compile failures - that's also intentional to expose
+    /// the places where useless checks are made.
+    fn first(&self) -> &Self::Item {
+        self.get_static::<0>()
+    }
+
+    /// Splits the array into two, non-overlaping smaller arrays covering the entire range.
+    ///
+    /// This is almost equivalent to just calling [`sub_array`](Self::sub_array) twice, except it also
+    /// checks that the arrays don't overlap and that they cover the full range. This is very useful
+    /// for demonstrating correctness, especially when chained. Using this technique even revealed
+    /// a bug in the past. ([#4195](https://github.com/rust-bitcoin/rust-bitcoin/issues/4195))
+    fn split_array<const LEFT: usize, const RIGHT: usize>(&self) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT]);
+
+    /// Splits the array into the first element and the remaining, one element shorter, array.
+    ///
+    /// Fails to compile if the array is empty.
+    ///
+    /// Note that this method's name is intentionally shadowing the `std`'s `split_first` method which
+    /// returns `Option`. The rationale is that given the known length of the array, we always know
+    /// that this will not return `None` so trying to keep the `std` method around is pointless.
+    /// Importing the trait will also cause compile failures - that's also intentional to expose
+    /// the places where useless checks are made.
+    fn split_first<const RIGHT: usize>(&self) -> (&Self::Item, &[Self::Item; RIGHT]) {
+        let (first, remaining) = self.split_array::<1, RIGHT>();
+        (&first[0], remaining)
+    }
+
+    /// Splits the array into the last element and the remaining, one element shorter, array.
+    ///
+    /// Fails to compile if the array is empty.
+    ///
+    /// Note that this method's name is intentionally shadowing the `std`'s `split_last` method which
+    /// returns `Option`. The rationale is that given the known length of the array, we always know
+    /// that this will not return `None` so trying to keep the `std` method around is pointless.
+    /// Importing the trait will also cause compile failures - that's also intentional to expose
+    /// the places where useless checks are made.
+    ///
+    /// The returned tuple is also reversed just as `std` for consistency and simpler diffs when
+    /// migrating.
+    fn split_last<const LEFT: usize>(&self) -> (&Self::Item, &[Self::Item; LEFT]) {
+        let (remaining, last) = self.split_array::<LEFT, 1>();
+        (&last[0], remaining)
+    }
+}
+
+impl<const N: usize, T> ArrayExt for [T; N] {
+    type Item = T;
+
+    fn sub_array<const OFFSET: usize, const LEN: usize>(&self) -> &[Self::Item; LEN] {
+        #[allow(clippy::let_unit_value)]
+        let _ = Hack::<N, OFFSET, LEN>::IS_VALID_RANGE;
+
+        self[OFFSET..(OFFSET + LEN)].try_into().expect("this is also compiler-checked above")
+    }
+
+    fn split_array<const LEFT: usize, const RIGHT: usize>(&self) -> (&[Self::Item; LEFT], &[Self::Item; RIGHT]) {
+        #[allow(clippy::let_unit_value)]
+        let _ = Hack2::<N, LEFT, RIGHT>::IS_FULL_RANGE;
+
+        (self.sub_array::<0, LEFT>(), self.sub_array::<LEFT, RIGHT>())
+    }
+}
+
+struct Hack<const N: usize, const OFFSET: usize, const LEN: usize>;
+
+impl<const N: usize, const OFFSET: usize, const LEN: usize> Hack<N, OFFSET, LEN> {
+    const IS_VALID_RANGE: () = assert!(OFFSET + LEN <= N);
+}
+
+struct Hack2<const N: usize, const LEFT: usize, const RIGHT: usize>;
+
+impl<const N: usize, const LEFT: usize, const RIGHT: usize> Hack2<N, LEFT, RIGHT> {
+    const IS_FULL_RANGE: () = assert!(LEFT + RIGHT == N);
+}
diff --git a/internals/src/lib.rs b/internals/src/lib.rs
index bed67bd2f1..c2e2ce7080 100644
--- a/internals/src/lib.rs
+++ b/internals/src/lib.rs
@@ -35,6 +35,7 @@ pub mod rust_version {
     include!(concat!(env!("OUT_DIR"), "/rust_version.rs"));
 }
 
+pub mod array;
 pub mod array_vec;
 pub mod compact_size;
 pub mod const_tools;
diff --git a/internals/src/slice.rs b/internals/src/slice.rs
index 4c32126d06..b703238e45 100644
--- a/internals/src/slice.rs
+++ b/internals/src/slice.rs
@@ -26,6 +26,25 @@ pub trait SliceExt {
     fn bitcoin_as_chunks_mut<const N: usize>(
         &mut self,
     ) -> (&mut [[Self::Item; N]], &mut [Self::Item]);
+
+    /// Tries to access a sub-array of length `ARRAY_LEN` at the specified `offset`.
+    ///
+    /// Returns `None` in case of out-of-bounds access.
+    fn get_array<const ARRAY_LEN: usize>(&self, offset: usize) -> Option<&[Self::Item; ARRAY_LEN]>;
+
+    /// Splits the slice into an array and remainder if it's long enough.
+    ///
+    /// Returns `None` if the slice is shorter than `ARRAY_LEN`
+    #[allow(clippy::type_complexity)] // it's not really complex and redefining would make it
+                                      // harder to understand
+    fn split_first_chunk<const ARRAY_LEN: usize>(&self) -> Option<(&[Self::Item; ARRAY_LEN], &[Self::Item])>;
+
+    /// Splits the slice into a remainder and an array if it's long enough.
+    ///
+    /// Returns `None` if the slice is shorter than `ARRAY_LEN`
+    #[allow(clippy::type_complexity)] // it's not really complex and redefining would make it
+                                      // harder to understand
+    fn split_last_chunk<const ARRAY_LEN: usize>(&self) -> Option<(&[Self::Item], &[Self::Item; ARRAY_LEN])>;
 }
 
 impl<T> SliceExt for [T] {
@@ -69,6 +88,27 @@ impl<T> SliceExt for [T] {
         };
         (left, right)
     }
+
+    fn get_array<const ARRAY_LEN: usize>(&self, offset: usize) -> Option<&[Self::Item; ARRAY_LEN]> {
+        self.get(offset..(offset + ARRAY_LEN))
+            .map(|slice| slice.try_into().expect("the arguments to `get` evaluate to the same length the return type uses"))
+    }
+
+    fn split_first_chunk<const ARRAY_LEN: usize>(&self) -> Option<(&[Self::Item; ARRAY_LEN], &[Self::Item])> {
+        if self.len() < ARRAY_LEN {
+            return None;
+        }
+        let (first, remainder) = self.split_at(ARRAY_LEN);
+        Some((first.try_into().expect("we're passing `ARRAY_LEN` to `split_at` above"), remainder))
+    }
+
+    fn split_last_chunk<const ARRAY_LEN: usize>(&self) -> Option<(&[Self::Item], &[Self::Item; ARRAY_LEN])> {
+        if self.len() < ARRAY_LEN {
+            return None;
+        }
+        let (remainder, last) = self.split_at(self.len() - ARRAY_LEN);
+        Some((remainder, last.try_into().expect("we're passing `self.len() - ARRAY_LEN` to `split_at` above")))
+    }
 }
 
 struct Hack<const N: usize>;
diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index bf2a8f9f8c..101c37caab 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -12,6 +12,7 @@ use arbitrary::{Arbitrary, Unstructured};
 use hex::DisplayHex;
 use internals::compact_size;
 use internals::wrap_debug::WrapDebug;
+use internals::slice::SliceExt;
 
 use crate::prelude::Vec;
 
@@ -234,12 +235,7 @@ fn encode_cursor(bytes: &mut [u8], start_of_indices: usize, index: usize, value:
 #[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)
-    }
+    bytes.get_array::<4>(start).map(|index_bytes| u32::from_ne_bytes(*index_bytes) as usize)
 }
 
 /// Debug implementation that displays the witness as a structured output containing:

From 437562e71cbb1e18179df3f5d01d2cc86961a150 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sat, 15 Mar 2025 15:38:30 +0100
Subject: [PATCH 541/554] Add official BIP32 test vectors for invalid keys

These are defined in the BIP as invalid. The previous commit fixed a bug
where invalid key was parsed as valid and this bug can be caught by
these vectors. Therefore, if this commit is ordered before the last one
the test will fail.
---
 bitcoin/src/bip32.rs | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/bitcoin/src/bip32.rs b/bitcoin/src/bip32.rs
index 057efe4513..73d74ffc82 100644
--- a/bitcoin/src/bip32.rs
+++ b/bitcoin/src/bip32.rs
@@ -1410,4 +1410,33 @@ mod tests {
         let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFAzHGBP2UuGCqWLTAPLcMtD9y5gkZ6Eq3Rjuahrv17fENZ3QzxW";
         xpriv_str.parse::<Xpriv>().unwrap();
     }
+
+    #[test]
+    fn official_vectors_5() {
+        let invalid_keys = [
+            "xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6LBpB85b3D2yc8sfvZU521AAwdZafEz7mnzBBsz4wKY5fTtTQBm",
+            "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFGTQQD3dC4H2D5GBj7vWvSQaaBv5cxi9gafk7NF3pnBju6dwKvH",
+            "xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6Txnt3siSujt9RCVYsx4qHZGc62TG4McvMGcAUjeuwZdduYEvFn",
+            "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFGpWnsj83BHtEy5Zt8CcDr1UiRXuWCmTQLxEK9vbz5gPstX92JQ",
+            "xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6N8ZMMXctdiCjxTNq964yKkwrkBJJwpzZS4HS2fxvyYUA4q2Xe4",
+            "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFAzHGBP2UuGCqWLTAPLcMtD9y5gkZ6Eq3Rjuahrv17fEQ3Qen6J",
+            "xprv9s2SPatNQ9Vc6GTbVMFPFo7jsaZySyzk7L8n2uqKXJen3KUmvQNTuLh3fhZMBoG3G4ZW1N2kZuHEPY53qmbZzCHshoQnNf4GvELZfqTUrcv",
+            "xpub661no6RGEX3uJkY4bNnPcw4URcQTrSibUZ4NqJEw5eBkv7ovTwgiT91XX27VbEXGENhYRCf7hyEbWrR3FewATdCEebj6znwMfQkhRYHRLpJ",
+            "xprv9s21ZrQH4r4TsiLvyLXqM9P7k1K3EYhA1kkD6xuquB5i39AU8KF42acDyL3qsDbU9NmZn6MsGSUYZEsuoePmjzsB3eFKSUEh3Gu1N3cqVUN",
+            "xpub661MyMwAuDcm6CRQ5N4qiHKrJ39Xe1R1NyfouMKTTWcguwVcfrZJaNvhpebzGerh7gucBvzEQWRugZDuDXjNDRmXzSZe4c7mnTK97pTvGS8",
+            "DMwo58pR1QLEFihHiXPVykYB6fJmsTeHvyTp7hRThAtCX8CvYzgPcn8XnmdfHGMQzT7ayAmfo4z3gY5KfbrZWZ6St24UVf2Qgo6oujFktLHdHY4",
+            "DMwo58pR1QLEFihHiXPVykYB6fJmsTeHvyTp7hRThAtCX8CvYzgPcn8XnmdfHPmHJiEDXkTiJTVV9rHEBUem2mwVbbNfvT2MTcAqj3nesx8uBf9",
+            "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzF93Y5wvzdUayhgkkFoicQZcP3y52uPPxFnfoLZB21Teqt1VvEHx",
+            "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFAzHGBP2UuGCqWLTAPLcMtD5SDKr24z3aiUvKr9bJpdrcLg1y3G",
+            "xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6Q5JXayek4PRsn35jii4veMimro1xefsM58PgBMrvdYre8QyULY",
+            "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHL",
+        ];
+        for key in invalid_keys {
+            if key.starts_with("xpub") {
+                key.parse::<Xpub>().unwrap_err();
+            } else {
+                key.parse::<Xpriv>().unwrap_err();
+            }
+        }
+    }
 }

From 200ff473276f62866f0db130ecb485c905714aaa Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Fri, 21 Mar 2025 09:07:00 +1100
Subject: [PATCH 542/554] Use compute_merkle_root

Remove manual implementation of merkle root calculation and just use the
function we already have.

Refactor only, no logic change.
---
 bitcoin/src/blockdata/constants.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/bitcoin/src/blockdata/constants.rs b/bitcoin/src/blockdata/constants.rs
index 6e8ef036e9..60d528862c 100644
--- a/bitcoin/src/blockdata/constants.rs
+++ b/bitcoin/src/blockdata/constants.rs
@@ -6,8 +6,6 @@
 //! consensus code. In particular, it defines the genesis block and its
 //! single transaction.
 
-use hashes::sha256d;
-
 use crate::block::{self, Block, Checked};
 use crate::internal_macros::{impl_array_newtype, impl_array_newtype_stringify};
 use crate::locktime::absolute;
@@ -124,8 +122,7 @@ fn bitcoin_genesis_tx(params: &Params) -> Transaction {
 pub fn genesis_block(params: impl AsRef<Params>) -> Block<Checked> {
     let params = params.as_ref();
     let transactions = vec![bitcoin_genesis_tx(params)];
-    let hash: sha256d::Hash = transactions[0].compute_txid().into();
-    let merkle_root: crate::TxMerkleNode = hash.into();
+    let merkle_root = block::compute_merkle_root(&transactions).expect("transactions is not empty");
     let witness_root = block::compute_witness_root(&transactions);
 
     match params.network {

From 6b2b89c2f71e9bc4c33f0a7385a2c1fab3bb59ec Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Wed, 26 Feb 2025 14:13:32 +1100
Subject: [PATCH 543/554] Remove From<hash> for not-general-hash types

The `hash_newtype` macro is explicitly designed to produce a hash that
is not a general purpose hash type to try and prevent users hashing
arbitrary stuff with it. E.g., `Txid` isn't meant to be just hash
arbitrary data. However we provide a `From` impl that will convert any
instance of the inner hash type into the new type. This kind of defeats
the purpose. We provide `from_byte_array` and `to_byte_array` to allow
folk to 'cast' from one hash type to another if they really want to and
its ugly on purpose.

Also, it is becoming apparent that we may be able to remove the `hashes`
crate from the public API of `primitives` allowing us to stabalise
`primitives` without stabalising `hashes`.

For both these reasons remove the `From` impl from the `hash_newtype`
macro. Note that deprecating doesn't seem to work so we just delete it.
---
 bitcoin/src/p2p/message.rs | 41 +++++++++++++++++++++-----------------
 hashes/src/macros.rs       |  7 -------
 2 files changed, 23 insertions(+), 25 deletions(-)

diff --git a/bitcoin/src/p2p/message.rs b/bitcoin/src/p2p/message.rs
index d02483a7f8..e9522a7c51 100644
--- a/bitcoin/src/p2p/message.rs
+++ b/bitcoin/src/p2p/message.rs
@@ -702,7 +702,8 @@ mod test {
 
     use super::*;
     use crate::bip152::BlockTransactionsRequest;
-    use crate::block::Block;
+    use crate::bip158::{FilterHeader, FilterHash};
+    use crate::block::{Block, BlockHash};
     use crate::consensus::encode::{deserialize, deserialize_partial, serialize};
     use crate::p2p::address::AddrV2;
     use crate::p2p::message_blockdata::{GetBlocksMessage, GetHeadersMessage, Inventory};
@@ -714,7 +715,7 @@ mod test {
     use crate::p2p::message_network::{Reject, RejectReason, VersionMessage};
     use crate::p2p::ServiceFlags;
     use crate::script::ScriptBuf;
-    use crate::transaction::Transaction;
+    use crate::transaction::{Transaction, Txid};
 
     fn hash(array: [u8; 32]) -> sha256d::Hash { sha256d::Hash::from_byte_array(array) }
 
@@ -737,16 +738,20 @@ mod test {
                 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::Inv(vec![Inventory::Block(BlockHash::from_byte_array(hash([8u8; 32]).to_byte_array()))]),
+            NetworkMessage::GetData(vec![Inventory::Transaction(Txid::from_byte_array(hash([45u8; 32]).to_byte_array()))]),
             NetworkMessage::NotFound(vec![Inventory::Error([0u8; 32])]),
             NetworkMessage::GetBlocks(GetBlocksMessage::new(
-                vec![hash([1u8; 32]).into(), hash([4u8; 32]).into()],
-                hash([5u8; 32]).into(),
+                vec![
+                    BlockHash::from_byte_array(hash([1u8; 32]).to_byte_array()),
+                    BlockHash::from_byte_array(hash([4u8; 32]).to_byte_array())],
+                BlockHash::from_byte_array(hash([5u8; 32]).to_byte_array()),
             )),
             NetworkMessage::GetHeaders(GetHeadersMessage::new(
-                vec![hash([10u8; 32]).into(), hash([40u8; 32]).into()],
-                hash([50u8; 32]).into(),
+                vec![
+                    BlockHash::from_byte_array(hash([10u8; 32]).to_byte_array()),
+                    BlockHash::from_byte_array(hash([40u8; 32]).to_byte_array())],
+                BlockHash::from_byte_array(hash([50u8; 32]).to_byte_array()),
             )),
             NetworkMessage::MemPool,
             NetworkMessage::Tx(tx),
@@ -771,32 +776,32 @@ mod test {
             NetworkMessage::GetCFilters(GetCFilters {
                 filter_type: 2,
                 start_height: BlockHeight::from(52),
-                stop_hash: hash([42u8; 32]).into(),
+                stop_hash: BlockHash::from_byte_array(hash([42u8; 32]).to_byte_array()),
             }),
             NetworkMessage::CFilter(CFilter {
                 filter_type: 7,
-                block_hash: hash([25u8; 32]).into(),
+                block_hash: BlockHash::from_byte_array(hash([25u8; 32]).to_byte_array()),
                 filter: vec![1, 2, 3],
             }),
             NetworkMessage::GetCFHeaders(GetCFHeaders {
                 filter_type: 4,
                 start_height: BlockHeight::from(102),
-                stop_hash: hash([47u8; 32]).into(),
+                stop_hash: BlockHash::from_byte_array(hash([47u8; 32]).to_byte_array()),
             }),
             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()],
+                stop_hash: BlockHash::from_byte_array(hash([53u8; 32]).to_byte_array()),
+                previous_filter_header: FilterHeader::from_byte_array(hash([12u8; 32]).to_byte_array()),
+                filter_hashes: vec![FilterHash::from_byte_array(hash([4u8; 32]).to_byte_array()), FilterHash::from_byte_array(hash([12u8; 32]).to_byte_array())],
             }),
             NetworkMessage::GetCFCheckpt(GetCFCheckpt {
                 filter_type: 17,
-                stop_hash: hash([25u8; 32]).into(),
+                stop_hash: BlockHash::from_byte_array(hash([25u8; 32]).to_byte_array()),
             }),
             NetworkMessage::CFCheckpt(CFCheckpt {
                 filter_type: 27,
-                stop_hash: hash([77u8; 32]).into(),
-                filter_headers: vec![hash([3u8; 32]).into(), hash([99u8; 32]).into()],
+                stop_hash: BlockHash::from_byte_array(hash([77u8; 32]).to_byte_array()),
+                filter_headers: vec![FilterHeader::from_byte_array(hash([3u8; 32]).to_byte_array()), FilterHeader::from_byte_array(hash([99u8; 32]).to_byte_array())],
             }),
             NetworkMessage::Alert(vec![45, 66, 3, 2, 6, 8, 9, 12, 3, 130]),
             NetworkMessage::Reject(Reject {
@@ -817,7 +822,7 @@ mod test {
             NetworkMessage::CmpctBlock(cmptblock),
             NetworkMessage::GetBlockTxn(GetBlockTxn {
                 txs_request: BlockTransactionsRequest {
-                    block_hash: hash([11u8; 32]).into(),
+                    block_hash: BlockHash::from_byte_array(hash([11u8; 32]).to_byte_array()),
                     indexes: vec![0, 1, 2, 3, 10, 3002],
                 },
             }),
diff --git a/hashes/src/macros.rs b/hashes/src/macros.rs
index 070b727281..f1b06727ce 100644
--- a/hashes/src/macros.rs
+++ b/hashes/src/macros.rs
@@ -158,13 +158,6 @@ macro_rules! hash_newtype {
             }
         }
 
-        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

From db9ec3bed8d6164a0345ba8db1e2162626db7cc5 Mon Sep 17 00:00:00 2001
From: "Tobin C. Harding" <me@tobin.cc>
Date: Thu, 20 Mar 2025 14:34:59 +1100
Subject: [PATCH 544/554] Remove From<newtype> for $hash

We provide the from/to_byte_array functions for casting between arrays.
We shouldn't be supporting calls to `into` to quickly do the cast.

We already removed the other direction, now remove this one.
---
 hashes/src/macros.rs          | 6 ------
 primitives/src/transaction.rs | 2 +-
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/hashes/src/macros.rs b/hashes/src/macros.rs
index f1b06727ce..2c9aa1bcf7 100644
--- a/hashes/src/macros.rs
+++ b/hashes/src/macros.rs
@@ -158,12 +158,6 @@ macro_rules! hash_newtype {
             }
         }
 
-        impl $crate::_export::_core::convert::From<$newtype> for $hash {
-            fn from(hashtype: $newtype) -> $hash {
-                hashtype.0
-            }
-        }
-
         impl $crate::Hash for $newtype {
             type Bytes = <$hash as $crate::Hash>::Bytes;
 
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index 764ed68c64..1c79a187db 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -151,7 +151,7 @@ impl Transaction {
                 .collect(),
             output: self.output.clone(),
         };
-        cloned_tx.compute_txid().into()
+        sha256d::Hash::from_byte_array(cloned_tx.compute_txid().to_byte_array())
     }
 
     /// Computes the [`Txid`].

From 36ebf6c186d65964efbfa150557c0fac630b4e21 Mon Sep 17 00:00:00 2001
From: Update Stable Rustc Bot <bot@example.com>
Date: Fri, 21 Mar 2025 00:59:22 +0000
Subject: [PATCH 545/554] Automated update to Github CI to rustc stable-1.85.1

---
 .github/workflows/stable-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stable-version b/.github/workflows/stable-version
index f288d11142..8510ffad03 100644
--- a/.github/workflows/stable-version
+++ b/.github/workflows/stable-version
@@ -1 +1 @@
-1.85.0
+1.85.1

From 069d2fd07e7d6dad1401fce6ab28ab1dc9f3c60f Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Fri, 14 Mar 2025 10:25:28 -0300
Subject: [PATCH 546/554] Add XOnlyPublicKey support for PSBT key retrieval and
 improve Taproot signing

This commit enhances PSBT signing functionality by:

1. Added new KeyRequest::XOnlyPubkey variant to support direct retrieval using XOnly public keys
2. Implemented GetKey for HashMap<XOnlyPublicKey, PrivateKey> for more efficient Taproot key management
3. Modified HashMap<PublicKey, PrivateKey> implementation to handle XOnlyPublicKey requests by checking both even and odd parity variants

These changes allow for more flexible key management in Taproot transactions.
Specifically, wallet implementations can now store keys indexed by either
PublicKey or XOnlyPublicKey and successfully sign PSBTs with Taproot inputs.

Added tests for both implementations to verify correct behavior.

Added test for odd parity key retrieval.

Closes #4150
---
 bitcoin/src/crypto/key.rs |  14 +++
 bitcoin/src/psbt/mod.rs   | 181 ++++++++++++++++++++++++++++++++++++--
 2 files changed, 186 insertions(+), 9 deletions(-)

diff --git a/bitcoin/src/crypto/key.rs b/bitcoin/src/crypto/key.rs
index 1c4dc32ae8..9db3079069 100644
--- a/bitcoin/src/crypto/key.rs
+++ b/bitcoin/src/crypto/key.rs
@@ -533,6 +533,20 @@ impl PrivateKey {
             inner: secp256k1::SecretKey::from_byte_array(key)?,
         })
     }
+
+    /// Returns a new private key with the negated secret value.
+    ///
+    /// The resulting key corresponds to the same x-only public key (identical x-coordinate)
+    /// but with the opposite y-coordinate parity. This is useful for ensuring compatibility 
+    /// with specific public key formats and BIP-340 requirements.
+    #[inline]
+    pub fn negate(&self) -> Self {
+        PrivateKey {
+            compressed: self.compressed,
+            network: self.network,
+            inner: self.inner.negate(),
+        }
+    }
 }
 
 impl fmt::Display for PrivateKey {
diff --git a/bitcoin/src/psbt/mod.rs b/bitcoin/src/psbt/mod.rs
index 1f582cfa1b..6f0ce3fc4b 100644
--- a/bitcoin/src/psbt/mod.rs
+++ b/bitcoin/src/psbt/mod.rs
@@ -427,6 +427,8 @@ impl Psbt {
                 k.get_key(&KeyRequest::Bip32(key_source.clone()), secp)
             {
                 secret_key
+            } else if let Ok(Some(sk)) = k.get_key(&KeyRequest::XOnlyPubkey(xonly), secp) {
+                sk
             } else {
                 continue;
             };
@@ -737,6 +739,8 @@ pub enum KeyRequest {
     Pubkey(PublicKey),
     /// Request a private key using BIP-32 fingerprint and derivation path.
     Bip32(KeySource),
+    /// Request a private key using the associated x-only public key.
+    XOnlyPubkey(XOnlyPublicKey),
 }
 
 /// Trait to get a private key from a key request, key is then used to sign an input.
@@ -768,6 +772,7 @@ impl GetKey for Xpriv {
     ) -> Result<Option<PrivateKey>, Self::Error> {
         match key_request {
             KeyRequest::Pubkey(_) => Err(GetKeyError::NotSupported),
+            KeyRequest::XOnlyPubkey(_) => Err(GetKeyError::NotSupported),
             KeyRequest::Bip32((fingerprint, path)) => {
                 let key = if self.fingerprint(secp) == *fingerprint {
                     let k = self.derive_xpriv(secp, &path);
@@ -831,7 +836,7 @@ impl_get_key_for_set!(BTreeSet);
 impl_get_key_for_set!(HashSet);
 
 #[rustfmt::skip]
-macro_rules! impl_get_key_for_map {
+macro_rules! impl_get_key_for_pubkey_map {
     ($map:ident) => {
 
 impl GetKey for $map<PublicKey, PrivateKey> {
@@ -844,13 +849,67 @@ impl GetKey for $map<PublicKey, PrivateKey> {
     ) -> Result<Option<PrivateKey>, Self::Error> {
         match key_request {
             KeyRequest::Pubkey(pk) => Ok(self.get(&pk).cloned()),
+            KeyRequest::XOnlyPubkey(xonly) => {
+                let pubkey_even = PublicKey::new(xonly.public_key(secp256k1::Parity::Even));
+                let key = self.get(&pubkey_even).cloned();
+                
+                if key.is_some() {
+                    return Ok(key);
+                }
+                
+                let pubkey_odd = PublicKey::new(xonly.public_key(secp256k1::Parity::Odd));
+                if let Some(priv_key) = self.get(&pubkey_odd).copied() {
+                    let negated_priv_key  = priv_key.negate();
+                    return Ok(Some(negated_priv_key));
+                }
+
+                Ok(None)
+            },
+            KeyRequest::Bip32(_) => Err(GetKeyError::NotSupported),
+        }
+    }
+}}}
+impl_get_key_for_pubkey_map!(BTreeMap);
+#[cfg(feature = "std")]
+impl_get_key_for_pubkey_map!(HashMap);
+
+#[rustfmt::skip]
+macro_rules! impl_get_key_for_xonly_map {
+    ($map:ident) => {
+
+impl GetKey for $map<XOnlyPublicKey, PrivateKey> {
+    type Error = GetKeyError;
+
+    fn get_key<C: Signing>(
+        &self,
+        key_request: &KeyRequest,
+        secp: &Secp256k1<C>,
+    ) -> Result<Option<PrivateKey>, Self::Error> {
+        match key_request {
+            KeyRequest::XOnlyPubkey(xonly) => Ok(self.get(xonly).cloned()),
+            KeyRequest::Pubkey(pk) => {
+                let (xonly, parity) = pk.inner.x_only_public_key();
+                
+                if let Some(mut priv_key) = self.get(&XOnlyPublicKey::from(xonly)).cloned() {
+                    let computed_pk = priv_key.public_key(&secp);
+                    let (_, computed_parity) = computed_pk.inner.x_only_public_key();
+                    
+                    if computed_parity != parity {
+                        priv_key = priv_key.negate();
+                    }
+                    
+                    return Ok(Some(priv_key));
+                }
+                
+                Ok(None)
+            },
             KeyRequest::Bip32(_) => Err(GetKeyError::NotSupported),
         }
     }
 }}}
-impl_get_key_for_map!(BTreeMap);
+impl_get_key_for_xonly_map!(BTreeMap);
 #[cfg(feature = "std")]
-impl_get_key_for_map!(HashMap);
+impl_get_key_for_xonly_map!(HashMap);
 
 /// Errors when getting a key.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -1228,7 +1287,14 @@ mod tests {
     use hashes::{hash160, ripemd160, sha256};
     use hex::{test_hex_unwrap as hex, FromHex};
     #[cfg(feature = "rand-std")]
-    use secp256k1::{All, SecretKey};
+    use {
+        crate::address::script_pubkey::ScriptBufExt as _,
+        crate::bip32::{DerivationPath, Fingerprint},
+        crate::locktime,
+        crate::witness_version::WitnessVersion,
+        crate::WitnessProgram,
+        secp256k1::{All, SecretKey},
+    };
 
     use super::*;
     use crate::address::script_pubkey::ScriptExt as _;
@@ -2169,6 +2235,42 @@ mod tests {
         assert_eq!(got.unwrap(), priv_key)
     }
 
+    #[test]
+    #[cfg(feature = "rand-std")]
+    fn pubkey_map_get_key_negates_odd_parity_keys() {
+        use crate::psbt::{GetKey, KeyRequest};
+
+        let (mut priv_key, mut pk, secp) = gen_keys();
+        let (xonly, parity) = pk.inner.x_only_public_key();
+
+        let mut pubkey_map: HashMap<PublicKey, PrivateKey> = HashMap::new();
+
+        if parity == secp256k1::Parity::Even {
+            priv_key = PrivateKey {
+                compressed: priv_key.compressed,
+                network: priv_key.network,
+                inner: priv_key.inner.negate(),
+            };
+            pk = priv_key.public_key(&secp);
+        }
+
+        pubkey_map.insert(pk, priv_key);
+
+        let req_result = pubkey_map.get_key(&KeyRequest::XOnlyPubkey(xonly), &secp).unwrap();
+
+        let retrieved_key = req_result.unwrap();
+
+        let retrieved_pub_key = retrieved_key.public_key(&secp);
+        let (retrieved_xonly, retrieved_parity) = retrieved_pub_key.inner.x_only_public_key();
+
+        assert_eq!(xonly, retrieved_xonly);
+        assert_eq!(
+            retrieved_parity,
+            secp256k1::Parity::Even,
+            "Key should be normalized to have even parity, even when original had odd parity"
+        );
+    }
+
     #[test]
     fn fee() {
         let output_0_val = Amount::from_sat_u32(99_999_699);
@@ -2273,12 +2375,73 @@ mod tests {
 
     #[test]
     #[cfg(feature = "rand-std")]
-    fn sign_psbt() {
-        use crate::address::script_pubkey::ScriptBufExt as _;
-        use crate::bip32::{DerivationPath, Fingerprint};
-        use crate::witness_version::WitnessVersion;
-        use crate::WitnessProgram;
+    fn hashmap_can_sign_taproot() {
+        let (priv_key, pk, secp) = gen_keys();
+        let internal_key: XOnlyPublicKey = pk.inner.into();
+
+        let tx = Transaction {
+            version: transaction::Version::TWO,
+            lock_time: locktime::absolute::LockTime::ZERO,
+            input: vec![TxIn::EMPTY_COINBASE],
+            output: vec![TxOut { value: Amount::ZERO, script_pubkey: ScriptBuf::new() }],
+        };
 
+        let mut psbt = Psbt::from_unsigned_tx(tx).unwrap();
+        psbt.inputs[0].tap_internal_key = Some(internal_key);
+        psbt.inputs[0].witness_utxo = Some(transaction::TxOut {
+            value: Amount::from_sat_u32(10),
+            script_pubkey: ScriptBuf::new_p2tr(&secp, internal_key, None),
+        });
+
+        let mut key_map: HashMap<PublicKey, PrivateKey> = HashMap::new();
+        key_map.insert(pk, priv_key);
+
+        let key_source = (Fingerprint::default(), DerivationPath::default());
+        let mut tap_key_origins = std::collections::BTreeMap::new();
+        tap_key_origins.insert(internal_key, (vec![], key_source));
+        psbt.inputs[0].tap_key_origins = tap_key_origins;
+
+        let signing_keys = psbt.sign(&key_map, &secp).unwrap();
+        assert_eq!(signing_keys.len(), 1);
+        assert_eq!(signing_keys[&0], SigningKeys::Schnorr(vec![internal_key]));
+    }
+
+    #[test]
+    #[cfg(feature = "rand-std")]
+    fn xonly_hashmap_can_sign_taproot() {
+        let (priv_key, pk, secp) = gen_keys();
+        let internal_key: XOnlyPublicKey = pk.inner.into();
+
+        let tx = Transaction {
+            version: transaction::Version::TWO,
+            lock_time: locktime::absolute::LockTime::ZERO,
+            input: vec![TxIn::EMPTY_COINBASE],
+            output: vec![TxOut { value: Amount::ZERO, script_pubkey: ScriptBuf::new() }],
+        };
+
+        let mut psbt = Psbt::from_unsigned_tx(tx).unwrap();
+        psbt.inputs[0].tap_internal_key = Some(internal_key);
+        psbt.inputs[0].witness_utxo = Some(transaction::TxOut {
+            value: Amount::from_sat_u32(10),
+            script_pubkey: ScriptBuf::new_p2tr(&secp, internal_key, None),
+        });
+
+        let mut xonly_key_map: HashMap<XOnlyPublicKey, PrivateKey> = HashMap::new();
+        xonly_key_map.insert(internal_key, priv_key);
+
+        let key_source = (Fingerprint::default(), DerivationPath::default());
+        let mut tap_key_origins = std::collections::BTreeMap::new();
+        tap_key_origins.insert(internal_key, (vec![], key_source));
+        psbt.inputs[0].tap_key_origins = tap_key_origins;
+
+        let signing_keys = psbt.sign(&xonly_key_map, &secp).unwrap();
+        assert_eq!(signing_keys.len(), 1);
+        assert_eq!(signing_keys[&0], SigningKeys::Schnorr(vec![internal_key]));
+    }
+
+    #[test]
+    #[cfg(feature = "rand-std")]
+    fn sign_psbt() {
         let unsigned_tx = Transaction {
             version: transaction::Version::TWO,
             lock_time: absolute::LockTime::ZERO,

From dfb49f014c2c5194f9ae0c1c1e6910a6e1b6189d Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Fri, 21 Mar 2025 14:19:25 -0300
Subject: [PATCH 547/554] Rename impl_try_from_array to impl_from_array

---
 bitcoin/src/taproot/merkle_branch/buf.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bitcoin/src/taproot/merkle_branch/buf.rs b/bitcoin/src/taproot/merkle_branch/buf.rs
index d06ffcadf3..a6e0e7526f 100644
--- a/bitcoin/src/taproot/merkle_branch/buf.rs
+++ b/bitcoin/src/taproot/merkle_branch/buf.rs
@@ -126,7 +126,7 @@ impl_try_from!(&[TapNodeHash]);
 impl_try_from!(Vec<TapNodeHash>);
 impl_try_from!(Box<[TapNodeHash]>);
 
-macro_rules! impl_try_from_array {
+macro_rules! impl_from_array {
     ($($len:expr),* $(,)?) => {
         $(
             impl From<[TapNodeHash; $len]> for TaprootMerkleBranchBuf {
@@ -142,7 +142,7 @@ macro_rules! impl_try_from_array {
 //
 // The reason zero is included is that `TaprootMerkleBranchBuf` 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!(
+impl_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,

From e744347022d1ad1e0ca0a83ec9350501af08297b Mon Sep 17 00:00:00 2001
From: Erick Cestari <erickcestari03@gmail.com>
Date: Fri, 21 Mar 2025 14:22:53 -0300
Subject: [PATCH 548/554] Make usage of Self and type uniform across both
 modules

This commit standardizes the function signatures in the Amount and SignedAmount
implementations by consistently using Self as the return type instead of the concrete
type names. This makes the code more consistent, easier to maintain, and follows Rust's
idiomatic practices.

Changes:

Replace all occurrences of -> Amount with -> Self in unsigned.rs
Replace all occurrences of -> SignedAmount with -> Self in signed.rs
Make similar replacements for Option/Result return types
Use Self:: instead of the explicit type name for static method calls
---
 units/src/amount/signed.rs   | 50 ++++++++++++++++++------------------
 units/src/amount/unsigned.rs | 44 +++++++++++++++----------------
 2 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/units/src/amount/signed.rs b/units/src/amount/signed.rs
index cc16fb8eef..7d8e194184 100644
--- a/units/src/amount/signed.rs
+++ b/units/src/amount/signed.rs
@@ -61,8 +61,8 @@ mod encapsulate {
         ///
         /// Accepts an `i32` which is guaranteed to be in range for the type, but which can only
         /// represent roughly -21.47 to 21.47 BTC.
-        pub const fn from_sat_i32(satoshi: i32) -> SignedAmount {
-            SignedAmount(satoshi as i64) // cannot use i64::from in a constfn
+        pub const fn from_sat_i32(satoshi: i32) -> Self {
+            Self(satoshi as i64) // cannot use i64::from in a constfn
         }
 
         /// Gets the number of satoshis in this [`SignedAmount`].
@@ -90,7 +90,7 @@ mod encapsulate {
         /// assert_eq!(amount.to_sat(), sat);
         /// # Ok::<_, amount::OutOfRangeError>(())
         /// ```
-        pub const fn from_sat(satoshi: i64) -> Result<SignedAmount, OutOfRangeError> {
+        pub const fn from_sat(satoshi: i64) -> Result<Self, OutOfRangeError> {
             if satoshi < Self::MIN.to_sat() {
                 Err(OutOfRangeError { is_signed: true, is_greater_than_max: false })
             } else if satoshi > Self::MAX_MONEY.to_sat() {
@@ -106,13 +106,13 @@ pub use encapsulate::SignedAmount;
 
 impl SignedAmount {
     /// The zero amount.
-    pub const ZERO: Self = SignedAmount::from_sat_i32(0);
+    pub const ZERO: Self = Self::from_sat_i32(0);
     /// Exactly one satoshi.
-    pub const ONE_SAT: Self = SignedAmount::from_sat_i32(1);
+    pub const ONE_SAT: Self = Self::from_sat_i32(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Self = SignedAmount::from_btc_i16(1);
+    pub const ONE_BTC: Self = Self::from_btc_i16(1);
     /// Exactly fifty bitcoin.
-    pub const FIFTY_BTC: Self = SignedAmount::from_btc_i16(50);
+    pub const FIFTY_BTC: Self = Self::from_btc_i16(50);
     /// The maximum value allowed as an amount. Useful for sanity checking.
     pub const MAX_MONEY: Self = Self::MAX;
 
@@ -133,24 +133,24 @@ impl SignedAmount {
     /// # Ok::<_, amount::ParseAmountError>(())
     /// ```
     #[cfg(feature = "alloc")]
-    pub fn from_btc(btc: f64) -> Result<SignedAmount, ParseAmountError> {
+    pub fn from_btc(btc: f64) -> Result<Self, ParseAmountError> {
         Self::from_float_in(btc, Denomination::Bitcoin)
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`].
     #[allow(clippy::missing_panics_doc)]
-    pub fn from_int_btc<T: Into<i16>>(whole_bitcoin: T) -> SignedAmount {
-        SignedAmount::from_btc_i16(whole_bitcoin.into())
+    pub fn from_int_btc<T: Into<i16>>(whole_bitcoin: T) -> Self {
+        Self::from_btc_i16(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to a [`SignedAmount`]
     /// in const context.
     #[allow(clippy::missing_panics_doc)]
-    pub const fn from_btc_i16(whole_bitcoin: i16) -> SignedAmount {
+    pub const fn from_btc_i16(whole_bitcoin: i16) -> Self {
         let btc = whole_bitcoin as i64; // Can't call `into` in const context.
         let sats = btc * 100_000_000;
 
-        match SignedAmount::from_sat(sats) {
+        match Self::from_sat(sats) {
             Ok(amount) => amount,
             Err(_) => panic!("unreachable - 65536 BTC is within range"),
         }
@@ -164,7 +164,7 @@ impl SignedAmount {
     /// # Errors
     ///
     /// If the amount is too big (positive or negative) or too precise.
-    pub fn from_str_in(s: &str, denom: Denomination) -> Result<SignedAmount, ParseAmountError> {
+    pub fn from_str_in(s: &str, denom: Denomination) -> Result<Self, ParseAmountError> {
         parse_signed_to_satoshi(s, denom)
             .map(|(_, amount)| amount)
             .map_err(|error| error.convert(true))
@@ -187,7 +187,7 @@ impl SignedAmount {
     /// assert_eq!(amount, SignedAmount::from_sat(10_000_000)?);
     /// # Ok::<_, amount::ParseError>(())
     /// ```
-    pub fn from_str_with_denomination(s: &str) -> Result<SignedAmount, ParseError> {
+    pub fn from_str_with_denomination(s: &str) -> Result<Self, ParseError> {
         let (amt, denom) = split_amount_and_denomination(s)?;
         Self::from_str_in(amt, denom).map_err(Into::into)
     }
@@ -236,7 +236,7 @@ impl SignedAmount {
     pub fn from_float_in(
         value: f64,
         denom: Denomination,
-    ) -> Result<SignedAmount, ParseAmountError> {
+    ) -> Result<Self, 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.
         Self::from_str_in(&value.to_string(), denom)
@@ -315,7 +315,7 @@ impl SignedAmount {
     ///
     /// This function never overflows or panics, unlike `i64::abs()`.
     #[must_use]
-    pub const fn abs(self) -> SignedAmount {
+    pub const fn abs(self) -> Self {
         // `i64::abs()` can never overflow because SignedAmount::MIN == -MAX_MONEY.
         match Self::from_sat(self.to_sat().abs()) {
             Ok(amount) => amount,
@@ -358,16 +358,16 @@ impl SignedAmount {
     #[must_use]
     #[deprecated(since = "TBD", note = "Never returns none, use `abs()` instead")]
     #[allow(clippy::unnecessary_wraps)] // To match stdlib function definition.
-    pub const fn checked_abs(self) -> Option<SignedAmount> { Some(self.abs()) }
+    pub const fn checked_abs(self) -> Option<Self> { Some(self.abs()) }
 
     /// Checked addition.
     ///
     /// Returns [`None`] if the sum is above [`SignedAmount::MAX`] or below [`SignedAmount::MIN`].
     #[must_use]
-    pub const fn checked_add(self, rhs: SignedAmount) -> Option<SignedAmount> {
+    pub const fn checked_add(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_add(rhs.to_sat()) {
-            Some(res) => match SignedAmount::from_sat(res) {
+            Some(res) => match Self::from_sat(res) {
                 Ok(amount) => Some(amount),
                 Err(_) => None,
             },
@@ -380,7 +380,7 @@ impl SignedAmount {
     /// Returns [`None`] if the difference is above [`SignedAmount::MAX`] or below
     /// [`SignedAmount::MIN`].
     #[must_use]
-    pub const fn checked_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
+    pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_sub(rhs.to_sat()) {
             Some(res) => match Self::from_sat(res) {
@@ -396,7 +396,7 @@ impl SignedAmount {
     /// Returns [`None`] if the product is above [`SignedAmount::MAX`] or below
     /// [`SignedAmount::MIN`].
     #[must_use]
-    pub const fn checked_mul(self, rhs: i64) -> Option<SignedAmount> {
+    pub const fn checked_mul(self, rhs: i64) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_mul(rhs) {
             Some(res) => match Self::from_sat(res) {
@@ -413,7 +413,7 @@ impl SignedAmount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[must_use]
-    pub const fn checked_div(self, rhs: i64) -> Option<SignedAmount> {
+    pub const fn checked_div(self, rhs: i64) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_div(rhs) {
             Some(res) => match Self::from_sat(res) {
@@ -428,7 +428,7 @@ impl SignedAmount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[must_use]
-    pub const fn checked_rem(self, rhs: i64) -> Option<SignedAmount> {
+    pub const fn checked_rem(self, rhs: i64) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_rem(rhs) {
             Some(res) => match Self::from_sat(res) {
@@ -443,7 +443,7 @@ impl SignedAmount {
     ///
     /// Returns [`None`] if either `self`, `rhs` or the result is strictly negative.
     #[must_use]
-    pub fn positive_sub(self, rhs: SignedAmount) -> Option<SignedAmount> {
+    pub fn positive_sub(self, rhs: Self) -> Option<Self> {
         if self.is_negative() || rhs.is_negative() || rhs > self {
             None
         } else {
@@ -469,7 +469,7 @@ impl SignedAmount {
 }
 
 impl default::Default for SignedAmount {
-    fn default() -> Self { SignedAmount::ZERO }
+    fn default() -> Self { Self::ZERO }
 }
 
 impl fmt::Debug for SignedAmount {
diff --git a/units/src/amount/unsigned.rs b/units/src/amount/unsigned.rs
index 1ff3637b64..20bb6f82b7 100644
--- a/units/src/amount/unsigned.rs
+++ b/units/src/amount/unsigned.rs
@@ -61,8 +61,8 @@ mod encapsulate {
         ///
         /// Accepts an `u32` which is guaranteed to be in range for the type, but which can only
         /// represent roughly 0 to 42.95 BTC.
-        pub const fn from_sat_u32(satoshi: u32) -> Amount {
-            Amount(satoshi as u64) // cannot use u64::from in a constfn
+        pub const fn from_sat_u32(satoshi: u32) -> Self {
+            Self(satoshi as u64) // cannot use u64::from in a constfn
         }
 
         /// Gets the number of satoshis in this [`Amount`].
@@ -90,7 +90,7 @@ mod encapsulate {
         /// assert_eq!(amount.to_sat(), sat);
         /// # Ok::<_, amount::OutOfRangeError>(())
         /// ```
-        pub const fn from_sat(satoshi: u64) -> Result<Amount, OutOfRangeError> {
+        pub const fn from_sat(satoshi: u64) -> Result<Self, OutOfRangeError> {
             if satoshi > Self::MAX_MONEY.to_sat() {
                 Err(OutOfRangeError { is_signed: false, is_greater_than_max: true })
             } else {
@@ -104,15 +104,15 @@ pub use encapsulate::Amount;
 
 impl Amount {
     /// The zero amount.
-    pub const ZERO: Self = Amount::from_sat_u32(0);
+    pub const ZERO: Self = Self::from_sat_u32(0);
     /// Exactly one satoshi.
-    pub const ONE_SAT: Self = Amount::from_sat_u32(1);
+    pub const ONE_SAT: Self = Self::from_sat_u32(1);
     /// Exactly one bitcoin.
-    pub const ONE_BTC: Self = Amount::from_btc_u16(1);
+    pub const ONE_BTC: Self = Self::from_btc_u16(1);
     /// Exactly fifty bitcoin.
-    pub const FIFTY_BTC: Self = Amount::from_btc_u16(50);
+    pub const FIFTY_BTC: Self = Self::from_btc_u16(50);
     /// The maximum value allowed as an amount. Useful for sanity checking.
-    pub const MAX_MONEY: Self = Amount::MAX;
+    pub const MAX_MONEY: Self = Self::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.
 
@@ -133,24 +133,24 @@ impl Amount {
     /// # Ok::<_, amount::ParseAmountError>(())
     /// ```
     #[cfg(feature = "alloc")]
-    pub fn from_btc(btc: f64) -> Result<Amount, ParseAmountError> {
+    pub fn from_btc(btc: f64) -> Result<Self, ParseAmountError> {
         Self::from_float_in(btc, Denomination::Bitcoin)
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`].
     #[allow(clippy::missing_panics_doc)]
-    pub fn from_int_btc<T: Into<u16>>(whole_bitcoin: T) -> Amount {
-        Amount::from_btc_u16(whole_bitcoin.into())
+    pub fn from_int_btc<T: Into<u16>>(whole_bitcoin: T) -> Self {
+        Self::from_btc_u16(whole_bitcoin.into())
     }
 
     /// Converts from a value expressing a whole number of bitcoin to an [`Amount`]
     /// in const context.
     #[allow(clippy::missing_panics_doc)]
-    pub const fn from_btc_u16(whole_bitcoin: u16) -> Amount {
+    pub const fn from_btc_u16(whole_bitcoin: u16) -> Self {
         let btc = whole_bitcoin as u64; // Can't call `into` in const context.
         let sats = btc * 100_000_000;
 
-        match Amount::from_sat(sats) {
+        match Self::from_sat(sats) {
             Ok(amount) => amount,
             Err(_) => panic!("unreachable - 65536 BTC is within range"),
         }
@@ -164,7 +164,7 @@ impl Amount {
     /// # Errors
     ///
     /// If the amount is too precise, negative, or greater than 21,000,000.
-    pub fn from_str_in(s: &str, denom: Denomination) -> Result<Amount, ParseAmountError> {
+    pub fn from_str_in(s: &str, denom: Denomination) -> Result<Self, ParseAmountError> {
         let (is_neg, amount) =
             parse_signed_to_satoshi(s, denom).map_err(|error| error.convert(false))?;
         if is_neg {
@@ -192,7 +192,7 @@ impl Amount {
     /// assert_eq!(amount, Amount::from_sat(10_000_000)?);
     /// # Ok::<_, amount::ParseError>(())
     /// ```
-    pub fn from_str_with_denomination(s: &str) -> Result<Amount, ParseError> {
+    pub fn from_str_with_denomination(s: &str) -> Result<Self, ParseError> {
         let (amt, denom) = split_amount_and_denomination(s)?;
         Self::from_str_in(amt, denom).map_err(Into::into)
     }
@@ -238,7 +238,7 @@ impl Amount {
     ///
     /// Please be aware of the risk of using floating-point numbers.
     #[cfg(feature = "alloc")]
-    pub fn from_float_in(value: f64, denom: Denomination) -> Result<Amount, ParseAmountError> {
+    pub fn from_float_in(value: f64, denom: Denomination) -> Result<Self, ParseAmountError> {
         if value < 0.0 {
             return Err(OutOfRangeError::negative().into());
         }
@@ -320,7 +320,7 @@ impl Amount {
     ///
     /// Returns [`None`] if the sum is larger than [`Amount::MAX`].
     #[must_use]
-    pub const fn checked_add(self, rhs: Amount) -> Option<Amount> {
+    pub const fn checked_add(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
         // Unchecked add ok, adding two values less than `MAX_MONEY` cannot overflow an `i64`.
         match Self::from_sat(self.to_sat() + rhs.to_sat()) {
@@ -333,7 +333,7 @@ impl Amount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[must_use]
-    pub const fn checked_sub(self, rhs: Amount) -> Option<Amount> {
+    pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_sub(rhs.to_sat()) {
             Some(res) => match Self::from_sat(res) {
@@ -348,7 +348,7 @@ impl Amount {
     ///
     /// Returns [`None`] if the product is larger than [`Amount::MAX`].
     #[must_use]
-    pub const fn checked_mul(self, rhs: u64) -> Option<Amount> {
+    pub const fn checked_mul(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_mul(rhs) {
             Some(res) => match Self::from_sat(res) {
@@ -365,7 +365,7 @@ impl Amount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[must_use]
-    pub const fn checked_div(self, rhs: u64) -> Option<Amount> {
+    pub const fn checked_div(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_div(rhs) {
             Some(res) => match Self::from_sat(res) {
@@ -380,7 +380,7 @@ impl Amount {
     ///
     /// Returns [`None`] if overflow occurred.
     #[must_use]
-    pub const fn checked_rem(self, rhs: u64) -> Option<Amount> {
+    pub const fn checked_rem(self, rhs: u64) -> Option<Self> {
         // No `map()` in const context.
         match self.to_sat().checked_rem(rhs) {
             Some(res) => match Self::from_sat(res) {
@@ -401,7 +401,7 @@ impl Amount {
 }
 
 impl default::Default for Amount {
-    fn default() -> Self { Amount::ZERO }
+    fn default() -> Self { Self::ZERO }
 }
 
 impl fmt::Debug for Amount {

From 1c13627cd8eef9b74e2e5636e82a0a41d2d59885 Mon Sep 17 00:00:00 2001
From: Update Nightly Rustc Bot <bot@example.com>
Date: Sat, 22 Mar 2025 01:45:43 +0000
Subject: [PATCH 549/554] Automated update to Github CI to rustc
 nightly-2025-03-21

---
 nightly-version | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nightly-version b/nightly-version
index 79656d4c37..ba747383dc 100644
--- a/nightly-version
+++ b/nightly-version
@@ -1 +1 @@
-nightly-2025-03-14
+nightly-2025-03-21

From d0bead6f94531b993af7d66eb9c1ffc87f391fe7 Mon Sep 17 00:00:00 2001
From: jike <jike2021@proton.me>
Date: Sun, 23 Mar 2025 11:41:07 +0000
Subject: [PATCH 550/554] docs: fix LICENCE link

---
 base58/README.md     | 2 +-
 primitives/README.md | 2 +-
 units/README.md      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/base58/README.md b/base58/README.md
index f28534d5a6..4b530e94ed 100644
--- a/base58/README.md
+++ b/base58/README.md
@@ -26,5 +26,5 @@ This library should always compile with any combination of features on **Rust 1.
 
 ## Licensing
 
-The code in this project is licensed under the [Creative Commons CC0 1.0 Universal license](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/primitives/README.md b/primitives/README.md
index 6eaae88684..f6c32ef68c 100644
--- a/primitives/README.md
+++ b/primitives/README.md
@@ -14,5 +14,5 @@ This library should always compile with any combination of features on **Rust 1.
 
 ## Licensing
 
-The code in this project is licensed under the [Creative Commons CC0 1.0 Universal license](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/units/README.md b/units/README.md
index 7530c96eda..aed33e6fc4 100644
--- a/units/README.md
+++ b/units/README.md
@@ -8,5 +8,5 @@ This library should always compile with any combination of features on **Rust 1.
 
 ## Licensing
 
-The code in this project is licensed under the [Creative Commons CC0 1.0 Universal license](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/).

From 587a66da4760424ef20676c46251488cd84d350e Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sun, 23 Mar 2025 18:44:28 +0100
Subject: [PATCH 551/554] Add a bunch of missing conversions for `Witness`

`Witness` was missing conversions from arrays (and variations) which was
annoying when creating known-sized witnesses. These come up when
spending statically-known inputs and in tests.
---
 primitives/src/witness.rs | 40 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index 101c37caab..b2242932a2 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -410,6 +410,46 @@ impl From<Vec<&[u8]>> for Witness {
     fn from(vec: Vec<&[u8]>) -> Self { Witness::from_slice(&vec) }
 }
 
+impl<const N: usize> From<[&[u8]; N]> for Witness {
+    #[inline]
+    fn from(arr: [&[u8]; N]) -> Self { Witness::from_slice(&arr) }
+}
+
+impl<const N: usize> From<&[&[u8]; N]> for Witness {
+    #[inline]
+    fn from(arr: &[&[u8]; N]) -> Self { Witness::from_slice(arr) }
+}
+
+impl<const N: usize> From<&[[u8; N]]> for Witness {
+    #[inline]
+    fn from(slice: &[[u8; N]]) -> Self { Witness::from_slice(slice) }
+}
+
+impl<const N: usize> From<&[&[u8; N]]> for Witness {
+    #[inline]
+    fn from(slice: &[&[u8; N]]) -> Self { Witness::from_slice(slice) }
+}
+
+impl<const N: usize, const M: usize> From<[[u8; M]; N]> for Witness {
+    #[inline]
+    fn from(slice: [[u8; M]; N]) -> Self { Witness::from_slice(&slice) }
+}
+
+impl<const N: usize, const M: usize> From<&[[u8; M]; N]> for Witness {
+    #[inline]
+    fn from(slice: &[[u8; M]; N]) -> Self { Witness::from_slice(slice) }
+}
+
+impl<const N: usize, const M: usize> From<[&[u8; M]; N]> for Witness {
+    #[inline]
+    fn from(slice: [&[u8; M]; N]) -> Self { Witness::from_slice(&slice) }
+}
+
+impl<const N: usize, const M: usize> From<&[&[u8; M]; N]> for Witness {
+    #[inline]
+    fn from(slice: &[&[u8; M]; N]) -> Self { Witness::from_slice(slice) }
+}
+
 impl Default for Witness {
     #[inline]
     fn default() -> Self { Self::new() }

From c8078360d24d2e1de85a31a2e97a7a4fe96c7912 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sun, 23 Mar 2025 18:46:35 +0100
Subject: [PATCH 552/554] Impl `PartialEq` between `Witness` and containers

Since `Witness` is semantically equivalent to `&[&[u8]]` they should
also be comparable. However we only had the impl to compare `Witness`
with itself. Being able to compare `Witness` with other containers is
particularly needed in tests.
---
 primitives/src/witness.rs | 126 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 125 insertions(+), 1 deletion(-)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index b2242932a2..f054562624 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -14,7 +14,7 @@ use internals::compact_size;
 use internals::wrap_debug::WrapDebug;
 use internals::slice::SliceExt;
 
-use crate::prelude::Vec;
+use crate::prelude::{Box, Vec};
 
 /// The Witness is the data used to unlock bitcoin since the [SegWit upgrade].
 ///
@@ -238,6 +238,109 @@ fn decode_cursor(bytes: &[u8], start_of_indices: usize, index: usize) -> Option<
     bytes.get_array::<4>(start).map(|index_bytes| u32::from_ne_bytes(*index_bytes) as usize)
 }
 
+// Note: we use `Borrow` in the following `PartialEq` impls specifically because of its additional
+// constraints on equality semantics.
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<[T]> for Witness {
+    fn eq(&self, rhs: &[T]) -> bool {
+        if self.len() != rhs.len() {
+            return false;
+        }
+        self.iter().zip(rhs).all(|(left, right)| left == right.borrow())
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<&[T]> for Witness {
+    fn eq(&self, rhs: &&[T]) -> bool {
+        *self == **rhs
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for [T] {
+    fn eq(&self, rhs: &Witness) -> bool {
+        *rhs == *self
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for &[T] {
+    fn eq(&self, rhs: &Witness) -> bool {
+        *rhs == **self
+    }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<[T; N]> for Witness {
+    fn eq(&self, rhs: &[T; N]) -> bool {
+        *self == *rhs.as_slice()
+    }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<&[T; N]> for Witness {
+    fn eq(&self, rhs: &&[T; N]) -> bool {
+        *self == *rhs.as_slice()
+    }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for [T; N] {
+    fn eq(&self, rhs: &Witness) -> bool {
+        *rhs == *self
+    }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for &[T; N] {
+    fn eq(&self, rhs: &Witness) -> bool {
+        *rhs == **self
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Vec<T>> for Witness {
+    fn eq(&self, rhs: &Vec<T>) -> bool {
+        *self == **rhs
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for Vec<T> {
+    fn eq(&self, rhs: &Witness) -> bool {
+        *rhs == *self
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Box<[T]>> for Witness {
+    fn eq(&self, rhs: &Box<[T]>) -> bool {
+        *self == **rhs
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for Box<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool {
+        *rhs == *self
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<alloc::rc::Rc<[T]>> for Witness {
+    fn eq(&self, rhs: &alloc::rc::Rc<[T]>) -> bool {
+        *self == **rhs
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for alloc::rc::Rc<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool {
+        *rhs == *self
+    }
+}
+
+#[cfg(target_has_atomic = "ptr")]
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<alloc::sync::Arc<[T]>> for Witness {
+    fn eq(&self, rhs: &alloc::sync::Arc<[T]>) -> bool {
+        *self == **rhs
+    }
+}
+
+#[cfg(target_has_atomic = "ptr")]
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for alloc::sync::Arc<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool {
+        *rhs == *self
+    }
+}
+
 /// Debug implementation that displays the witness as a structured output containing:
 /// - Number of witness elements
 /// - Total bytes across all elements
@@ -643,6 +746,27 @@ mod test {
         assert!(expected.is_empty());
     }
 
+    #[test]
+    fn partial_eq() {
+        const EMPTY_BYTES: &[u8] = &[];
+        assert_eq!(Vec::<&[u8]>::new(), Witness::new());
+        macro_rules! ck {
+            ($container:expr) => {
+                {
+                    let container = $container;
+                    let witness = Witness::from(Clone::clone(&container));
+                    assert_eq!(witness, container, stringify!($container));
+                }
+            }
+        }
+        ck!([EMPTY_BYTES]);
+        ck!([EMPTY_BYTES, EMPTY_BYTES]);
+        ck!([[42]]);
+        ck!([[42, 21]]);
+        ck!([&[42], EMPTY_BYTES]);
+        ck!([[42u8], [21]]);
+    }
+
     #[test]
     #[cfg(feature = "serde")]
     fn serde_bincode_backward_compatibility() {

From 3551ec2c698fe682da972e727da63cf1d574818f Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sun, 23 Mar 2025 19:26:39 +0100
Subject: [PATCH 553/554] Don't access internalls of `Witness` in tests

Accessing the internals of tested object is problematic because it makes
changes to layout harder, it makes tests harder to read and it checks
implementation details rather than semantics of the API (behvaior).

We had such tests in `primitives::witness` so this changes them to use
the newly added APIs instead. However, it still leaves
`from_parts__unstable` which needs to be dealt with separately.
---
 primitives/src/witness.rs | 30 ++++--------------------------
 1 file changed, 4 insertions(+), 26 deletions(-)

diff --git a/primitives/src/witness.rs b/primitives/src/witness.rs
index f054562624..880781e9c4 100644
--- a/primitives/src/witness.rs
+++ b/primitives/src/witness.rs
@@ -581,11 +581,7 @@ mod test {
 
     // A witness with a single element that is empty (zero length).
     fn single_empty_element() -> Witness {
-        // The first is 0 serialized as a compact size integer.
-        // The last four bytes represent start at index 0.
-        let content = [0_u8; 5];
-
-        Witness { witness_elements: 1, content: content.to_vec(), indices_start: 1 }
+        Witness::from([[0u8; 0]])
     }
 
     #[test]
@@ -620,13 +616,7 @@ mod test {
         witness.push(push);
         assert!(!witness.is_empty());
 
-        let elements = [1u8, 11];
-        let expected = Witness {
-            witness_elements: 1,
-            content: append_u32_vec(&elements, &[0]), // Start at index 0.
-            indices_start: elements.len(),
-        };
-        assert_eq!(witness, expected);
+        assert_eq!(witness, [[11_u8]]);
 
         let element_0 = push.as_slice();
         assert_eq!(element_0, &witness[0]);
@@ -643,13 +633,7 @@ mod test {
         let push = [21u8, 22u8];
         witness.push(push);
 
-        let elements = [1u8, 11, 2, 21, 22];
-        let expected = Witness {
-            witness_elements: 2,
-            content: append_u32_vec(&elements, &[0, 2]),
-            indices_start: elements.len(),
-        };
-        assert_eq!(witness, expected);
+        assert_eq!(witness, [&[11_u8] as &[_], &[21, 22]]);
 
         let element_1 = push.as_slice();
         assert_eq!(element_1, &witness[1]);
@@ -666,13 +650,7 @@ mod test {
         let push = [31u8, 32u8];
         witness.push(push);
 
-        let elements = [1u8, 11, 2, 21, 22, 2, 31, 32];
-        let expected = Witness {
-            witness_elements: 3,
-            content: append_u32_vec(&elements, &[0, 2, 5]),
-            indices_start: elements.len(),
-        };
-        assert_eq!(witness, expected);
+        assert_eq!(witness, [&[11_u8] as &[_], &[21, 22], &[31, 32]]);
 
         let element_2 = push.as_slice();
         assert_eq!(element_2, &witness[2]);

From 84bee2f7b06a7bd1f435aaad18fa76a15188326e Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Sun, 23 Mar 2025 21:00:47 +0100
Subject: [PATCH 554/554] Simplify `Witness` construction in tests

The `Witness`-related tests were constructing `Witness` in
over-complicated way by serializing `Vec<Vec<u8>>` and then
deserializing `Witness` even though they were not supposed to test
serialization but Taproot accessor methods. This was difficult to
understand and maintain.

This change simplifies them to just construct the `Witness` from array
of `Vec<u8>`s using the recently-added constructors. Note that we
already have serialization tests written separately so we're not losing
meaningful coverage here.
---
 bitcoin/src/blockdata/witness.rs | 65 +++++++-------------------------
 1 file changed, 13 insertions(+), 52 deletions(-)

diff --git a/bitcoin/src/blockdata/witness.rs b/bitcoin/src/blockdata/witness.rs
index fd57da387d..f8e8abe5ba 100644
--- a/bitcoin/src/blockdata/witness.rs
+++ b/bitcoin/src/blockdata/witness.rs
@@ -387,14 +387,8 @@ mod test {
         // 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 = deserialize::<Witness>(&witness_serialized[..]).unwrap();
-        let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
+        let witness = Witness::from([&*tapscript, &control_block]);
+        let witness_annex = Witness::from([&*tapscript, &control_block, &annex]);
 
         // With or without annex, the tapscript should be returned.
         assert_eq!(witness.tapscript(), Some(Script::from_bytes(&tapscript[..])));
@@ -409,14 +403,8 @@ mod test {
         // 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 = deserialize::<Witness>(&witness_serialized[..]).unwrap();
-        let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
+        let witness = Witness::from([&*tapscript, &control_block]);
+        let witness_annex = Witness::from([&*tapscript, &control_block, &annex]);
 
         let expected_leaf_script =
             LeafScript { version: LeafVersion::TapScript, script: Script::from_bytes(&tapscript) };
@@ -432,14 +420,8 @@ mod test {
         // annex starting with 0x50 causes the branching logic.
         let annex = hex!("50");
 
-        let witness_vec = vec![signature.clone()];
-        let witness_vec_annex = vec![signature.clone(), annex];
-
-        let witness_serialized: Vec<u8> = serialize(&witness_vec);
-        let witness_serialized_annex: Vec<u8> = serialize(&witness_vec_annex);
-
-        let witness = deserialize::<Witness>(&witness_serialized[..]).unwrap();
-        let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
+        let witness = Witness::from([&*signature]);
+        let witness_annex = Witness::from([&*signature, &annex]);
 
         // With or without annex, no tapscript should be returned.
         assert_eq!(witness.tapscript(), None);
@@ -454,18 +436,9 @@ mod test {
         let annex = hex!("50");
         let signature = vec![0xff; 64];
 
-        let witness_vec = vec![tapscript.clone(), control_block.clone()];
-        let witness_vec_annex = vec![tapscript.clone(), control_block.clone(), annex.clone()];
-        let witness_vec_key_spend_annex = vec![signature, annex];
-
-        let witness_serialized: Vec<u8> = serialize(&witness_vec);
-        let witness_serialized_annex: Vec<u8> = serialize(&witness_vec_annex);
-        let witness_serialized_key_spend_annex: Vec<u8> = serialize(&witness_vec_key_spend_annex);
-
-        let witness = deserialize::<Witness>(&witness_serialized[..]).unwrap();
-        let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
-        let witness_key_spend_annex =
-            deserialize::<Witness>(&witness_serialized_key_spend_annex[..]).unwrap();
+        let witness = Witness::from([&*tapscript, &control_block]);
+        let witness_annex = Witness::from([&*tapscript, &control_block, &annex]);
+        let witness_key_spend_annex = Witness::from([&*signature, &annex]);
 
         // With or without annex, the tapscript should be returned.
         assert_eq!(witness.taproot_control_block(), Some(&control_block[..]));
@@ -480,14 +453,8 @@ mod test {
         // 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.clone(), annex.clone()];
-
-        let witness_serialized: Vec<u8> = serialize(&witness_vec);
-        let witness_serialized_annex: Vec<u8> = serialize(&witness_vec_annex);
-
-        let witness = deserialize::<Witness>(&witness_serialized[..]).unwrap();
-        let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
+        let witness = Witness::from([&*tapscript, &control_block]);
+        let witness_annex = Witness::from([&*tapscript, &control_block, &annex]);
 
         // With or without annex, the tapscript should be returned.
         assert_eq!(witness.taproot_annex(), None);
@@ -498,14 +465,8 @@ mod test {
         // annex starting with 0x50 causes the branching logic.
         let annex = hex!("50");
 
-        let witness_vec = vec![signature.clone()];
-        let witness_vec_annex = vec![signature.clone(), annex.clone()];
-
-        let witness_serialized: Vec<u8> = serialize(&witness_vec);
-        let witness_serialized_annex: Vec<u8> = serialize(&witness_vec_annex);
-
-        let witness = deserialize::<Witness>(&witness_serialized[..]).unwrap();
-        let witness_annex = deserialize::<Witness>(&witness_serialized_annex[..]).unwrap();
+        let witness = Witness::from([&*signature]);
+        let witness_annex = Witness::from([&*signature, &annex]);
 
         // With or without annex, the tapscript should be returned.
         assert_eq!(witness.taproot_annex(), None);