From d7e742118cc654438089614988de95252273bba4 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Thu, 22 May 2025 21:02:18 +0000
Subject: [PATCH 1/8] add dependency on bitcoin-units

---
 Cargo.toml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index f6b8444a..de598a72 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,7 +15,7 @@ default = ["json-contract"]
 json-contract = ["serde_json"]
 "serde" = [
     "bitcoin/serde",
-    "bitcoin/serde",
+    "bitcoin-units/serde",
     "secp256k1-zkp/serde",
     "actual-serde",
 ]
@@ -24,6 +24,7 @@ base64 = ["bitcoin/base64"]
 [dependencies]
 bech32 = "0.11.0"
 bitcoin = "0.32.2"
+bitcoin-units = { version = "1.0.0-rc.0", default-features = false, features = [ "std" ] }
 secp256k1-zkp = { version = "0.11.0", features = ["global-context", "hashes"] }
 
 # Used for ContractHash::from_json_contract.

From 186515fe367197a1c51022854d48c9141bcfb846 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Thu, 26 Jun 2025 02:14:28 +0000
Subject: [PATCH 2/8] serde: replace `actual_serde` with `dep:serde`

We don't need to rename packages anymore to have an optional dependency
that also triggers other depenedncies when enabled.
---
 Cargo.toml             |  6 ++----
 src/blind.rs           |  6 +-----
 src/lib.rs             |  3 +--
 src/locktime.rs        |  9 +++------
 src/pset/map/global.rs |  4 ++--
 src/pset/map/input.rs  |  2 +-
 src/pset/map/output.rs |  4 ++--
 src/pset/mod.rs        |  2 +-
 src/pset/raw.rs        | 18 +++---------------
 src/schnorr.rs         |  2 +-
 src/serde_utils.rs     |  6 ++----
 src/taproot.rs         | 13 ++++++-------
 src/transaction.rs     |  3 +--
 13 files changed, 26 insertions(+), 52 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index de598a72..2b3b32a1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,7 @@ json-contract = ["serde_json"]
     "bitcoin/serde",
     "bitcoin-units/serde",
     "secp256k1-zkp/serde",
-    "actual-serde",
+    "dep:serde",
 ]
 base64 = ["bitcoin/base64"]
 
@@ -30,9 +30,7 @@ secp256k1-zkp = { version = "0.11.0", features = ["global-context", "hashes"] }
 # Used for ContractHash::from_json_contract.
 serde_json = { version = "1.0", optional = true }
 
-actual-serde = { package = "serde", version = "1.0.103", features = [
-    "derive",
-], optional = true }
+serde = { version = "1.0.103", features = ["derive"], optional = true }
 
 
 [target.wasm32-unknown-unknown.dev-dependencies]
diff --git a/src/blind.rs b/src/blind.rs
index 340e62c5..c293d05a 100644
--- a/src/blind.rs
+++ b/src/blind.rs
@@ -229,11 +229,7 @@ impl RangeProofMessage {
 }
 
 /// Information about Transaction Input Asset
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "actual_serde")
-)]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 pub struct TxOutSecrets {
     /// Asset
diff --git a/src/lib.rs b/src/lib.rs
index b54fc1f5..6aa2da4c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -32,8 +32,7 @@ pub extern crate bitcoin;
 pub extern crate secp256k1_zkp;
 /// Re-export of serde crate
 #[cfg(feature = "serde")]
-#[macro_use]
-pub extern crate actual_serde as serde;
+pub extern crate serde;
 #[cfg(all(test, feature = "serde"))]
 extern crate serde_test;
 
diff --git a/src/locktime.rs b/src/locktime.rs
index e93f10b6..79c79c3e 100644
--- a/src/locktime.rs
+++ b/src/locktime.rs
@@ -66,8 +66,7 @@ pub const LOCK_TIME_THRESHOLD: u32 = 500_000_000;
 /// ```
 #[allow(clippy::derive_ord_xor_partial_ord)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub enum LockTime {
     /// A block height lock time value.
     ///
@@ -293,8 +292,7 @@ impl Decodable for LockTime {
 
 /// An absolute block height, guaranteed to always contain a valid height value.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Height(u32);
 
 impl Height {
@@ -379,8 +377,7 @@ impl TryFrom<String> for Height {
 /// `to_consensus_u32()`. Said another way, `Time(x)` means 'x seconds since epoch' _not_ '(x -
 /// threshold) seconds since epoch'.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Time(u32);
 
 impl Time {
diff --git a/src/pset/map/global.rs b/src/pset/map/global.rs
index 4f9b0e24..70d2cafb 100644
--- a/src/pset/map/global.rs
+++ b/src/pset/map/global.rs
@@ -58,7 +58,7 @@ const PSBT_ELEMENTS_GLOBAL_TX_MODIFIABLE: u8 = 0x01;
 
 /// Global transaction data
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct TxData {
     /// Transaction version. Must be 2.
     pub version: u32,
@@ -93,7 +93,7 @@ impl Default for TxData {
 
 /// A key-value map for global data.
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Global {
     /// Global transaction data
     #[cfg_attr(feature = "serde", serde(flatten))]
diff --git a/src/pset/map/input.rs b/src/pset/map/input.rs
index 72702525..f28dcf50 100644
--- a/src/pset/map/input.rs
+++ b/src/pset/map/input.rs
@@ -171,7 +171,7 @@ const PSBT_ELEMENTS_IN_BLINDED_ISSUANCE: u8 = 0x15;
 /// A key-value map for an input of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Input {
     /// The non-witness transaction this input spends from. Should only be
     /// [`std::option::Option::Some`] for inputs which spend non-segwit outputs or
diff --git a/src/pset/map/output.rs b/src/pset/map/output.rs
index d86d3389..2eb7e027 100644
--- a/src/pset/map/output.rs
+++ b/src/pset/map/output.rs
@@ -87,7 +87,7 @@ const PSBT_ELEMENTS_OUT_BLIND_ASSET_PROOF: u8 = 0x0a;
 /// A key-value map for an output of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Default, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Output {
     /// The redeem script for this output.
     pub redeem_script: Option<Script>,
@@ -146,7 +146,7 @@ pub struct Output {
 
 /// Taproot Tree representing a finalized [`TaprootBuilder`] (a complete binary tree)
 #[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct TapTree(pub(crate) TaprootBuilder);
 
 impl PartialEq for TapTree {
diff --git a/src/pset/mod.rs b/src/pset/mod.rs
index 532826ec..3c738e03 100644
--- a/src/pset/mod.rs
+++ b/src/pset/mod.rs
@@ -56,7 +56,7 @@ pub use self::map::{Global, GlobalTxData, Input, Output, PsbtSighashType, TapTre
 
 /// A Partially Signed Transaction.
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct PartiallySignedTransaction {
     /// The key-value pairs for all global data.
     pub global: Global,
diff --git a/src/pset/raw.rs b/src/pset/raw.rs
index 66a4b9a2..d058e0f9 100644
--- a/src/pset/raw.rs
+++ b/src/pset/raw.rs
@@ -24,11 +24,7 @@ use crate::encode::{self, deserialize, serialize, Decodable, Encodable, VarInt,
 use crate::hex;
 /// A PSET key in its raw byte form.
 #[derive(Debug, PartialEq, Hash, Eq, Clone, Ord, PartialOrd)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "actual_serde")
-)]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Key {
     /// The type of this PSET key.
     pub type_value: u8,
@@ -51,11 +47,7 @@ impl Key {
 
 /// A PSET key-value pair in its raw byte form.
 #[derive(Debug, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "actual_serde")
-)]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Pair {
     /// The key of this key-value pair.
     pub key: Key,
@@ -69,11 +61,7 @@ pub type ProprietaryType = u8;
 
 /// Proprietary keys (i.e. keys starting with 0xFC byte) with their internal
 /// structure according to BIP 174.
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "actual_serde")
-)]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct ProprietaryKey<Subtype = ProprietaryType>
 where
diff --git a/src/schnorr.rs b/src/schnorr.rs
index 5cd4526e..476eebea 100644
--- a/src/schnorr.rs
+++ b/src/schnorr.rs
@@ -205,7 +205,7 @@ impl From<TweakedKeypair> for TweakedPublicKey {
 
 /// A BIP340-341 serialized schnorr signature with the corresponding hash type.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct SchnorrSig {
     /// The underlying schnorr signature
     pub sig: secp256k1_zkp::schnorr::Signature,
diff --git a/src/serde_utils.rs b/src/serde_utils.rs
index 0c9dd806..4f91f2d7 100644
--- a/src/serde_utils.rs
+++ b/src/serde_utils.rs
@@ -146,8 +146,7 @@ pub mod btreemap_as_seq_byte_values {
     use serde;
 
     /// A custom key-value pair type that serialized the bytes as hex.
-    #[derive(Debug, Deserialize)]
-    #[serde(crate = "actual_serde")]
+    #[derive(Debug, serde::Deserialize)]
     struct OwnedPair<T>(
         T,
         #[serde(deserialize_with = "crate::serde_utils::hex_bytes::deserialize")]
@@ -155,8 +154,7 @@ pub mod btreemap_as_seq_byte_values {
     );
 
     /// A custom key-value pair type that serialized the bytes as hex.
-    #[derive(Debug, Serialize)]
-    #[serde(crate = "actual_serde")]
+    #[derive(Debug, serde::Serialize)]
     struct BorrowedPair<'a, T: 'static>(
         &'a T,
         #[serde(serialize_with = "crate::serde_utils::hex_bytes::serialize")]
diff --git a/src/taproot.rs b/src/taproot.rs
index 7f5940e3..3a648f46 100644
--- a/src/taproot.rs
+++ b/src/taproot.rs
@@ -294,7 +294,7 @@ impl TaprootSpendInfo {
 /// branches in a DFS(Depth first search) walk to construct this tree.
 // Similar to Taproot Builder in bitcoin core
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct TaprootBuilder {
     // The following doc-comment is from bitcoin core, but modified for rust
     // The comment below describes the current state of the builder for a given tree.
@@ -444,7 +444,7 @@ impl TaprootBuilder {
 
 /// Structure to represent the node information in taproot tree
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct NodeInfo {
     /// Merkle Hash for this node
     pub(crate) hash: sha256::Hash,
@@ -498,7 +498,7 @@ impl NodeInfo {
 
 /// Data Structure to store information about taproot leaf node
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct LeafInfo {
     // The underlying script
     pub(crate) script: Script,
@@ -529,8 +529,7 @@ impl LeafInfo {
 // The type of hash is sha256::Hash because the vector might contain
 // both TapNodeHash and TapLeafHash
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct TaprootMerkleBranch(Vec<sha256::Hash>);
 
 impl TaprootMerkleBranch {
@@ -602,7 +601,7 @@ impl TaprootMerkleBranch {
 
 /// Control Block data structure used in Tapscript satisfaction
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct ControlBlock {
     /// The tapleaf version,
     pub leaf_version: LeafVersion,
@@ -711,7 +710,7 @@ impl ControlBlock {
 
 /// The leaf version for tapleafs
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct LeafVersion(u8);
 
 impl Default for LeafVersion {
diff --git a/src/transaction.rs b/src/transaction.rs
index ae012df8..a94bd756 100644
--- a/src/transaction.rs
+++ b/src/transaction.rs
@@ -171,8 +171,7 @@ impl ::std::str::FromStr for OutPoint {
 /// [BIP-68]: <https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki>
 /// [BIP-125]: <https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki>
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Sequence(pub u32);
 
 #[derive(Clone, PartialEq, Eq, Debug)]

From 30039636f782df86ecc68fb0c1560e694d94c7e5 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Thu, 26 Jun 2025 02:59:09 +0000
Subject: [PATCH 3/8] locktime: replace serde impl with u32-based one

This completely changes the serde format for `LockTime`, which in turn
changes the format for `Transaction`. This will break e.g. hal-elements.
However, the existing format is kinda ridiculous and I don't believe it
is used anywhere.

Alarmingly this change does not break a single test. We should add some
regression tests.
---
 src/locktime.rs | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/locktime.rs b/src/locktime.rs
index 79c79c3e..f9db4b42 100644
--- a/src/locktime.rs
+++ b/src/locktime.rs
@@ -66,7 +66,6 @@ pub const LOCK_TIME_THRESHOLD: u32 = 500_000_000;
 /// ```
 #[allow(clippy::derive_ord_xor_partial_ord)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub enum LockTime {
     /// A block height lock time value.
     ///
@@ -275,6 +274,24 @@ impl fmt::Display for LockTime {
     }
 }
 
+#[cfg(feature = "serde")]
+impl serde::Serialize for LockTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer {
+        self.to_consensus_u32().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for LockTime {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: serde::Deserializer<'de> {
+        u32::deserialize(deserializer).map(Self::from_consensus)
+    }
+}
+
 impl Encodable for LockTime {
     #[inline]
     fn consensus_encode<W: Write>(&self, w: W) -> Result<usize, encode::Error> {

From bb4e4ec2d4723dcf2c26542490fb66d32f0e9273 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Sat, 28 Jun 2025 22:35:00 +0000
Subject: [PATCH 4/8] pset: replace ad-hoc serde implementation with base64
 string

There is a standard serialization of PSETs (and PSBTs, and PSBT2s): the
base64 of the byte encoding. Rather than making up our own serialization
based on the details of our rust-elements types, which makes basically
every structural property of our types a property of our API, just use
the standard encoding.

This is a major breaking change; we may need a compatibility layer based
on rust-elements 0.25.
---
 src/lib.rs             |   2 -
 src/pset/map/global.rs |  11 --
 src/pset/map/input.rs  |  35 ------
 src/pset/map/output.rs |  12 --
 src/pset/mod.rs        |  21 +++-
 src/pset/raw.rs        |   7 --
 src/serde_utils.rs     | 274 -----------------------------------------
 7 files changed, 20 insertions(+), 342 deletions(-)
 delete mode 100644 src/serde_utils.rs

diff --git a/src/lib.rs b/src/lib.rs
index 6aa2da4c..f99a703f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -64,8 +64,6 @@ mod parse;
 pub mod pset;
 pub mod schnorr;
 pub mod script;
-#[cfg(feature = "serde")]
-mod serde_utils;
 pub mod sighash;
 pub mod taproot;
 mod transaction;
diff --git a/src/pset/map/global.rs b/src/pset/map/global.rs
index 70d2cafb..24b94d56 100644
--- a/src/pset/map/global.rs
+++ b/src/pset/map/global.rs
@@ -58,7 +58,6 @@ const PSBT_ELEMENTS_GLOBAL_TX_MODIFIABLE: u8 = 0x01;
 
 /// Global transaction data
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct TxData {
     /// Transaction version. Must be 2.
     pub version: u32,
@@ -93,10 +92,8 @@ impl Default for TxData {
 
 /// A key-value map for global data.
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Global {
     /// Global transaction data
-    #[cfg_attr(feature = "serde", serde(flatten))]
     pub tx_data: TxData,
     /// The version number of this PSET. Must be present.
     pub version: u32,
@@ -109,16 +106,8 @@ pub struct Global {
     /// Elements tx modifiable flag
     pub elements_tx_modifiable_flag: Option<u8>,
     /// Other Proprietary fields
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_as_seq_byte_values")
-    )]
     pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
     /// Unknown global key-value pairs.
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_as_seq_byte_values")
-    )]
     pub unknown: BTreeMap<raw::Key, Vec<u8>>,
 }
 
diff --git a/src/pset/map/input.rs b/src/pset/map/input.rs
index f28dcf50..e3324718 100644
--- a/src/pset/map/input.rs
+++ b/src/pset/map/input.rs
@@ -171,7 +171,6 @@ const PSBT_ELEMENTS_IN_BLINDED_ISSUANCE: u8 = 0x15;
 /// A key-value map for an input of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Input {
     /// The non-witness transaction this input spends from. Should only be
     /// [`std::option::Option::Some`] for inputs which spend non-segwit outputs or
@@ -183,10 +182,6 @@ pub struct Input {
     pub witness_utxo: Option<TxOut>,
     /// A map from public keys to their corresponding signature as would be
     /// pushed to the stack from a scriptSig or witness.
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub partial_sigs: BTreeMap<PublicKey, Vec<u8>>,
     /// The sighash type to be used for this input. Signatures for this input
     /// must use the sighash type.
@@ -197,7 +192,6 @@ pub struct Input {
     pub witness_script: Option<Script>,
     /// A map from public keys needed to sign this input to their corresponding
     /// master key fingerprints and derivation paths.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub bip32_derivation: BTreeMap<PublicKey, KeySource>,
     /// The finalized, fully-constructed scriptSig with signatures and any other
     /// scripts necessary for this input to pass validation.
@@ -207,28 +201,12 @@ pub struct Input {
     pub final_script_witness: Option<Vec<Vec<u8>>>,
     /// TODO: Proof of reserves commitment
     /// RIPEMD160 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub ripemd160_preimages: BTreeMap<ripemd160::Hash, Vec<u8>>,
     /// SHA256 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub sha256_preimages: BTreeMap<sha256::Hash, Vec<u8>>,
     /// HSAH160 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub hash160_preimages: BTreeMap<hash160::Hash, Vec<u8>>,
     /// HAS256 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub hash256_preimages: BTreeMap<sha256d::Hash, Vec<u8>>,
     /// (PSET) Prevout TXID of the input
     pub previous_txid: Txid,
@@ -243,13 +221,10 @@ pub struct Input {
     /// Serialized schnorr signature with sighash type for key spend
     pub tap_key_sig: Option<schnorr::SchnorrSig>,
     /// Map of `<xonlypubkey>|<leafhash>` with signature
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub tap_script_sigs: BTreeMap<(XOnlyPublicKey, TapLeafHash), schnorr::SchnorrSig>,
     /// Map of Control blocks to Script version pair
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub tap_scripts: BTreeMap<ControlBlock, (Script, LeafVersion)>,
     /// Map of tap root x only keys to origin info and leaf hashes contained in it
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
     /// Taproot Internal key
     pub tap_internal_key: Option<XOnlyPublicKey>,
@@ -302,16 +277,8 @@ pub struct Input {
     /// Whether the issuance is blinded
     pub blinded_issuance: Option<u8>,
     /// Other fields
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_as_seq_byte_values")
-    )]
     pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
     /// Unknown key-value pairs for this input.
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_as_seq_byte_values")
-    )]
     pub unknown: BTreeMap<raw::Key, Vec<u8>>,
 }
 
@@ -381,8 +348,6 @@ pub struct PsbtSighashType {
     pub(crate) inner: u32,
 }
 
-serde_string_impl!(PsbtSighashType, "a PsbtSighashType data");
-
 impl fmt::Display for PsbtSighashType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.schnorr_hash_ty() {
diff --git a/src/pset/map/output.rs b/src/pset/map/output.rs
index 2eb7e027..547c2175 100644
--- a/src/pset/map/output.rs
+++ b/src/pset/map/output.rs
@@ -87,7 +87,6 @@ const PSBT_ELEMENTS_OUT_BLIND_ASSET_PROOF: u8 = 0x0a;
 /// A key-value map for an output of the corresponding index in the unsigned
 /// transaction.
 #[derive(Clone, Default, Debug, PartialEq)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Output {
     /// The redeem script for this output.
     pub redeem_script: Option<Script>,
@@ -95,14 +94,12 @@ pub struct Output {
     pub witness_script: Option<Script>,
     /// A map from public keys needed to spend this output to their
     /// corresponding master key fingerprints and derivation paths.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub bip32_derivation: BTreeMap<PublicKey, KeySource>,
     /// The internal pubkey
     pub tap_internal_key: Option<XOnlyPublicKey>,
     /// Taproot Output tree
     pub tap_tree: Option<TapTree>,
     /// Map of tap root x only keys to origin info and leaf hashes contained in it
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub tap_key_origins: BTreeMap<XOnlyPublicKey, (Vec<TapLeafHash>, KeySource)>,
     /// (PSET) The explicit amount of the output
     pub amount: Option<u64>,
@@ -131,22 +128,13 @@ pub struct Output {
     pub blind_asset_proof: Option<Box<SurjectionProof>>,
     /// Pset
     /// Other fields
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_as_seq_byte_values")
-    )]
     pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
     /// Unknown key-value pairs for this output.
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_as_seq_byte_values")
-    )]
     pub unknown: BTreeMap<raw::Key, Vec<u8>>,
 }
 
 /// Taproot Tree representing a finalized [`TaprootBuilder`] (a complete binary tree)
 #[derive(Clone, Debug)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct TapTree(pub(crate) TaprootBuilder);
 
 impl PartialEq for TapTree {
diff --git a/src/pset/mod.rs b/src/pset/mod.rs
index 3c738e03..e9124683 100644
--- a/src/pset/mod.rs
+++ b/src/pset/mod.rs
@@ -56,7 +56,6 @@ pub use self::map::{Global, GlobalTxData, Input, Output, PsbtSighashType, TapTre
 
 /// A Partially Signed Transaction.
 #[derive(Debug, Clone, PartialEq)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct PartiallySignedTransaction {
     /// The key-value pairs for all global data.
     pub global: Global,
@@ -769,6 +768,26 @@ impl Decodable for PartiallySignedTransaction {
     }
 }
 
+#[cfg(feature = "base64")]
+#[cfg(feature = "serde")]
+impl serde::Serialize for PartiallySignedTransaction {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        self.to_string().serialize(s)
+    }
+}
+
+#[cfg(feature = "base64")]
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for PartiallySignedTransaction {
+    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        use serde::de::Error as _;
+
+        let b64 = String::deserialize(d)?;
+        b64.parse().map_err(D::Error::custom)
+    }
+}
+
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/pset/raw.rs b/src/pset/raw.rs
index d058e0f9..fdc626c9 100644
--- a/src/pset/raw.rs
+++ b/src/pset/raw.rs
@@ -24,12 +24,10 @@ use crate::encode::{self, deserialize, serialize, Decodable, Encodable, VarInt,
 use crate::hex;
 /// A PSET key in its raw byte form.
 #[derive(Debug, PartialEq, Hash, Eq, Clone, Ord, PartialOrd)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Key {
     /// The type of this PSET key.
     pub type_value: u8,
     /// The key itself in raw byte form.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub key: Vec<u8>,
 }
 
@@ -47,12 +45,10 @@ impl Key {
 
 /// A PSET key-value pair in its raw byte form.
 #[derive(Debug, PartialEq)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 pub struct Pair {
     /// The key of this key-value pair.
     pub key: Key,
     /// The value of this key-value pair in raw byte form.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub value: Vec<u8>,
 }
 
@@ -61,7 +57,6 @@ pub type ProprietaryType = u8;
 
 /// Proprietary keys (i.e. keys starting with 0xFC byte) with their internal
 /// structure according to BIP 174.
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct ProprietaryKey<Subtype = ProprietaryType>
 where
@@ -69,12 +64,10 @@ where
 {
     /// Proprietary type prefix used for grouping together keys under some
     /// application and avoid namespace collision
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub prefix: Vec<u8>,
     /// Custom proprietary subtype
     pub subtype: Subtype,
     /// Additional key bytes (like serialized public key data etc)
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub key: Vec<u8>,
 }
 
diff --git a/src/serde_utils.rs b/src/serde_utils.rs
deleted file mode 100644
index 4f91f2d7..00000000
--- a/src/serde_utils.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-//! Module for special serde serializations.
-//! Copied from rust-bitcoin as is.
-pub mod btreemap_byte_values {
-    //! Module for serialization of `BTreeMaps` with hex byte values.
-    #![allow(missing_docs)]
-
-    // NOTE: This module can be exactly copied to use with HashMap.
-
-    use ::std::collections::BTreeMap;
-    use crate::hex::{FromHex, ToHex};
-    use serde;
-
-    pub fn serialize<S, T>(v: &BTreeMap<T, Vec<u8>>, s: S)
-        -> Result<S::Ok, S::Error> where
-        S: serde::Serializer,
-        T: serde::Serialize + ::std::hash::Hash + Eq + Ord,
-    {
-        use serde::ser::SerializeMap;
-
-        // Don't do anything special when not human readable.
-        if s.is_human_readable() {
-            let mut map = s.serialize_map(Some(v.len()))?;
-            for (key, value) in v {
-                map.serialize_entry(key, &value.to_hex())?;
-            }
-            map.end()
-        } else {
-            serde::Serialize::serialize(v, s)
-        }
-    }
-
-    pub fn deserialize<'de, D, T>(d: D)
-        -> Result<BTreeMap<T, Vec<u8>>, D::Error> where
-        D: serde::Deserializer<'de>,
-        T: serde::Deserialize<'de> + ::std::hash::Hash + Eq + Ord,
-    {
-        use ::std::marker::PhantomData;
-
-        struct Visitor<T>(PhantomData<T>);
-        impl<'de, T> serde::de::Visitor<'de> for Visitor<T> where
-            T: serde::Deserialize<'de> + ::std::hash::Hash + Eq + Ord,
-        {
-            type Value = BTreeMap<T, Vec<u8>>;
-
-            fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                write!(f, "a map with hexadecimal values")
-            }
-
-            fn visit_map<A: serde::de::MapAccess<'de>>(self, mut a: A)
-                -> Result<Self::Value, A::Error>
-            {
-                let mut ret = BTreeMap::new();
-                while let Some((key, value)) = a.next_entry()? {
-                    ret.insert(key, FromHex::from_hex(value).map_err(serde::de::Error::custom)?);
-                }
-                Ok(ret)
-            }
-        }
-
-        // Don't do anything special when not human readable.
-        if d.is_human_readable() {
-            d.deserialize_map(Visitor(PhantomData))
-        } else {
-            serde::Deserialize::deserialize(d)
-        }
-    }
-}
-
-pub mod btreemap_as_seq {
-    //! Module for serialization of `BTreeMaps` as lists of sequences because
-    //! `serde_json` will not serialize hashmaps with non-string keys be default.
-    #![allow(missing_docs)]
-
-    // NOTE: This module can be exactly copied to use with HashMap.
-
-    use ::std::collections::BTreeMap;
-    use serde;
-
-    pub fn serialize<S, T, U>(v: &BTreeMap<T, U>, s: S)
-        -> Result<S::Ok, S::Error> where
-        S: serde::Serializer,
-        T: serde::Serialize + ::std::hash::Hash + Eq + Ord,
-        U: serde::Serialize,
-    {
-        use serde::ser::SerializeSeq;
-
-        // Don't do anything special when not human readable.
-        if s.is_human_readable() {
-            let mut seq = s.serialize_seq(Some(v.len()))?;
-            for pair in v {
-                seq.serialize_element(&pair)?;
-            }
-            seq.end()
-        } else {
-            serde::Serialize::serialize(v, s)
-        }
-    }
-
-    pub fn deserialize<'de, D, T, U>(d: D)
-        -> Result<BTreeMap<T, U>, D::Error> where
-        D: serde::Deserializer<'de>,
-        T: serde::Deserialize<'de> + ::std::hash::Hash + Eq + Ord,
-        U: serde::Deserialize<'de>,
-    {
-        use ::std::marker::PhantomData;
-
-        struct Visitor<T, U>(PhantomData<(T, U)>);
-        impl<'de, T, U> serde::de::Visitor<'de> for Visitor<T, U> where
-            T: serde::Deserialize<'de> + ::std::hash::Hash + Eq + Ord,
-            U: serde::Deserialize<'de>,
-        {
-            type Value = BTreeMap<T, U>;
-
-            fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                write!(f, "a sequence of pairs")
-            }
-
-            fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut a: A)
-                -> Result<Self::Value, A::Error>
-            {
-                let mut ret = BTreeMap::new();
-                while let Some((key, value)) = a.next_element()? {
-                    ret.insert(key, value);
-                }
-                Ok(ret)
-            }
-        }
-
-        // Don't do anything special when not human readable.
-        if d.is_human_readable() {
-            d.deserialize_seq(Visitor(PhantomData))
-        } else {
-            serde::Deserialize::deserialize(d)
-        }
-    }
-}
-
-pub mod btreemap_as_seq_byte_values {
-    //! Module for serialization of `BTreeMaps` as lists of sequences because
-    //! `serde_json` will not serialize hashmaps with non-string keys be default.
-    #![allow(missing_docs)]
-
-    // NOTE: This module can be exactly copied to use with HashMap.
-
-    use ::std::collections::BTreeMap;
-    use serde;
-
-    /// A custom key-value pair type that serialized the bytes as hex.
-    #[derive(Debug, serde::Deserialize)]
-    struct OwnedPair<T>(
-        T,
-        #[serde(deserialize_with = "crate::serde_utils::hex_bytes::deserialize")]
-        Vec<u8>,
-    );
-
-    /// A custom key-value pair type that serialized the bytes as hex.
-    #[derive(Debug, serde::Serialize)]
-    struct BorrowedPair<'a, T: 'static>(
-        &'a T,
-        #[serde(serialize_with = "crate::serde_utils::hex_bytes::serialize")]
-        &'a [u8],
-    );
-
-    pub fn serialize<S, T>(v: &BTreeMap<T, Vec<u8>>, s: S)
-        -> Result<S::Ok, S::Error> where
-        S: serde::Serializer,
-        T: serde::Serialize + ::std::hash::Hash + Eq + Ord + 'static,
-    {
-        use serde::ser::SerializeSeq;
-
-        // Don't do anything special when not human readable.
-        if s.is_human_readable() {
-            let mut seq = s.serialize_seq(Some(v.len()))?;
-            for (key, value) in v {
-                seq.serialize_element(&BorrowedPair(key, value))?;
-            }
-            seq.end()
-        } else {
-            serde::Serialize::serialize(v, s)
-        }
-    }
-
-    pub fn deserialize<'de, D, T>(d: D)
-        -> Result<BTreeMap<T, Vec<u8>>, D::Error> where
-        D: serde::Deserializer<'de>,
-        T: serde::Deserialize<'de> + ::std::hash::Hash + Eq + Ord,
-    {
-        use ::std::marker::PhantomData;
-
-        struct Visitor<T>(PhantomData<T>);
-        impl<'de, T> serde::de::Visitor<'de> for Visitor<T> where
-            T: serde::Deserialize<'de> + ::std::hash::Hash + Eq + Ord,
-        {
-            type Value = BTreeMap<T, Vec<u8>>;
-
-            fn expecting(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                write!(f, "a sequence of pairs")
-            }
-
-            fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut a: A)
-                -> Result<Self::Value, A::Error>
-            {
-                let mut ret = BTreeMap::new();
-                while let Option::Some(OwnedPair(key, value)) = a.next_element()? {
-                    ret.insert(key, value);
-                }
-                Ok(ret)
-            }
-        }
-
-        // Don't do anything special when not human readable.
-        if d.is_human_readable() {
-            d.deserialize_seq(Visitor(PhantomData))
-        } else {
-            serde::Deserialize::deserialize(d)
-        }
-    }
-}
-
-pub mod hex_bytes {
-    //! Module for serialization of byte arrays as hex strings.
-    #![allow(missing_docs)]
-
-    use crate::hex::{FromHex, ToHex};
-    use serde;
-
-    pub fn serialize<T, S>(bytes: &T, s: S) -> Result<S::Ok, S::Error>
-        where T: serde::Serialize + AsRef<[u8]>, S: serde::Serializer
-    {
-        // Don't do anything special when not human readable.
-        if s.is_human_readable() {
-            s.serialize_str(&bytes.as_ref().to_hex())
-        } else {
-            serde::Serialize::serialize(bytes, s)
-        }
-    }
-
-    pub fn deserialize<'de, D, B>(d: D) -> Result<B, D::Error>
-        where D: serde::Deserializer<'de>, B: serde::Deserialize<'de> + FromHex,
-    {
-        struct Visitor<B>(::std::marker::PhantomData<B>);
-
-        impl<B: FromHex> serde::de::Visitor<'_> for Visitor<B> {
-            type Value = B;
-
-            fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                formatter.write_str("an ASCII hex string")
-            }
-
-            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-                where E: serde::de::Error,
-            {
-                if let Ok(hex) = ::std::str::from_utf8(v) {
-                    FromHex::from_hex(hex).map_err(E::custom)
-                } else {
-                    Err(E::invalid_value(serde::de::Unexpected::Bytes(v), &self))
-                }
-            }
-
-            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-                where E: serde::de::Error,
-            {
-                FromHex::from_hex(v).map_err(E::custom)
-            }
-        }
-
-        // Don't do anything special when not human readable.
-        if d.is_human_readable() {
-            d.deserialize_str(Visitor(::std::marker::PhantomData))
-        } else {
-            serde::Deserialize::deserialize(d)
-        }
-    }
-}

From 68d35074868189a2cfe24371f3998a51406a115f Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Thu, 26 Jun 2025 02:13:31 +0000
Subject: [PATCH 5/8] locktime: use bitcoin-units locktime types

In bitcoin-units 1.0 we have types that represent locktime times and
heights. The locktimes themselves are not in units (they will be exposed
in bitcoin-primitives once that comes out) but the essential hard logic
is implemented on these supporting types.

Importantly, the new types don't implement serde, which is why we needed
to do breaking serde changes in the last couple of commits. (But we
should have done these changes a long time ago, anyway.)
---
 src/lib.rs      |   6 +
 src/locktime.rs | 315 +-----------------------------------------------
 2 files changed, 12 insertions(+), 309 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index f99a703f..74e4e87b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -71,6 +71,12 @@ mod transaction;
 mod endian;
 // re-export bitcoin deps which we re-use
 pub use bitcoin::hashes;
+// Re-export units which are identical in Bitcoin and Elements
+pub use bitcoin_units::{
+    BlockHeight, BlockHeightInterval, BlockMtp, BlockMtpInterval, BlockTime,
+    MathOp, NumOpError, NumOpResult,
+    Weight,
+};
 // export everything at the top level so it can be used as `elements::Transaction` etc.
 pub use crate::address::{Address, AddressError, AddressParams};
 pub use crate::blind::{
diff --git a/src/locktime.rs b/src/locktime.rs
index f9db4b42..90b5a834 100644
--- a/src/locktime.rs
+++ b/src/locktime.rs
@@ -19,28 +19,14 @@
 
 use std::{mem, fmt};
 use std::cmp::{PartialOrd, Ordering};
-use std::convert::TryFrom;
-use std::str::FromStr;
 use std::io::{Read, Write};
-use crate::error::ParseIntError;
-use crate::parse;
 
 use crate::encode::{self, Decodable, Encodable};
-use crate::error::write_err;
 use crate::parse::impl_parse_str_through_int;
 
-/// The Threshold for deciding whether a lock time value is a height or a time (see [Bitcoin Core]).
-///
-/// `LockTime` values _below_ the threshold are interpreted as block heights, values _above_ (or
-/// equal to) the threshold are interpreted as block times (UNIX timestamp, seconds since epoch).
-///
-/// Elements is able to safely use this value because a block height greater than 500,000,000 would
-/// never occur because it would represent a height in approximately 950 years. Conversely, block
-/// times under 500,000,000 will never happen because they would represent times before 1986 which
-/// are, for obvious reasons, not useful within any Elements network.
-///
-/// [Bitcoin Core]: https://github.com/bitcoin/bitcoin/blob/9ccaee1d5e2e4b79b0a7c29aadb41b97e4741332/src/script/script.h#L39
-pub const LOCK_TIME_THRESHOLD: u32 = 500_000_000;
+pub use bitcoin_units::locktime::absolute::{Height, Time};
+pub use bitcoin_units::locktime::absolute::ConversionError;
+pub use bitcoin_units::locktime::absolute::LOCK_TIME_THRESHOLD;
 
 /// A lock time value, representing either a block height or a UNIX timestamp (seconds since epoch).
 ///
@@ -96,7 +82,7 @@ pub enum LockTime {
 impl LockTime {
     /// If [`crate::Transaction::lock_time`] is set to zero it is ignored, in other words a
     /// transaction with nLocktime==0 is able to be included immediately in any block.
-    pub const ZERO: LockTime = LockTime::Blocks(Height(0));
+    pub const ZERO: LockTime = LockTime::Blocks(Height::ZERO);
 
     /// Constructs a `LockTime` from an nLockTime value or the argument to `OP_CHEKCLOCKTIMEVERIFY`.
     ///
@@ -130,7 +116,7 @@ impl LockTime {
     /// assert!(LockTime::from_height(1653195600).is_err());
     /// ```
     #[inline]
-    pub fn from_height(n: u32) -> Result<Self, Error> {
+    pub fn from_height(n: u32) -> Result<Self, ConversionError> {
         let height = Height::from_consensus(n)?;
         Ok(LockTime::Blocks(height))
     }
@@ -146,7 +132,7 @@ impl LockTime {
     /// assert!(LockTime::from_time(741521).is_err());
     /// ```
     #[inline]
-    pub fn from_time(n: u32) -> Result<Self, Error> {
+    pub fn from_time(n: u32) -> Result<Self, ConversionError> {
         let time = Time::from_consensus(n)?;
         Ok(LockTime::Seconds(time))
     }
@@ -307,300 +293,11 @@ impl Decodable for LockTime {
     }
 }
 
-/// An absolute block height, guaranteed to always contain a valid height value.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
-pub struct Height(u32);
-
-impl Height {
-    /// Height zero
-    pub const ZERO: Self = Height(0);
-
-    /// Constructs a new block height.
-    ///
-    /// # Errors
-    ///
-    /// If `n` does not represent a block height value (see documentation on [`LockTime`]).
-    ///
-    /// # Examples
-    /// ```rust
-    /// use elements::locktime::Height;
-    ///
-    /// let h: u32 = 741521;
-    /// let height = Height::from_consensus(h).expect("invalid height value");
-    /// assert_eq!(height.to_consensus_u32(), h);
-    /// ```
-    #[inline]
-    pub fn from_consensus(n: u32) -> Result<Height, Error> {
-        if is_block_height(n) {
-            Ok(Self(n))
-        } else {
-            Err(ConversionError::invalid_height(n).into())
-        }
-    }
-
-    /// Converts this `Height` to its inner `u32` value.
-    ///
-    /// # Examples
-    /// ```rust
-    /// use elements::LockTime;
-    ///
-    /// let n_lock_time: u32 = 741521;
-    /// let lock_time = LockTime::from_consensus(n_lock_time);
-    /// assert!(lock_time.is_block_height());
-    /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
-    #[inline]
-    pub fn to_consensus_u32(self) -> u32 {
-        self.0
-    }
-}
-
-impl fmt::Display for Height {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.0, f)
-    }
-}
-
-impl FromStr for Height {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let n = parse::int(s)?;
-        Height::from_consensus(n)
-    }
-}
-
-impl TryFrom<&str> for Height {
-    type Error = Error;
-
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        let n = parse::int(s)?;
-        Height::from_consensus(n)
-    }
-}
-
-impl TryFrom<String> for Height {
-    type Error = Error;
-
-    fn try_from(s: String) -> Result<Self, Self::Error> {
-        let n = parse::int(s)?;
-        Height::from_consensus(n)
-    }
-}
-
-/// A UNIX timestamp, seconds since epoch, guaranteed to always contain a valid time value.
-///
-/// Note that there is no manipulation of the inner value during construction or when using
-/// `to_consensus_u32()`. Said another way, `Time(x)` means 'x seconds since epoch' _not_ '(x -
-/// threshold) seconds since epoch'.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde",  derive(serde::Serialize, serde::Deserialize))]
-pub struct Time(u32);
-
-impl Time {
-    /// Constructs a new block time.
-    ///
-    /// # Errors
-    ///
-    /// If `n` does not encode a UNIX time stamp (see documentation on [`LockTime`]).
-    ///
-    /// # Examples
-    /// ```rust
-    /// use elements::locktime::Time;
-    ///
-    /// let t: u32 = 1653195600; // May 22nd, 5am UTC.
-    /// let time = Time::from_consensus(t).expect("invalid time value");
-    /// assert_eq!(time.to_consensus_u32(), t);
-    /// ```
-    #[inline]
-    pub fn from_consensus(n: u32) -> Result<Time, Error> {
-        if is_block_time(n) {
-            Ok(Self(n))
-        } else {
-            Err(ConversionError::invalid_time(n).into())
-        }
-    }
-
-    /// Converts this `Time` to its inner `u32` value.
-    ///
-    /// # Examples
-    /// ```rust
-    /// use elements::LockTime;
-    ///
-    /// let n_lock_time: u32 = 1653195600; // May 22nd, 5am UTC.
-    /// let lock_time = LockTime::from_consensus(n_lock_time);
-    /// assert_eq!(lock_time.to_consensus_u32(), n_lock_time);
-    /// ```
-    #[inline]
-    pub fn to_consensus_u32(self) -> u32 {
-        self.0
-    }
-}
-
-impl fmt::Display for Time {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.0, f)
-    }
-}
-
-impl FromStr for Time {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let n = parse::int(s)?;
-        Time::from_consensus(n)
-    }
-}
-
-impl TryFrom<&str> for Time {
-    type Error = Error;
-
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        let n = parse::int(s)?;
-        Time::from_consensus(n)
-    }
-}
-
-impl TryFrom<String> for Time {
-    type Error = Error;
-
-    fn try_from(s: String) -> Result<Self, Self::Error> {
-        let n = parse::int(s)?;
-        Time::from_consensus(n)
-    }
-}
-
 /// Returns true if `n` is a block height i.e., less than 500,000,000.
 fn is_block_height(n: u32) -> bool {
     n < LOCK_TIME_THRESHOLD
 }
 
-/// Returns true if `n` is a UNIX timestamp i.e., greater than or equal to 500,000,000.
-fn is_block_time(n: u32) -> bool {
-    n >= LOCK_TIME_THRESHOLD
-}
-
-/// Catchall type for errors that relate to time locks.
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum Error {
-    /// An error occurred while converting a `u32` to a lock time variant.
-    Conversion(ConversionError),
-    /// An error occurred while operating on lock times.
-    Operation(OperationError),
-    /// An error occurred while parsing a string into an `u32`.
-    Parse(ParseIntError),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Self::Conversion(ref e) => write_err!(f, "error converting lock time value"; e),
-            Self::Operation(ref e) => write_err!(f, "error during lock time operation"; e),
-            Self::Parse(ref e) => write_err!(f, "failed to parse lock time from string"; e),
-        }
-    }
-}
-
-impl std::error::Error for Error {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match *self {
-            Self::Conversion(ref e) => Some(e),
-            Self::Operation(ref e) => Some(e),
-            Self::Parse(ref e) => Some(e),
-        }
-    }
-}
-
-impl From<ConversionError> for Error {
-    fn from(e: ConversionError) -> Self {
-        Error::Conversion(e)
-    }
-}
-
-impl From<OperationError> for Error {
-    fn from(e: OperationError) -> Self {
-        Error::Operation(e)
-    }
-}
-
-impl From<ParseIntError> for Error {
-    fn from(e: ParseIntError) -> Self {
-        Error::Parse(e)
-    }
-}
-
-/// An error that occurs when converting a `u32` to a lock time variant.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ConversionError {
-    /// The expected timelock unit, height (blocks) or time (seconds).
-    unit: LockTimeUnit,
-    /// The invalid input value.
-    input: u32,
-}
-
-impl ConversionError {
-    /// Constructs a `ConversionError` from an invalid `n` when expecting a height value.
-    fn invalid_height(n: u32) -> Self {
-        Self {
-            unit: LockTimeUnit::Blocks,
-            input: n,
-        }
-    }
-
-    /// Constructs a `ConversionError` from an invalid `n` when expecting a time value.
-    fn invalid_time(n: u32) -> Self {
-        Self {
-            unit: LockTimeUnit::Seconds,
-            input: n,
-        }
-    }
-}
-
-impl fmt::Display for ConversionError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "invalid lock time value {}, {}", self.input, self.unit)
-    }
-}
-
-impl std::error::Error for ConversionError {}
-
-/// Describes the two types of locking, lock-by-blockheight and lock-by-blocktime.
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-enum LockTimeUnit {
-    /// Lock by blockheight.
-    Blocks,
-    /// Lock by blocktime.
-    Seconds,
-}
-
-impl fmt::Display for LockTimeUnit {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Self::Blocks => write!(f, "expected lock-by-blockheight (must be < {})", LOCK_TIME_THRESHOLD),
-            Self::Seconds => write!(f, "expected lock-by-blocktime (must be >= {})", LOCK_TIME_THRESHOLD),
-        }
-    }
-}
-
-/// Errors than occur when operating on lock times.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[non_exhaustive]
-pub enum OperationError {
-    /// Cannot compare different lock time units (height vs time).
-    InvalidComparison,
-}
-
-impl fmt::Display for OperationError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Self::InvalidComparison => f.write_str("cannot compare different lock units (height vs time)"),
-        }
-    }
-}
-
-impl std::error::Error for OperationError {}
-
 #[cfg(test)]
 mod tests {
     use super::*;

From c495a9535ad71693db2dd31ce3151400b508fcf4 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Sat, 28 Jun 2025 23:05:25 +0000
Subject: [PATCH 6/8] remove some deprecated weight-related methods

---
 fuzz/fuzz_targets/deserialize_block.rs       |  6 +++---
 fuzz/fuzz_targets/deserialize_output.rs      |  6 +++---
 fuzz/fuzz_targets/deserialize_pset.rs        |  6 +++---
 fuzz/fuzz_targets/deserialize_transaction.rs |  8 ++++----
 src/block.rs                                 | 12 ------------
 src/transaction.rs                           | 13 -------------
 6 files changed, 13 insertions(+), 38 deletions(-)

diff --git a/fuzz/fuzz_targets/deserialize_block.rs b/fuzz/fuzz_targets/deserialize_block.rs
index 061fec7e..9cf79206 100644
--- a/fuzz/fuzz_targets/deserialize_block.rs
+++ b/fuzz/fuzz_targets/deserialize_block.rs
@@ -39,9 +39,9 @@ mod tests {
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
                 _ => panic!("Bad hex"),
             }
             if (idx & 1) == 1 {
diff --git a/fuzz/fuzz_targets/deserialize_output.rs b/fuzz/fuzz_targets/deserialize_output.rs
index 22bc06d9..f8964056 100644
--- a/fuzz/fuzz_targets/deserialize_output.rs
+++ b/fuzz/fuzz_targets/deserialize_output.rs
@@ -45,9 +45,9 @@ mod tests {
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
                 _ => panic!("Bad hex"),
             }
             if (idx & 1) == 1 {
diff --git a/fuzz/fuzz_targets/deserialize_pset.rs b/fuzz/fuzz_targets/deserialize_pset.rs
index bf1576a5..9c03c087 100644
--- a/fuzz/fuzz_targets/deserialize_pset.rs
+++ b/fuzz/fuzz_targets/deserialize_pset.rs
@@ -41,9 +41,9 @@ mod tests {
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
                 _ => panic!("Bad hex"),
             }
             if (idx & 1) == 1 {
diff --git a/fuzz/fuzz_targets/deserialize_transaction.rs b/fuzz/fuzz_targets/deserialize_transaction.rs
index 25148086..7b42b5cc 100644
--- a/fuzz/fuzz_targets/deserialize_transaction.rs
+++ b/fuzz/fuzz_targets/deserialize_transaction.rs
@@ -9,7 +9,7 @@ fn do_test(data: &[u8]) {
             let reser = elements::encode::serialize(&tx);
             assert_eq!(data, &reser[..]);
             let len = reser.len();
-            let calculated_weight = tx.get_weight();
+            let calculated_weight = tx.weight();
             for input in &mut tx.input {
                 input.witness = elements::TxInWitness::default();
             }
@@ -58,9 +58,9 @@ mod tests {
         for (idx, c) in hex.as_bytes().iter().enumerate() {
             b <<= 4;
             match *c {
-                b'A'...b'F' => b |= c - b'A' + 10,
-                b'a'...b'f' => b |= c - b'a' + 10,
-                b'0'...b'9' => b |= c - b'0',
+                b'A'..=b'F' => b |= c - b'A' + 10,
+                b'a'..=b'f' => b |= c - b'a' + 10,
+                b'0'..=b'9' => b |= c - b'0',
                 _ => panic!("Bad hex"),
             }
             if (idx & 1) == 1 {
diff --git a/src/block.rs b/src/block.rs
index f16f790f..896ce565 100644
--- a/src/block.rs
+++ b/src/block.rs
@@ -364,12 +364,6 @@ impl Block {
         self.header.block_hash()
     }
 
-    /// Get the size of the block
-    #[deprecated(since = "0.19.1", note = "Please use `Block::size` instead.")]
-    pub fn get_size(&self) -> usize {
-        self.size()
-    }
-
     /// Get the size of the block
     pub fn size(&self) -> usize {
         // The size of the header + the size of the varint with the tx count + the txs themselves
@@ -378,12 +372,6 @@ impl Block {
         base_size + txs_size
     }
 
-    /// Get the weight of the block
-    #[deprecated(since = "0.19.1", note = "Please use `Block::weight` instead.")]
-    pub fn get_weight(&self) -> usize {
-        self.weight()
-    }
-
     /// Get the weight of the block
     pub fn weight(&self) -> usize {
         let base_weight = 4 * (serialize(&self.header).len() + VarInt(self.txdata.len() as u64).size());
diff --git a/src/transaction.rs b/src/transaction.rs
index a94bd756..33437117 100644
--- a/src/transaction.rs
+++ b/src/transaction.rs
@@ -896,25 +896,12 @@ impl Transaction {
             self.output.iter().any(|o| !o.witness.is_empty())
     }
 
-    /// Get the "weight" of this transaction; roughly equivalent to BIP141, in that witness data is
-    /// counted as 1 while non-witness data is counted as 4.
-    #[deprecated(since = "0.19.1", note = "Please use `Transaction::weight` instead.")]
-    pub fn get_weight(&self) -> usize {
-        self.weight()
-    }
-
     /// Get the "weight" of this transaction; roughly equivalent to BIP141, in that witness data is
     /// counted as 1 while non-witness data is counted as 4.
     pub fn weight(&self) -> usize {
         self.scaled_size(4)
     }
 
-    /// Gets the regular byte-wise consensus-serialized size of this transaction.
-    #[deprecated(since = "0.19.1", note = "Please use `Transaction::size` instead.")]
-    pub fn get_size(&self) -> usize {
-        self.size()
-    }
-
     /// Gets the regular byte-wise consensus-serialized size of this transaction.
     pub fn size(&self) -> usize {
         self.scaled_size(1)

From f9aa5b85dc3e5dc4d73fb44de953dc0113270ced Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Sat, 28 Jun 2025 23:19:39 +0000
Subject: [PATCH 7/8] encode: introduce encoded_length utility function

---
 src/confidential.rs | 57 ++++++++++++++++++++++++---------------------
 src/encode.rs       | 16 +++++++++++++
 2 files changed, 46 insertions(+), 27 deletions(-)

diff --git a/src/confidential.rs b/src/confidential.rs
index 34f1a564..2319dced 100644
--- a/src/confidential.rs
+++ b/src/confidential.rs
@@ -70,15 +70,6 @@ impl Value {
         Value::Confidential(comm)
     }
 
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Value::Null => 1,
-            Value::Explicit(..) => 9,
-            Value::Confidential(..) => 33,
-        }
-    }
-
     /// Create from commitment.
     pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
         Ok(Value::Confidential(PedersenCommitment::from_slice(bytes)?))
@@ -145,6 +136,14 @@ impl Encodable for Value {
             Value::Confidential(commitment) => commitment.consensus_encode(&mut s),
         }
     }
+
+    fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 9,
+            Self::Confidential(..) => 33,
+        }
+    }
 }
 
 impl Encodable for PedersenCommitment {
@@ -152,6 +151,8 @@ impl Encodable for PedersenCommitment {
         e.write_all(&self.serialize())?;
         Ok(33)
     }
+
+    fn encoded_length(&self) -> usize { 33 }
 }
 
 impl Decodable for Value {
@@ -272,15 +273,6 @@ impl Asset {
         ))
     }
 
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Asset::Null => 1,
-            Asset::Explicit(..) => 33,
-            Asset::Confidential(..) => 33,
-        }
-    }
-
     /// Create from commitment.
     pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
         Ok(Asset::Confidential(Generator::from_slice(bytes)?))
@@ -367,6 +359,14 @@ impl Encodable for Asset {
             Asset::Confidential(generator) => generator.consensus_encode(&mut s)
         }
     }
+
+    fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 33,
+            Self::Confidential(..) => 33,
+        }
+    }
 }
 
 impl Encodable for Generator {
@@ -374,6 +374,8 @@ impl Encodable for Generator {
         e.write_all(&self.serialize())?;
         Ok(33)
     }
+
+    fn encoded_length(&self) -> usize { 33 }
 }
 
 impl Decodable for Asset {
@@ -537,15 +539,6 @@ impl Nonce {
         SecretKey::from_slice(&shared_secret[..32]).expect("always has exactly 32 bytes")
     }
 
-    /// Serialized length, in bytes
-    pub fn encoded_length(&self) -> usize {
-        match *self {
-            Nonce::Null => 1,
-            Nonce::Explicit(..) => 33,
-            Nonce::Confidential(..) => 33,
-        }
-    }
-
     /// Create from commitment.
     pub fn from_commitment(bytes: &[u8]) -> Result<Self, encode::Error> {
         Ok(Nonce::Confidential(
@@ -619,6 +612,14 @@ impl Encodable for Nonce {
             Nonce::Confidential(commitment) => commitment.consensus_encode(&mut s),
         }
     }
+
+    fn encoded_length(&self) -> usize {
+        match *self {
+            Self::Null => 1,
+            Self::Explicit(..) => 33,
+            Self::Confidential(..) => 33,
+        }
+    }
 }
 
 impl Encodable for PublicKey {
@@ -626,6 +627,8 @@ impl Encodable for PublicKey {
         e.write_all(&self.serialize())?;
         Ok(33)
     }
+
+    fn encoded_length(&self) -> usize { 33 }
 }
 
 impl Decodable for Nonce {
diff --git a/src/encode.rs b/src/encode.rs
index 6868cee2..cffc29f2 100644
--- a/src/encode.rs
+++ b/src/encode.rs
@@ -147,6 +147,22 @@ pub trait Encodable {
     /// the underlying `Write` errors. Returns the number of bytes written on
     /// success
     fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error>;
+
+    /// The length of the object, in bytes, when encoded.
+    #[inline]
+    fn encoded_length(&self) -> usize {
+        self.consensus_encode(io::sink()).expect("no errors on sink")
+    }
+
+    /// The length of the object, in bytes, when encoded.
+    ///
+    /// Convenience function to minimize the amount of explicit casting that
+    /// users need to do. No object in Bitcoin or Elements will ever approach
+    /// [`u64::MAX`] in encoded size, regardless of the range of `usize`.
+    #[inline]
+    fn encoded_len64(&self) -> u64 {
+        self.encoded_length() as u64
+    }
 }
 
 /// Data which can be encoded in a consensus-consistent way

From e7c1565e71a1585042ebb2fc4ffaa901833779c6 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Sat, 28 Jun 2025 22:39:58 +0000
Subject: [PATCH 8/8] transaction and block: use Weight as return type for
 weight methods

The API change is actually only a couple LOC. The real change is that we
start using u64 arithmetic to compute weights rather than usize
arithmetic, because Weight::from_wu wants a u64.

To facilitate this we introduce the private Len64 trait which provides
lengths in u64, and use it throughout the crate. This replaces 23 casts
to usize or u64 with four.
---
 fuzz/fuzz_targets/deserialize_transaction.rs |   2 +-
 src/block.rs                                 |  21 +--
 src/encode.rs                                |   5 +-
 src/lib.rs                                   |  36 +++++
 src/pset/raw.rs                              |  21 ++-
 src/script.rs                                |   3 +-
 src/transaction.rs                           | 150 ++++++++++---------
 7 files changed, 145 insertions(+), 93 deletions(-)

diff --git a/fuzz/fuzz_targets/deserialize_transaction.rs b/fuzz/fuzz_targets/deserialize_transaction.rs
index 7b42b5cc..d5af7fa4 100644
--- a/fuzz/fuzz_targets/deserialize_transaction.rs
+++ b/fuzz/fuzz_targets/deserialize_transaction.rs
@@ -18,7 +18,7 @@ fn do_test(data: &[u8]) {
             }
             assert_eq!(tx.has_witness(), false);
             let no_witness_len = elements::encode::serialize(&tx).len();
-            assert_eq!(no_witness_len * 3 + len, calculated_weight);
+            assert_eq!(no_witness_len * 3 + len, calculated_weight.to_wu() as usize);
 
             for output in &tx.output {
                 output.is_null_data();
diff --git a/src/block.rs b/src/block.rs
index 896ce565..89353198 100644
--- a/src/block.rs
+++ b/src/block.rs
@@ -24,7 +24,8 @@ use crate::dynafed;
 use crate::hashes::{Hash, sha256};
 use crate::Transaction;
 use crate::encode::{self, serialize, Decodable, Encodable, VarInt};
-use crate::{BlockHash, Script, TxMerkleNode};
+use crate::{BlockHash, Script, TxMerkleNode, Weight};
+use crate::Len64 as _;
 
 /// Data related to block signatures
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
@@ -365,17 +366,19 @@ impl Block {
     }
 
     /// Get the size of the block
+    #[deprecated(since = "0.26.0", note = "use Self::weight or Self::encoded_length instead")]
     pub fn size(&self) -> usize {
         // The size of the header + the size of the varint with the tx count + the txs themselves
-        let base_size = serialize(&self.header).len() + VarInt(self.txdata.len() as u64).size();
-        let txs_size: usize = self.txdata.iter().map(Transaction::size).sum();
+        let base_size = serialize(&self.header).len() + VarInt(self.txdata.len64()).size();
+        let txs_size = self.txdata.iter().map(Transaction::encoded_length).sum::<usize>();
         base_size + txs_size
     }
 
     /// Get the weight of the block
-    pub fn weight(&self) -> usize {
-        let base_weight = 4 * (serialize(&self.header).len() + VarInt(self.txdata.len() as u64).size());
-        let txs_weight: usize = self.txdata.iter().map(Transaction::weight).sum();
+    pub fn weight(&self) -> Weight {
+        let base_weight = Weight::from_vb(self.header.encoded_len64() + VarInt(self.txdata.len64()).len64())
+            .expect("base weight does not overflow the Weight type");
+        let txs_weight = self.txdata.iter().map(Transaction::weight).sum::<Weight>();
         base_weight + txs_weight
     }
 }
@@ -454,8 +457,8 @@ mod tests {
         assert_eq!(block.header.version, 0x2000_0000);
         assert_eq!(block.header.height, 2);
         assert_eq!(block.txdata.len(), 1);
-        assert_eq!(block.size(), serialize(&block).len());
-        assert_eq!(block.weight(), 1089);
+        assert_eq!(block.encoded_length(), serialize(&block).len());
+        assert_eq!(block.weight().to_wu(), 1089);
 
         // Block with 3 transactions ... the rangeproofs are very large :)
         let block: Block = hex_deserialize!(
@@ -666,7 +669,7 @@ mod tests {
         assert_eq!(block.header.version, 0x2000_0000);
         assert_eq!(block.header.height, 1);
         assert_eq!(block.txdata.len(), 3);
-        assert_eq!(block.size(), serialize(&block).len());
+        assert_eq!(block.encoded_length(), serialize(&block).len());
 
         // 2-of-3 signed block from Liquid integration tests
         let block: Block = hex_deserialize!(
diff --git a/src/encode.rs b/src/encode.rs
index cffc29f2..10744731 100644
--- a/src/encode.rs
+++ b/src/encode.rs
@@ -24,6 +24,7 @@ use secp256k1_zkp::{self, RangeProof, SurjectionProof, Tweak};
 use crate::hashes::{sha256, Hash};
 use crate::pset;
 use crate::transaction::{Transaction, TxIn, TxOut};
+use crate::Len64 as _;
 
 pub use bitcoin::{self, consensus::encode::MAX_VEC_SIZE};
 
@@ -224,7 +225,7 @@ pub(crate) fn consensus_encode_with_size<S: crate::WriteExt>(
     data: &[u8],
     mut s: S,
 ) -> Result<usize, Error> {
-    let vi_len = VarInt(data.len() as u64).consensus_encode(&mut s)?;
+    let vi_len = VarInt(data.len64()).consensus_encode(&mut s)?;
     s.emit_slice(data)?;
     Ok(vi_len + data.len())
 }
@@ -336,7 +337,7 @@ macro_rules! impl_vec {
             #[inline]
             fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, Error> {
                 let mut len = 0;
-                len += VarInt(self.len() as u64).consensus_encode(&mut s)?;
+                len += VarInt(self.len64()).consensus_encode(&mut s)?;
                 for c in self.iter() {
                     len += c.consensus_encode(&mut s)?;
                 }
diff --git a/src/lib.rs b/src/lib.rs
index 74e4e87b..57df6dac 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -98,3 +98,39 @@ pub use crate::transaction::{
     AssetIssuance, EcdsaSighashType, OutPoint, PeginData, PegoutData, Transaction, TxIn,
     TxInWitness, TxOut, TxOutWitness,
 };
+
+/// Utility trait for producing lengths in u64, for use in weight computations.
+trait Len64 {
+    fn len64(&self) -> u64;
+}
+
+impl<T> Len64 for [T] {
+    fn len64(&self) -> u64 { self.len() as u64 }
+}
+impl<T> Len64 for &[T] {
+    fn len64(&self) -> u64 { (*self).len64() }
+}
+impl<T> Len64 for Vec<T> {
+    fn len64(&self) -> u64 { self[..].len64() }
+}
+impl Len64 for crate::script::Script {
+    fn len64(&self) -> u64 { self[..].len64() }
+}
+impl Len64 for secp256k1_zkp::RangeProof {
+    fn len64(&self) -> u64 { self.serialize().len64() }
+}
+impl Len64 for secp256k1_zkp::SurjectionProof {
+    fn len64(&self) -> u64 { self.serialize().len64() }
+}
+impl Len64 for bitcoin::VarInt {
+    fn len64(&self) -> u64 { self.size() as u64 }
+}
+impl Len64 for crate::encode::VarInt {
+    fn len64(&self) -> u64 { self.size() as u64 }
+}
+impl<T: Len64> Len64 for Option<T> {
+    fn len64(&self) -> u64 { self.as_ref().map_or(0, T::len64) }
+}
+impl<T: Len64> Len64 for Box<T> {
+    fn len64(&self) -> u64 { (**self).len64() }
+}
diff --git a/src/pset/raw.rs b/src/pset/raw.rs
index fdc626c9..0f11b669 100644
--- a/src/pset/raw.rs
+++ b/src/pset/raw.rs
@@ -99,24 +99,31 @@ impl fmt::Display for Key {
 
 impl Decodable for Key {
     fn consensus_decode<D: io::Read>(mut d: D) -> Result<Self, encode::Error> {
+        use core::convert::TryFrom;
+
         let VarInt(byte_size): VarInt = Decodable::consensus_decode(&mut d)?;
 
         if byte_size == 0 {
             return Err(Error::NoMorePairs.into());
         }
+        let key_byte_size = match usize::try_from(byte_size) {
+            Ok(n) => n - 1,
+            Err(_) => return Err(encode::Error::OversizedVectorAllocation {
+                requested: usize::MAX,
+                max: MAX_VEC_SIZE,
+            }),
+        };
 
-        let key_byte_size: u64 = byte_size - 1;
-
-        if key_byte_size > MAX_VEC_SIZE as u64 {
+        if key_byte_size > MAX_VEC_SIZE {
             return Err(encode::Error::OversizedVectorAllocation {
-                requested: key_byte_size as usize,
+                requested: key_byte_size,
                 max: MAX_VEC_SIZE,
             });
         }
 
         let type_value: u8 = Decodable::consensus_decode(&mut d)?;
 
-        let mut key = Vec::with_capacity(key_byte_size as usize);
+        let mut key = Vec::with_capacity(key_byte_size);
         for _ in 0..key_byte_size {
             key.push(Decodable::consensus_decode(&mut d)?);
         }
@@ -127,8 +134,10 @@ impl Decodable for Key {
 
 impl Encodable for Key {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
+        use crate::Len64 as _;
+
         let mut len = 0;
-        len += VarInt((self.key.len() + 1) as u64).consensus_encode(&mut s)?;
+        len += VarInt(self.key.len64() + 1).consensus_encode(&mut s)?;
 
         len += self.type_value.consensus_encode(&mut s)?;
 
diff --git a/src/script.rs b/src/script.rs
index 81adcba1..42bffd78 100644
--- a/src/script.rs
+++ b/src/script.rs
@@ -33,6 +33,7 @@ use secp256k1_zkp::{Verification, Secp256k1};
 use crate::encode::{self, Decodable, Encodable};
 use crate::hashes::Hash;
 use crate::{hex, opcodes, ScriptHash, WScriptHash, PubkeyHash, WPubkeyHash};
+use crate::Len64 as _;
 
 use bitcoin::PublicKey;
 
@@ -780,7 +781,7 @@ impl Builder {
     #[must_use]
     pub fn push_slice(mut self, data: &[u8]) -> Builder {
         // Start with a PUSH opcode
-        match data.len() as u64 {
+        match data.len64() {
             n if n < opcodes::Ordinary::OP_PUSHDATA1 as u64 => { self.0.push(n as u8); },
             n if n < 0x100 => {
                 self.0.push(opcodes::Ordinary::OP_PUSHDATA1.into_u8());
diff --git a/src/transaction.rs b/src/transaction.rs
index 33437117..42540d48 100644
--- a/src/transaction.rs
+++ b/src/transaction.rs
@@ -28,7 +28,7 @@ use crate::issuance::AssetId;
 use crate::opcodes;
 use crate::parse::impl_parse_str_through_int;
 use crate::script::Instruction;
-use crate::{LockTime, Script, Txid, Wtxid};
+use crate::{LockTime, Script, Txid, Weight, Wtxid};
 use secp256k1_zkp::{
     RangeProof, SurjectionProof, Tweak, ZERO_TWEAK,
 };
@@ -898,33 +898,35 @@ impl Transaction {
 
     /// Get the "weight" of this transaction; roughly equivalent to BIP141, in that witness data is
     /// counted as 1 while non-witness data is counted as 4.
-    pub fn weight(&self) -> usize {
-        self.scaled_size(4)
+    pub fn weight(&self) -> Weight {
+        Weight::from_wu(self.scaled_size(4))
     }
 
     /// Gets the regular byte-wise consensus-serialized size of this transaction.
+    #[deprecated(since = "0.26.0", note = "use Self::weight or Self::vsize or Self::encoded_length instead")]
     pub fn size(&self) -> usize {
-        self.scaled_size(1)
+        self.scaled_size(1) as usize
     }
 
     /// Returns the "virtual size" (vsize) of this transaction.
     ///
     /// Will be `ceil(weight / 4.0)`.
     #[inline]
-    pub fn vsize(&self) -> usize {
-        let weight = self.weight();
-        (weight + 4 - 1) / 4
+    pub fn vsize(&self) -> u64 {
+        self.weight().to_vbytes_ceil()
     }
 
     /// Get the "discount weight" of this transaction; this is the weight minus the output witnesses and minus the
     /// differences between asset and nonce commitments from their explicit values (weighted as part of the base transaction).
-    pub fn discount_weight(&self) -> usize {
+    pub fn discount_weight(&self) -> Weight {
+        use crate::Len64 as _;
+
         let mut weight = self.scaled_size(4);
 
         for out in &self.output {
-            let rp_len = out.witness.rangeproof_len();
-            let sp_len = out.witness.surjectionproof_len();
-            let witness_weight = VarInt(sp_len as u64).size() + sp_len + VarInt(rp_len as u64).size() + rp_len;
+            let rp_len = out.witness.rangeproof.len64();
+            let sp_len = out.witness.surjection_proof.len64();
+            let witness_weight = VarInt(sp_len).len64() + sp_len + VarInt(rp_len).len64() + rp_len;
             weight -= witness_weight.saturating_sub(2); // explicit transactions have 1 byte for each empty proof
             if out.value.is_confidential() {
                 weight -= (33 - 9) * 4;
@@ -934,79 +936,79 @@ impl Transaction {
             }
         }
 
-        weight
+        Weight::from_wu(weight)
     }
 
     /// Returns the "discount virtual size" (discountvsize) of this transaction.
     ///
     /// Will be `ceil(discount weight / 4.0)`.
-    pub fn discount_vsize(&self) -> usize {
-        (self.discount_weight() + 4 - 1) / 4
+    pub fn discount_vsize(&self) -> u64 {
+        self.discount_weight().to_vbytes_ceil()
     }
 
-    fn scaled_size(&self, scale_factor: usize) -> usize {
+    fn scaled_size(&self, scale_factor: u64) -> u64 {
+        use crate::Len64 as _;
+
         let witness_flag = self.has_witness();
 
         let input_weight = self.input.iter().map(|input| {
             scale_factor * (
                 32 + 4 + 4 + // output + nSequence
-                VarInt(input.script_sig.len() as u64).size() +
-                input.script_sig.len() + if input.has_issuance() {
+                VarInt(input.script_sig.len64()).len64() +
+                input.script_sig.len64() + if input.has_issuance() {
                     64 +
-                    input.asset_issuance.amount.encoded_length() +
-                    input.asset_issuance.inflation_keys.encoded_length()
+                    input.asset_issuance.amount.encoded_len64() +
+                    input.asset_issuance.inflation_keys.encoded_len64()
                 } else {
                     0
                 }
             ) + if witness_flag {
-                let amt_prf_len = input.witness.amount_rangeproof.as_ref()
-                    .map_or(0, |x| x.len());
-                let keys_prf_len = input.witness.inflation_keys_rangeproof.as_ref()
-                    .map_or(0, |x| x.len());
+                let amt_prf_len = input.witness.amount_rangeproof.len64();
+                let keys_prf_len = input.witness.inflation_keys_rangeproof.len64();
 
-                VarInt(amt_prf_len as u64).size() +
+                VarInt(amt_prf_len).len64() +
                 amt_prf_len +
-                VarInt(keys_prf_len as u64).size() +
+                VarInt(keys_prf_len).len64() +
                 keys_prf_len +
-                VarInt(input.witness.script_witness.len() as u64).size() +
+                VarInt(input.witness.script_witness.len64()).len64() +
                 input.witness.script_witness.iter().map(|wit|
-                    VarInt(wit.len() as u64).size() +
-                    wit.len()
-                ).sum::<usize>() +
-                VarInt(input.witness.pegin_witness.len() as u64).size() +
+                    VarInt(wit.len64()).len64() +
+                    wit.len64()
+                ).sum::<u64>() +
+                VarInt(input.witness.pegin_witness.len64()).len64() +
                 input.witness.pegin_witness.iter().map(|wit|
-                    VarInt(wit.len() as u64).size() +
-                    wit.len()
-                ).sum::<usize>()
+                    VarInt(wit.len64()).len64() +
+                    wit.len64()
+                ).sum::<u64>()
             } else {
                 0
             }
-        }).sum::<usize>();
+        }).sum::<u64>();
 
         let output_weight = self.output.iter().map(|output| {
             scale_factor * (
-                output.asset.encoded_length() +
-                output.value.encoded_length() +
-                output.nonce.encoded_length() +
-                VarInt(output.script_pubkey.len() as u64).size() +
-                output.script_pubkey.len()
+                output.asset.encoded_len64() +
+                output.value.encoded_len64() +
+                output.nonce.encoded_len64() +
+                VarInt(output.script_pubkey.len64()).len64() +
+                output.script_pubkey.len64()
             ) + if witness_flag {
-                let range_prf_len = output.witness.rangeproof_len();
-                let surj_prf_len = output.witness.surjectionproof_len();
-                VarInt(surj_prf_len as u64).size() +
+                let range_prf_len = output.witness.rangeproof.len64();
+                let surj_prf_len = output.witness.surjection_proof.len64();
+                VarInt(surj_prf_len).len64() +
                 surj_prf_len +
-                VarInt(range_prf_len as u64).size() +
+                VarInt(range_prf_len).len64() +
                 range_prf_len
             } else {
                 0
             }
-        }).sum::<usize>();
+        }).sum::<u64>();
 
         scale_factor * (
             4 + // version
             4 + // locktime
-            VarInt(self.input.len() as u64).size() +
-            VarInt(self.output.len() as u64).size() +
+            VarInt(self.input.len64()).len64() +
+            VarInt(self.output.len64()).len64() +
             1 // segwit flag byte (note this is *not* witness data in Elements)
         ) + input_weight + output_weight
     }
@@ -1355,8 +1357,8 @@ mod tests {
         );
         assert_eq!(tx.input.len(), 1);
         assert_eq!(tx.output.len(), 2);
-        assert_eq!(tx.size(), serialize(&tx).len());
-        assert_eq!(tx.weight(), tx.size() * 4);
+        assert_eq!(tx.encoded_length(), serialize(&tx).len());
+        assert_eq!(tx.weight().to_wu(), tx.vsize() * 4);
         assert!(!tx.output[0].is_fee());
         assert!(tx.output[1].is_fee());
         assert_eq!(tx.output[0].value, confidential::Value::Explicit(9_999_996_700));
@@ -1565,8 +1567,8 @@ mod tests {
             tx.txid().to_string(),
             "d606b563122409191e3b114a41d5611332dc58237ad5d2dccded302664fd56c4"
         );
-        assert_eq!(tx.size(), serialize(&tx).len());
-        assert_eq!(tx.weight(), 7296);
+        assert_eq!(tx.encoded_length(), serialize(&tx).len());
+        assert_eq!(tx.weight().to_wu(), 7296);
         assert_eq!(tx.input.len(), 1);
         assert!(!tx.input[0].is_coinbase());
         assert!(!tx.is_coinbase());
@@ -1608,8 +1610,8 @@ mod tests {
             "cc1f895908af2509e55719e662acf4a50ca4dcf0454edd718459241745e2b0aa"
         );
         assert_eq!(tx.input.len(), 1);
-        assert_eq!(tx.size(), serialize(&tx).len());
-        assert_eq!(tx.weight(), 769);
+        assert_eq!(tx.encoded_length(), serialize(&tx).len());
+        assert_eq!(tx.weight().to_wu(), 769);
         assert!(tx.input[0].is_coinbase());
         assert!(!tx.input[0].is_pegin());
         assert_eq!(tx.input[0].pegin_data(), None);
@@ -2420,89 +2422,89 @@ mod tests {
         assert_eq!(tx.input.len(), 1);
         assert!(tx.input[0].is_pegin());
         assert_eq!(tx.output.len(), 2);
-        assert_eq!(tx.weight(), 2403);
+        assert_eq!(tx.weight().to_wu(), 2403);
         assert_eq!(tx.vsize(), 601);
-        assert_eq!(tx.discount_weight(), 2403);
+        assert_eq!(tx.discount_weight().to_wu(), 2403);
         assert_eq!(tx.discount_vsize(), 601);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/1in2out_tx.hex"));
         assert_eq!(tx.input.len(), 1);
         assert_eq!(tx.output.len(), 2);
-        assert_eq!(tx.weight(), 5330);
+        assert_eq!(tx.weight().to_wu(), 5330);
         assert_eq!(tx.vsize(), 1333);
-        assert_eq!(tx.discount_weight(), 863);
+        assert_eq!(tx.discount_weight().to_wu(), 863);
         assert_eq!(tx.discount_vsize(), 216);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/1in3out_tx.hex"));
         assert_eq!(tx.input.len(), 1);
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.weight(), 10107);
+        assert_eq!(tx.weight().to_wu(), 10107);
         assert_eq!(tx.vsize(), 2527);
-        assert_eq!(tx.discount_weight(), 1173);
+        assert_eq!(tx.discount_weight().to_wu(), 1173);
         assert_eq!(tx.discount_vsize(), 294);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in3out_exp.hex"));
         assert_eq!(tx.input.len(), 2);
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.weight(), 1302);
+        assert_eq!(tx.weight().to_wu(), 1302);
         assert_eq!(tx.vsize(), 326);
-        assert_eq!(tx.discount_weight(), 1302);
+        assert_eq!(tx.discount_weight().to_wu(), 1302);
         assert_eq!(tx.discount_vsize(), 326);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in3out_tx.hex"));
         assert_eq!(tx.input.len(), 2);
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.weight(), 10300);
+        assert_eq!(tx.weight().to_wu(), 10300);
         assert_eq!(tx.vsize(), 2575);
-        assert_eq!(tx.discount_weight(), 1302);
+        assert_eq!(tx.discount_weight().to_wu(), 1302);
         assert_eq!(tx.discount_vsize(), 326);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in3out_tx.hex"));
         assert_eq!(tx.input.len(), 2);
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.weight(), 10300);
+        assert_eq!(tx.weight().to_wu(), 10300);
         assert_eq!(tx.vsize(), 2575);
-        assert_eq!(tx.discount_weight(), 1302);
+        assert_eq!(tx.discount_weight().to_wu(), 1302);
         assert_eq!(tx.discount_vsize(), 326);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in3out_tx2.hex"));
         assert_eq!(tx.input.len(), 2);
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.weight(), 10536);
+        assert_eq!(tx.weight().to_wu(), 10536);
         assert_eq!(tx.vsize(), 2634);
-        assert_eq!(tx.discount_weight(), 1538);
+        assert_eq!(tx.discount_weight().to_wu(), 1538);
         assert_eq!(tx.discount_vsize(), 385);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/3in3out_tx.hex"));
         assert_eq!(tx.input.len(), 3);
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.weight(), 10922);
+        assert_eq!(tx.weight().to_wu(), 10922);
         assert_eq!(tx.vsize(), 2731);
-        assert_eq!(tx.discount_weight(), 1860);
+        assert_eq!(tx.discount_weight().to_wu(), 1860);
         assert_eq!(tx.discount_vsize(), 465);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/4in3out_tx.hex"));
         assert_eq!(tx.input.len(), 4);
         assert_eq!(tx.output.len(), 3);
-        assert_eq!(tx.weight(), 11192);
+        assert_eq!(tx.weight().to_wu(), 11192);
         assert_eq!(tx.vsize(), 2798);
-        assert_eq!(tx.discount_weight(), 2130);
+        assert_eq!(tx.discount_weight().to_wu(), 2130);
         assert_eq!(tx.discount_vsize(), 533);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in4out_tx.hex"));
         assert_eq!(tx.input.len(), 2);
         assert_eq!(tx.output.len(), 4);
-        assert_eq!(tx.weight(), 15261);
+        assert_eq!(tx.weight().to_wu(), 15261);
         assert_eq!(tx.vsize(), 3816);
-        assert_eq!(tx.discount_weight(), 1764);
+        assert_eq!(tx.discount_weight().to_wu(), 1764);
         assert_eq!(tx.discount_vsize(), 441);
 
         let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in5out_tx.hex"));
         assert_eq!(tx.input.len(), 2);
         assert_eq!(tx.output.len(), 5);
-        assert_eq!(tx.weight(), 20030);
+        assert_eq!(tx.weight().to_wu(), 20030);
         assert_eq!(tx.vsize(), 5008);
-        assert_eq!(tx.discount_weight(), 2034);
+        assert_eq!(tx.discount_weight().to_wu(), 2034);
         assert_eq!(tx.discount_vsize(), 509);
     }
 }