diff --git a/Cargo.toml b/Cargo.toml
index f6b8444a..2b3b32a1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,23 +15,22 @@ default = ["json-contract"]
 json-contract = ["serde_json"]
 "serde" = [
     "bitcoin/serde",
-    "bitcoin/serde",
+    "bitcoin-units/serde",
     "secp256k1-zkp/serde",
-    "actual-serde",
+    "dep:serde",
 ]
 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.
 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/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..d5af7fa4 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();
             }
@@ -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();
@@ -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/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/block.rs b/src/block.rs
index f16f790f..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,29 +366,19 @@ impl Block {
     }
 
     /// 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
+    #[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
-    #[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());
-        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
     }
 }
@@ -466,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!(
@@ -678,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/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..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};
 
@@ -147,6 +148,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
@@ -208,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())
 }
@@ -320,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 b54fc1f5..57df6dac 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;
 
@@ -65,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;
@@ -74,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::{
@@ -95,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/locktime.rs b/src/locktime.rs
index e93f10b6..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).
 ///
@@ -66,8 +52,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(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
 pub enum LockTime {
     /// A block height lock time value.
     ///
@@ -98,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`.
     ///
@@ -132,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))
     }
@@ -148,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))
     }
@@ -276,6 +260,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> {
@@ -291,302 +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(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
-pub struct Height(u32);
-
-impl Height {
-    /// Height zero
-    pub const ZERO: Self = Height(0);
-
-    /// Constructs a new block height.
-    ///
-    /// # Errors
-    ///
-    /// 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(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
-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::*;
diff --git a/src/pset/map/global.rs b/src/pset/map/global.rs
index 4f9b0e24..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(Serialize, Deserialize), serde(crate = "actual_serde"))]
 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(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct Global {
     /// Global transaction data
-    #[cfg_attr(feature = "serde", serde(flatten))]
     pub tx_data: TxData,
     /// The version number of this PSET. Must be present.
     pub version: u32,
@@ -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 72702525..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(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct Input {
     /// The non-witness transaction this input spends from. Should only be
     /// [`std::option::Option::Some`] for inputs which spend non-segwit outputs or
@@ -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 d86d3389..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(Serialize, Deserialize), serde(crate = "actual_serde"))]
 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(Serialize, Deserialize), serde(crate = "actual_serde"))]
 pub struct TapTree(pub(crate) TaprootBuilder);
 
 impl PartialEq for TapTree {
diff --git a/src/pset/mod.rs b/src/pset/mod.rs
index 532826ec..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(Serialize, Deserialize), serde(crate = "actual_serde"))]
 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 66a4b9a2..0f11b669 100644
--- a/src/pset/raw.rs
+++ b/src/pset/raw.rs
@@ -24,16 +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(Serialize, Deserialize),
-    serde(crate = "actual_serde")
-)]
 pub struct Key {
     /// The type of this PSET key.
     pub type_value: u8,
     /// The key itself in raw byte form.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub key: Vec<u8>,
 }
 
@@ -51,16 +45,10 @@ impl Key {
 
 /// A PSET key-value pair in its raw byte form.
 #[derive(Debug, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "actual_serde")
-)]
 pub struct Pair {
     /// The key of this key-value pair.
     pub key: Key,
     /// The value of this key-value pair in raw byte form.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::hex_bytes"))]
     pub value: Vec<u8>,
 }
 
@@ -69,11 +57,6 @@ pub type ProprietaryType = u8;
 
 /// Proprietary keys (i.e. keys starting with 0xFC byte) with their internal
 /// structure according to BIP 174.
-#[cfg_attr(
-    feature = "serde",
-    derive(Serialize, Deserialize),
-    serde(crate = "actual_serde")
-)]
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
 pub struct ProprietaryKey<Subtype = ProprietaryType>
 where
@@ -81,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>,
 }
 
@@ -118,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)?);
         }
@@ -146,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/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/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/serde_utils.rs b/src/serde_utils.rs
deleted file mode 100644
index 0c9dd806..00000000
--- a/src/serde_utils.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-//! Module for special serde serializations.
-//! Copied from rust-bitcoin as is.
-pub mod btreemap_byte_values {
-    //! Module for serialization of `BTreeMaps` with hex byte values.
-    #![allow(missing_docs)]
-
-    // NOTE: This module can be exactly copied to use with HashMap.
-
-    use ::std::collections::BTreeMap;
-    use 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, Deserialize)]
-    #[serde(crate = "actual_serde")]
-    struct OwnedPair<T>(
-        T,
-        #[serde(deserialize_with = "crate::serde_utils::hex_bytes::deserialize")]
-        Vec<u8>,
-    );
-
-    /// A custom key-value pair type that serialized the bytes as hex.
-    #[derive(Debug, Serialize)]
-    #[serde(crate = "actual_serde")]
-    struct BorrowedPair<'a, T: 'static>(
-        &'a T,
-        #[serde(serialize_with = "crate::serde_utils::hex_bytes::serialize")]
-        &'a [u8],
-    );
-
-    pub fn serialize<S, T>(v: &BTreeMap<T, Vec<u8>>, s: S)
-        -> Result<S::Ok, S::Error> where
-        S: serde::Serializer,
-        T: serde::Serialize + ::std::hash::Hash + Eq + Ord + 'static,
-    {
-        use serde::ser::SerializeSeq;
-
-        // Don't do anything special when not human readable.
-        if s.is_human_readable() {
-            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)
-        }
-    }
-}
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..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,
 };
@@ -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)]
@@ -899,46 +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.
-    #[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()
+    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;
@@ -948,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
     }
@@ -1369,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));
@@ -1579,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());
@@ -1622,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);
@@ -2434,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);
     }
 }