diff --git a/Cargo-recent.lock b/Cargo-recent.lock
index f83c2120..54c72aa2 100644
--- a/Cargo-recent.lock
+++ b/Cargo-recent.lock
@@ -22,12 +22,11 @@ checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "base58ck"
-version = "0.1.0"
+version = "0.1.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c8d66485a3a2ea485c1913c4572ce0256067a5377ac8c75c4960e1cda98605f"
+checksum = "365c0acd5b2e8dd0111a46c4faea83fb3cfb6e39a49a7c73a06e090db7b2eff0"
 dependencies = [
- "bitcoin-internals 0.3.0",
- "bitcoin_hashes 0.14.0",
+ "bitcoin_hashes 0.14.101",
 ]
 
 [[package]]
@@ -59,18 +58,18 @@ dependencies = [
 
 [[package]]
 name = "bitcoin"
-version = "0.32.6"
+version = "0.32.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad8929a18b8e33ea6b3c09297b687baaa71fb1b97353243a3f1029fad5c59c5b"
+checksum = "bb0ce8bd5baaa0d303a19915a6d93afed161f528654e42da2a7a97d05c59499a"
 dependencies = [
  "base58ck",
  "base64 0.21.7",
  "bech32",
- "bitcoin-internals 0.3.0",
+ "bitcoin-consensus-encoding",
  "bitcoin-io",
  "bitcoin-units",
- "bitcoin_hashes 0.14.0",
- "hex-conservative 0.2.1",
+ "bitcoin_hashes 0.14.101",
+ "hex-conservative 0.2.2",
  "hex_lit",
  "secp256k1",
  "serde",
@@ -78,33 +77,29 @@ dependencies = [
 
 [[package]]
 name = "bitcoin-consensus-encoding"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2d6094e2a1ba3c93b5a596fe5a10d1a10c3c6e06785cde89f693a044c01aa40"
-dependencies = [
- "bitcoin-internals 0.5.0",
-]
-
-[[package]]
-name = "bitcoin-internals"
-version = "0.3.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30bdbe14aa07b06e6cfeffc529a1f099e5fbe249524f8125358604df99a4bed2"
+checksum = "207311705279250ba465076a1bac4b1ac982855fff73fc5f67e22158ac58cdc9"
 dependencies = [
+ "bitcoin-internals",
+ "hex-conservative 1.1.0",
  "serde",
 ]
 
 [[package]]
 name = "bitcoin-internals"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a30a22d1f112dde8e16be7b45c63645dc165cef254f835b3e1e9553e485cfa64"
+checksum = "d573f4cf32996a8dce612e4348cece65a241f1882ed594047c9ba348e8869fa5"
 
 [[package]]
 name = "bitcoin-io"
-version = "0.1.3"
+version = "0.1.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b47c4ab7a93edb0c7198c5535ed9b52b63095f4e9b45279c6736cec4b856baf"
+checksum = "bb5de036369d1ac59d3c1819ebc4d850f89466f5401c571a285b6ed564a4cb78"
+dependencies = [
+ "bitcoin-consensus-encoding",
+]
 
 [[package]]
 name = "bitcoin-private"
@@ -114,33 +109,33 @@ checksum = "73290177011694f38ec25e165d0387ab7ea749a4b81cd4c80dae5988229f7a57"
 
 [[package]]
 name = "bitcoin-units"
-version = "0.1.2"
+version = "0.1.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5285c8bcaa25876d07f37e3d30c303f2609179716e11d688f51e8f1fe70063e2"
+checksum = "9cb95693f371d089a4b5b6fc41c6f3ea6e01ee8c15388335dfac8ea685173b51"
 dependencies = [
- "bitcoin-internals 0.3.0",
+ "bitcoin-consensus-encoding",
  "serde",
 ]
 
 [[package]]
 name = "bitcoin_hashes"
-version = "0.14.0"
+version = "0.14.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb18c03d0db0247e147a21a6faafd5a7eb851c743db062de72018b6b7e8e4d16"
+checksum = "bca4c7abb40c8817d77403c880988cfd484f23ab2365726afb2f798363e2c4a2"
 dependencies = [
  "bitcoin-io",
- "hex-conservative 0.2.1",
+ "hex-conservative 0.2.2",
  "serde",
 ]
 
 [[package]]
 name = "bitcoin_hashes"
-version = "1.0.0"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f70c29ac06e7effa19682e91318deae86bdb46c4fd1bbd0f12fd196ff427ab0"
+checksum = "a67800fcf7f3ca52f7796d4466948a424326b225950c79d1e76d0458760bb25d"
 dependencies = [
  "bitcoin-consensus-encoding",
- "bitcoin-internals 0.5.0",
+ "bitcoin-internals",
  "hex-conservative 1.1.0",
  "serde",
 ]
@@ -230,8 +225,9 @@ dependencies = [
  "bech32",
  "bincode",
  "bitcoin",
- "bitcoin-internals 0.5.0",
- "bitcoin_hashes 1.0.0",
+ "bitcoin-consensus-encoding",
+ "bitcoin-internals",
+ "bitcoin_hashes 1.1.0",
  "getrandom 0.2.16",
  "hex-conservative 1.1.0",
  "rand",
@@ -313,9 +309,9 @@ dependencies = [
 
 [[package]]
 name = "hex-conservative"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5313b072ce3c597065a808dbf612c4c8e8590bdbf8b579508bf7a762c5eae6cd"
+checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f"
 dependencies = [
  "arrayvec",
 ]
@@ -512,7 +508,7 @@ version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113"
 dependencies = [
- "bitcoin_hashes 0.14.0",
+ "bitcoin_hashes 0.14.101",
  "rand",
  "secp256k1-sys",
  "serde",
diff --git a/Cargo.toml b/Cargo.toml
index 256c2c16..5850b505 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,9 +29,10 @@ base64 = ["bitcoin/base64"]
 
 [dependencies]
 bech32 = "0.11.0"
-bitcoin = "0.32.2"
-hashes = { package = "bitcoin_hashes", version = "1.0", features = [ "hex" ] }
-internals = { package = "bitcoin-internals", version = "0.5" }
+bitcoin = { version = "0.32.102", default-features = false, features = [ "encoding", "std" ] }
+encoding = { package = "bitcoin-consensus-encoding", version = "1.1.0", default-features = false, features = [ "hex", "std" ] }
+hashes = { package = "bitcoin_hashes", version = "1.1", features = [ "hex" ] }
+internals = { package = "bitcoin-internals", version = "0.6" }
 secp256k1-zkp = { version = "0.11.0", features = ["global-context", "hashes"] }
 
 # Used for ContractHash::from_json_contract.
@@ -73,6 +74,7 @@ match_bool = "allow" # Adds extra indentation and LOC.
 match_same_arms = "allow" # Collapses things that are conceptually unrelated to each other.
 must_use_candidate = "allow" # Useful for audit but many false positives.
 similar_names = "allow" # Too many (subjectively) false positives.
+struct_field_names = "allow" # Dumb
 # Exhaustive list of pedantic clippy lints
 assigning_clones = "warn"
 bool_to_int_with_if = "warn"
@@ -167,7 +169,6 @@ stable_sort_primitive = "warn"
 str_split_at_newline = "warn"
 string_add_assign = "warn"
 struct_excessive_bools = "warn"
-struct_field_names = "warn"
 too_many_lines = "allow" # FIXME 14 triggers for this lint; probably most should be fixed
 transmute_ptr_to_ptr = "warn"
 trivially_copy_pass_by_ref = "warn"
@@ -191,7 +192,6 @@ zero_sized_map_values = "warn"
 [package.metadata.rbmt.lint]
 allowed_duplicates = [
     "bitcoin_hashes",
-    "bitcoin-internals",
     "hex-conservative",
 ]
 
diff --git a/elementsd-tests/src/taproot.rs b/elementsd-tests/src/taproot.rs
index 0bfdc0c9..364c7230 100644
--- a/elementsd-tests/src/taproot.rs
+++ b/elementsd-tests/src/taproot.rs
@@ -223,7 +223,7 @@ fn taproot_spend_test(
             hash_ty: sighash_ty,
         };
 
-        tx.input[0].witness.script_witness = vec![schnorr_sig.to_vec()];
+        tx.input[0].witness.script_witness.push(schnorr_sig.to_vec());
     } else {
         // script spend
         // try spending using leaf1
@@ -250,11 +250,9 @@ fn taproot_spend_test(
             hash_ty: sighash_ty,
         };
 
-        tx.input[0].witness.script_witness = vec![
-            schnorr_sig.to_vec(), // witness
-            script_ver.0.into_bytes(), // leaf script
-            ctrl_block.serialize(), // control block
-        ];
+        tx.input[0].witness.script_witness.push(schnorr_sig.to_vec()); // witness
+        tx.input[0].witness.script_witness.push(script_ver.0.into_bytes()); // leaf script
+        tx.input[0].witness.script_witness.push(ctrl_block.serialize()); // control block
     }
 
     let tx_hex = serialize_hex(&tx);
diff --git a/examples/raw_blind.rs b/examples/raw_blind.rs
index c45be283..18a0e974 100644
--- a/examples/raw_blind.rs
+++ b/examples/raw_blind.rs
@@ -305,15 +305,13 @@ fn main() {
 
     // Finalize(TODO in miniscript)
     pset.inputs_mut()[0].partial_sigs.clear();
-    pset.inputs_mut()[0].final_script_witness = Some(vec![
-        inp0_sig,
-        inp0_pk.to_bytes(),
-    ]);
+    let wit = pset.inputs_mut()[0].final_script_witness.insert(elements::Witness::new());
+    wit.push(inp0_sig);
+    wit.push(inp0_pk.to_bytes());
     pset.inputs_mut()[1].partial_sigs.clear();
-    pset.inputs_mut()[1].final_script_witness = Some(vec![
-        inp1_sig,
-        inp1_pk.to_bytes(),
-    ]);
+    let wit = pset.inputs_mut()[1].final_script_witness.insert(elements::Witness::new());
+    wit.push(inp1_sig);
+    wit.push(inp1_pk.to_bytes());
     assert_eq!(pset, deser_pset(&tests["finalized"]));
 
     // Extracted tx
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index 14d0784b..5bbfee40 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -33,6 +33,13 @@ allowed_duplicates = [
     "wasi",
 ]
 
+[[bin]]
+name = "decode_equiv_transaction"
+path = "fuzz_targets/decode_equiv_transaction.rs"
+test = false
+doc = false
+bench = false
+
 [[bin]]
 name = "deserialize_block"
 path = "fuzz_targets/deserialize_block.rs"
diff --git a/fuzz/fuzz_targets/decode_equiv_transaction.rs b/fuzz/fuzz_targets/decode_equiv_transaction.rs
new file mode 100644
index 00000000..684a62b9
--- /dev/null
+++ b/fuzz/fuzz_targets/decode_equiv_transaction.rs
@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Fuzz test for equivalent decoding between the legacy and consensus-encoding decoding schemes.
+
+#![cfg_attr(fuzzing, no_main)]
+#![cfg_attr(not(fuzzing), allow(unused))]
+use libfuzzer_sys::fuzz_target;
+
+use elements::bitcoin::hex::DisplayHex as _;
+
+type Target = elements::Transaction;
+
+#[cfg(not(fuzzing))]
+fn main() {}
+
+struct DisplayError<'e>(&'e dyn std::error::Error);
+
+impl core::fmt::Display for DisplayError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{}", self.0)?;
+        let mut e = self.0;
+        while let Some(source) = e.source() {
+            writeln!(f, "caused by {}", source)?;
+            e = source;
+        }
+        Ok(())
+    }
+}
+
+fn do_test(data: &[u8]) {
+    let old: Result<Target, _> = elements::encode::deserialize(data);
+    let new: Result<Target, _> = elements::encoding::decode_from_slice(data);
+
+    match (old, new) {
+        (Err(_), Err(_)) => {},
+        (Err(e), Ok(new)) => {
+            let e = DisplayError(&e);
+            panic!("Decodable trait failed with {e}; Decode parsed {:?}", new);
+        }
+        (Ok(old), Err(e)) => {
+            let e = DisplayError(&e);
+            panic!("Decode trait failed with {e}; Decodable parsed {:?}", old);
+        }
+        (Ok(old), Ok(new)) => {
+            assert_eq!(
+                old, new,
+                "Decodable (left) did not match Decode (right)",
+            );
+
+            let reser_old = elements::encode::serialize(&old);
+            let reser_new = elements::encoding::encode_to_vec(&new);
+            assert_eq!(
+                reser_old, reser_new,
+                "Encodable (left) did not match Encode (right)\nOld hex: {}\nNew hex: {}\nTransaction: {:?}",
+                reser_old.as_hex(),
+                reser_new.as_hex(),
+                old,
+            );
+        }
+    }
+}
+
+fuzz_target!(|data: &[u8]| {
+    do_test(data);
+});
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn duplicate_crash() {
+        let v = elements::hex::decode_to_vec("abcd");
+        super::do_test(&v);
+    }
+}
diff --git a/rustfmt.toml b/rustfmt.toml
index 09b6229f..e9b78f17 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -2,6 +2,9 @@ ignore = [
     "/",
     "!/src/lib.rs",
     "!/src/confidential/*.rs",
+    "!/src/transaction/decoders.rs",
+    "!/src/transaction/encoders.rs",
+    "!/src/transaction/pegin_witness.rs"
 ]
 hard_tabs = false
 tab_spaces = 4
diff --git a/src/block.rs b/src/block.rs
index f022f1ae..c2153b33 100644
--- a/src/block.rs
+++ b/src/block.rs
@@ -360,7 +360,6 @@ pub struct Block {
     /// Complete list of transaction in the block
     pub txdata: Vec<Transaction>,
 }
-serde_struct_impl!(Block, header, txdata);
 impl_consensus_encoding!(Block, header, txdata);
 
 impl Block {
diff --git a/src/confidential/asset.rs b/src/confidential/asset.rs
index d419ebde..5636b4bf 100644
--- a/src/confidential/asset.rs
+++ b/src/confidential/asset.rs
@@ -10,7 +10,9 @@ use secp256k1_zkp::{self, Generator, Secp256k1, Signing, Tweak, ZERO_TWEAK};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+use super::CommitmentEncoder;
 use crate::encode::{self, Decodable, Encodable};
+use crate::encoding;
 use crate::issuance::AssetId;
 
 type ExplicitInner = AssetId;
@@ -18,6 +20,7 @@ type ConfInner = Generator;
 
 const EXPLICIT_LEN: usize = 32;
 const CONFIDENTIAL_LEN: usize = 33;
+const CONFIDENTIAL_LEN_LESS_PREFIX: usize = CONFIDENTIAL_LEN - 1;
 const CONF_PREFIX_1: u8 = 0x0a;
 const CONF_PREFIX_2: u8 = 0x0b;
 
@@ -344,3 +347,112 @@ impl<'de> Deserialize<'de> for BlindingFactor {
         }
     }
 }
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`Asset`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(CommitmentEncoder<'e>);
+}
+
+impl encoding::Encode for Asset {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(match *self {
+            Self::Null => CommitmentEncoder::Null(0),
+            Self::Explicit(ref id) => CommitmentEncoder::Explicit32(Some(1), id.as_byte_array()),
+            Self::Confidential(ref gen) => CommitmentEncoder::Explicit33(gen.serialize()),
+        })
+    }
+}
+
+decoder_state_machine! {
+    /// A decoder for the [`Asset`] type.
+    pub struct Decoder(enum DecoderInner {
+        Done(Asset),
+        Errored,
+        DecodePrefix {
+            decoder: encoding::ArrayDecoder<1>,
+            => transition_decode_prefix(prefix, ...) -> Result {
+                match prefix {
+                    [0] => Ok(DecoderInner::Done(Asset::Null)),
+                    [1] => {
+                        Ok(DecoderInner::DecodeExplicit { decoder: encoding::ArrayDecoder::default() })
+                    },
+                    [prefix @ (CONF_PREFIX_1 | CONF_PREFIX_2)] => {
+                        Ok(DecoderInner::DecodeConfidential { decoder: encoding::ArrayDecoder::default(), prefix })
+                    },
+                    [prefix] => Err(DecoderErrorInner::InvalidConfidentialPrefix { prefix })
+                }
+            }
+        },
+        DecodeExplicit {
+            decoder: encoding::ArrayDecoder<EXPLICIT_LEN>
+            => transition_decode_explicit(bytes, ...) -> Result {
+                Ok(DecoderInner::Done(Asset::Explicit(AssetId::from_byte_array(bytes))))
+            }
+        },
+        DecodeConfidential {
+            decoder: encoding::ArrayDecoder<CONFIDENTIAL_LEN_LESS_PREFIX>,
+            prefix: u8
+            => transition_decode_confidential(x_coord, ...) -> Result {
+                let mut bytes = [0; CONFIDENTIAL_LEN];
+                bytes[0] = prefix;
+                bytes[1..].copy_from_slice(&x_coord);
+                let gen = ConfInner::from_slice(&bytes)
+                    .map_err(DecoderErrorInner::InvalidCommitment)?;
+                Ok(DecoderInner::Done(Asset::Confidential(gen)))
+            }
+        },
+    });
+
+    /// A decoder error for the [`Asset`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        [macro-inserted decoder variants]
+        /// Confidential prefix was not one of the two allowable values.
+        InvalidConfidentialPrefix {
+            prefix: u8,
+        },
+        /// Malformed confidential commitment.
+        InvalidCommitment(secp256k1_zkp::Error),
+    });
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(_) => f.write_str("failed to decode prefix"),
+            Inner::DecodeExplicit(_) => f.write_str("failed to decode explicit value"),
+            Inner::DecodeConfidential(_) => f.write_str("failed to decode confidential value"),
+            Inner::InvalidConfidentialPrefix { prefix, .. } => {
+                write!(
+                    f,
+                    "confidential prefix 0x{:02x} was not one of 0, 1, 0x{:02x} or 0x{:02x}",
+                    prefix, CONF_PREFIX_1, CONF_PREFIX_2,
+                )
+            }
+            Inner::InvalidCommitment(_) => f.write_str("failed to parse confidential commitment"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(ref e) => Some(e),
+            Inner::DecodeExplicit(ref e) => Some(e),
+            Inner::DecodeConfidential(ref e) => Some(e),
+            Inner::InvalidConfidentialPrefix { .. } => None,
+            Inner::InvalidCommitment(ref e) => Some(e),
+        }
+    }
+}
+
+impl Default for Decoder {
+    fn default() -> Self {
+        Self(DecoderInner::DecodePrefix { decoder: encoding::ArrayDecoder::default() })
+    }
+}
diff --git a/src/confidential/mod.rs b/src/confidential/mod.rs
index b6dbe807..22fe9542 100644
--- a/src/confidential/mod.rs
+++ b/src/confidential/mod.rs
@@ -25,17 +25,120 @@ mod range_proof;
 mod surjection_proof;
 mod value;
 
-use core::fmt;
+use core::{fmt, slice};
 
 use secp256k1_zkp;
 
-pub use self::asset::{Asset, BlindingFactor as AssetBlindingFactor};
-pub use self::nonce::Nonce;
-pub use self::range_proof::RangeProof;
-pub use self::surjection_proof::SurjectionProof;
-pub use self::value::{BlindingFactor as ValueBlindingFactor, Value};
-use crate::encode;
+pub use self::asset::{
+    Asset, BlindingFactor as AssetBlindingFactor, Decoder as AssetDecoder,
+    DecoderError as AssetDecoderError, Encoder as AssetEncoder,
+};
+pub use self::nonce::{
+    Decoder as NonceDecoder, DecoderError as NonceDecoderError, Encoder as NonceEncoder, Nonce,
+};
+pub use self::range_proof::{
+    Decoder as RangeProofDecoder, DecoderError as RangeProofDecoderError,
+    Encoder as RangeProofEncoder, RangeProof,
+};
+pub use self::surjection_proof::{
+    Decoder as SurjectionProofDecoder, DecoderError as SurjectionProofDecoderError,
+    Encoder as SurjectionProofEncoder, SurjectionProof,
+};
+pub use self::value::{
+    BlindingFactor as ValueBlindingFactor, Decoder as ValueDecoder,
+    DecoderError as ValueDecoderError, Encoder as ValueEncoder, Value,
+};
 use crate::issuance::AssetId;
+use crate::{encode, encoding};
+
+#[derive(Clone, Debug)]
+enum CommitmentEncoder<'e> {
+    Null(u8),
+    Explicit8(Option<u8>, [u8; 8]),
+    Explicit32(Option<u8>, &'e [u8; 32]),
+    Explicit33([u8; 33]),
+}
+
+impl encoding::Encoder for CommitmentEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] {
+        match *self {
+            Self::Null(ref prefix) => slice::from_ref(prefix),
+            Self::Explicit8(ref prefix, ref arr) => prefix.as_ref().map_or(arr, slice::from_ref),
+            Self::Explicit32(ref prefix, arr) => prefix.as_ref().map_or(arr, slice::from_ref),
+            Self::Explicit33(ref arr) => arr,
+        }
+    }
+
+    fn advance(&mut self) -> encoding::EncoderStatus {
+        match *self {
+            Self::Explicit8(ref mut prefix @ Some(_), _)
+            | Self::Explicit32(ref mut prefix @ Some(_), _) => {
+                *prefix = None;
+                encoding::EncoderStatus::HasMore
+            }
+            _ => encoding::EncoderStatus::Finished,
+        }
+    }
+}
+
+impl encoding::ExactSizeEncoder for CommitmentEncoder<'_> {
+    fn len(&self) -> usize {
+        match *self {
+            Self::Null(_) => 1,
+            Self::Explicit8(Some(_), _) => 9,
+            Self::Explicit8(None, _) => 8,
+            Self::Explicit32(Some(_), _) => 33,
+            Self::Explicit32(None, _) => 32,
+            Self::Explicit33(_) => 33,
+        }
+    }
+}
+
+/// Because the rust-secp256k1-zkp proof types have no `as_bytes()` method, we need
+/// to serialize them to a byte vector before encoding them.
+///
+/// This encoder accomplishes that -- this situation never happens in rust-bitcoin
+/// so there is no "owned bytes encoder" shipped with bitcoin-consensus-encoding.
+#[derive(Clone, Debug)]
+struct PrefixedByteVecEncoder {
+    prefix_encoder: Option<encoding::CompactSizeEncoder>,
+    data: Vec<u8>,
+}
+
+impl PrefixedByteVecEncoder {
+    pub fn new(data: Vec<u8>) -> Self {
+        Self { prefix_encoder: Some(encoding::CompactSizeEncoder::new(data.len())), data }
+    }
+}
+
+impl encoding::Encoder for PrefixedByteVecEncoder {
+    fn current_chunk(&self) -> &[u8] {
+        if let Some(ref enc) = self.prefix_encoder {
+            return enc.current_chunk();
+        }
+        &self.data
+    }
+
+    fn advance(&mut self) -> encoding::EncoderStatus {
+        if let Some(ref mut enc) = self.prefix_encoder {
+            if enc.advance().has_finished() {
+                self.prefix_encoder = None;
+                if self.data.is_empty() {
+                    return encoding::EncoderStatus::Finished;
+                }
+            }
+            encoding::EncoderStatus::HasMore
+        } else {
+            encoding::EncoderStatus::Finished
+        }
+    }
+}
+
+impl encoding::ExactSizeEncoder for PrefixedByteVecEncoder {
+    fn len(&self) -> usize {
+        self.prefix_encoder.as_ref().map_or(0, encoding::CompactSizeEncoder::len) + self.data.len()
+    }
+}
 
 /// Error decoding hexadecimal string into tweak-like value.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -96,6 +199,7 @@ mod tests {
 
     use super::*;
     use crate::encode::Encodable as _;
+    use crate::encoding;
 
     const VALUE_EXPLICIT: [u8; 9] = [1, 0, 0, 0, 0, 0, 0, 3, 232];
 
@@ -139,6 +243,15 @@ mod tests {
         1, 1, 1, 1,
     ];
 
+    #[test]
+    fn prefixed_byte_encoder() {
+        assert_eq!(encoding::drain_to_vec(&mut PrefixedByteVecEncoder::new(vec![])), [0]);
+        assert_eq!(
+            encoding::drain_to_vec(&mut PrefixedByteVecEncoder::new(vec![1, 2, 3])),
+            [3, 1, 2, 3]
+        );
+    }
+
     #[test]
     fn encode_length() {
         let val_encodings = [
@@ -158,6 +271,9 @@ mod tests {
             assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
             assert_eq!(x.len(), v.encoded_length());
             assert_eq!(x, *enc);
+
+            assert_eq!(encoding::encode_to_vec(v), *enc);
+            assert_eq!(encoding::decode_from_slice(enc), Ok(*v));
         }
 
         let nonce_encodings = [
@@ -177,6 +293,9 @@ mod tests {
             assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
             assert_eq!(x.len(), v.encoded_length());
             assert_eq!(x, *enc);
+
+            assert_eq!(encoding::encode_to_vec(v), *enc);
+            assert_eq!(encoding::decode_from_slice(enc), Ok(*v));
         }
 
         let asset_encodings = [
@@ -196,6 +315,9 @@ mod tests {
             assert_eq!(v.consensus_encode(&mut x).unwrap(), v.encoded_length());
             assert_eq!(x.len(), v.encoded_length());
             assert_eq!(x, *enc);
+
+            assert_eq!(encoding::encode_to_vec(v), *enc);
+            assert_eq!(encoding::decode_from_slice(enc), Ok(*v));
         }
     }
 
@@ -207,6 +329,7 @@ mod tests {
         assert_eq!(x, Value::from_commitment(&commitment[..]).unwrap());
         commitment[0] = 42;
         assert!(Value::from_commitment(&commitment[..]).is_err());
+        assert_eq!(encoding::encode_to_vec(&x), VALUE_COMMITMENT1);
 
         let x = Asset::from_commitment(&ASSET_COMMITMENT1).unwrap();
         let commitment = x.commitment().unwrap();
@@ -214,6 +337,7 @@ mod tests {
         assert_eq!(x, Asset::from_commitment(&commitment[..]).unwrap());
         commitment[0] = 42;
         assert!(Asset::from_commitment(&commitment[..]).is_err());
+        assert_eq!(encoding::encode_to_vec(&x), ASSET_COMMITMENT1);
 
         let x = Nonce::from_commitment(&NONCE_COMMITMENT1).unwrap();
         let commitment = x.commitment().unwrap();
@@ -221,6 +345,7 @@ mod tests {
         assert_eq!(x, Nonce::from_commitment(&commitment[..]).unwrap());
         commitment[0] = 42;
         assert!(Nonce::from_commitment(&commitment[..]).is_err());
+        assert_eq!(encoding::encode_to_vec(&x), NONCE_COMMITMENT1);
     }
 
     #[cfg(feature = "serde")]
diff --git a/src/confidential/nonce.rs b/src/confidential/nonce.rs
index 0d9ca000..12310e0c 100644
--- a/src/confidential/nonce.rs
+++ b/src/confidential/nonce.rs
@@ -10,7 +10,9 @@ use secp256k1_zkp::{self, PublicKey, Secp256k1, SecretKey, Signing};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+use super::CommitmentEncoder;
 use crate::encode::{self, Decodable, Encodable};
+use crate::encoding;
 use crate::hashes::sha256d;
 
 type ExplicitInner = [u8; 32];
@@ -18,6 +20,7 @@ type ConfInner = PublicKey;
 
 const EXPLICIT_LEN: usize = 32;
 const CONFIDENTIAL_LEN: usize = 33;
+const CONFIDENTIAL_LEN_LESS_PREFIX: usize = CONFIDENTIAL_LEN - 1;
 const CONF_PREFIX_1: u8 = 0x02;
 const CONF_PREFIX_2: u8 = 0x03;
 
@@ -247,3 +250,112 @@ impl<'de> Deserialize<'de> for Nonce {
         d.deserialize_seq(CommitVisitor)
     }
 }
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`Nonce`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(CommitmentEncoder<'e>);
+}
+
+impl encoding::Encode for Nonce {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(match *self {
+            Self::Null => CommitmentEncoder::Null(0),
+            Self::Explicit(ref id) => CommitmentEncoder::Explicit32(Some(1), id),
+            Self::Confidential(ref gen) => CommitmentEncoder::Explicit33(gen.serialize()),
+        })
+    }
+}
+
+decoder_state_machine! {
+    /// A decoder for the [`Nonce`] type.
+    pub struct Decoder(enum DecoderInner {
+        Done(Nonce),
+        Errored,
+        DecodePrefix {
+            decoder: encoding::ArrayDecoder<1>,
+            => transition_decode_prefix(prefix, ...) -> Result {
+                match prefix {
+                    [0] => Ok(DecoderInner::Done(Nonce::Null)),
+                    [1] => {
+                        Ok(DecoderInner::DecodeExplicit { decoder: encoding::ArrayDecoder::default() })
+                    },
+                    [prefix @ (CONF_PREFIX_1 | CONF_PREFIX_2)] => {
+                        Ok(DecoderInner::DecodeConfidential { decoder: encoding::ArrayDecoder::default(), prefix })
+                    },
+                    [prefix] => Err(DecoderErrorInner::InvalidConfidentialPrefix { prefix })
+                }
+            }
+        },
+        DecodeExplicit {
+            decoder: encoding::ArrayDecoder<EXPLICIT_LEN>
+            => transition_decode_explicit(bytes, ...) -> Result {
+                Ok(DecoderInner::Done(Nonce::Explicit(bytes)))
+            }
+        },
+        DecodeConfidential {
+            decoder: encoding::ArrayDecoder<CONFIDENTIAL_LEN_LESS_PREFIX>,
+            prefix: u8
+            => transition_decode_confidential(x_coord, ...) -> Result {
+                let mut bytes = [0; CONFIDENTIAL_LEN];
+                bytes[0] = prefix;
+                bytes[1..].copy_from_slice(&x_coord);
+                let gen = ConfInner::from_slice(&bytes)
+                    .map_err(DecoderErrorInner::InvalidCommitment)?;
+                Ok(DecoderInner::Done(Nonce::Confidential(gen)))
+            }
+        },
+    });
+
+    /// A decoder error for the [`Nonce`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        [macro-inserted decoder variants]
+        /// Confidential prefix was not one of the two allowable values.
+        InvalidConfidentialPrefix {
+            prefix: u8,
+        },
+        /// Malformed confidential commitment.
+        InvalidCommitment(bitcoin::secp256k1::Error),
+    });
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(_) => f.write_str("failed to decode prefix"),
+            Inner::DecodeExplicit(_) => f.write_str("failed to decode explicit value"),
+            Inner::DecodeConfidential(_) => f.write_str("failed to decode confidential value"),
+            Inner::InvalidConfidentialPrefix { prefix, .. } => {
+                write!(
+                    f,
+                    "confidential prefix 0x{:02x} was not one of 0, 1, 0x{:02x} or 0x{:02x}",
+                    prefix, CONF_PREFIX_1, CONF_PREFIX_2,
+                )
+            }
+            Inner::InvalidCommitment(_) => f.write_str("failed to parse confidential commitment"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(ref e) => Some(e),
+            Inner::DecodeExplicit(ref e) => Some(e),
+            Inner::DecodeConfidential(ref e) => Some(e),
+            Inner::InvalidConfidentialPrefix { .. } => None,
+            Inner::InvalidCommitment(ref e) => Some(e),
+        }
+    }
+}
+
+impl Default for Decoder {
+    fn default() -> Self {
+        Self(DecoderInner::DecodePrefix { decoder: encoding::ArrayDecoder::default() })
+    }
+}
diff --git a/src/confidential/range_proof.rs b/src/confidential/range_proof.rs
index 89894333..441b8c4f 100644
--- a/src/confidential/range_proof.rs
+++ b/src/confidential/range_proof.rs
@@ -3,6 +3,7 @@
 //! Range Proofs
 
 use core::convert::TryInto;
+use core::fmt;
 use std::io;
 
 use secp256k1_zkp::rand::{CryptoRng, RngCore};
@@ -11,7 +12,7 @@ use secp256k1_zkp::{self, Generator, PedersenCommitment, Secp256k1, SecretKey, S
 use serde::{Deserializer, Serializer};
 
 use crate::confidential::ValueBlindingFactor;
-use crate::encode;
+use crate::{encode, encoding};
 
 /// A range proof, which represents a proof that a confidential value lies within
 /// some range (typically `[0, 2^64)`).
@@ -190,3 +191,56 @@ impl<'de> serde::Deserialize<'de> for RangeProof {
             .map(|inner| Self { inner: inner.map(Box::new) })
     }
 }
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`RangeProof`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(super::PrefixedByteVecEncoder);
+}
+
+impl encoding::Encode for RangeProof {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(super::PrefixedByteVecEncoder::new(self.to_vec()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`RangeProof`] type.
+    #[derive(Default)]
+    pub struct Decoder(encoding::ByteVecDecoder);
+
+    /// Decoder error for the [`RangeProof`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        Decode(encoding::ByteVecDecoderError),
+        RangeProof(secp256k1_zkp::Error),
+    });
+
+    impl Decode for RangeProof {
+        fn convert_inner(v) -> Result<_, DecoderErrorInner> {
+            Self::Output::from_slice(&v).map_err(DecoderErrorInner::RangeProof)
+        }
+    }
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(..) => f.write_str("error decoding byte vector"),
+            Inner::RangeProof(..) => f.write_str("error decoding range proof"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(ref e) => Some(e),
+            Inner::RangeProof(ref e) => Some(e),
+        }
+    }
+}
diff --git a/src/confidential/surjection_proof.rs b/src/confidential/surjection_proof.rs
index 6fb6f8ea..9a9ceed5 100644
--- a/src/confidential/surjection_proof.rs
+++ b/src/confidential/surjection_proof.rs
@@ -2,6 +2,7 @@
 
 //! Surjection Proofs
 
+use core::fmt;
 use std::io;
 
 use secp256k1_zkp::rand::{CryptoRng, RngCore};
@@ -10,7 +11,7 @@ use secp256k1_zkp::{self, Generator, Secp256k1, Signing, Tweak, ZERO_TWEAK};
 use serde::{Deserializer, Serializer};
 
 use crate::confidential::{AssetBlindingFactor, AssetId};
-use crate::encode;
+use crate::{encode, encoding};
 
 /// A surjection proof, proving that an asset commitment commits to the same asset ID
 /// as a commitment from a given set.
@@ -143,3 +144,56 @@ impl<'de> serde::Deserialize<'de> for SurjectionProof {
             .map(|inner| Self { inner: inner.map(Box::new) })
     }
 }
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`SurjectionProof`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(super::PrefixedByteVecEncoder);
+}
+
+impl encoding::Encode for SurjectionProof {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(super::PrefixedByteVecEncoder::new(self.to_vec()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`SurjectionProof`] type.
+    #[derive(Default)]
+    pub struct Decoder(encoding::ByteVecDecoder);
+
+    /// Decoder error for the [`SurjectionProof`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        Decode(encoding::ByteVecDecoderError),
+        SurjectionProof(secp256k1_zkp::Error),
+    });
+
+    impl Decode for SurjectionProof {
+        fn convert_inner(v) -> Result<_, DecoderErrorInner> {
+            Self::Output::from_slice(&v).map_err(DecoderErrorInner::SurjectionProof)
+        }
+    }
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(..) => f.write_str("error decoding byte vector"),
+            Inner::SurjectionProof(..) => f.write_str("error decoding surjection proof"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(ref e) => Some(e),
+            Inner::SurjectionProof(ref e) => Some(e),
+        }
+    }
+}
diff --git a/src/confidential/value.rs b/src/confidential/value.rs
index a8267148..930e20c3 100644
--- a/src/confidential/value.rs
+++ b/src/confidential/value.rs
@@ -14,8 +14,10 @@ use secp256k1_zkp::{
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+use super::CommitmentEncoder;
 use crate::confidential::AssetBlindingFactor;
 use crate::encode::{self, Decodable, Encodable};
+use crate::encoding;
 use crate::issuance::AssetId;
 
 type ExplicitInner = u64;
@@ -23,6 +25,7 @@ type ConfInner = PedersenCommitment;
 
 const EXPLICIT_LEN: usize = 8;
 const CONFIDENTIAL_LEN: usize = 33;
+const CONFIDENTIAL_LEN_LESS_PREFIX: usize = CONFIDENTIAL_LEN - 1;
 const CONF_PREFIX_1: u8 = 0x08;
 const CONF_PREFIX_2: u8 = 0x09;
 
@@ -407,3 +410,112 @@ impl<'de> Deserialize<'de> for BlindingFactor {
         }
     }
 }
+
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`Asset`] type.
+    #[derive(Clone, Debug)]
+    pub struct Encoder<'e>(CommitmentEncoder<'e>);
+}
+
+impl encoding::Encode for Value {
+    type Encoder<'e> = Encoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        Encoder::new(match *self {
+            Self::Null => CommitmentEncoder::Null(0),
+            Self::Explicit(ref id) => CommitmentEncoder::Explicit8(Some(1), id.to_be_bytes()),
+            Self::Confidential(ref gen) => CommitmentEncoder::Explicit33(gen.serialize()),
+        })
+    }
+}
+
+decoder_state_machine! {
+    /// A decoder for the [`Value`] type.
+    pub struct Decoder(enum DecoderInner {
+        Done(Value),
+        Errored,
+        DecodePrefix {
+            decoder: encoding::ArrayDecoder<1>,
+            => transition_decode_prefix(prefix, ...) -> Result {
+                match prefix {
+                    [0] => Ok(DecoderInner::Done(Value::Null)),
+                    [1] => {
+                        Ok(DecoderInner::DecodeExplicit { decoder: encoding::ArrayDecoder::default() })
+                    },
+                    [prefix @ (CONF_PREFIX_1 | CONF_PREFIX_2)] => {
+                        Ok(DecoderInner::DecodeConfidential { decoder: encoding::ArrayDecoder::default(), prefix })
+                    },
+                    [prefix] => Err(DecoderErrorInner::InvalidConfidentialPrefix { prefix })
+                }
+            }
+        },
+        DecodeExplicit {
+            decoder: encoding::ArrayDecoder<EXPLICIT_LEN>
+            => transition_decode_explicit(bytes, ...) -> Result {
+                Ok(DecoderInner::Done(Value::Explicit(u64::from_be_bytes(bytes))))
+            }
+        },
+        DecodeConfidential {
+            decoder: encoding::ArrayDecoder<CONFIDENTIAL_LEN_LESS_PREFIX>,
+            prefix: u8
+            => transition_decode_confidential(x_coord, ...) -> Result {
+                let mut bytes = [0; CONFIDENTIAL_LEN];
+                bytes[0] = prefix;
+                bytes[1..].copy_from_slice(&x_coord);
+                let gen = ConfInner::from_slice(&bytes)
+                    .map_err(DecoderErrorInner::InvalidCommitment)?;
+                Ok(DecoderInner::Done(Value::Confidential(gen)))
+            }
+        },
+    });
+
+    /// A decoder error for the [`Value`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct DecoderError(enum DecoderErrorInner {
+        [macro-inserted decoder variants]
+        /// Confidential prefix was not one of the two allowable values.
+        InvalidConfidentialPrefix {
+            prefix: u8,
+        },
+        /// Malformed confidential commitment.
+        InvalidCommitment(secp256k1_zkp::Error),
+    });
+}
+
+impl fmt::Display for DecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(_) => f.write_str("failed to decode prefix"),
+            Inner::DecodeExplicit(_) => f.write_str("failed to decode explicit value"),
+            Inner::DecodeConfidential(_) => f.write_str("failed to decode confidential value"),
+            Inner::InvalidConfidentialPrefix { prefix, .. } => {
+                write!(
+                    f,
+                    "confidential prefix 0x{:02x} was not one of 0, 1, 0x{:02x} or 0x{:02x}",
+                    prefix, CONF_PREFIX_1, CONF_PREFIX_2,
+                )
+            }
+            Inner::InvalidCommitment(_) => f.write_str("failed to parse confidential commitment"),
+        }
+    }
+}
+
+impl std::error::Error for DecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use DecoderErrorInner as Inner;
+        match self.0 {
+            Inner::DecodePrefix(ref e) => Some(e),
+            Inner::DecodeExplicit(ref e) => Some(e),
+            Inner::DecodeConfidential(ref e) => Some(e),
+            Inner::InvalidConfidentialPrefix { .. } => None,
+            Inner::InvalidCommitment(ref e) => Some(e),
+        }
+    }
+}
+
+impl Default for Decoder {
+    fn default() -> Self {
+        Self(DecoderInner::DecodePrefix { decoder: encoding::ArrayDecoder::default() })
+    }
+}
diff --git a/src/encode.rs b/src/encode.rs
index a1204062..578e2d87 100644
--- a/src/encode.rs
+++ b/src/encode.rs
@@ -29,6 +29,39 @@ pub use bitcoin::{self, consensus::encode::MAX_VEC_SIZE};
 
 use crate::taproot::TapLeafHash;
 
+/// Adaptor to count bytes, used to implement Encodable/Decodable
+/// in terms of the new Encode/Decode traits.
+pub(crate) struct ByteCounter<W> {
+    inner: W,
+    count: usize,
+}
+
+impl<W> ByteCounter<W> {
+    pub(crate) fn new(inner: W) -> Self {
+        Self { inner, count: 0 }
+    }
+
+    pub(crate) fn into_count(self) -> usize {
+        self.count
+    }
+}
+
+impl<W> io::Write for ByteCounter<W>
+    where W: io::Write
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let res = self.inner.write(buf);
+        if let Ok(size) = res {
+            self.count += size;
+        }
+        res
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
 /// Encoding error
 #[derive(Debug)]
 pub enum Error {
@@ -63,6 +96,10 @@ pub enum Error {
     BadLockTime(crate::LockTime),
     /// `VarInt` was encoded in a non-minimal way.
     NonMinimalVarInt,
+    /// Error decoding a pegin witness.
+    PeginWitness(crate::PeginWitnessDecoderError),
+    /// Error decoding a script witness.
+    Witness(crate::WitnessDecoderError),
 }
 
 impl fmt::Display for Error {
@@ -90,6 +127,8 @@ impl fmt::Display for Error {
             Error::HexVariableError(ref e) => write!(f, "Hex variable error: {}", e),
             Error::BadLockTime(ref lt) => write!(f, "Invalid locktime {}", lt),
             Error::NonMinimalVarInt => write!(f, "non-minimal varint"),
+            Self::PeginWitness(..) => f.write_str("error decoding pegin witness"),
+            Self::Witness(..) => f.write_str("error decoding script witness"),
         }
     }
 }
@@ -98,6 +137,8 @@ impl error::Error for Error {
     fn cause(&self) -> Option<&dyn error::Error> {
         match *self {
             Error::Secp256k1zkp(ref e) => Some(e),
+            Self::PeginWitness(ref e) => Some(e),
+            Self::Witness(ref e) => Some(e),
             _ => None,
         }
     }
@@ -240,6 +281,24 @@ impl Decodable for crate::locktime::Time {
     }
 }
 
+impl Encodable for crate::Witness {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, Error> {
+        let mut counter = ByteCounter::new(e);
+        crate::encoding::encode_to_writer(self, &mut counter)?;
+        Ok(counter.into_count())
+    }
+}
+
+impl Decodable for crate::Witness {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, Error> {
+        match crate::encoding::decode_from_read_unbuffered(d) {
+            Ok(wit) => Ok(wit),
+            Err(crate::encoding::ReadError::Io(e)) => Err(Error::Io(e)),
+            Err(crate::encoding::ReadError::Decode(e)) => Err(Error::Witness(e)),
+        }
+    }
+}
+
 /// A variable sized integer.
 pub struct VarInt(pub u64);
 impl Encodable for VarInt {
diff --git a/src/internal_macros.rs b/src/internal_macros.rs
index 3e2b7431..a26ff92c 100644
--- a/src/internal_macros.rs
+++ b/src/internal_macros.rs
@@ -527,3 +527,547 @@ macro_rules! hex_deserialize(
 macro_rules! hex_script(
     ($e:expr) => (crate::Script::from_hex_no_prefix($e).expect("hex decoding"))
 );
+
+/// Generates a state machine decoder satisfying the [`crate::encoding::Decoder`] trait.
+///
+/// This macro creates a decoder that processes input bytes through multiple states,
+/// transitioning between states based on decoded data. It automatically generates
+/// both the decoder struct and associated error types.
+///
+/// # Syntax
+///
+/// ```ignore
+/// decoder_state_machine! {
+///     /// Documentation for the decoder struct
+///     pub struct DecoderName(enum InnerEnumName {
+///         Done(TargetType),
+///         Errored,
+///         StateName {
+///             decoder: DecoderType,
+///             field1: FieldType1,
+///             field2: FieldType2,
+///             => transition_function_name(output, ...) -> Result {
+///                 // Transition logic that returns Ok(NextState) or Err(error)
+///             }
+///         },
+///         // ... more states
+///     });
+///
+///     /// Documentation for the error struct
+///     pub struct ErrorName(enum InnerErrorName {
+///         [macro-inserted decoder variants]
+///         CustomError1(ErrorType1),
+///         CustomError2 { field: ErrorType2 },
+///         // ... custom error variants
+///     });
+/// }
+/// ```
+///
+/// # Generated Code
+///
+/// The macro generates:
+/// - A public decoder struct wrapping a private enum
+/// - A private enum with states, Done, and Errored variants
+/// - Transition functions for each state
+/// - A public error struct wrapping a private error enum
+/// - A private error enum with decoder errors and custom variants
+/// - `Decoder` trait implementation with `push_bytes`, `end`, and `read_limit` methods
+/// - `Decode` impl for the target type
+///
+/// The macro does **not** generate a `fmt::Display` or `std::error::Error` impl
+/// for `ErrorName`, so the user must implement these outside of the macro.
+///
+/// The variants that the macro inserts into `ErrorName` have the same names
+/// as the variants on `InnerEnumName`, and they contain a single value of
+/// type `<DecoderType as Decoder>::Error`.
+///
+/// # State Structure
+///
+/// Each state must have:
+/// - `decoder: SomeDecoderType` - The decoder for this state's data
+/// - Optional additional fields to carry state between transitions
+/// - A transition function that processes the decoder's output
+///
+/// # Transition Functions
+///
+/// Transition functions:
+/// - Take the decoder's output as first parameter
+/// - Take any additional state fields as subsequent parameters
+/// - Return `Result<InnerEnumName, InnerErrorName>`
+/// - Are called automatically when the decoder completes
+///
+/// # Error Handling
+///
+/// The macro automatically:
+/// - Creates error variants for each decoder type
+/// - Maps decoder errors to the appropriate variant
+///
+/// # Example Usage
+///
+/// ```ignore
+/// decoder_state_machine! {
+///     /// Decodes a length-prefixed string
+///     pub struct StringDecoder(enum StringDecoderInner {
+///         Done(String),
+///         Errored,
+///         ReadLength {
+///             decoder: encoding::ArrayDecoder<4>
+///             => transition_read_length(length_bytes, ...) -> Result {
+///                 let length = u32::from_be_bytes(length_bytes) as usize;
+///                 if length > MAX_STRING_LENGTH {
+///                     return Err(StringDecoderErrorInner::StringTooLong { length });
+///                 }
+///                 Ok(StringDecoderInner::ReadData {
+///                     decoder: encoding::VecDecoder::new(length),
+///                     expected_length: length
+///                 })
+///             }
+///         },
+///         ReadData {
+///             decoder: encoding::VecDecoder,
+///             expected_length: usize
+///             => transition_read_data(data, expected_length, ...) -> Result {
+///                 if data.len() != expected_length {
+///                     return Err(StringDecoderErrorInner::LengthMismatch);
+///                 }
+///                 let string = String::from_utf8(data)
+///                     .map_err(StringDecoderErrorInner::InvalidUtf8)?;
+///                 Ok(StringDecoderInner::Done(string))
+///             }
+///         },
+///     });
+///
+///     /// Errors that can occur during string decoding
+///     #[derive(Debug)]
+///     pub struct StringDecoderError(enum StringDecoderErrorInner {
+///         [macro-inserted decoder variants]
+///         StringTooLong { length: usize },
+///         LengthMismatch,
+///         InvalidUtf8(std::string::FromUtf8Error),
+///     });
+/// }
+/// ```
+macro_rules! decoder_state_machine {
+    (
+        $(#[$($struct_attr:tt)*])*
+        pub struct $outer_ty:ident(enum $inner_ty:ident {
+            Done($target_ty:ty),
+            Errored,
+            $(
+            $variant:ident {
+                decoder: $decoder_ty:ty$(,)?
+                $(, $field:ident: $field_ty:ty)*
+                => $transition_fn:ident($output:ident, ...) -> Result {
+                    $($transition_fn_inner:tt)*
+                }
+            },
+            )*
+        });
+
+        $(#[$($error_struct_attr:tt)*])*
+        pub struct $error_ty:ident(enum $inner_error_ty:ident {
+            [macro-inserted decoder variants]
+            $($extra_variants:tt)*
+        });
+    ) => {
+        $(#[$($struct_attr)*])*
+        pub struct $outer_ty($inner_ty);
+
+        #[allow(clippy::large_enum_variant)]
+        enum $inner_ty {
+            $($variant {
+                decoder: $decoder_ty
+                $(, $field: $field_ty)*
+            },)*
+            Done($target_ty),
+            Errored,
+        }
+
+        impl $inner_ty {
+            $(
+            #[inline]
+            #[allow(clippy::unnecessary_wraps)] // returns a Result even if it never returns Err
+            fn $transition_fn(
+                $output: <$decoder_ty as $crate::encoding::Decoder>::Output
+                $(, $field: $field_ty)*
+            ) -> Result<Self, $inner_error_ty> {
+                $($transition_fn_inner)*
+            }
+            )*
+        }
+
+        $(#[$($error_struct_attr)*])*
+        pub struct $error_ty($inner_error_ty);
+
+        $(#[$($error_struct_attr)*])*
+        enum $inner_error_ty {
+            $(
+            $variant(<$decoder_ty as $crate::encoding::Decoder>::Error),
+            )*
+            $($extra_variants)*
+        }
+
+        impl $crate::encoding::Decoder for $outer_ty {
+            type Output = $target_ty;
+            type Error = $error_ty;
+
+            fn push_bytes(
+                &mut self,
+                bytes: &mut &[u8],
+            ) -> Result<$crate::encoding::DecoderStatus, Self::Error> {
+                use $inner_ty as Inner;
+                loop {
+                    match core::mem::replace(&mut self.0, Inner::Errored) {
+                        $(
+                        Inner::$variant { mut decoder $(, $field)* } => {
+                            if decoder
+                                .push_bytes(bytes)
+                                .map_err($inner_error_ty::$variant)
+                                .map_err($error_ty)?
+                                .needs_more()
+                            {
+                                self.0 = Inner::$variant { decoder $(, $field)* };
+                                return Ok($crate::encoding::DecoderStatus::NeedsMore);
+                            }
+
+                            let output = decoder.end()
+                                .map_err($inner_error_ty::$variant)
+                                .map_err($error_ty)?;
+                            self.0 = $inner_ty::$transition_fn(output $(, $field)*)
+                                .map_err($error_ty)?;
+                        }
+                        )*
+                        Inner::Done(out) => {
+                            self.0 = Inner::Done(out);
+                            return Ok($crate::encoding::DecoderStatus::Ready);
+                        }
+                        Inner::Errored => panic!("called push_bytes() on an errored decoder"),
+
+                    }
+                }
+            }
+
+            fn end(self) -> Result<Self::Output, Self::Error> {
+                use $inner_ty as Inner;
+                match self.0 {
+                    $(
+                    Inner::$variant { decoder, .. } => {
+                        decoder.end()
+                            .map_err($inner_error_ty::$variant)
+                            .map_err($error_ty)?;
+                        // This unreachable! can be hit by badly behaved decoders where push_bytes()
+                        // returns DecoderStatus::NeedMore, but end() returns Ok. In general, end()
+                        // should return Ok only if push_bytes has returned DecoderStatus::Ready.
+                        unreachable!(
+                            "end() succeeded on decoder for {} state, but we did not leave that state",
+                            stringify!($variant),
+                        )
+                    }
+                    )*
+                    Inner::Done(out) => Ok(out),
+                    Inner::Errored => panic!("called end() on an errored decoder"),
+                }
+            }
+
+            fn read_limit(&self) -> usize {
+                use $inner_ty as Inner;
+                match self.0 {
+                    $(
+                    Inner::$variant { ref decoder, .. } => decoder.read_limit(),
+                    )*
+                    Inner::Done(_) | Inner::Errored => 0,
+                }
+            }
+        }
+
+        impl $crate::encoding::Decode for $target_ty {
+            type Decoder = $outer_ty;
+        }
+    };
+}
+
+/// Generates a simple decoder wrapper that converts output from an inner decoder.
+///
+/// This macro creates a decoder that wraps an existing decoder and applies a conversion
+/// function to transform the inner decoder's output into the target type. It's simpler
+/// than `decoder_state_machine!` as it only wraps a single decoder without state transitions.
+///
+/// # Syntax
+///
+/// There are two invocation patterns:
+///
+/// ## Direct Error Wrapping
+/// ```ignore
+/// decoder_newtype! {
+///     /// Documentation for the decoder struct
+///     pub struct DecoderName(InnerDecoderType);
+///
+///     /// Documentation for the error struct
+///     pub struct ErrorName(InnerErrorName);
+///     const ERROR_DISPLAY = "output of the Display::fmt function";
+///
+///     impl Decode for TargetType {
+///         fn convert_inner(output_var) -> Result<_, InnerErrorName> {
+///             // Conversion logic -- returns `InnerErrorName` for errors!
+///         }
+///     }
+/// }
+/// ```
+///
+/// In this case `InnerErrorName` must be an already-existing error type.
+///
+/// ## Error Enum Wrapping
+/// ```ignore
+/// decoder_newtype! {
+///     /// Documentation for the decoder struct
+///     pub struct DecoderName(InnerDecoderType);
+///
+///     /// Documentation for the error struct
+///     pub struct ErrorName(enum InnerErrorName {
+///         // The first variant must be called Decode and hold the inner decoder type.
+///         Decode(InnerDecoderErrorType),
+///         // All other variants are free-form.
+///         CustomError1(ErrorType1),
+///         CustomError2 { field: ErrorType2 },
+///         // ... custom error variants
+///     });
+///
+///     impl Decode for TargetType {
+///         fn convert_inner(output_var) -> Result<_, ErrorName> {
+///             // Conversion logic -- returns `ErrorName` for errors!
+///         }
+///     }
+/// }
+/// ```
+///
+/// In this case `InnerErrorName` will be generated as a private enum by the macro.
+///
+/// # Generated Code
+///
+/// The macro generates:
+/// - A public decoder struct wrapping the inner decoder
+/// - A public error struct wrapping a private error enum
+/// - A private error enum with `Decode` variant and custom variants
+/// - `Decoder` trait implementation with `push_bytes`, `end`, and `read_limit` methods
+/// - `Decode` trait implementation for the target type
+///
+/// **When using the enum pattern, the macro does not generate a `fmt::Display` or
+/// `std::error::Error` impl for `ErrorName`. The user must implement these outside
+/// of the macro.** When using the non-enum pattern, both `Display` and `Error` are
+/// generated by the macro.
+///
+/// # Parameters
+///
+/// - `DecoderName` - The wrapper decoder struct name
+/// - `InnerDecoderType` - The existing decoder type to wrap
+/// - `ErrorName` - The error struct name
+/// - `InnerErrorName` - The private error enum name
+/// - `InnerDecoderErrorType` - The error type from the inner decoder
+/// - `TargetType` - The final output type after conversion
+/// - `convert_inner` - Function that converts inner output to target type
+///
+/// # Conversion Function
+///
+/// The conversion function:
+/// - Takes the inner decoder's output as its parameter
+/// - Returns `Result<TargetType, ErrorName>` for enum pattern, `Result<TargetType, InnerErrorName>`
+///   for direct-wrapping pattern.
+/// - Is called automatically when the inner decoder completes
+/// - Can return custom errors defined in the error enum (enum pattern only)
+///
+/// # Pattern Selection
+///
+/// - Use **direct error wrapping** when conversion cannot fail or only needs to propagate the inner decoder's errors
+/// - Use **error enum wrapping** when conversion can fail with custom error types
+///
+/// # Error Handling
+///
+/// The macro automatically:
+/// - Creates a `Decode` variant containing the inner decoder's error
+/// - Maps inner decoder errors to the `Decode` variant
+/// - Allows custom error variants for conversion failures
+///
+/// # Example Usage
+///
+/// ## Direct Error Wrapping
+/// ```ignore
+/// decoder_newtype! {
+///     /// Decoder for the [`TxOut`] type.
+///     #[derive(Default)]
+///     pub struct TxOutDecoder(Decoder4< crate::confidential::AssetDecoder,
+///         crate::confidential::ValueDecoder,
+///         crate::confidential::NonceDecoder,
+///         crate::script::ScriptDecoder,
+///     >);
+///
+///     /// Decoder error for the [`TxOut`] type.
+///     #[derive(Clone, PartialEq, Eq, Debug)]
+///     pub struct TxOutDecoderError(Decoder4Error<
+///         crate::confidential::AssetDecoderError,
+///         crate::confidential::ValueDecoderError,
+///         crate::confidential::NonceDecoderError,
+///         crate::script::ScriptDecoderError,
+///     >);
+///     const ERROR_DISPLAY = "error decoding transaction output witness";
+///
+///     impl Decode for TxOut {
+///         fn convert_inner(output) -> Result<_, TxOutDecoderErrorInner> {
+///             let (asset, value, nonce, script_pubkey) = output;
+///             Ok(TxOut { asset, value, nonce, script_pubkey, witness: TxOutWitness::empty() })
+///         }
+///     }
+/// }
+/// ```
+///
+/// ## Error Enum Wrapping
+/// ```ignore
+/// decoder_newtype! {
+///     /// Decoder for range proofs
+///     #[derive(Default)]
+///     pub struct Decoder(encoding::ByteVecDecoder);
+///
+///     /// Decoder error for range proofs
+///     #[derive(Clone, PartialEq, Eq, Debug)]
+///     pub struct DecoderError(enum DecoderErrorInner {
+///         Decode(encoding::ByteVecDecoderError),
+///         RangeProof(secp256k1_zkp::Error),
+///     });
+///
+///     impl Decode for RangeProof {
+///         fn convert_inner(v) -> Result<_, DecoderError> {
+///             RangeProof::from_slice(&v).map_err(DecoderError::RangeProof)
+///         }
+///     }
+/// }
+/// ```
+macro_rules! decoder_newtype {
+    // With directly wrapped inner error
+    (
+        $(#[$($struct_attr:tt)*])*
+        pub struct $outer_ty:ident($inner_ty:ty);
+
+        $(#[$($error_struct_attr:tt)*])*
+        pub struct $error_ty:ident($inner_ty_error:ty);
+
+        const ERROR_DISPLAY = $error_display:expr;
+
+        impl Decode for $target_ty:ty {
+            fn convert_inner($output:ident) -> Result<_, $error_inner1:ty> {
+                $($output_fn_inner:tt)*
+            }
+        }
+    ) => {
+        $(#[$($struct_attr)*])*
+        pub struct $outer_ty($inner_ty);
+
+        $(#[$($error_struct_attr)*])*
+        pub struct $error_ty($inner_ty_error);
+
+        impl core::fmt::Display for $error_ty {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str($error_display)
+            }
+        }
+
+        impl std::error::Error for $error_ty {
+            fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+                Some(&self.0)
+            }
+        }
+
+        impl $crate::encoding::Decoder for $outer_ty {
+            type Output = $target_ty;
+            type Error = $error_ty;
+
+            fn push_bytes(
+                &mut self,
+                bytes: &mut &[u8],
+            ) -> Result<$crate::encoding::DecoderStatus, Self::Error> {
+                self.0
+                    .push_bytes(bytes)
+                    .map_err($error_ty)
+            }
+
+            fn end(self) -> Result<Self::Output, Self::Error> {
+                let $output = self.0
+                    .end()
+                    .map_err($error_ty)?;
+                let converted = {
+                    $($output_fn_inner)*
+                };
+                converted.map_err($error_ty)
+            }
+
+            fn read_limit(&self) -> usize {
+                self.0.read_limit()
+            }
+        }
+
+        impl $crate::encoding::Decode for $target_ty{
+            type Decoder = $outer_ty;
+        }
+    };
+    // With inner error enum
+    (
+        $(#[$($struct_attr:tt)*])*
+        pub struct $outer_ty:ident($inner_ty:ty);
+
+        $(#[$($error_struct_attr:tt)*])*
+        pub struct $error_ty:ident(enum $inner_error_ty:ident {
+            Decode($inner_ty_error:ty),
+            $($extra_variants:tt)*
+        });
+
+        impl Decode for $target_ty:ty {
+            fn convert_inner($output:ident) -> Result<_, $error_inner1:ty> {
+                $($output_fn_inner:tt)*
+            }
+        }
+    ) => {
+        $(#[$($struct_attr)*])*
+        pub struct $outer_ty($inner_ty);
+
+        $(#[$($error_struct_attr)*])*
+        pub struct $error_ty($inner_error_ty);
+
+        $(#[$($error_struct_attr)*])*
+        enum $inner_error_ty {
+            Decode($inner_ty_error),
+            $($extra_variants)*
+        }
+
+        impl $crate::encoding::Decoder for $outer_ty {
+            type Output = $target_ty;
+            type Error = $error_ty;
+
+            fn push_bytes(
+                &mut self,
+                bytes: &mut &[u8],
+            ) -> Result<$crate::encoding::DecoderStatus, Self::Error> {
+                self.0
+                    .push_bytes(bytes)
+                    .map_err($inner_error_ty::Decode)
+                    .map_err($error_ty)
+            }
+
+            fn end(self) -> Result<Self::Output, Self::Error> {
+                let $output = self.0
+                    .end()
+                    .map_err($inner_error_ty::Decode)
+                    .map_err($error_ty)?;
+                let converted = {
+                    $($output_fn_inner)*
+                };
+                converted.map_err($error_ty)
+            }
+
+            fn read_limit(&self) -> usize {
+                self.0.read_limit()
+            }
+        }
+
+        impl $crate::encoding::Decode for $target_ty{
+            type Decoder = $outer_ty;
+        }
+    };
+}
diff --git a/src/lib.rs b/src/lib.rs
index 18c92cea..68b2a1c7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,6 +28,8 @@
 
 /// Re-export of bitcoin crate
 pub extern crate bitcoin;
+/// Re-export of bitcoin-consensus-encoding crate
+pub extern crate encoding;
 /// Re-export of `bitcoin_hashes` crate
 pub extern crate hashes;
 /// Re-export of hex crate
@@ -67,8 +69,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;
@@ -77,6 +77,8 @@ mod endian;
 pub mod genesis;
 
 // export everything at the top level so it can be used as `elements::Transaction` etc.
+use internals::array_vec::ArrayVec;
+
 pub use crate::address::{Address, AddressError, AddressParams};
 pub use crate::blind::{
     BlindError, ConfidentialTxOutError, CtLocation, CtLocationType, RangeProofMessage,
@@ -93,6 +95,21 @@ pub use crate::schnorr::{SchnorrSig, SchnorrSigError};
 pub use crate::script::Script;
 pub use crate::sighash::SchnorrSighashType;
 pub use crate::transaction::{
-    AssetIssuance, EcdsaSighashType, OutPoint, PeginData, PegoutData, Sequence, Transaction, TxIn,
-    TxInWitness, TxOut, TxOutWitness,
+    AssetIssuance, AssetIssuanceDecoder, AssetIssuanceDecoderError, AssetIssuanceEncoder,
+    EcdsaSighashType, OutPoint, PeginData, PeginDataDecoder, PeginDataEncoder, PeginWitness,
+    PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder, PegoutData, Sequence,
+    SequenceDecoder, SequenceDecoderError, SequenceEncoder, Transaction, TransactionDecoder,
+    TransactionDecoderError, TransactionEncoder, TxIn, TxInDecoder, TxInDecoderError, TxInEncoder,
+    TxInWitness, TxInWitnessDecoder, TxInWitnessDecoderError, TxInWitnessEncoder, TxOut,
+    TxOutDecoder, TxOutDecoderError, TxOutEncoder, TxOutWitness, TxOutWitnessDecoder,
+    TxOutWitnessDecoderError, TxOutWitnessEncoder, Witness, WitnessDecoder, WitnessDecoderError,
+    WitnessEncoder,
 };
+
+// Encode a compact size to a slice without allocating
+pub(crate) fn compact_size_encode(value: usize) -> ArrayVec<u8, 9> {
+    use crate::encoding::Encoder as _;
+
+    let encoder = encoding::CompactSizeEncoder::new(value);
+    ArrayVec::from_slice(encoder.current_chunk())
+}
diff --git a/src/locktime.rs b/src/locktime.rs
index 0fd8c043..40b58ae3 100644
--- a/src/locktime.rs
+++ b/src/locktime.rs
@@ -22,6 +22,7 @@ use std::cmp::{PartialOrd, Ordering};
 use std::convert::TryFrom;
 use std::str::FromStr;
 use std::io::{Read, Write};
+use crate::encoding;
 use crate::error::ParseIntError;
 use crate::parse;
 
@@ -66,7 +67,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 +275,36 @@ impl fmt::Display for LockTime {
     }
 }
 
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`LockTime`] type.
+    pub struct LockTimeEncoder<'e>(encoding::ArrayEncoder<4>);
+}
+
+impl encoding::Encode for LockTime {
+    type Encoder<'e> = LockTimeEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        LockTimeEncoder::new(encoding::ArrayEncoder::without_length_prefix(self.to_consensus_u32().to_le_bytes()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`LockTime`] type.
+    #[derive(Default)]
+    pub struct LockTimeDecoder(encoding::ArrayDecoder<4>);
+
+    /// Decoder error for the [`LockTime`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct LockTimeDecoderError(encoding::UnexpectedEofError);
+    const ERROR_DISPLAY = "failed to decode locktime";
+
+    impl Decode for LockTime {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(LockTime::from_consensus(u32::from_le_bytes(bytes)))
+        }
+    }
+}
+
 impl Encodable for LockTime {
     #[inline]
     fn consensus_encode<W: Write>(&self, w: W) -> Result<usize, encode::Error> {
@@ -292,7 +322,6 @@ 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 {
@@ -377,7 +406,6 @@ impl TryFrom<String> for Height {
 /// `to_consensus_u32()`. Said another way, `Time(x)` means 'x seconds since epoch' _not_ '(x -
 /// threshold) seconds since epoch'.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Time(u32);
 
 impl Time {
diff --git a/src/opcodes.rs b/src/opcodes.rs
index fb8648c4..d9cfec5b 100644
--- a/src/opcodes.rs
+++ b/src/opcodes.rs
@@ -20,8 +20,6 @@
 
 #![allow(non_camel_case_types)]
 
-#[cfg(feature = "serde")] use serde;
-
 use std::fmt;
 
 // Note: I am deliberately not implementing PartialOrd or Ord on the
@@ -862,16 +860,6 @@ impl fmt::Display for All {
     }
 }
 
-#[cfg(feature = "serde")]
-impl serde::Serialize for All {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
 /// Empty stack is also FALSE
 pub static OP_FALSE: All = all::OP_PUSHBYTES_0;
 /// Number 1 is also TRUE
diff --git a/src/pset/map/global.rs b/src/pset/map/global.rs
index 8051cc39..4ed267e3 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 53438a1a..1aa02d75 100644
--- a/src/pset/map/input.rs
+++ b/src/pset/map/input.rs
@@ -32,7 +32,7 @@ use crate::pset::raw;
 use crate::pset::serialize;
 use crate::pset::{self, error, Error};
 use crate::{transaction::SighashTypeParseError, SchnorrSighashType};
-use crate::{AssetIssuance, BlockHash, EcdsaSighashType, RangeProof, Script, Transaction, TxIn, TxOut, Txid, SurjectionProof};
+use crate::{AssetIssuance, BlockHash, EcdsaSighashType, PeginWitness, RangeProof, Script, Transaction, TxIn, TxOut, Txid, SurjectionProof};
 use bitcoin::bip32::KeySource;
 use bitcoin::{PublicKey, key::XOnlyPublicKey};
 use secp256k1_zkp::{self, Tweak, ZERO_TWEAK};
@@ -172,7 +172,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
@@ -184,10 +183,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.
@@ -198,38 +193,21 @@ pub struct Input {
     pub witness_script: Option<Script>,
     /// A map from public keys needed to sign this input to their corresponding
     /// master key fingerprints and derivation paths.
-    #[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq"))]
     pub bip32_derivation: BTreeMap<PublicKey, KeySource>,
     /// The finalized, fully-constructed scriptSig with signatures and any other
     /// scripts necessary for this input to pass validation.
     pub final_script_sig: Option<Script>,
     /// The finalized, fully-constructed scriptWitness with signatures and any
     /// other scripts necessary for this input to pass validation.
-    pub final_script_witness: Option<Vec<Vec<u8>>>,
+    pub final_script_witness: Option<crate::Witness>,
     /// TODO: Proof of reserves commitment
     /// RIPEMD160 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub ripemd160_preimages: BTreeMap<ripemd160::Hash, Vec<u8>>,
     /// SHA256 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub sha256_preimages: BTreeMap<sha256::Hash, Vec<u8>>,
     /// HSAH160 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub hash160_preimages: BTreeMap<hash160::Hash, Vec<u8>>,
     /// HAS256 hash to preimage map
-    #[cfg_attr(
-        feature = "serde",
-        serde(with = "crate::serde_utils::btreemap_byte_values")
-    )]
     pub hash256_preimages: BTreeMap<sha256d::Hash, Vec<u8>>,
     /// (PSET) Prevout TXID of the input
     pub previous_txid: Txid,
@@ -244,13 +222,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>,
@@ -277,7 +252,7 @@ pub struct Input {
     /// Pegin Value
     pub pegin_value: Option<u64>,
     /// Pegin Witness
-    pub pegin_witness: Option<Vec<Vec<u8>>>,
+    pub pegin_witness: Option<PeginWitness>,
     /// Issuance inflation keys
     pub issuance_inflation_keys: Option<u64>,
     /// Issuance inflation keys commitment
@@ -303,16 +278,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>>,
 }
 
@@ -660,7 +627,7 @@ impl Map for Input {
             }
             PSET_IN_FINAL_SCRIPTWITNESS => {
                 impl_pset_insert_pair! {
-                    self.final_script_witness <= <raw_key: _>|<raw_value: Vec<Vec<u8>>>
+                    self.final_script_witness <= <raw_key: _>|<raw_value: crate::Witness>
                 }
             }
             PSET_IN_RIPEMD160 => {
@@ -776,7 +743,7 @@ impl Map for Input {
                             impl_pset_prop_insert_pair!(self.pegin_value <= <raw_key: _> | <raw_value : u64>);
                         }
                         PSBT_ELEMENTS_IN_PEG_IN_WITNESS => {
-                            impl_pset_prop_insert_pair!(self.pegin_witness <= <raw_key: _> | <raw_value : Vec<Vec<u8>>>);
+                            impl_pset_prop_insert_pair!(self.pegin_witness <= <raw_key: _> | <raw_value : PeginWitness>);
                         }
                         PSBT_ELEMENTS_IN_ISSUANCE_INFLATION_KEYS => {
                             impl_pset_prop_insert_pair!(self.issuance_inflation_keys <= <raw_key: _> | <raw_value : u64>);
diff --git a/src/pset/map/output.rs b/src/pset/map/output.rs
index 990f2816..04c23d1d 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<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 aeb3cea7..372dcbb7 100644
--- a/src/pset/mod.rs
+++ b/src/pset/mod.rs
@@ -58,7 +58,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,
@@ -307,13 +306,11 @@ impl PartiallySignedTransaction {
                         .unwrap_or(RangeProof::EMPTY),
                     script_witness: psetin
                         .final_script_witness
-                        .as_ref()
-                        .map(Vec::to_owned)
+                        .clone()
                         .unwrap_or_default(),
                     pegin_witness: psetin
                         .pegin_witness
-                        .as_ref()
-                        .map(Vec::to_owned)
+                        .clone()
                         .unwrap_or_default(),
                 },
             };
diff --git a/src/pset/raw.rs b/src/pset/raw.rs
index ffa912ee..55b8169e 100644
--- a/src/pset/raw.rs
+++ b/src/pset/raw.rs
@@ -24,15 +24,10 @@ use crate::encode::{self, deserialize, serialize, Decodable, Encodable, VarInt,
 use hex::DisplayHex as _;
 /// A PSET key in its raw byte form.
 #[derive(Debug, PartialEq, Hash, Eq, Clone, Ord, PartialOrd)]
-#[cfg_attr(
-    feature = "serde",
-    derive(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>,
 }
 
@@ -50,15 +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>,
 }
 
@@ -67,10 +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
@@ -78,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/pset/serialize.rs b/src/pset/serialize.rs
index 16e3b8b1..28b52e05 100644
--- a/src/pset/serialize.rs
+++ b/src/pset/serialize.rs
@@ -68,7 +68,8 @@ impl_pset_de_serialize!(crate::Sequence);
 impl_pset_de_serialize!(crate::locktime::Height);
 impl_pset_de_serialize!(crate::locktime::Time);
 impl_pset_de_serialize!([u8; 32]);
-impl_pset_de_serialize!(Vec<Vec<u8>>); // scriptWitness
+impl_pset_de_serialize!(crate::PeginWitness); // peginWitness
+impl_pset_de_serialize!(crate::Witness); // scriptWitness
 impl_pset_hash_de_serialize!(Txid);
 impl_pset_hash_de_serialize!(ripemd160::Hash);
 impl_pset_hash_de_serialize!(sha256::Hash);
diff --git a/src/script.rs b/src/script.rs
index 5388463f..09fbb285 100644
--- a/src/script.rs
+++ b/src/script.rs
@@ -31,6 +31,7 @@ use secp256k1_zkp::{Verification, Secp256k1};
 #[cfg(feature = "serde")] use serde;
 
 use crate::encode::{self, Decodable, Encodable};
+use crate::encoding;
 use crate::{opcodes, ScriptHash, WScriptHash, PubkeyHash, WPubkeyHash};
 
 use bitcoin::PublicKey;
@@ -943,6 +944,36 @@ impl Decodable for Script {
     }
 }
 
+encoding::encoder_newtype_exact! {
+    /// Encoder for a [`Script`].
+    #[derive(Clone, Debug)]
+    pub struct ScriptEncoder<'e>(encoding::PrefixedBytesEncoder<'e>);
+}
+
+impl encoding::Encode for Script {
+    type Encoder<'e> = ScriptEncoder<'e>;
+    fn encoder(&self) -> Self::Encoder<'_> {
+        ScriptEncoder::new(encoding::PrefixedBytesEncoder::new(self.as_bytes()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for a [`Script`].
+    #[derive(Default)]
+    pub struct ScriptDecoder(encoding::ByteVecDecoder);
+
+    /// Decoder error for the [`Script`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct ScriptDecoderError(encoding::ByteVecDecoderError);
+    const ERROR_DISPLAY = "failed to decode script";
+
+    impl Decode for Script {
+        fn convert_inner(bytes) -> Result<_, _> {
+            Ok(Script::from(bytes))
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use bitcoin::PublicKey;
diff --git a/src/serde_utils.rs b/src/serde_utils.rs
deleted file mode 100644
index 6534acb6..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 hex::DisplayHex as _;
-    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_lower_hex_string())?;
-            }
-            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, hex::decode_to_vec(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 hex::DisplayHex as _;
-    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.collect_str(&bytes.as_ref().as_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> + From<Vec<u8>>,
-    {
-        struct Visitor<B>(::std::marker::PhantomData<B>);
-
-        impl<B: From<Vec<u8>>> 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) = ::core::str::from_utf8(v) {
-                    hex::decode_to_vec(hex).map_err(E::custom).map(B::from)
-                } 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,
-            {
-                hex::decode_to_vec(v).map_err(E::custom).map(B::from)
-            }
-        }
-
-        // 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/sighash.rs b/src/sighash.rs
index 78b408c7..d1710bf0 100644
--- a/src/sighash.rs
+++ b/src/sighash.rs
@@ -831,7 +831,7 @@ impl<R: DerefMut<Target = Transaction>> SighashCache<R> {
     ///     sig_hasher.witness_mut(inp).unwrap().push(Vec::new());
     /// }
     /// ```
-    pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut Vec<Vec<u8>>> {
+    pub fn witness_mut(&mut self, input_index: usize) -> Option<&mut crate::Witness> {
         self.tx.input.get_mut(input_index).map(|i| &mut i.witness.script_witness)
     }
 }
diff --git a/src/taproot.rs b/src/taproot.rs
index e6496cca..4bffd3fd 100644
--- a/src/taproot.rs
+++ b/src/taproot.rs
@@ -20,21 +20,41 @@ use crate::hashes::HashEngine as _;
 use crate::schnorr::{UntweakedPublicKey, TweakedPublicKey, TapTweak};
 use crate::Script;
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap};
-use hashes::sha256t;
+use hashes::{sha256, sha256t};
 use secp256k1_zkp::{self, Secp256k1, Scalar};
 use crate::encode::Encodable;
 
-hashes::sha256t_tag! {
-    pub struct TapLeafTag = hash_str("TapLeaf/elements");
+
+/// The tag for tapleaves.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct TapLeafTag;
+
+/// The tag for tapbranches.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct TapBranchTag;
+
+/// The tag for taptweaks.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct TapTweakTag;
+
+/// The tag for Taproot sighashes.
+#[derive(Copy, Clone, PartialEq, Eq, Default, PartialOrd, Ord, Hash)]
+pub struct TapSighashTag;
+
+impl sha256t::Tag for TapLeafTag {
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::hash_tag(b"TapLeaf/elements");
 }
-hashes::sha256t_tag! {
-    pub struct TapBranchTag = hash_str("TapBranch/elements");
+
+impl sha256t::Tag for TapBranchTag {
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::hash_tag(b"TapBranch/elements");
 }
-hashes::sha256t_tag! {
-    pub struct TapTweakTag = hash_str("TapTweak/elements");
+
+impl sha256t::Tag for TapTweakTag {
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::hash_tag(b"TapTweak/elements");
 }
-hashes::sha256t_tag! {
-    pub struct TapSighashTag = hash_str("TapSighash/elements");
+
+impl sha256t::Tag for TapSighashTag {
+    const MIDSTATE: sha256::Midstate = sha256::Midstate::hash_tag(b"TapSighash/elements");
 }
 
 // Taproot test vectors from BIP-341 state the hashes without any reversing
diff --git a/src/transaction/decoders.rs b/src/transaction/decoders.rs
new file mode 100644
index 00000000..9e34e931
--- /dev/null
+++ b/src/transaction/decoders.rs
@@ -0,0 +1,546 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Transaction Decoders
+//!
+//! These are encapsulated because there are many of them, but in the end we
+//! only expose the top-level ones outside of this module.
+
+use core::fmt;
+
+use super::{
+    AssetIssuance, OutPoint, Script, Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutWitness,
+    Txid,
+};
+use crate::confidential::{RangeProofDecoder, RangeProofDecoderError};
+use crate::encoding::{
+    ArrayDecoder, Decode, Decoder, Decoder2, Decoder2Error, Decoder3, Decoder4, Decoder4Error,
+    DecoderStatus, UnexpectedEofError, VecDecoder,
+};
+use crate::locktime::{LockTime, LockTimeDecoder};
+use crate::{PeginWitnessDecoder, PeginWitnessDecoderError, WitnessDecoder, WitnessDecoderError};
+
+/// Decoder for the [`OutPoint`] type.
+///
+/// This is a non-public struct and we do not implement [`Decode`] for [`OutPoint`]
+/// because we can't actually encode/decode outpoints independently of the rest of
+/// a [`TxIn`]. This is because we mask bits into the vout of the outpoint.
+#[derive(Default)]
+struct OutPointDecoder {
+    inner: Decoder2<ArrayDecoder<32>, ArrayDecoder<4>>,
+}
+
+/// Decoder error for the [`OutPoint`] type.
+#[derive(Clone, PartialEq, Eq, Debug)]
+struct OutPointDecoderError(Decoder2Error<UnexpectedEofError, UnexpectedEofError>);
+
+impl fmt::Display for OutPointDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("error decoding outpoint")
+    }
+}
+
+impl std::error::Error for OutPointDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
+impl Decoder for OutPointDecoder {
+    type Output = OutPoint;
+    type Error = OutPointDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(OutPointDecoderError)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (txid, vout) = self.inner.end().map_err(OutPointDecoderError)?;
+        Ok(OutPoint { txid: Txid::from_byte_array(txid), vout: u32::from_le_bytes(vout) })
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`Sequence`] type.
+    #[derive(Default)]
+    pub struct SequenceDecoder(ArrayDecoder<4>);
+
+    /// Decoder error for the [`Sequence`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct SequenceDecoderError(UnexpectedEofError);
+    const ERROR_DISPLAY = "error decoding sequence";
+
+    impl Decode for Sequence {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(Sequence::from_consensus(u32::from_le_bytes(bytes)))
+        }
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`AssetIssuance`] type.
+    #[derive(Default)]
+    pub struct AssetIssuanceDecoder(Decoder4<
+        ArrayDecoder<32>,
+        ArrayDecoder<32>,
+        crate::confidential::ValueDecoder,
+        crate::confidential::ValueDecoder,
+    >);
+    /// Decoder error for the [`AssetIssuance`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct AssetIssuanceDecoderError(enum AssetIssuanceDecoderErrorInner {
+        Decode(Decoder4Error<
+            UnexpectedEofError,
+            UnexpectedEofError,
+            crate::confidential::ValueDecoderError,
+            crate::confidential::ValueDecoderError,
+        >),
+        InvalidTweak(secp256k1_zkp::Error),
+    });
+
+    impl Decode for AssetIssuance {
+        fn convert_inner(output) -> Result<_, AssetIssuanceDecoderError> {
+            let (asset_blinding_nonce, asset_entropy, amount, inflation_keys) = output;
+            Ok(AssetIssuance {
+                asset_blinding_nonce: secp256k1_zkp::Tweak::from_inner(asset_blinding_nonce)
+                    .map_err(AssetIssuanceDecoderErrorInner::InvalidTweak)
+                    .map_err(AssetIssuanceDecoderError)?,
+                asset_entropy,
+                amount,
+                inflation_keys,
+            })
+        }
+    }
+}
+
+impl fmt::Display for AssetIssuanceDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use AssetIssuanceDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(_) => f.write_str("error decoding asset issuance"),
+            Inner::InvalidTweak(_) => f.write_str("asset issuance had out-of-range blinding nonce"),
+        }
+    }
+}
+
+impl std::error::Error for AssetIssuanceDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use AssetIssuanceDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(ref e) => Some(e),
+            Inner::InvalidTweak(ref e) => Some(e),
+        }
+    }
+}
+
+decoder_state_machine! {
+    /// Decoder for the [`TxIn`] type.
+    pub struct TxInDecoder(enum TxInDecoderInner {
+        Done(TxIn),
+        Errored,
+        Initial {
+            decoder: Decoder3<
+                OutPointDecoder,
+                crate::script::ScriptDecoder,
+                SequenceDecoder,
+            >,
+            => transition_initial(output, ...) -> Result {
+                let (mut outpoint, script_sig, sequence) = output;
+                let (is_pegin, has_issuance) = if outpoint.vout == 0xffff_ffff {
+                    (false, false)
+                } else {
+                    let vout = outpoint.vout;
+                    outpoint.vout &= !((1 << 30) | (1 << 31));
+                    (vout & (1 << 30) != 0, vout & (1 << 31) != 0)
+                };
+                if has_issuance {
+                    Ok(TxInDecoderInner::AssetIssuance {
+                        decoder: AssetIssuanceDecoder::default(),
+                        outpoint, script_sig, sequence, is_pegin,
+                    })
+                } else {
+                    if outpoint.vout != 0xffff_ffff {
+                        outpoint.vout &= !((1 << 30) | (1 << 31));
+                    }
+                    Ok(TxInDecoderInner::Done(TxIn {
+                        previous_output: outpoint,
+                        is_pegin,
+                        script_sig,
+                        sequence,
+                        asset_issuance: AssetIssuance::null(),
+                        witness: TxInWitness::default(),
+                    }))
+                }
+            }
+        },
+        AssetIssuance {
+            decoder: AssetIssuanceDecoder,
+            outpoint: OutPoint,
+            script_sig: Script,
+            sequence: Sequence,
+            is_pegin: bool
+            => transition_asset_issuance(asset_issuance, ...) -> Result {
+                if asset_issuance.is_null() {
+                    return Err(TxInDecoderErrorInner::SuperfluousIssuance);
+                }
+
+                Ok(TxInDecoderInner::Done(TxIn {
+                    previous_output: outpoint,
+                    is_pegin,
+                    script_sig,
+                    sequence,
+                    asset_issuance,
+                    witness: TxInWitness::default(),
+                }))
+            }
+        },
+    });
+
+    /// Decoder error for the [`TxIn`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TxInDecoderError(enum TxInDecoderErrorInner {
+        [macro-inserted decoder variants]
+        SuperfluousIssuance,
+    });
+}
+
+impl Default for TxInDecoder {
+    fn default() -> Self { Self(TxInDecoderInner::Initial { decoder: Decoder3::default() }) }
+}
+
+impl fmt::Display for TxInDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use TxInDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Initial(..) => f.write_str("error decoding outpoint, scriptsig or sequence"),
+            Inner::AssetIssuance(..) => f.write_str("error decoding asset issuance"),
+            Inner::SuperfluousIssuance =>
+                f.write_str("input had issuance flag set, but null issuance"),
+        }
+    }
+}
+
+impl std::error::Error for TxInDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TxInDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Initial(ref e) => Some(e),
+            Inner::AssetIssuance(ref e) => Some(e),
+            Inner::SuperfluousIssuance => None,
+        }
+    }
+}
+
+/// Decoder for the [`TxInWitness`] type.
+#[derive(Default)]
+pub struct TxInWitnessDecoder {
+    inner: Decoder4<RangeProofDecoder, RangeProofDecoder, WitnessDecoder, PeginWitnessDecoder>,
+}
+
+/// Decoder error for the [`TxInWitness`] type.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct TxInWitnessDecoderError(
+    Decoder4Error<
+        RangeProofDecoderError,
+        RangeProofDecoderError,
+        WitnessDecoderError,
+        PeginWitnessDecoderError,
+    >,
+);
+
+impl fmt::Display for TxInWitnessDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("error decoding transaction input witness")
+    }
+}
+
+impl std::error::Error for TxInWitnessDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
+impl Decoder for TxInWitnessDecoder {
+    type Output = TxInWitness;
+    type Error = TxInWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(TxInWitnessDecoderError)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (amount_rangeproof, inflation_keys_rangeproof, script_witness, pegin_witness) =
+            self.inner.end().map_err(TxInWitnessDecoderError)?;
+
+        Ok(TxInWitness {
+            amount_rangeproof,
+            inflation_keys_rangeproof,
+            script_witness,
+            pegin_witness,
+        })
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+impl Decode for TxInWitness {
+    type Decoder = TxInWitnessDecoder;
+}
+
+/// An decoder for the witnesses in a sequence of [`TxIn`]s.
+///
+/// Comsumes a vec of [`TxIn`]s on construction and then yields that
+/// same vector, with the witness fields overwritten.
+#[derive(Default)]
+struct TxInWitnessesDecoder {
+    txins: Vec<TxIn>,
+    index: usize,
+    // Invariant: if this is Some then
+    decoder: Option<TxInWitnessDecoder>,
+}
+
+impl TxInWitnessesDecoder {
+    fn new(txins: Vec<TxIn>) -> Self { Self { txins, index: 0, decoder: None } }
+}
+
+impl Decoder for TxInWitnessesDecoder {
+    type Output = Vec<TxIn>;
+    type Error = TxInWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        loop {
+            let Some(next_txin) = self.txins.get_mut(self.index) else {
+                return Ok(DecoderStatus::Ready);
+            };
+
+            let mut decoder = self.decoder.take().unwrap_or_else(TxInWitness::decoder);
+            if decoder.push_bytes(bytes)?.needs_more() {
+                self.decoder = Some(decoder);
+                return Ok(DecoderStatus::NeedsMore);
+            }
+            next_txin.witness = decoder.end()?;
+            self.index += 1;
+        }
+    }
+
+    fn end(mut self) -> Result<Self::Output, Self::Error> {
+        loop {
+            let Some(last_txin) = self.txins.get_mut(self.index) else {
+                return Ok(self.txins);
+            };
+
+            last_txin.witness = self.decoder.take().unwrap_or_else(TxInWitness::decoder).end()?;
+            self.index += 1;
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        self.decoder.as_ref().map_or(0, TxInWitnessDecoder::read_limit)
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`TxOutWitness`] type.
+    #[derive(Default)]
+    pub struct TxOutWitnessDecoder(Decoder2<
+        crate::confidential::SurjectionProofDecoder,
+        crate::confidential::RangeProofDecoder,
+    >);
+
+    /// Decoder error for the [`TxOutWitness`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TxOutWitnessDecoderError(Decoder2Error<
+        crate::confidential::SurjectionProofDecoderError,
+        crate::confidential::RangeProofDecoderError,
+    >);
+    const ERROR_DISPLAY = "error decoding transaction output witness";
+
+    impl Decode for TxOutWitness {
+        fn convert_inner(output) -> Result<_, TxOutWitnessDecoderErrorInner> {
+            let (surjection_proof, rangeproof) = output;
+            Ok(TxOutWitness {surjection_proof, rangeproof })
+        }
+    }
+}
+
+/// An decoder for the witnesses in a sequence of [`TxOut`]s.
+///
+/// Comsumes a vec of [`TxOut`]s on construction and then yields that
+/// same vector, with the witness fields overwritten.
+#[derive(Default)]
+struct TxOutWitnessesDecoder {
+    txouts: Vec<TxOut>,
+    index: usize,
+    // Invariant: if this is Some then
+    decoder: Option<TxOutWitnessDecoder>,
+}
+
+impl TxOutWitnessesDecoder {
+    fn new(txouts: Vec<TxOut>) -> Self { Self { txouts, index: 0, decoder: None } }
+}
+
+impl Decoder for TxOutWitnessesDecoder {
+    type Output = Vec<TxOut>;
+    type Error = TxOutWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        loop {
+            let Some(next_txout) = self.txouts.get_mut(self.index) else {
+                return Ok(DecoderStatus::Ready);
+            };
+
+            let mut decoder = self.decoder.take().unwrap_or_else(TxOutWitness::decoder);
+            if decoder.push_bytes(bytes)?.needs_more() {
+                self.decoder = Some(decoder);
+                return Ok(DecoderStatus::NeedsMore);
+            }
+            next_txout.witness = decoder.end()?;
+            self.index += 1;
+        }
+    }
+
+    fn end(mut self) -> Result<Self::Output, Self::Error> {
+        loop {
+            let Some(last_txout) = self.txouts.get_mut(self.index) else {
+                return Ok(self.txouts);
+            };
+
+            last_txout.witness = self.decoder.take().unwrap_or_else(TxOutWitness::decoder).end()?;
+            self.index += 1;
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        self.decoder.as_ref().map_or(0, TxOutWitnessDecoder::read_limit)
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`TxOut`] type.
+    #[derive(Default)]
+    pub struct TxOutDecoder(Decoder4<
+        crate::confidential::AssetDecoder,
+        crate::confidential::ValueDecoder,
+        crate::confidential::NonceDecoder,
+        crate::script::ScriptDecoder,
+    >);
+
+
+    /// Decoder error for the [`TxOut`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TxOutDecoderError(Decoder4Error<
+            crate::confidential::AssetDecoderError,
+            crate::confidential::ValueDecoderError,
+            crate::confidential::NonceDecoderError,
+            crate::script::ScriptDecoderError,
+    >);
+    const ERROR_DISPLAY = "error decoding transaction output witness";
+
+    impl Decode for TxOut {
+        fn convert_inner(output) -> Result<_, TxOutDecoderErrorInner> {
+            let (asset, value, nonce, script_pubkey) = output;
+            Ok(TxOut { asset, value, nonce, script_pubkey, witness: TxOutWitness::empty() })
+        }
+    }
+}
+
+decoder_state_machine! {
+    /// Decoder for the [`Transaction`] type.
+    pub struct TransactionDecoder(enum TransactionDecoderInner {
+        Done(Transaction),
+        Errored,
+        DecodingNonWitness {
+            decoder: Decoder4<
+                ArrayDecoder<4>,
+                ArrayDecoder<1>,
+                Decoder2<
+                    VecDecoder<TxIn>,
+                    VecDecoder<TxOut>,
+                >,
+                LockTimeDecoder,
+            >,
+            => transition_non_witness(output, ...) -> Result {
+                let (version, wit_flag, (input, output), lock_time) = output;
+                match wit_flag {
+                    [0] => Ok(TransactionDecoderInner::Done(Transaction {
+                        version: u32::from_le_bytes(version),
+                        lock_time,
+                        input,
+                        output,
+                    })),
+                    [1] => Ok(TransactionDecoderInner::DecodingWitnesses {
+                        decoder: Decoder2::new(
+                            TxInWitnessesDecoder::new(input),
+                            TxOutWitnessesDecoder::new(output),
+                        ),
+                        version: u32::from_le_bytes(version),
+                        lock_time,
+                    }),
+                    [x] => Err(TransactionDecoderErrorInner::InvalidWitnessFlag(x)),
+                }
+            }
+        },
+        DecodingWitnesses {
+            decoder: Decoder2<
+                TxInWitnessesDecoder,
+                TxOutWitnessesDecoder,
+            >,
+            version: u32,
+            lock_time: LockTime
+            => transition_witnesses(output, ...) -> Result {
+                let (input, output) = output;
+                if input.iter().all(|input| input.witness.is_empty()) &&
+                    output.iter().all(|output| output.witness.is_empty()) {
+                    Err(TransactionDecoderErrorInner::NoWitnesses)
+                } else {
+                    Ok(TransactionDecoderInner::Done(Transaction {
+                        version,
+                        lock_time,
+                        input,
+                        output,
+                    }))
+                }
+            }
+        },
+    });
+
+    /// Decoder error for the [`Transaction`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TransactionDecoderError(enum TransactionDecoderErrorInner {
+        [macro-inserted decoder variants]
+        InvalidWitnessFlag(u8),
+        NoWitnesses,
+    });
+}
+
+impl Default for TransactionDecoder {
+    fn default() -> Self {
+        Self(TransactionDecoderInner::DecodingNonWitness { decoder: Decoder4::default() })
+    }
+}
+
+impl fmt::Display for TransactionDecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use TransactionDecoderErrorInner as Inner;
+
+        match self.0 {
+            Inner::DecodingNonWitness(..) =>
+                f.write_str("failed to decode non-witness part of transaction"),
+            Inner::DecodingWitnesses(..) => f.write_str("failed to decode transaction witnesses"),
+            Inner::InvalidWitnessFlag(flag) => {
+                write!(f, "invalid witness flag {flag} (must be 0 or 1)")
+            }
+            Inner::NoWitnesses => f.write_str("witness flag set but all witnesses were empty"),
+        }
+    }
+}
+
+impl std::error::Error for TransactionDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TransactionDecoderErrorInner as Inner;
+
+        match self.0 {
+            Inner::DecodingNonWitness(ref e) => Some(e),
+            Inner::DecodingWitnesses(ref e) => Some(e),
+            Inner::InvalidWitnessFlag(_) => None,
+            Inner::NoWitnesses => None,
+        }
+    }
+}
diff --git a/src/transaction/encoders.rs b/src/transaction/encoders.rs
new file mode 100644
index 00000000..17bcc0dd
--- /dev/null
+++ b/src/transaction/encoders.rs
@@ -0,0 +1,297 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Transaction Encoders
+//!
+//! These are encapsulated because there are many of them, but in the end we
+//! only expose the top-level ones outside of this module.
+
+use super::{AssetIssuance, Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutWitness};
+use crate::confidential::RangeProofEncoder;
+use crate::encoding::{
+    encoder_newtype, encoder_newtype_exact, ArrayEncoder, ArrayRefEncoder, Encode, Encoder,
+    Encoder2, Encoder4, Encoder6, EncoderStatus, PrefixedSliceEncoder,
+};
+use crate::locktime::LockTimeEncoder;
+use crate::{PeginWitnessEncoder, WitnessEncoder};
+
+// While we define an [`OutPointEncoder`] struct, we don't actually implement `Encode` or `Decode`
+// for [`OutPoint`], since the outpoint encoding depends on pegin/issuance data from the rest of
+// the txin. We just use it as a private building block.
+
+encoder_newtype_exact! {
+    /// Encoder for the [`OutPoint`] type.
+    #[derive(Clone, Debug)]
+    struct OutPointEncoder<'e>(Encoder2<
+        ArrayRefEncoder<'e, 32>,
+        ArrayEncoder<4>,
+    >);
+}
+
+impl<'e> OutPointEncoder<'e> {
+    fn from_txin(txin: &'e TxIn) -> Self {
+        let mut vout = txin.previous_output.vout;
+        if txin.is_pegin {
+            vout |= 1 << 30;
+        }
+        if txin.has_issuance() {
+            vout |= 1 << 31;
+        }
+
+        Self::new(Encoder2::new(
+            ArrayRefEncoder::without_length_prefix(txin.previous_output.txid.as_byte_array()),
+            ArrayEncoder::without_length_prefix(vout.to_le_bytes()),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`Sequence`] type.
+    #[derive(Clone, Debug)]
+    pub struct SequenceEncoder<'e>(ArrayEncoder<4>);
+}
+
+impl Encode for Sequence {
+    type Encoder<'e> = SequenceEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        SequenceEncoder::new(ArrayEncoder::without_length_prefix(
+            self.to_consensus_u32().to_le_bytes(),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`AssetIssuance`] type.
+    #[derive(Clone, Debug)]
+    pub struct AssetIssuanceEncoder<'e>(Encoder4<
+        ArrayRefEncoder<'e, 32>,
+        ArrayRefEncoder<'e, 32>,
+        crate::confidential::ValueEncoder<'e>,
+        crate::confidential::ValueEncoder<'e>,
+    >);
+}
+
+impl Encode for AssetIssuance {
+    type Encoder<'e> = AssetIssuanceEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        AssetIssuanceEncoder::new(Encoder4::new(
+            ArrayRefEncoder::without_length_prefix(self.asset_blinding_nonce.as_ref()),
+            ArrayRefEncoder::without_length_prefix(&self.asset_entropy),
+            self.amount.encoder(),
+            self.inflation_keys.encoder(),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxInWitness`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxInWitnessEncoder<'e>(Encoder4<
+        RangeProofEncoder<'e>,
+        RangeProofEncoder<'e>,
+        WitnessEncoder<'e>,
+        PeginWitnessEncoder<'e>,
+    >);
+}
+
+impl Encode for TxInWitness {
+    type Encoder<'e> = TxInWitnessEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxInWitnessEncoder::new(Encoder4::new(
+            self.amount_rangeproof.encoder(),
+            self.inflation_keys_rangeproof.encoder(),
+            self.script_witness.encoder(),
+            self.pegin_witness.encoder(),
+        ))
+    }
+}
+
+/// An encoder for the witnesses in a sequence of [`TxIn`]s.
+#[derive(Clone, Debug)]
+struct TxInWitnessesEncoder<'e> {
+    txins: &'e [TxIn],
+    cur_enc: Option<TxInWitnessEncoder<'e>>,
+}
+
+impl<'e> TxInWitnessesEncoder<'e> {
+    fn new(txins: &'e [TxIn]) -> Self {
+        Self { txins, cur_enc: txins.first().map(|txin| txin.witness.encoder()) }
+    }
+}
+
+impl Encoder for TxInWitnessesEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] {
+        self.cur_enc.as_ref().map(Encoder::current_chunk).unwrap_or_default()
+    }
+
+    fn advance(&mut self) -> EncoderStatus {
+        let Some(cur) = self.cur_enc.as_mut() else {
+            return EncoderStatus::Finished;
+        };
+
+        loop {
+            if cur.advance().has_more() {
+                return EncoderStatus::HasMore;
+            }
+            // self.inputs guaranteed to be non-empty if cur_enc is non-None.
+            self.txins = &self.txins[1..];
+            if let Some(txin) = self.txins.first() {
+                *cur = txin.witness.encoder();
+                if !cur.current_chunk().is_empty() {
+                    return EncoderStatus::HasMore;
+                }
+            } else {
+                self.cur_enc = None;
+                return EncoderStatus::Finished;
+            }
+        }
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxIn`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxInEncoder<'e>(Encoder4<
+        OutPointEncoder<'e>,
+        crate::script::ScriptEncoder<'e>,
+        SequenceEncoder<'e>,
+        Option<AssetIssuanceEncoder<'e>>,
+    >);
+}
+
+impl Encode for TxIn {
+    type Encoder<'e> = TxInEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxInEncoder::new(Encoder4::new(
+            OutPointEncoder::from_txin(self),
+            self.script_sig.encoder(),
+            self.sequence.encoder(),
+            self.has_issuance().then(|| self.asset_issuance.encoder()),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxOutWitness`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxOutWitnessEncoder<'e>(Encoder2<
+        crate::confidential::SurjectionProofEncoder<'e>,
+        crate::confidential::RangeProofEncoder<'e>,
+    >);
+}
+
+impl Encode for TxOutWitness {
+    type Encoder<'e> = TxOutWitnessEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxOutWitnessEncoder::new(Encoder2::new(
+            self.surjection_proof.encoder(),
+            self.rangeproof.encoder(),
+        ))
+    }
+}
+
+/// An encoder for the witnesses in a sequence of [`TxOut`]s.
+#[derive(Clone, Debug)]
+struct TxOutWitnessesEncoder<'e> {
+    txouts: &'e [TxOut],
+    cur_enc: Option<TxOutWitnessEncoder<'e>>,
+}
+
+impl<'e> TxOutWitnessesEncoder<'e> {
+    fn new(txouts: &'e [TxOut]) -> Self {
+        Self { txouts, cur_enc: txouts.first().map(|txout| txout.witness.encoder()) }
+    }
+}
+
+impl Encoder for TxOutWitnessesEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] {
+        self.cur_enc.as_ref().map(Encoder::current_chunk).unwrap_or_default()
+    }
+
+    fn advance(&mut self) -> EncoderStatus {
+        let Some(cur) = self.cur_enc.as_mut() else {
+            return EncoderStatus::Finished;
+        };
+
+        loop {
+            if cur.advance().has_more() {
+                return EncoderStatus::HasMore;
+            }
+            // self.inputs guaranteed to be non-empty if cur_enc is non-None.
+            self.txouts = &self.txouts[1..];
+            if let Some(txout) = self.txouts.first() {
+                *cur = txout.witness.encoder();
+                if !cur.current_chunk().is_empty() {
+                    return EncoderStatus::HasMore;
+                }
+            } else {
+                self.cur_enc = None;
+                return EncoderStatus::Finished;
+            }
+        }
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxOut`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxOutEncoder<'e>(Encoder4<
+        crate::confidential::AssetEncoder<'e>,
+        crate::confidential::ValueEncoder<'e>,
+        crate::confidential::NonceEncoder<'e>,
+        crate::script::ScriptEncoder<'e>,
+    >);
+}
+
+impl Encode for TxOut {
+    type Encoder<'e> = TxOutEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxOutEncoder::new(Encoder4::new(
+            self.asset.encoder(),
+            self.value.encoder(),
+            self.nonce.encoder(),
+            self.script_pubkey.encoder(),
+        ))
+    }
+}
+
+encoder_newtype! {
+    /// Encoder for the [`Transaction`] type.
+    pub struct TransactionEncoder<'e>(Encoder6<
+        ArrayEncoder<4>,
+        ArrayEncoder<1>,
+        PrefixedSliceEncoder<'e, TxIn>,
+        PrefixedSliceEncoder<'e, TxOut>,
+        LockTimeEncoder<'e>,
+        Option<Encoder2<
+            TxInWitnessesEncoder<'e>,
+            TxOutWitnessesEncoder<'e>,
+        >>
+    >);
+}
+
+impl Encode for Transaction {
+    type Encoder<'e> = TransactionEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        let witness_flag = self.has_witness();
+        TransactionEncoder::new(Encoder6::new(
+            ArrayEncoder::without_length_prefix(self.version.to_le_bytes()),
+            ArrayEncoder::without_length_prefix([u8::from(witness_flag)]),
+            PrefixedSliceEncoder::new(&self.input),
+            PrefixedSliceEncoder::new(&self.output),
+            self.lock_time.encoder(),
+            witness_flag.then(|| {
+                Encoder2::new(
+                    TxInWitnessesEncoder::new(&self.input),
+                    TxOutWitnessesEncoder::new(&self.output),
+                )
+            }),
+        ))
+    }
+}
diff --git a/src/transaction.rs b/src/transaction/mod.rs
similarity index 95%
rename from src/transaction.rs
rename to src/transaction/mod.rs
index 694c43ac..1f3c6847 100644
--- a/src/transaction.rs
+++ b/src/transaction/mod.rs
@@ -15,13 +15,17 @@
 //! # Transactions
 //!
 
+mod decoders;
+mod encoders;
+mod pegin_witness;
+mod witness;
+
 use std::{io, fmt, str, cmp};
 use std::collections::HashMap;
 use std::convert::TryFrom;
 
 use bitcoin::{self, VarInt};
 use bitcoin::hashes::Hash as _;
-use internals::slice::SliceExt;
 use crate::hashes::{sha256d, HashEngine as _};
 
 use crate::{confidential, ContractHash};
@@ -35,6 +39,13 @@ use secp256k1_zkp::{
     Tweak, ZERO_TWEAK,
 };
 
+pub use self::decoders::{AssetIssuanceDecoder, AssetIssuanceDecoderError, SequenceDecoder, SequenceDecoderError, TransactionDecoder, TransactionDecoderError, TxInDecoder, TxInDecoderError, TxInWitnessDecoder, TxInWitnessDecoderError, TxOutDecoder, TxOutDecoderError, TxOutWitnessDecoder, TxOutWitnessDecoderError};
+pub use self::encoders::{AssetIssuanceEncoder, SequenceEncoder, TransactionEncoder, TxInEncoder, TxInWitnessEncoder, TxOutEncoder, TxOutWitnessEncoder};
+pub use self::pegin_witness::{
+    PeginData, PeginDataDecoder, PeginDataEncoder,
+    PeginWitness, PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder};
+pub use self::witness::{Witness, WitnessDecoder, WitnessDecoderError, WitnessEncoder};
+
 /// Description of an asset issuance in a transaction input
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct AssetIssuance {
@@ -64,7 +75,6 @@ impl AssetIssuance {
         self.amount.is_null() && self.inflation_keys.is_null()
     }
 }
-serde_struct_impl!(AssetIssuance, asset_blinding_nonce, asset_entropy, amount, inflation_keys);
 impl_consensus_encoding!(AssetIssuance, asset_blinding_nonce, asset_entropy, amount, inflation_keys);
 
 impl Default for AssetIssuance {
@@ -357,7 +367,6 @@ impl std::error::Error for RelativeLockTimeError {
     }
 }
 
-
 /// Transaction input witness
 #[derive(Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 pub struct TxInWitness {
@@ -366,11 +375,10 @@ pub struct TxInWitness {
     /// Rangeproof for inflation keys
     pub inflation_keys_rangeproof: RangeProof,
     /// Traditional script witness
-    pub script_witness: Vec<Vec<u8>>,
+    pub script_witness: Witness,
     /// Pegin witness, basically the same thing
-    pub pegin_witness: Vec<Vec<u8>>,
+    pub pegin_witness: PeginWitness,
 }
-serde_struct_impl!(TxInWitness, amount_rangeproof, inflation_keys_rangeproof, script_witness, pegin_witness);
 impl_consensus_encoding!(TxInWitness, amount_rangeproof, inflation_keys_rangeproof, script_witness, pegin_witness);
 
 impl TxInWitness {
@@ -379,8 +387,8 @@ impl TxInWitness {
         TxInWitness {
             amount_rangeproof: RangeProof::EMPTY,
             inflation_keys_rangeproof: RangeProof::EMPTY,
-            script_witness: Vec::new(),
-            pegin_witness: Vec::new(),
+            script_witness: Witness::new(),
+            pegin_witness: PeginWitness::EMPTY,
         }
     }
 
@@ -399,84 +407,6 @@ impl Default for TxInWitness {
     }
 }
 
-
-/// Parsed data from a transaction input's pegin witness
-#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
-pub struct PeginData<'tx> {
-    /// Reference to the pegin output on the mainchain
-    pub outpoint: bitcoin::OutPoint,
-    /// The value, in satoshis, of the pegin
-    pub value: u64,
-    /// Asset type being pegged in
-    pub asset: AssetId,
-    /// Hash of genesis block of originating blockchain
-    pub genesis_hash: bitcoin::BlockHash,
-    /// The claim script that we should hash to tweak our address. Unparsed
-    /// to avoid unnecessary allocation and copying. Typical use is simply
-    /// to feed it raw into a hash function.
-    pub claim_script: &'tx [u8],
-    /// Mainchain transaction; not parsed to save time/memory since the
-    /// parsed transaction is typically not useful without auxiliary
-    /// data (e.g. knowing how to compute pegin addresses for the
-    /// sidechain).
-    pub tx: &'tx [u8],
-    /// Merkle proof of transaction inclusion; also not parsed
-    pub merkle_proof: &'tx [u8],
-    /// The Bitcoin block that the pegin output appears in; scraped
-    /// from the transaction inclusion proof
-    pub referenced_block: bitcoin::BlockHash,
-}
-
-impl<'tx> PeginData<'tx> {
-    /// Construct the pegin data from a pegin witness.
-    /// Returns None if not a valid pegin witness.
-    pub fn from_pegin_witness(
-        pegin_witness: &'tx [Vec<u8>],
-        prevout: bitcoin::OutPoint,
-    ) -> Result<PeginData<'tx>, &'static str> {
-        let Ok(pegin_witness) = <&[Vec<u8>; 6]>::try_from(pegin_witness)  else {
-            return Err("size not 6");
-        };
-        let Some((block_header, _)) = SliceExt::split_first_chunk::<80>(pegin_witness[5].as_slice()) else {
-            return Err("merkle proof too short");
-        };
-
-        Ok(PeginData {
-            outpoint: prevout,
-            value: bitcoin::consensus::deserialize(&pegin_witness[0]).map_err(|_| "invalid value")?,
-            asset: encode::deserialize(&pegin_witness[1]).map_err(|_| "invalid asset")?,
-            genesis_hash: bitcoin::consensus::deserialize(&pegin_witness[2])
-                .map_err(|_| "invalid genesis hash")?,
-            claim_script: &pegin_witness[3],
-            tx: &pegin_witness[4],
-            merkle_proof: &pegin_witness[5],
-            referenced_block: bitcoin::BlockHash::hash(block_header),
-        })
-    }
-
-    /// Construct a pegin witness from the pegin data.
-    pub fn to_pegin_witness(&self) -> Vec<Vec<u8>> {
-        vec![
-            bitcoin::consensus::serialize(&self.value),
-            encode::serialize(&self.asset),
-            bitcoin::consensus::serialize(&self.genesis_hash),
-            self.claim_script.to_vec(),
-            self.tx.to_vec(),
-            self.merkle_proof.to_vec(),
-        ]
-    }
-
-    /// Parse the mainchain tx provided as pegin data.
-    pub fn parse_tx(&self) -> Result<bitcoin::Transaction, bitcoin::consensus::encode::Error> {
-        bitcoin::consensus::encode::deserialize(self.tx)
-    }
-
-    /// Parse the merkle inclusion proof provided as pegin data.
-    pub fn parse_merkle_proof(&self) -> Result<bitcoin::MerkleBlock, bitcoin::consensus::encode::Error> {
-        bitcoin::consensus::encode::deserialize(self.merkle_proof)
-    }
-}
-
 /// A transaction input, which defines old coins to be consumed
 #[derive(Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 pub struct TxIn {
@@ -513,8 +443,6 @@ impl Default for TxIn {
     }
 }
 
-serde_struct_impl!(TxIn, previous_output, is_pegin, script_sig, sequence, asset_issuance, witness);
-
 impl Encodable for TxIn {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
         let mut ret = 0;
@@ -603,10 +531,8 @@ impl TxIn {
     /// Extracts witness data from a pegin. Will return `None` if any data
     /// cannot be parsed. The combination of `is_pegin()` returning `true`
     /// and `pegin_data()` returning `None` indicates an invalid transaction.
-    pub fn pegin_data(&self) -> Option<PeginData<'_>> {
-        self.pegin_prevout().and_then(|p| {
-            PeginData::from_pegin_witness(&self.witness.pegin_witness, p).ok()
-        })
+    pub fn pegin_data(&self) -> Option<&PeginData> {
+        self.witness.pegin_witness.data()
     }
 
     /// Helper to determine whether an input has an asset issuance attached
@@ -650,7 +576,6 @@ pub struct TxOutWitness {
     // allocates on stack even when the range proof is empty
     pub rangeproof: RangeProof,
 }
-serde_struct_impl!(TxOutWitness, surjection_proof, rangeproof);
 impl_consensus_encoding!(TxOutWitness, surjection_proof, rangeproof);
 
 impl TxOutWitness {
@@ -715,7 +640,6 @@ pub struct TxOut {
     /// part of the txin.
     pub witness: TxOutWitness,
 }
-serde_struct_impl!(TxOut, asset, value, nonce, script_pubkey, witness);
 
 impl Encodable for TxOut {
     fn consensus_encode<S: io::Write>(&self, mut s: S) -> Result<usize, encode::Error> {
@@ -862,7 +786,6 @@ pub struct Transaction {
     /// Vector of outputs
     pub output: Vec<TxOut>,
 }
-serde_struct_impl!(Transaction, version, lock_time, input, output);
 
 impl Transaction {
     /// Whether the transaction is a coinbase tx
@@ -964,11 +887,7 @@ impl Transaction {
                     VarInt(wit.len() as u64).size() +
                     wit.len()
                 ).sum::<usize>() +
-                VarInt(input.witness.pegin_witness.len() as u64).size() +
-                input.witness.pegin_witness.iter().map(|wit|
-                    VarInt(wit.len() as u64).size() +
-                    wit.len()
-                ).sum::<usize>()
+                input.witness.pegin_witness.encoded_size()
             } else {
                 0
             }
@@ -1657,24 +1576,18 @@ mod tests {
         assert_eq!(tx.input[0].witness.pegin_witness.len(), 6);
         assert_eq!(
             tx.input[0].pegin_data(),
-            Some(super::PeginData {
-                outpoint: bitcoin::OutPoint {
-                    txid: bitcoin::Txid::from_str(
-                        "c9d88eb5130365deed045eab11cfd3eea5ba32ad45fa2e156ae6ead5f1fce93f",
-                    ).unwrap(),
-                    vout: 0,
-                },
+            Some(&super::PeginData {
                 value: 100_000_000,
-                asset: tx.output[0].asset.explicit().unwrap(),
+                asset_id: tx.output[0].asset.explicit().unwrap(),
                 genesis_hash: bitcoin::BlockHash::from_str(
                     "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"
                 ).unwrap(),
-                claim_script: &[
+                claim_script: bitcoin::ScriptBuf::from(vec![
                     0x00, 0x14, 0x1a, 0xb7, 0xf5, 0x99, 0x5c, 0xf0,
                     0xdf, 0xcb, 0x90, 0xcb, 0xb0, 0x2b, 0x63, 0x39,
                     0x7e, 0x53, 0x26, 0xea, 0xe6, 0xfe,
-                ],
-                tx: &[
+                ]),
+                transaction: vec![
                     0x02, 0x00, 0x00, 0x00, 0x01, 0x13, 0x24, 0x4f,
                     0xa5, 0x9f, 0xcb, 0x40, 0x71, 0x24, 0x03, 0x8f,
                     0xf9, 0x12, 0x1e, 0xd5, 0x46, 0xf6, 0xdc, 0x21,
@@ -1700,7 +1613,7 @@ mod tests {
                     0xfc, 0x1f, 0xc8, 0xf1, 0xa4, 0x95, 0xaf, 0xfa,
                     0x88, 0xac, 0xf4, 0x01, 0x00, 0x00,
                 ],
-                merkle_proof: &[
+                merkle_proof: vec![
                     0x00, 0x00, 0x00, 0x20, 0xa0, 0x60, 0x08, 0x6a,
                     0xf9, 0x2a, 0xc3, 0x4d, 0xbb, 0xc8, 0xbd, 0x89,
                     0xbb, 0xbe, 0x03, 0xef, 0x7e, 0x00, 0x16, 0x93,
@@ -1732,7 +1645,7 @@ mod tests {
         );
         assert_eq!(
             tx.input[0].witness.pegin_witness,
-            tx.input[0].pegin_data().unwrap().to_pegin_witness(),
+            PeginWitness::new(tx.input[0].pegin_data().unwrap().clone()),
         );
 
         assert_eq!(tx.output.len(), 2);
@@ -2389,24 +2302,18 @@ mod tests {
 
     #[test]
     fn malformed_pegin() {
-        let mut input: TxIn = hex_deserialize!("\
-            0004000000000000ffffffff0000040000c0c0c0c0c0c0c0c0c0000000000000\
-            00805555555555555505c0c0c0c0c03fc0c0c0c0c0c0c0c0c0c0c0c00200ff01\
-            0000000000fd0000000000000000010000000000ffffffffffffffff00000000\
-            000000ff000000000000010000000000000000000001002d342d35313700\
-        ");
-        input.witness = hex_deserialize!("\
+        let wit = hex::decode_to_vec("\
             0000000608202020202020202020202020202020202020202020202020202020\
             2020202020202020202020202020202020202020202020202020202020202020\
             2020202020202020202020202020202020202020202020202020202020200000\
             00000000000000000000000000000002000400000000\
-        ");
-        assert!(input.pegin_data().is_none());
+        ").unwrap();
+        assert!(TxInWitness::consensus_decode(&wit[..]).is_err());
     }
 
     #[test]
     fn discount_vsize() {
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/1in2out_pegin.hex"));
+        let tx: Transaction = hex_deserialize!(include_str!("../../tests/data/1in2out_pegin.hex"));
         assert_eq!(tx.input.len(), 1);
         assert!(tx.input[0].is_pegin());
         assert_eq!(tx.output.len(), 2);
@@ -2415,7 +2322,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 2403);
         assert_eq!(tx.discount_vsize(), 601);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/1in2out_tx.hex"));
+        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);
@@ -2423,7 +2330,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 863);
         assert_eq!(tx.discount_vsize(), 216);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/1in3out_tx.hex"));
+        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);
@@ -2431,7 +2338,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 1173);
         assert_eq!(tx.discount_vsize(), 294);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in3out_exp.hex"));
+        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);
@@ -2439,7 +2346,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 1302);
         assert_eq!(tx.discount_vsize(), 326);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in3out_tx.hex"));
+        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);
@@ -2447,7 +2354,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 1302);
         assert_eq!(tx.discount_vsize(), 326);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in3out_tx.hex"));
+        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);
@@ -2455,7 +2362,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 1302);
         assert_eq!(tx.discount_vsize(), 326);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in3out_tx2.hex"));
+        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);
@@ -2463,7 +2370,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 1538);
         assert_eq!(tx.discount_vsize(), 385);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/3in3out_tx.hex"));
+        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);
@@ -2471,7 +2378,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 1860);
         assert_eq!(tx.discount_vsize(), 465);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/4in3out_tx.hex"));
+        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);
@@ -2479,7 +2386,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 2130);
         assert_eq!(tx.discount_vsize(), 533);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in4out_tx.hex"));
+        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);
@@ -2487,7 +2394,7 @@ mod tests {
         assert_eq!(tx.discount_weight(), 1764);
         assert_eq!(tx.discount_vsize(), 441);
 
-        let tx: Transaction = hex_deserialize!(include_str!("../tests/data/2in5out_tx.hex"));
+        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);
@@ -2501,8 +2408,8 @@ mod tests {
         // Check that rust-elements can deserialize tests vector from ELIP203
         // from
         // https://github.com/ElementsProject/ELIPs/blob/main/elip-0203.mediawiki
-        let tx3: Transaction = hex_deserialize!(include_str!("../tests/data/elip203_3.hex"));
-        let tx4: Transaction = hex_deserialize!(include_str!("../tests/data/elip203_4.hex"));
+        let tx3: Transaction = hex_deserialize!(include_str!("../../tests/data/elip203_3.hex"));
+        let tx4: Transaction = hex_deserialize!(include_str!("../../tests/data/elip203_4.hex"));
         let max_money = 2_100_000_000_000_000;
         assert!(tx3.input[0].asset_issuance.amount.explicit().unwrap() > max_money);
         assert!(tx4.input[0].asset_issuance.inflation_keys.explicit().unwrap() > max_money);
@@ -2513,7 +2420,7 @@ mod tests {
         use crate::encode::{serialize, deserialize};
 
         // Start with a transaction that has a pegin.
-        let base_tx: Transaction = hex_deserialize!(include_str!("../tests/data/1in2out_pegin.hex"));
+        let base_tx: Transaction = hex_deserialize!(include_str!("../../tests/data/1in2out_pegin.hex"));
 
         // Test case (a): input witnesses but no output witnesses
         let mut tx_input_only = base_tx.clone();
diff --git a/src/transaction/pegin_witness.rs b/src/transaction/pegin_witness.rs
new file mode 100644
index 00000000..c80d66b8
--- /dev/null
+++ b/src/transaction/pegin_witness.rs
@@ -0,0 +1,558 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Pegin Witnesses
+
+use core::fmt;
+use std::io;
+
+// lol should these be accessible from a more convenient path?
+use bitcoin::block::BlockHashDecoder as GenesisHashDecoder;
+use bitcoin::block::{
+    BlockHashDecoderError as GenesisHashDecoderError, BlockHashEncoder as GenesisHashEncoder,
+};
+use bitcoin::hashes::Hash as _;
+use hashes::encoding::UnexpectedEofError;
+
+use crate::{encode, encoding, AssetId};
+
+const TOTAL_PEGIN_LENGTH: usize = 6;
+
+/// A pegin witness, which must be either a stack of 6 well-formed pieces of pegin data, or an empty witness stack.
+#[derive(Default, Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
+pub struct PeginWitness {
+    inner: Option<PeginData>,
+}
+
+impl PeginWitness {
+    /// An empty pegin witness.
+    pub const EMPTY: Self = Self { inner: None };
+
+    /// A pegin witness containing the given data.
+    pub fn new(data: PeginData) -> Self { Self { inner: Some(data) } }
+
+    /// Accessor for the pegin witness data.
+    pub fn data(&self) -> Option<&PeginData> { self.inner.as_ref() }
+
+    /// Accessor for the pegin witness data.
+    pub fn into_data(self) -> Option<PeginData> { self.inner }
+
+    /// Whether this pegin witness is empty (no pegin).
+    pub fn is_empty(&self) -> bool { self.inner.is_none() }
+
+    /// The number of witness elements in the [`PeginWitness`].
+    pub fn len(&self) -> usize {
+        if self.inner.is_some() {
+            TOTAL_PEGIN_LENGTH
+        } else {
+            0
+        }
+    }
+
+    /// The number of bytes used to encode the [`PeginWitness`].
+    pub fn encoded_size(&self) -> usize {
+        use encoding::{Encode as _, ExactSizeEncoder as _};
+        match self.inner {
+            Some(ref data) => data.encoder().len(),
+            None => 1,
+        }
+    }
+}
+
+/// Encoder for the [`PeginWitness`] type.
+#[derive(Clone, Debug)]
+pub struct PeginWitnessEncoder<'e>(PeginWitnessEncoderInner<'e>);
+
+#[derive(Clone, Debug)]
+#[allow(clippy::large_enum_variant)]
+enum PeginWitnessEncoderInner<'e> {
+    Pegin(PeginDataEncoder<'e>),
+    Empty(encoding::CompactSizeEncoder),
+}
+
+impl encoding::Encoder for PeginWitnessEncoder<'_> {
+    fn current_chunk(&self) -> &[u8] {
+        use PeginWitnessEncoderInner as Inner;
+        match self.0 {
+            Inner::Pegin(ref enc) => enc.current_chunk(),
+            Inner::Empty(ref enc) => enc.current_chunk(),
+        }
+    }
+
+    fn advance(&mut self) -> encoding::EncoderStatus {
+        use PeginWitnessEncoderInner as Inner;
+        match self.0 {
+            Inner::Pegin(ref mut enc) => enc.advance(),
+            Inner::Empty(ref mut enc) => enc.advance(),
+        }
+    }
+}
+
+impl encoding::ExactSizeEncoder for PeginWitnessEncoder<'_> {
+    fn len(&self) -> usize {
+        use PeginWitnessEncoderInner as Inner;
+        match self.0 {
+            Inner::Pegin(ref enc) => enc.len(),
+            Inner::Empty(ref enc) => enc.len(),
+        }
+    }
+}
+
+impl encoding::Encode for PeginWitness {
+    type Encoder<'e> = PeginWitnessEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        match self.inner {
+            Some(ref data) => PeginWitnessEncoder(PeginWitnessEncoderInner::Pegin(data.encoder())),
+            None => PeginWitnessEncoder(PeginWitnessEncoderInner::Empty(
+                encoding::CompactSizeEncoder::new(0),
+            )),
+        }
+    }
+}
+
+/// Decoder for the [`PeginWitness`] type.
+#[derive(Default)]
+pub struct PeginWitnessDecoder(PeginWitnessDecoderInner);
+
+#[derive(Default)]
+#[allow(clippy::large_enum_variant)]
+enum PeginWitnessDecoderInner {
+    #[default]
+    Undetermined,
+    Empty,
+    Pegin(PeginDataDecoder),
+}
+
+impl encoding::Decoder for PeginWitnessDecoder {
+    type Output = PeginWitness;
+    type Error = PeginWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
+        use PeginWitnessDecoderInner as Inner;
+        loop {
+            match self.0 {
+                Inner::Undetermined => {
+                    match bytes.first().copied().map(usize::from) {
+                        None => return Ok(encoding::DecoderStatus::NeedsMore),
+                        Some(0) => {
+                            *bytes = &bytes[1..];
+                            self.0 = Inner::Empty;
+                        }
+                        Some(TOTAL_PEGIN_LENGTH) => {
+                            // don't advance `bytes`; the PeginDataDecoder will
+                            self.0 = Inner::Pegin(PeginDataDecoder::default());
+                        }
+                        Some(x) => {
+                            return Err(PeginWitnessDecoderError {
+                                field: "pegin witness",
+                                inner: PeginDataDecoderErrorInner::Length(
+                                    ExactLengthDecoderError::IncorrectLength {
+                                        expected: TOTAL_PEGIN_LENGTH,
+                                        got: x,
+                                    },
+                                ),
+                            });
+                        }
+                    }
+                }
+                Inner::Empty => return Ok(encoding::DecoderStatus::Ready),
+                Inner::Pegin(ref mut decoder) => return decoder.push_bytes(bytes),
+            }
+        }
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        use PeginWitnessDecoderInner as Inner;
+        match self.0 {
+            Inner::Undetermined => Err(PeginWitnessDecoderError {
+                field: "pegin witness",
+                inner: PeginDataDecoderErrorInner::InsufficientLength { minimum: 1, got: 0 },
+            }),
+            Inner::Empty => Ok(PeginWitness { inner: None }),
+            Inner::Pegin(decoder) => decoder.end().map(|inner| PeginWitness { inner: Some(inner) }),
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        use PeginWitnessDecoderInner as Inner;
+        match self.0 {
+            Inner::Undetermined => 1,
+            Inner::Empty => 0,
+            Inner::Pegin(ref decoder) => decoder.read_limit(),
+        }
+    }
+}
+
+impl encoding::Decode for PeginWitness {
+    type Decoder = PeginWitnessDecoder;
+}
+
+/// Parsed data from a transaction input's pegin witness
+#[derive(Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
+pub struct PeginData {
+    /// The value, in satoshis, of the pegin
+    pub value: u64,
+    /// Asset type being pegged in
+    pub asset_id: AssetId,
+    /// Hash of genesis block of originating blockchain
+    pub genesis_hash: bitcoin::BlockHash,
+    /// The claim script that we should hash to tweak our address.
+    pub claim_script: bitcoin::ScriptBuf,
+    /// Mainchain transaction; not parsed to save time/memory since the
+    /// parsed transaction is typically not useful without auxiliary
+    /// data (e.g. knowing how to compute pegin addresses for the
+    /// sidechain).
+    pub transaction: Vec<u8>,
+    /// Merkle proof of transaction inclusion. Also not parsed.
+    pub merkle_proof: Vec<u8>,
+    /// The Bitcoin block that the pegin output appears in; scraped
+    /// from the transaction inclusion proof
+    pub referenced_block: bitcoin::BlockHash,
+}
+
+impl PeginData {
+    /// Parse the mainchain tx provided as pegin data.
+    pub fn parse_tx(&self) -> Result<bitcoin::Transaction, bitcoin::consensus::encode::Error> {
+        bitcoin::consensus::encode::deserialize(&self.transaction)
+    }
+
+    /// Parse the merkle inclusion proof provided as pegin data.
+    pub fn parse_merkle_proof(
+        &self,
+    ) -> Result<bitcoin::MerkleBlock, bitcoin::consensus::encode::Error> {
+        bitcoin::consensus::encode::deserialize(&self.merkle_proof)
+    }
+}
+
+encoding::encoder_newtype_exact! {
+    /// An encoder for the [`PeginWitness`] type.
+    #[derive(Clone, Debug)]
+    pub struct PeginDataEncoder<'e>(
+        encoding::Encoder3<
+            // top-level compactsize
+            encoding::CompactSizeEncoder,
+            encoding::Encoder6<
+                // value
+                encoding::CompactSizeEncoder,
+                encoding::ArrayEncoder<8>,
+                // asset ID
+                encoding::CompactSizeEncoder,
+                encoding::ArrayRefEncoder<'e, 32>,
+                // genesis hash
+                encoding::CompactSizeEncoder,
+                GenesisHashEncoder<'e>,
+            >,
+            encoding::Encoder3<
+                // claim script
+                bitcoin::blockdata::script::ScriptEncoder<'e>,
+                // transaction
+                encoding::PrefixedBytesEncoder<'e>,
+                // merkle proof
+                encoding::PrefixedBytesEncoder<'e>,
+
+            >,
+        >
+    );
+}
+
+impl encoding::Encode for PeginData {
+    type Encoder<'e> = PeginDataEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        PeginDataEncoder::new(encoding::Encoder3::new(
+            encoding::CompactSizeEncoder::new(TOTAL_PEGIN_LENGTH),
+            encoding::Encoder6::new(
+                encoding::CompactSizeEncoder::new(8),
+                encoding::ArrayEncoder::without_length_prefix(self.value.to_le_bytes()),
+                encoding::CompactSizeEncoder::new(32),
+                encoding::ArrayRefEncoder::without_length_prefix(self.asset_id.as_byte_array()),
+                encoding::CompactSizeEncoder::new(32),
+                self.genesis_hash.encoder(),
+            ),
+            encoding::Encoder3::new(
+                self.claim_script.encoder(),
+                encoding::PrefixedBytesEncoder::new(&self.transaction),
+                encoding::PrefixedBytesEncoder::new(&self.merkle_proof),
+            ),
+        ))
+    }
+}
+
+struct ExactLengthDecoder {
+    target: usize,
+    inner: encoding::CompactSizeDecoder,
+}
+
+impl ExactLengthDecoder {
+    fn new(target: usize) -> Self { Self { target, inner: encoding::CompactSizeDecoder::new() } }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+enum ExactLengthDecoderError {
+    IncorrectLength { expected: usize, got: usize },
+    InvalidCompactSize(encoding::CompactSizeDecoderError),
+}
+
+impl fmt::Display for ExactLengthDecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            Self::IncorrectLength { expected, got } => {
+                write!(f, "expected length {expected} but got {got}")
+            }
+            Self::InvalidCompactSize(_) => f.write_str("failed to decode compact size"),
+        }
+    }
+}
+
+impl std::error::Error for ExactLengthDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            Self::IncorrectLength { .. } => None,
+            Self::InvalidCompactSize(ref error) => Some(error),
+        }
+    }
+}
+
+impl encoding::Decoder for ExactLengthDecoder {
+    type Output = usize;
+    type Error = ExactLengthDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(ExactLengthDecoderError::InvalidCompactSize)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let expected = self.target;
+        let got = self.inner.end().map_err(ExactLengthDecoderError::InvalidCompactSize)?;
+
+        if got == self.target {
+            Ok(got)
+        } else {
+            Err(ExactLengthDecoderError::IncorrectLength { expected, got })
+        }
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+/// A decoder for the [`PeginData`] type.
+#[allow(clippy::type_complexity)]
+pub struct PeginDataDecoder {
+    inner: encoding::Decoder3<
+        // top-level compactsize
+        ExactLengthDecoder,
+        encoding::Decoder6<
+            // value
+            ExactLengthDecoder,
+            encoding::ArrayDecoder<8>,
+            // asset ID
+            ExactLengthDecoder,
+            encoding::ArrayDecoder<32>,
+            // genesis hash
+            ExactLengthDecoder,
+            GenesisHashDecoder,
+        >,
+        encoding::Decoder3<
+            // claim script
+            bitcoin::blockdata::script::ScriptBufDecoder,
+            // transaction
+            encoding::ByteVecDecoder,
+            // merkle proof
+            encoding::ByteVecDecoder,
+        >,
+    >,
+}
+
+impl Default for PeginDataDecoder {
+    fn default() -> Self {
+        Self {
+            inner: encoding::Decoder3::new(
+                ExactLengthDecoder::new(TOTAL_PEGIN_LENGTH),
+                encoding::Decoder6::new(
+                    ExactLengthDecoder::new(8),
+                    encoding::ArrayDecoder::new(),
+                    ExactLengthDecoder::new(32),
+                    encoding::ArrayDecoder::new(),
+                    ExactLengthDecoder::new(32),
+                    GenesisHashDecoder::new(),
+                ),
+                encoding::Decoder3::new(
+                    bitcoin::blockdata::script::ScriptBufDecoder::new(),
+                    encoding::ByteVecDecoder::new(),
+                    encoding::ByteVecDecoder::new(),
+                ),
+            ),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+enum PeginDataDecoderErrorInner {
+    ClaimScript(bitcoin::blockdata::script::ScriptBufDecoderError),
+    GenesisHash(GenesisHashDecoderError),
+    Length(ExactLengthDecoderError),
+    InsufficientLength { minimum: usize, got: usize },
+    Eof(encoding::UnexpectedEofError),
+    ByteVec(encoding::ByteVecDecoderError),
+}
+
+/// Error type for the decoding of [`PeginData`] or [`PeginWitness`].
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct PeginWitnessDecoderError {
+    field: &'static str,
+    inner: PeginDataDecoderErrorInner,
+}
+
+impl fmt::Display for PeginWitnessDecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.field == "pegin witness" {
+            f.write_str("error decoding pegin witness")?;
+        } else {
+            write!(f, "error decoding pegin witness field {}", self.field)?;
+        }
+        if let PeginDataDecoderErrorInner::InsufficientLength { minimum, got } = self.inner {
+            write!(f, ": needed at least {minimum} bytes, got {got}")?;
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for PeginWitnessDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use PeginDataDecoderErrorInner as Inner;
+        match self.inner {
+            Inner::ClaimScript(ref e) => Some(e),
+            Inner::GenesisHash(ref e) => Some(e),
+            Inner::Length(ref e) => Some(e),
+            Inner::InsufficientLength { .. } => None,
+            Inner::Eof(ref e) => Some(e),
+            Inner::ByteVec(ref e) => Some(e),
+        }
+    }
+}
+
+impl PeginWitnessDecoderError {
+    /// Private error conversion function.
+    #[allow(clippy::type_complexity)]
+    fn from(
+        inner: encoding::Decoder3Error<
+            ExactLengthDecoderError,
+            encoding::Decoder6Error<
+                ExactLengthDecoderError,
+                UnexpectedEofError,
+                ExactLengthDecoderError,
+                UnexpectedEofError,
+                ExactLengthDecoderError,
+                GenesisHashDecoderError,
+            >,
+            encoding::Decoder3Error<
+                bitcoin::blockdata::script::ScriptBufDecoderError,
+                encoding::ByteVecDecoderError,
+                encoding::ByteVecDecoderError,
+            >,
+        >,
+    ) -> Self {
+        use encoding::{Decoder3Error as Dec3Err, Decoder6Error as Dec6Err};
+
+        match inner {
+            Dec3Err::First(error) =>
+                Self { field: "pegin witness", inner: PeginDataDecoderErrorInner::Length(error) },
+            Dec3Err::Second(Dec6Err::First(error)) =>
+                Self { field: "value", inner: PeginDataDecoderErrorInner::Length(error) },
+            Dec3Err::Second(Dec6Err::Second(error)) =>
+                Self { field: "value", inner: PeginDataDecoderErrorInner::Eof(error) },
+            Dec3Err::Second(Dec6Err::Third(error)) =>
+                Self { field: "asset ID", inner: PeginDataDecoderErrorInner::Length(error) },
+            Dec3Err::Second(Dec6Err::Fourth(error)) =>
+                Self { field: "asset ID", inner: PeginDataDecoderErrorInner::Eof(error) },
+            Dec3Err::Second(Dec6Err::Fifth(error)) =>
+                Self { field: "genesis hash", inner: PeginDataDecoderErrorInner::Length(error) },
+            Dec3Err::Second(Dec6Err::Sixth(error)) => Self {
+                field: "genesis hash",
+                inner: PeginDataDecoderErrorInner::GenesisHash(error),
+            },
+            Dec3Err::Third(Dec3Err::First(error)) => Self {
+                field: "claim script",
+                inner: PeginDataDecoderErrorInner::ClaimScript(error),
+            },
+            Dec3Err::Third(Dec3Err::Second(error)) =>
+                Self { field: "transaction", inner: PeginDataDecoderErrorInner::ByteVec(error) },
+            Dec3Err::Third(Dec3Err::Third(error)) =>
+                Self { field: "merkle proof", inner: PeginDataDecoderErrorInner::ByteVec(error) },
+        }
+    }
+}
+
+impl encoding::Decoder for PeginDataDecoder {
+    type Output = PeginData;
+    type Error = PeginWitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<encoding::DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(PeginWitnessDecoderError::from)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        use internals::slice::SliceExt;
+
+        let (
+            _,
+            (_, value, _, asset_id, _, genesis_hash),
+            (claim_script, transaction, merkle_proof),
+        ) = self.inner.end().map_err(PeginWitnessDecoderError::from)?;
+
+        let Some((block_header, _)) = SliceExt::split_first_chunk::<80>(merkle_proof.as_slice())
+        else {
+            return Err(PeginWitnessDecoderError {
+                field: "merkle proof",
+                inner: PeginDataDecoderErrorInner::InsufficientLength {
+                    minimum: 80,
+                    got: merkle_proof.len(),
+                },
+            });
+        };
+        let referenced_block = bitcoin::BlockHash::hash(block_header);
+
+        Ok(PeginData {
+            value: u64::from_le_bytes(value),
+            asset_id: AssetId::from_byte_array(asset_id),
+            genesis_hash,
+            claim_script,
+            transaction,
+            merkle_proof,
+            referenced_block,
+        })
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+impl encoding::Decode for PeginData {
+    type Decoder = PeginDataDecoder;
+}
+
+impl encode::Encodable for PeginData {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+        let mut counter = encode::ByteCounter::new(e);
+        crate::encoding::encode_to_writer(self, &mut counter)?;
+        Ok(counter.into_count())
+    }
+}
+
+impl encode::Decodable for PeginWitness {
+    fn consensus_decode<D: io::Read>(d: D) -> Result<Self, encode::Error> {
+        match encoding::decode_from_read_unbuffered(d) {
+            Ok(res) => Ok(res),
+            Err(encoding::ReadError::Io(e)) => Err(encode::Error::Io(e)),
+            Err(encoding::ReadError::Decode(e)) => Err(encode::Error::PeginWitness(e)),
+        }
+    }
+}
+
+impl encode::Encodable for PeginWitness {
+    fn consensus_encode<W: io::Write>(&self, e: W) -> Result<usize, encode::Error> {
+        match self.inner {
+            Some(ref wit) => wit.consensus_encode(e),
+            None => 0u8.consensus_encode(e),
+        }
+    }
+}
diff --git a/src/transaction/witness.rs b/src/transaction/witness.rs
new file mode 100644
index 00000000..e079d476
--- /dev/null
+++ b/src/transaction/witness.rs
@@ -0,0 +1,1721 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! A witness.
+//!
+//! This module contains the [`Witness`] struct and related methods to operate on it
+
+use core::fmt;
+use core::convert::{TryFrom as _, TryInto as _};
+use core::iter::FromIterator;
+use core::ops::Index;
+use std::{rc, sync};
+
+#[cfg(doc)]
+use crate::encoding::Decoder4;
+use crate::encoding::{
+    self, BytesEncoder, CompactSizeDecoder, CompactSizeEncoder, Decoder as _, DecoderStatus,
+    Encoder2,
+};
+use internals::slice::SliceExt;
+
+#[cfg(doc)]
+use crate::TxIn;
+
+#[rustfmt::skip]                // Keep public re-exports separate.
+#[doc(no_inline)]
+pub use self::error::{UnexpectedEofError, WitnessDecoderError};
+
+use self::error::WitnessDecoderErrorInner;
+
+/// Maximum number of items in a witness stack.
+///
+/// This is an anti-DoS limit based on Bitcoin's 4MB block weight limit.
+/// Witness data is part of transactions, which are part of blocks, so witness
+/// items (assuming 1-byte per item) cannot exceed what fits in a block.
+const MAX_WITNESS_STACK_ITEMS: usize = 4_000_000;
+
+/// Maximum byte size of a single witness stack item.
+///
+/// This is an anti-DoS limit based on Bitcoin's 4MB block weight limit.
+/// Witness data is part of transactions, which are part of blocks, so a
+/// single witness item cannot exceed what fits in a block.
+const MAX_WITNESS_ITEM_SIZE: usize = 4_000_000;
+
+/// The Witness is the data used to unlock bitcoin since the [SegWit upgrade].
+///
+/// Can be logically seen as an array of bytestrings, i.e. `Vec<Vec<u8>>`, and it is serialized on the wire
+/// in that format. You can convert between this type and `Vec<Vec<u8>>` by using [`Witness::from_slice`]
+/// and [`Witness::to_vec`].
+///
+/// For serialization and deserialization performance it is stored internally as a single `Vec`,
+/// saving some allocations.
+///
+/// [SegWit upgrade]: <https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki>
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Witness {
+    /// Contains the witness `Vec<Vec<u8>>` serialization.
+    ///
+    /// Does not include the initial length prefix indicating the number of elements. Each element
+    /// however, does include a [`CompactSize`] indicating the element length. The number of
+    /// elements is stored in `witness_elements`.
+    ///
+    /// Concatenated onto the end of `content` is the index area. This is a `4 * witness_elements`
+    /// bytes area which stores the index of the start of each witness item.
+    ///
+    /// [`CompactSize`]: <https://en.bitcoin.it/wiki/Protocol_documentation#Variable_length_integer>
+    content: Vec<u8>,
+
+    /// The number of elements in the witness.
+    ///
+    /// Stored separately (instead of as a compact size encoding in the initial part of content) so
+    /// that methods like [`Witness::push`] don't have to shift the entire array.
+    witness_elements: usize,
+
+    /// This is the valid index pointing to the beginning of the index area.
+    ///
+    /// Said another way, this is the total length of all witness elements serialized (without the
+    /// element count but with their sizes serialized as compact size).
+    indices_start: usize,
+}
+
+impl Witness {
+    /// Constructs a new empty [`Witness`].
+    #[inline]
+    pub const fn new() -> Self {
+        Self { content: Vec::new(), witness_elements: 0, indices_start: 0 }
+    }
+
+    /// Constructs a new [`Witness`] object from a slice of bytes slices where each slice is a witness item.
+    pub fn from_slice<T: AsRef<[u8]>>(slice: &[T]) -> Self {
+        let witness_elements = slice.len();
+        let index_size = witness_elements * 4;
+        let content_size = slice
+            .iter()
+            .map(|elem| elem.as_ref().len() + CompactSizeEncoder::encoded_size(elem.as_ref().len()))
+            .sum();
+
+        let mut content = vec![0u8; content_size + index_size];
+        let mut cursor = 0usize;
+        for (i, elem) in slice.iter().enumerate() {
+            encode_cursor(&mut content, content_size, i, cursor);
+            let encoded = crate::compact_size_encode(elem.as_ref().len());
+            let encoded_size = encoded.as_slice().len();
+            content[cursor..cursor + encoded_size].copy_from_slice(encoded.as_slice());
+            cursor += encoded_size;
+            content[cursor..cursor + elem.as_ref().len()].copy_from_slice(elem.as_ref());
+            cursor += elem.as_ref().len();
+        }
+
+        Self { witness_elements, content, indices_start: content_size }
+    }
+
+    /// Convenience method to create an array of byte-arrays from this witness.
+    #[inline]
+    pub fn to_vec(&self) -> Vec<Vec<u8>> { self.iter().map(<[u8]>::to_vec).collect() }
+
+    /// Returns `true` if the witness contains no element.
+    #[inline]
+    pub fn is_empty(&self) -> bool { self.witness_elements == 0 }
+
+    /// Returns a struct implementing [`Iterator`].
+    #[must_use = "iterators are lazy and do nothing unless consumed"]
+    #[inline]
+    pub fn iter(&self) -> Iter<'_> {
+        Iter { inner: self.content.as_slice(), indices_start: self.indices_start, current_index: 0 }
+    }
+
+    /// Returns the number of elements this witness holds.
+    #[inline]
+    pub const fn len(&self) -> usize { self.witness_elements }
+
+    /// Returns the number of bytes this witness contributes to a transaction's total size.
+    ///
+    /// # Panics
+    ///
+    /// If the size calculation overflows.
+    pub fn size(&self) -> usize {
+        let mut size: usize = 0;
+
+        size += CompactSizeEncoder::encoded_size(self.witness_elements);
+        size += self
+            .iter()
+            .map(|witness_element| {
+                let len = witness_element.len();
+                CompactSizeEncoder::encoded_size(len) + len
+            })
+            .sum::<usize>();
+
+        size
+    }
+
+    /// Clears the witness.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.content.clear();
+        self.witness_elements = 0;
+        self.indices_start = 0;
+    }
+
+    /// Pushes a new element on the witness, requires an allocation.
+    #[inline]
+    pub fn push<T: AsRef<[u8]>>(&mut self, new_element: T) {
+        self.push_slice(new_element.as_ref());
+    }
+
+    /// Pushes a new element slice onto the witness stack.
+    fn push_slice(&mut self, new_element: &[u8]) {
+        self.witness_elements += 1;
+        let previous_content_end = self.indices_start;
+        let encoded = crate::compact_size_encode(new_element.len());
+        let encoded_size = encoded.as_slice().len();
+        let current_content_len = self.content.len();
+        let new_item_total_len = encoded_size + new_element.len();
+        self.content.resize(current_content_len + new_item_total_len + 4, 0);
+
+        self.content[previous_content_end..].rotate_right(new_item_total_len);
+        self.indices_start += new_item_total_len;
+        encode_cursor(
+            &mut self.content,
+            self.indices_start,
+            self.witness_elements - 1,
+            previous_content_end,
+        );
+
+        let end_compact_size = previous_content_end + encoded_size;
+        self.content[previous_content_end..end_compact_size].copy_from_slice(encoded.as_slice());
+        self.content[end_compact_size..end_compact_size + new_element.len()]
+            .copy_from_slice(new_element);
+    }
+
+    /// Returns the last element in the witness, if any.
+    #[inline]
+    pub fn last(&self) -> Option<&[u8]> { self.get_back(0) }
+
+    /// Retrieves an element from the end of the witness by its reverse index.
+    ///
+    /// `index` is 0-based from the end, where 0 is the last element, 1 is the second-to-last, etc.
+    ///
+    /// Returns `None` if the requested index is beyond the witness's elements.
+    ///
+    /// # Examples
+    /// ```
+    /// use elements::Witness;
+    ///
+    /// let mut witness = Witness::new();
+    /// witness.push(b"A");
+    /// witness.push(b"B");
+    /// witness.push(b"C");
+    /// witness.push(b"D");
+    ///
+    /// assert_eq!(witness.get_back(0), Some(b"D".as_slice()));
+    /// assert_eq!(witness.get_back(1), Some(b"C".as_slice()));
+    /// assert_eq!(witness.get_back(2), Some(b"B".as_slice()));
+    /// assert_eq!(witness.get_back(3), Some(b"A".as_slice()));
+    /// assert_eq!(witness.get_back(4), None);
+    /// ```
+    pub fn get_back(&self, index: usize) -> Option<&[u8]> {
+        if self.witness_elements <= index {
+            None
+        } else {
+            self.get(self.witness_elements - 1 - index)
+        }
+    }
+
+    /// Returns a specific element from the witness by its index, if any.
+    #[inline]
+    pub fn get(&self, index: usize) -> Option<&[u8]> {
+        let pos = decode_cursor(&self.content, self.indices_start, index)?;
+
+        let mut slice = &self.content[pos..]; // Start of element.
+        let element_len = decode_unchecked(&mut slice);
+        let end = cast_to_usize_if_valid(element_len)?;
+        Some(&slice[..end])
+    }
+
+    /// Constructs a new witness from a list of hex strings.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if any of the hex strings are invalid.
+    pub fn from_hex<I, T>(iter: I) -> Result<Self, hex::DecodeVariableLengthBytesError>
+    where
+        I: IntoIterator<Item = T>,
+        T: AsRef<str>,
+    {
+        let result = iter
+            .into_iter()
+            .map(|hex_str| crate::hex::decode_to_vec(hex_str.as_ref()))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(Self::from_slice(&result))
+    }
+}
+
+/// Correctness Requirements: value must always fit within u32
+// This is duplicated in `bitcoin::blockdata::witness`, if you change it please do so over there also.
+#[inline]
+fn encode_cursor(bytes: &mut [u8], start_of_indices: usize, index: usize, value: usize) {
+    let start = start_of_indices + index * 4;
+    let end = start + 4;
+    bytes[start..end]
+        .copy_from_slice(&u32::to_ne_bytes(value.try_into().expect("larger than u32")));
+}
+
+#[inline]
+fn decode_cursor(bytes: &[u8], start_of_indices: usize, index: usize) -> Option<usize> {
+    let start = start_of_indices + index * 4;
+    let pos = bytes.get_array::<4>(start).map(|index_bytes| u32::from_ne_bytes(*index_bytes))?;
+    usize::try_from(pos).ok()
+}
+
+impl encoding::Encode for Witness {
+    type Encoder<'e>
+        = WitnessEncoder<'e>
+    where
+        Self: 'e;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        let num_elements = CompactSizeEncoder::new(self.len());
+        let witness_elements =
+            BytesEncoder::without_length_prefix(&self.content[..self.indices_start]);
+
+        WitnessEncoder::new(Encoder2::new(num_elements, witness_elements))
+    }
+}
+
+impl encoding::Decode for Witness {
+    type Decoder = WitnessDecoder;
+}
+
+encoding::encoder_newtype_exact! {
+    /// The encoder for the [`Witness`] type.
+    #[derive(Debug, Clone)]
+    pub struct WitnessEncoder<'e>(Encoder2<CompactSizeEncoder, BytesEncoder<'e>>);
+}
+
+/// The decoder for the [`Witness`] type.
+#[derive(Debug, Clone)]
+pub struct WitnessDecoder {
+    /// The single buffer that will become the Witness content.
+    /// The index entries are written in [`Self::end`].
+    content: Vec<u8>,
+    /// Decoder for the initial witness element count.
+    witness_count_decoder: CompactSizeDecoder,
+    /// Total number of witness elements to decode (None until initial count is read).
+    witness_elements: Option<usize>,
+    /// Index of the current element being decoded.
+    element_idx: usize,
+    /// Decoder for the current element's length.
+    element_length_decoder: CompactSizeDecoder,
+    /// Bytes remaining to read for the current element's data.
+    /// - `None` means we're currently reading the length.
+    /// - `Some(n)` means we're reading element data with `n` bytes remaining.
+    element_bytes_remaining: Option<usize>,
+}
+
+impl WitnessDecoder {
+    /// Constructs a new witness decoder.
+    pub const fn new() -> Self {
+        Self {
+            content: Vec::new(),
+            witness_elements: None,
+            witness_count_decoder: CompactSizeDecoder::new_with_limit(MAX_WITNESS_STACK_ITEMS),
+            element_idx: 0,
+            element_length_decoder: CompactSizeDecoder::new_with_limit(MAX_WITNESS_ITEM_SIZE),
+            element_bytes_remaining: None,
+        }
+    }
+}
+
+impl Default for WitnessDecoder {
+    fn default() -> Self { Self::new() }
+}
+
+impl encoding::Decoder for WitnessDecoder {
+    type Output = Witness;
+    type Error = WitnessDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        use WitnessDecoderError as E;
+        use WitnessDecoderErrorInner as Inner;
+
+        // Read initial witness element count.
+        if self.witness_elements.is_none() {
+            if self
+                .witness_count_decoder
+                .push_bytes(bytes)
+                .map_err(|e| E(Inner::LengthPrefixDecode(e)))?
+                .needs_more()
+            {
+                return Ok(DecoderStatus::NeedsMore);
+            }
+            // Take ownership of the decoder in order to consume it.
+            let decoder = core::mem::take(&mut self.witness_count_decoder);
+            let witness_elements = decoder.end().map_err(|e| E(Inner::LengthPrefixDecode(e)))?;
+            self.witness_elements = Some(witness_elements);
+
+            // Short circuit for zero witness elements.
+            if witness_elements == 0 {
+                return Ok(DecoderStatus::Ready);
+            }
+
+            // Allocate space for the buffer. The buffer
+            // is initialized to 128 bytes which should be large enough
+            // to cover most witnesses, the typical pubkey + signature
+            // and some overhead (e.g. P2WPKH witness is ~100 bytes),
+            // without reallocating.
+            self.content.reserve(128);
+        }
+
+        let Some(witness_elements) = self.witness_elements else {
+            unreachable!("witness_elements must be Some after initial read")
+        };
+
+        // Read witness elements.
+        loop {
+            // Check if we're done processing all elements.
+            if self.element_idx >= witness_elements {
+                return Ok(DecoderStatus::Ready);
+            }
+
+            if bytes.is_empty() {
+                return Ok(DecoderStatus::NeedsMore);
+            }
+
+            // If we have some bytes to read, then reading element data.
+            // Else we are reading the element's length.
+            if let Some(bytes_to_read) = self.element_bytes_remaining {
+                let can_copy = bytes.len().min(bytes_to_read);
+                // To avoid reallocating the index space in `end()` we reserve it here, the moment
+                // the final element's data is copied.
+                if can_copy == bytes_to_read && self.element_idx + 1 == witness_elements {
+                    self.content.reserve_exact(can_copy + witness_elements * 4);
+                }
+                self.content.extend_from_slice(&bytes[..can_copy]);
+                *bytes = &bytes[can_copy..];
+                let remaining = bytes_to_read - can_copy;
+
+                if remaining == 0 {
+                    // Element complete, move to next element.
+                    self.element_idx += 1;
+                    self.element_bytes_remaining = None;
+                } else {
+                    self.element_bytes_remaining = Some(remaining);
+                }
+            } else {
+                if self
+                    .element_length_decoder
+                    .push_bytes(bytes)
+                    .map_err(|e| E(Inner::LengthPrefixDecode(e)))?
+                    .needs_more()
+                {
+                    return Ok(DecoderStatus::NeedsMore);
+                }
+
+                // Take ownership of the decoder so we can consume it.
+                let decoder = core::mem::take(&mut self.element_length_decoder);
+                let element_length = decoder.end().map_err(|e| E(Inner::LengthPrefixDecode(e)))?;
+
+                // keep the element length prefix in the content area.
+                let encoded_compact_size = crate::compact_size_encode(element_length);
+                self.content.extend_from_slice(encoded_compact_size.as_slice());
+
+                if element_length == 0 {
+                    // Complete immediately for zero-length element to
+                    // avoid incorrectly signaling "need more data".
+                    self.element_idx += 1;
+                    self.element_bytes_remaining = None;
+                } else {
+                    self.element_bytes_remaining = Some(element_length);
+                }
+            }
+        }
+    }
+
+    fn end(mut self) -> Result<Self::Output, Self::Error> {
+        use WitnessDecoderError as E;
+        use WitnessDecoderErrorInner as Inner;
+
+        let Some(witness_elements) = self.witness_elements else {
+            // Never read the witness element count.
+            return Err(E(Inner::UnexpectedEof(UnexpectedEofError { missing_elements: 0 })));
+        };
+
+        let remaining = witness_elements - self.element_idx;
+
+        if remaining == 0 {
+            // `content` now holds the complete content area (all element bytes have been already received)
+            // The index area begins at its current end.
+            let indices_start = self.content.len();
+
+            // Build the index area by walking the content area
+            // This is the only allocation sized by the element count, and it happens only here
+            self.content.reserve(witness_elements * 4);
+            let mut read_pos = 0;
+            for _ in 0..witness_elements {
+                let offset = u32::try_from(read_pos).expect("larger than u32");
+                let (element_length, prefix_size) = {
+                    let mut slice = &self.content[read_pos..indices_start];
+                    let before = slice.len();
+                    let element_length = decode_unchecked(&mut slice);
+                    (element_length, before - slice.len())
+                };
+                let data_len = usize::try_from(element_length).expect("element data is present");
+                read_pos += prefix_size + data_len;
+                self.content.extend_from_slice(&offset.to_ne_bytes());
+            }
+
+            Ok(Witness { content: self.content, witness_elements, indices_start })
+        } else {
+            Err(E(Inner::UnexpectedEof(UnexpectedEofError { missing_elements: remaining })))
+        }
+    }
+
+    fn read_limit(&self) -> usize {
+        if self.witness_elements.is_none() {
+            // Reading witness count (haven't started processing elements yet).
+            self.witness_count_decoder.read_limit()
+        } else {
+            // Reading an element.
+            match self.element_bytes_remaining {
+                None => self.element_length_decoder.read_limit(),
+                Some(remaining) => remaining,
+            }
+        }
+    }
+}
+
+// Note: we use `Borrow` in the following `PartialEq` impls specifically because of its additional
+// constraints on equality semantics.
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<[T]> for Witness {
+    fn eq(&self, rhs: &[T]) -> bool {
+        if self.len() != rhs.len() {
+            return false;
+        }
+        self.iter().zip(rhs).all(|(left, right)| left == right.borrow())
+    }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<&[T]> for Witness {
+    fn eq(&self, rhs: &&[T]) -> bool { *self == **rhs }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for [T] {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for &[T] {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == **self }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<[T; N]> for Witness {
+    fn eq(&self, rhs: &[T; N]) -> bool { *self == *rhs.as_slice() }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<&[T; N]> for Witness {
+    fn eq(&self, rhs: &&[T; N]) -> bool { *self == *rhs.as_slice() }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for [T; N] {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+impl<const N: usize, T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for &[T; N] {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == **self }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Vec<T>> for Witness {
+    fn eq(&self, rhs: &Vec<T>) -> bool { *self == **rhs }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for Vec<T> {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Box<[T]>> for Witness {
+    fn eq(&self, rhs: &Box<[T]>) -> bool { *self == **rhs }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for Box<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<rc::Rc<[T]>> for Witness {
+    fn eq(&self, rhs: &rc::Rc<[T]>) -> bool { *self == **rhs }
+}
+
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for rc::Rc<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+#[cfg(target_has_atomic = "ptr")]
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<sync::Arc<[T]>> for Witness {
+    fn eq(&self, rhs: &sync::Arc<[T]>) -> bool { *self == **rhs }
+}
+
+#[cfg(target_has_atomic = "ptr")]
+impl<T: core::borrow::Borrow<[u8]>> PartialEq<Witness> for sync::Arc<[T]> {
+    fn eq(&self, rhs: &Witness) -> bool { *rhs == *self }
+}
+
+/// Debug implementation that displays the witness as a structured output containing:
+/// - Number of witness elements
+/// - Total bytes across all elements
+/// - List of hex-encoded witness elements if `hex` feature is enabled.
+#[allow(clippy::missing_fields_in_debug)] // We don't want to show `indices_start`.
+impl fmt::Debug for Witness {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let total_bytes: usize = self.iter().map(<[u8]>::len).sum();
+
+        f.debug_struct("Witness")
+            .field("num_elements", &self.witness_elements)
+            .field("total_bytes", &total_bytes)
+            .field(
+                "elements",
+                &WrapDebug(|f| {
+                    f.debug_list().entries(self.iter().map(hex::DisplayHex::as_hex)).finish()
+                }),
+            )
+            .finish()
+    }
+}
+
+/// An iterator returning individual witness elements.
+#[derive(Clone)]
+pub struct Iter<'a> {
+    inner: &'a [u8],
+    indices_start: usize,
+    current_index: usize,
+}
+
+impl Index<usize> for Witness {
+    type Output = [u8];
+
+    #[track_caller]
+    #[inline]
+    fn index(&self, index: usize) -> &Self::Output { self.get(index).expect("out of bounds") }
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a [u8];
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let index = decode_cursor(self.inner, self.indices_start, self.current_index)?;
+        let mut slice = &self.inner[index..]; // Start of element.
+        let element_len = decode_unchecked(&mut slice);
+        let end = cast_to_usize_if_valid(element_len)?;
+        self.current_index += 1;
+        Some(&slice[..end])
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let total_count = (self.inner.len() - self.indices_start) / 4;
+        let remaining = total_count - self.current_index;
+        (remaining, Some(remaining))
+    }
+}
+
+impl ExactSizeIterator for Iter<'_> {}
+
+impl<'a> IntoIterator for &'a Witness {
+    type IntoIter = Iter<'a>;
+    type Item = &'a [u8];
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter { self.iter() }
+}
+
+impl<T: AsRef<[u8]>> FromIterator<T> for Witness {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut decoder = WitnessDecoder::new();
+
+        // We can't count the number of witness elements without consuming the iterator.
+        // So instead, we build up the full push_bytes buffer and then push it all at once.
+        // We'll start with a 256 byte buffer to double the initial WitnessDecoder size.
+        let mut buffer = Vec::with_capacity(256);
+        let mut witness_elements = 0;
+
+        // For each witness element, the decoder expects an element length, followed by
+        // the data itself. The iterator's yielded elements do not include the length prefix,
+        // so we add them.
+        for elem in iter {
+            let encoded = crate::compact_size_encode(elem.as_ref().len());
+            buffer.extend_from_slice(encoded.as_slice());
+            buffer.extend_from_slice(elem.as_ref());
+            witness_elements += 1;
+        }
+
+        let witness_count = crate::compact_size_encode(witness_elements);
+        let _ = decoder.push_bytes(&mut witness_count.as_slice());
+
+        let _ = decoder.push_bytes(&mut buffer.as_slice());
+
+        decoder.end().expect("witness_elements in decoder is equal to number of provided elements")
+    }
+}
+
+// Serde keep backward compatibility with old Vec<Vec<u8>> format
+#[cfg(feature = "serde")]
+impl serde::Serialize for Witness {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeSeq;
+
+        let human_readable = serializer.is_human_readable();
+        let mut seq = serializer.serialize_seq(Some(self.witness_elements))?;
+
+        // Note that the `Iter` strips the varints out when iterating.
+        for elem in self {
+            if human_readable {
+                seq.serialize_element(&SerializeBytesAsHex(elem))?;
+            } else {
+                seq.serialize_element(&elem)?;
+            }
+        }
+        seq.end()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for Witness {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor; // Human-readable visitor.
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = Witness;
+
+            fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+                write!(f, "a sequence of hex arrays")
+            }
+
+            fn visit_seq<A: serde::de::SeqAccess<'de>>(
+                self,
+                mut a: A,
+            ) -> Result<Self::Value, A::Error> {
+                let mut ret = match a.size_hint() {
+                    Some(len) => Vec::with_capacity(len),
+                    None => Vec::new(),
+                };
+
+                while let Some(elem) = a.next_element::<String>()? {
+                    let vec = hex::decode_to_vec(&elem).map_err(serde::de::Error::custom)?;
+                    ret.push(vec);
+                }
+                Ok(Witness::from_slice(&ret))
+            }
+        }
+
+        if deserializer.is_human_readable() {
+            deserializer.deserialize_seq(Visitor)
+        } else {
+            let vec: Vec<Vec<u8>> = serde::Deserialize::deserialize(deserializer)?;
+            Ok(Self::from_slice(&vec))
+        }
+    }
+}
+
+impl From<Vec<Vec<u8>>> for Witness {
+    #[inline]
+    fn from(vec: Vec<Vec<u8>>) -> Self { Self::from_slice(&vec) }
+}
+
+impl From<&[&[u8]]> for Witness {
+    #[inline]
+    fn from(slice: &[&[u8]]) -> Self { Self::from_slice(slice) }
+}
+
+impl From<&[Vec<u8>]> for Witness {
+    #[inline]
+    fn from(slice: &[Vec<u8>]) -> Self { Self::from_slice(slice) }
+}
+
+impl From<Vec<&[u8]>> for Witness {
+    #[inline]
+    fn from(vec: Vec<&[u8]>) -> Self { Self::from_slice(&vec) }
+}
+
+impl<const N: usize> From<[&[u8]; N]> for Witness {
+    #[inline]
+    fn from(arr: [&[u8]; N]) -> Self { Self::from_slice(&arr) }
+}
+
+impl<const N: usize> From<&[&[u8]; N]> for Witness {
+    #[inline]
+    fn from(arr: &[&[u8]; N]) -> Self { Self::from_slice(arr) }
+}
+
+impl<const N: usize> From<&[[u8; N]]> for Witness {
+    #[inline]
+    fn from(slice: &[[u8; N]]) -> Self { Self::from_slice(slice) }
+}
+
+impl<const N: usize> From<&[&[u8; N]]> for Witness {
+    #[inline]
+    fn from(slice: &[&[u8; N]]) -> Self { Self::from_slice(slice) }
+}
+
+impl<const N: usize, const M: usize> From<[[u8; M]; N]> for Witness {
+    #[inline]
+    fn from(slice: [[u8; M]; N]) -> Self { Self::from_slice(&slice) }
+}
+
+impl<const N: usize, const M: usize> From<&[[u8; M]; N]> for Witness {
+    #[inline]
+    fn from(slice: &[[u8; M]; N]) -> Self { Self::from_slice(slice) }
+}
+
+impl<const N: usize, const M: usize> From<[&[u8; M]; N]> for Witness {
+    #[inline]
+    fn from(slice: [&[u8; M]; N]) -> Self { Self::from_slice(&slice) }
+}
+
+impl<const N: usize, const M: usize> From<&[&[u8; M]; N]> for Witness {
+    #[inline]
+    fn from(slice: &[&[u8; M]; N]) -> Self { Self::from_slice(slice) }
+}
+
+impl Default for Witness {
+    #[inline]
+    fn default() -> Self { Self::new() }
+}
+
+/// Cast a decoded length prefix to a `usize`.
+///
+/// This function is basically just defensive. For all sane use cases the length prefix should be
+/// less than `MAX_VEC_SIZE` (on a 32-bit machine). If the value is bigger that `u16::MAX` and we
+/// are on a 16-bit machine you'll likely hit an error later anyway, better to just check it now.
+///
+/// # 16-bits
+///
+/// The compact size may be bigger than what can be represented in a `usize` on a 16-bit machine but
+/// this shouldn't happen if we created the witness because one would get an OOM error before that.
+fn cast_to_usize_if_valid(n: u64) -> Option<usize> {
+    /// Maximum size, in bytes, of a vector we are allowed to decode.
+    const MAX_VEC_SIZE: u64 = 4_000_000;
+
+    if n > MAX_VEC_SIZE {
+        return None;
+    }
+
+    usize::try_from(n).ok()
+}
+
+/// Gets the compact size encoded value from `slice` and moves slice past the encoding.
+///
+/// Caller to guarantee that the encoding is well formed. Well formed is defined as:
+///
+/// * Being at least long enough.
+/// * Containing a minimal encoding.
+///
+/// # Panics
+///
+/// * Panics in release mode if the `slice` does not contain a valid minimal compact size encoding.
+/// * Panics in debug mode if the encoding is not minimal (referred to as "non-canonical" in Core).
+fn decode_unchecked(slice: &mut &[u8]) -> u64 {
+    assert!(!slice.is_empty(), "tried to decode an empty slice");
+
+    match slice[0] {
+        0xFF => {
+            const SIZE: usize = 9;
+            assert!(slice.len() >= SIZE, "slice too short, expected at least 9 bytes");
+
+            let mut bytes = [0_u8; SIZE - 1];
+            bytes.copy_from_slice(&slice[1..SIZE]);
+
+            let v = u64::from_le_bytes(bytes);
+            debug_assert!(v > u32::MAX.into(), "non-minimal encoding of a u64");
+            *slice = &slice[SIZE..];
+            v
+        }
+        0xFE => {
+            const SIZE: usize = 5;
+            assert!(slice.len() >= SIZE, "slice too short, expected at least 5 bytes");
+
+            let mut bytes = [0_u8; SIZE - 1];
+            bytes.copy_from_slice(&slice[1..SIZE]);
+
+            let v = u32::from_le_bytes(bytes);
+            debug_assert!(v > u16::MAX.into(), "non-minimal encoding of a u32");
+            *slice = &slice[SIZE..];
+            u64::from(v)
+        }
+        0xFD => {
+            const SIZE: usize = 3;
+            assert!(slice.len() >= SIZE, "slice too short, expected at least 3 bytes");
+
+            let mut bytes = [0_u8; SIZE - 1];
+            bytes.copy_from_slice(&slice[1..SIZE]);
+
+            let v = u16::from_le_bytes(bytes);
+            debug_assert!(v >= 0xFD, "non-minimal encoding of a u16");
+            *slice = &slice[SIZE..];
+            u64::from(v)
+        }
+        n => {
+            *slice = &slice[1..];
+            u64::from(n)
+        }
+    }
+}
+
+/// A wrapper for a function that implements `Debug`.
+struct WrapDebug<F: Fn(&mut fmt::Formatter) -> fmt::Result>(pub F);
+
+impl<F: Fn(&mut fmt::Formatter) -> fmt::Result> fmt::Debug for WrapDebug<F> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { (self.0)(f) }
+}
+
+/// Serializes a byte slice using the `hex` crate.
+#[cfg(feature = "serde")]
+struct SerializeBytesAsHex<'a>(pub &'a [u8]);
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for SerializeBytesAsHex<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use hex::DisplayHex;
+
+        serializer.collect_str(&format_args!("{:x}", self.0.as_hex()))
+    }
+}
+
+/// Error types for witness data.
+pub mod error {
+    use core::convert::Infallible;
+    use core::fmt;
+
+    use crate::encoding::CompactSizeDecoderError;
+
+    /// An error when consensus decoding a [`Witness`].
+    ///
+    /// [`Witness`]: super::Witness
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct WitnessDecoderError(pub(super) WitnessDecoderErrorInner);
+
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub(super) enum WitnessDecoderErrorInner {
+        /// Error decoding the vector length prefix.
+        LengthPrefixDecode(CompactSizeDecoderError),
+        /// Not enough bytes given to decoder.
+        UnexpectedEof(UnexpectedEofError),
+    }
+
+    impl From<Infallible> for WitnessDecoderError {
+        fn from(never: Infallible) -> Self { match never {} }
+    }
+
+    impl fmt::Display for WitnessDecoderError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            use WitnessDecoderErrorInner as E;
+
+            match self.0 {
+                E::LengthPrefixDecode(..) => f.write_str("vec decoder error"),
+                E::UnexpectedEof(..) => f.write_str("decoder error"),
+            }
+        }
+    }
+
+    impl std::error::Error for WitnessDecoderError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            use WitnessDecoderErrorInner as E;
+
+            match self.0 {
+                E::LengthPrefixDecode(ref e) => Some(e),
+                E::UnexpectedEof(ref e) => Some(e),
+            }
+        }
+    }
+
+    /// Not enough witness elements (bytes) given to decoder.
+    #[derive(Debug, Clone, PartialEq, Eq)]
+    pub struct UnexpectedEofError {
+        /// Number of elements missing to complete decoder.
+        pub(super) missing_elements: usize,
+    }
+
+    impl From<Infallible> for UnexpectedEofError {
+        fn from(never: Infallible) -> Self { match never {} }
+    }
+
+    impl fmt::Display for UnexpectedEofError {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            write!(f, "not enough witness elements for decoder, missing {}", self.missing_elements)
+        }
+    }
+
+    impl std::error::Error for UnexpectedEofError {
+        fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+            let Self { missing_elements: _ } = self;
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::error::Error as _;
+
+    use encoding::check_encode;
+    use encoding::Decode as _;
+
+    use super::*;
+
+    // A witness with a single element that is empty (zero length).
+    fn single_empty_element() -> Witness { Witness::from([[0u8; 0]]) }
+
+    #[test]
+    fn witness_single_empty_element() {
+        let mut got = Witness::new();
+        got.push([]);
+        let want = single_empty_element();
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn push() {
+        // Sanity check default.
+        let mut witness = Witness::default();
+        assert!(witness.is_empty());
+        assert_eq!(witness.last(), None);
+        assert_eq!(witness.get_back(1), None);
+
+        assert_eq!(witness.get(0), None);
+        assert_eq!(witness.get(1), None);
+        assert_eq!(witness.get(2), None);
+        assert_eq!(witness.get(3), None);
+
+        // Push a single byte element onto the witness stack.
+        let push = [11_u8];
+        witness.push(push);
+        assert!(!witness.is_empty());
+
+        assert_eq!(witness, [[11_u8]]);
+
+        let element_0 = push.as_slice();
+        assert_eq!(element_0, &witness[0]);
+
+        assert_eq!(witness.get_back(1), None);
+        assert_eq!(witness.last(), Some(element_0));
+
+        assert_eq!(witness.get(0), Some(element_0));
+        assert_eq!(witness.get(1), None);
+        assert_eq!(witness.get(2), None);
+        assert_eq!(witness.get(3), None);
+
+        // Now push 2 byte element onto the witness stack.
+        let push = [21u8, 22u8];
+        witness.push(push);
+
+        assert_eq!(witness, [&[11_u8] as &[_], &[21, 22]]);
+
+        let element_1 = push.as_slice();
+        assert_eq!(element_1, &witness[1]);
+
+        assert_eq!(witness.get(0), Some(element_0));
+        assert_eq!(witness.get(1), Some(element_1));
+        assert_eq!(witness.get(2), None);
+        assert_eq!(witness.get(3), None);
+
+        assert_eq!(witness.get_back(1), Some(element_0));
+        assert_eq!(witness.last(), Some(element_1));
+
+        // Now push another 2 byte element onto the witness stack.
+        let push = [31u8, 32u8];
+        witness.push(push);
+
+        assert_eq!(witness, [&[11_u8] as &[_], &[21, 22], &[31, 32]]);
+
+        let element_2 = push.as_slice();
+        assert_eq!(element_2, &witness[2]);
+
+        assert_eq!(witness.get(0), Some(element_0));
+        assert_eq!(witness.get(1), Some(element_1));
+        assert_eq!(witness.get(2), Some(element_2));
+        assert_eq!(witness.get(3), None);
+
+        assert_eq!(witness.get_back(2), Some(element_0));
+        assert_eq!(witness.get_back(1), Some(element_1));
+        assert_eq!(witness.last(), Some(element_2));
+    }
+
+    #[test]
+    fn exact_sized_iterator() {
+        let arbitrary_element = [1_u8, 2, 3];
+        let num_pushes = 5; // Somewhat arbitrary.
+
+        let mut witness = Witness::default();
+
+        for i in 0..num_pushes {
+            assert_eq!(witness.iter().len(), i);
+            witness.push(arbitrary_element);
+        }
+
+        let mut iter = witness.iter();
+        for i in (0..=num_pushes).rev() {
+            assert_eq!(iter.len(), i);
+            iter.next();
+        }
+    }
+
+    #[test]
+    fn witness_from_impl() {
+        // Test From implementations with the same 2 elements
+        let vec = vec![vec![11], vec![21, 22]];
+        let slice_vec: &[Vec<u8>] = &vec;
+        let slice_slice: &[&[u8]] = &[&[11u8], &[21, 22]];
+        let vec_slice: Vec<&[u8]> = vec![&[11u8], &[21, 22]];
+
+        let witness_vec_vec = Witness::from(vec.clone());
+        let witness_slice_vec = Witness::from(slice_vec);
+        let witness_slice_slice = Witness::from(slice_slice);
+        let witness_vec_slice = Witness::from(vec_slice);
+
+        let mut expected = Witness::from_slice(&vec);
+        assert_eq!(expected.len(), 2);
+        assert_eq!(expected.to_vec(), vec);
+
+        assert_eq!(witness_vec_vec, expected);
+        assert_eq!(witness_slice_vec, expected);
+        assert_eq!(witness_slice_slice, expected);
+        assert_eq!(witness_vec_slice, expected);
+
+        // Test clear method
+        expected.clear();
+        assert!(expected.is_empty());
+    }
+
+    #[test]
+    fn witness_from_array_impl() {
+        const DATA_1: [u8; 3] = [1, 2, 3];
+        const DATA_2: [u8; 3] = [4, 5, 6];
+        let witness = Witness::from_slice(&[DATA_1, DATA_2]);
+
+        let witness_from_array_ref = Witness::from(&[DATA_1, DATA_2]);
+        let witness_from_array_of_refs = Witness::from([&DATA_1, &DATA_2]);
+        let witness_from_ref_to_array_of_refs = Witness::from(&[&DATA_1, &DATA_2]);
+        let witness_from_fixed_array = Witness::from([DATA_1, DATA_2]);
+        let witness_from_slice_of_refs = Witness::from(&[&DATA_1, &DATA_2][..]);
+        let witness_from_nested_array = Witness::from(&[DATA_1, DATA_2][..]);
+
+        assert_eq!(witness_from_array_ref, witness);
+        assert_eq!(witness_from_array_of_refs, witness);
+        assert_eq!(witness_from_ref_to_array_of_refs, witness);
+        assert_eq!(witness_from_fixed_array, witness);
+        assert_eq!(witness_from_slice_of_refs, witness);
+        assert_eq!(witness_from_nested_array, witness);
+    }
+
+    #[test]
+    fn witness_size() {
+        let mut witness = Witness::new();
+        let want = 1; // Number of elements compact size encoded.
+        assert_eq!(witness.size(), want);
+
+        witness.push([1, 2, 3]);
+        let want = 5; // 1 + 1 + 3
+        assert_eq!(witness.size(), want);
+
+        witness.push([4, 5]);
+        let want = 8; // 5 + 1 + 2
+        assert_eq!(witness.size(), want);
+    }
+
+    #[test]
+    fn partial_eq() {
+        const EMPTY_BYTES: &[u8] = &[];
+        const DATA_1: &[u8] = &[42];
+        const DATA_2: &[u8] = &[42, 21];
+
+        macro_rules! ck {
+            ($witness:expr, $container:expr, $different:expr) => {{
+                let witness = $witness;
+                let container = $container;
+                let different = $different;
+
+                assert_eq!(witness, container, stringify!($container));
+                assert_eq!(container, witness, stringify!($container));
+
+                assert_ne!(witness, different, stringify!($container));
+                assert_ne!(different, witness, stringify!($container));
+            }};
+        }
+
+        // &[T]
+        let container: &[&[u8]] = &[EMPTY_BYTES];
+        let different: &[&[u8]] = &[DATA_1];
+        ck!(Witness::from(container), container, different);
+
+        let container: &[&[u8]] = &[DATA_1];
+        let different: &[&[u8]] = &[DATA_2];
+        ck!(Witness::from(container), container, different);
+
+        // &[T; N]
+        let container: &[&[u8]; 2] = &[DATA_1, DATA_2];
+        let different: &[&[u8]; 2] = &[DATA_2, DATA_1];
+        ck!(Witness::from(container), container, different);
+
+        // [&[T]; N]
+        let container: [&[u8]; 2] = [DATA_1, DATA_2];
+        let different: [&[u8]; 2] = [DATA_2, DATA_1];
+        ck!(Witness::from(container), container, different);
+
+        // Vec<T>
+        let container: Vec<&[u8]> = vec![DATA_1, DATA_2];
+        let different: Vec<&[u8]> = vec![DATA_2, DATA_1];
+        ck!(Witness::from(container.as_slice()), container, different);
+
+        // Box<[T]>
+        let container: Box<[&[u8]]> = vec![DATA_1, DATA_2].into_boxed_slice();
+        let different: Box<[&[u8]]> = vec![DATA_2, DATA_1].into_boxed_slice();
+        ck!(Witness::from(&*container), container, different);
+
+        // Rc<[T]>
+        let container: rc::Rc<[&[u8]]> = vec![DATA_1, DATA_2].into();
+        let different: rc::Rc<[&[u8]]> = vec![DATA_2, DATA_1].into();
+        ck!(Witness::from(&*container), container, different);
+
+        // Arc<[T]>
+        let container: sync::Arc<[&[u8]]> = vec![DATA_1, DATA_2].into();
+        let different: sync::Arc<[&[u8]]> = vec![DATA_2, DATA_1].into();
+        ck!(Witness::from(&*container), container, different);
+    }
+
+    #[test]
+    fn partial_eq_for_slice() {
+        let witness = Witness::from_slice(&[vec![1, 2, 3], vec![4, 5, 6]]);
+        let container: &[Vec<u8>] = &[vec![1, 2, 3], vec![4, 5, 6]];
+        let different: &[Vec<u8>] = &[vec![1, 2], vec![4, 5]];
+
+        // Explicitly dereference the slice to invoke the `[T]` implementation.
+        assert_eq!(*container, witness);
+        assert_ne!(*different, witness);
+    }
+
+    #[test]
+    fn partial_eq_len_mismatch() {
+        let witness = Witness::from_slice(&[&[1u8][..]]);
+        let rhs = vec![vec![1u8], vec![2u8]];
+        assert_ne!(witness, rhs.as_slice());
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_bincode_backward_compatibility() {
+        let old_witness_format = vec![vec![0u8], vec![2]];
+        let new_witness_format = Witness::from_slice(&old_witness_format);
+
+        let old = bincode::serialize(&old_witness_format).unwrap();
+        let new = bincode::serialize(&new_witness_format).unwrap();
+
+        assert_eq!(old, new);
+    }
+
+    #[cfg(feature = "serde")]
+    fn arbitrary_witness() -> Witness {
+        let mut witness = Witness::default();
+
+        witness.push([0_u8]);
+        witness.push([1_u8; 32]);
+        witness.push([2_u8; 72]);
+
+        witness
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_bincode_roundtrips() {
+        let original = arbitrary_witness();
+        let ser = bincode::serialize(&original).unwrap();
+        let roundtrip: Witness = bincode::deserialize(&ser).unwrap();
+        assert_eq!(roundtrip, original);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_human_roundtrips() {
+        let original = arbitrary_witness();
+        let ser = serde_json::to_string(&original).unwrap();
+        let roundtrip: Witness = serde_json::from_str(&ser).unwrap();
+        assert_eq!(roundtrip, original);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_human() {
+        let witness = Witness::from_slice(&[vec![0u8, 123, 75], vec![2u8, 6, 3, 7, 8]]);
+        let json = serde_json::to_string(&witness).unwrap();
+        assert_eq!(json, r#"["007b4b","0206030708"]"#);
+    }
+
+    #[test]
+    fn test_witness_from_iterator() {
+        let bytes1 = [1u8, 2, 3];
+        let bytes2 = [4u8, 5];
+        let bytes3 = [6u8, 7, 8, 9];
+        let data = [&bytes1[..], &bytes2[..], &bytes3[..]];
+
+        // Use FromIterator directly
+        let witness1 = Witness::from_iter(data);
+
+        // Create a witness manually for comparison
+        let mut witness2 = Witness::new();
+        for item in &data {
+            witness2.push(item);
+        }
+        assert_eq!(witness1, witness2);
+        assert_eq!(witness1.len(), witness2.len());
+        assert_eq!(witness1.to_vec(), witness2.to_vec());
+
+        // Test with collect
+        let bytes4 = [0u8, 123, 75];
+        let bytes5 = [2u8, 6, 3, 7, 8];
+        let data = [bytes4.to_vec(), bytes5.to_vec()];
+        let witness3: Witness = data.iter().collect();
+        assert_eq!(witness3.len(), 2);
+        assert_eq!(witness3.to_vec(), data);
+
+        // Test with empty iterator
+        let empty_data: Vec<Vec<u8>> = vec![];
+        let witness4: Witness = empty_data.iter().collect();
+        assert!(witness4.is_empty());
+    }
+
+    #[test]
+    fn test_from_hex() {
+        let hex_strings = [
+            "30440220703350f1c8be5b41b4cb03b3b680c4f3337f987514a6b08e16d5d9f81e9b5f72022018fb269ba5b82864c0e1edeaf788829eb332fe34a859cc1f99c4a02edfb5d0df01",
+            "0208689fe2cca52d8726cefaf274de8fa61d5faa5e1058ad35b49fb194c035f9a4",
+        ];
+
+        let witness = Witness::from_hex(hex_strings).unwrap();
+        assert_eq!(witness.len(), 2);
+    }
+
+    #[test]
+    fn encode() {
+        let bytes1 = [1u8, 2, 3];
+        let bytes2 = [4u8, 5];
+        let bytes3 = [6u8, 7, 8, 9];
+        let data = [&bytes1[..], &bytes2[..], &bytes3[..]];
+
+        // Use FromIterator directly
+        let witness = Witness::from_iter(data);
+
+        let want = [0x03, 0x03, 0x01, 0x02, 0x03, 0x02, 0x04, 0x05, 0x04, 0x06, 0x07, 0x08, 0x09];
+        let got = encoding::encode_to_vec(&witness);
+
+        assert_eq!(&got, &want);
+    }
+
+    #[test]
+    fn encodes_using_correct_chunks() {
+        let bytes1 = [1u8, 2, 3];
+        let bytes2 = [4u8, 5];
+        let data = [&bytes1[..], &bytes2[..]];
+
+        // Use FromIterator directly
+        let witness = Witness::from_iter(data);
+
+        check_encode(&witness, &[2u8, 3u8, 1, 2, 3, 2, 4, 5]);
+    }
+
+    #[test]
+    fn encode_empty() {
+        let witness = Witness::default();
+
+        let want = [0x00];
+        let got = encoding::encode_to_vec(&witness);
+
+        assert_eq!(&got, &want);
+    }
+
+    fn witness_test_case() -> (Witness, Vec<u8>) {
+        let bytes1 = [1u8];
+        let bytes2 = [2u8, 3];
+        let bytes3 = [4u8, 5, 6];
+        let data = [&bytes1[..], &bytes2[..], &bytes3[..]];
+
+        let witness = Witness::from_iter(data);
+
+        #[rustfmt::skip]
+        let encoded = vec![
+            0x03_u8,
+            0x01, 0x01,
+            0x02, 0x02, 0x03,
+            0x03, 0x04, 0x05, 0x06
+        ];
+
+        (witness, encoded)
+    }
+
+    #[test]
+    fn decode_witness_one_single_call() {
+        let (want, encoded) = witness_test_case();
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+        decoder.push_bytes(&mut slice).unwrap();
+
+        let got = decoder.end().unwrap();
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    #[allow(clippy::many_single_char_names)]
+    fn decode_witness_many_calls() {
+        let (want, encoded) = witness_test_case();
+
+        let mut decoder = WitnessDecoder::new();
+
+        let mut a = &encoded.as_slice()[0..1]; // [3]
+        let mut b = &encoded.as_slice()[1..2]; // [1]
+        let mut c = &encoded.as_slice()[2..5]; // [1, 2, 2]
+        let mut d = &encoded.as_slice()[5..6]; // [3]
+        let mut e = &encoded.as_slice()[6..7]; // [3]
+        let mut f = &encoded.as_slice()[7..9]; // [4, 5]
+        let mut g = &encoded.as_slice()[9..]; // [6]
+
+        decoder.push_bytes(&mut a).unwrap();
+        decoder.push_bytes(&mut b).unwrap();
+        decoder.push_bytes(&mut c).unwrap();
+        decoder.push_bytes(&mut d).unwrap();
+        decoder.push_bytes(&mut e).unwrap();
+        decoder.push_bytes(&mut f).unwrap();
+        decoder.push_bytes(&mut g).unwrap();
+
+        let got = decoder.end().unwrap();
+
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn decode_max_length() {
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(crate::compact_size_encode(1usize).as_slice());
+        encoded.extend_from_slice(crate::compact_size_encode(4_000_000usize).as_slice());
+        encoded.resize(encoded.len() + 4_000_000, 0u8);
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+        decoder.push_bytes(&mut slice).unwrap();
+        let witness = decoder.end().unwrap();
+        assert_eq!(witness[0].len(), 4_000_000);
+    }
+
+    #[test]
+    fn decode_length_prefix_error() {
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(crate::compact_size_encode(1usize).as_slice());
+        encoded.extend_from_slice(crate::compact_size_encode(4_000_001usize).as_slice());
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+        let err = decoder.push_bytes(&mut slice).unwrap_err();
+        assert!(matches!(
+            err,
+            WitnessDecoderError(WitnessDecoderErrorInner::LengthPrefixDecode(_))
+        ));
+        assert!(!err.to_string().is_empty());
+        assert!(err.source().is_some());
+    }
+
+    #[test]
+    fn decode_empty_witness() {
+        // Witness with 0 elements.
+        let encoded = vec![0x00];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 0);
+        assert!(witness.is_empty());
+    }
+
+    #[test]
+    fn decode_single_element() {
+        // Witness with 1 element containing [0xAB, 0xCD].
+        let encoded = vec![0x01, 0x02, 0xAB, 0xCD];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 1);
+        assert_eq!(&witness[0], &[0xABu8, 0xCD][..]);
+    }
+
+    #[test]
+    fn decode_empty_element() {
+        // Witness with 1 element that is empty (0 bytes).
+        let encoded = vec![0x01, 0x00];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 1);
+        assert_eq!(&witness[0], &[] as &[u8]);
+    }
+
+    #[test]
+    fn decode_multiple_empty_elements() {
+        // Witness with 3 empty elements.
+        let encoded = vec![0x03, 0x00, 0x00, 0x00];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
+        let witness = decoder.end().unwrap();
+
+        assert_eq!(witness.len(), 3);
+        assert_eq!(&witness[0], &[] as &[u8]);
+        assert_eq!(&witness[1], &[] as &[u8]);
+        assert_eq!(&witness[2], &[] as &[u8]);
+    }
+
+    #[test]
+    fn decode_incomplete_witness_count() {
+        // 3-byte compact size but only provide 2 bytes.
+        let encoded = vec![0xFD, 0x03];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    fn decode_incomplete_element_length() {
+        // Witness count = 1, but element length is incomplete.
+        let encoded = vec![0x01, 0xFD, 0x05]; // Element length should be 3 bytes.
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    fn decode_incomplete_element_data() {
+        // Witness count = 1, element length = 5, but only 3 bytes of data provided.
+        let encoded = vec![0x01, 0x05, 0xAA, 0xBB, 0xCC];
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+
+        assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
+
+        let err = decoder.end().unwrap_err();
+        assert!(matches!(err, WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(_))));
+    }
+
+    #[test]
+    fn decoder_read_limit() {
+        let mut decoder = Witness::decoder();
+        // witness_count_decoder is CompactSize: needs 1 byte.
+        assert_eq!(decoder.read_limit(), 1);
+
+        // Set witness count = 1.
+        let mut bytes = [0x01u8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        // element_length_decoder is CompactSize: needs 1 byte..
+        assert_eq!(decoder.read_limit(), 1);
+
+        // Provide only first byte of a 3 byte CompactSize.
+        let mut bytes = [0xFDu8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        assert_eq!(decoder.read_limit(), 2);
+
+        // Set element length to 500 (0x01F4 little-endian).
+        let mut bytes = [0xF4u8, 0x01].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        // Decoder now reads element data and the limit becomes the element length.
+        assert_eq!(decoder.read_limit(), 500);
+
+        // Provide 1 byte of element data decreasing the read limit by 1.
+        let mut bytes = [0xAAu8].as_slice();
+        decoder.push_bytes(&mut bytes).unwrap();
+        assert_eq!(decoder.read_limit(), 499);
+    }
+
+    #[test]
+    fn decoder_end_without_witness_count_errors() {
+        let err = WitnessDecoder::new().end().unwrap_err();
+        assert!(matches!(
+            err,
+            WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(UnexpectedEofError {
+                missing_elements: 0
+            }))
+        ));
+        assert!(!err.to_string().is_empty());
+        assert!(err.source().is_some());
+    }
+
+    #[test]
+    fn decoder_unexpected_eof_error() {
+        let mut decoder = WitnessDecoder::new();
+        let mut slice = [0x01].as_slice(); // witness element count = 1.
+        assert!(decoder.push_bytes(&mut slice).unwrap().needs_more());
+
+        let inner = match decoder.end().unwrap_err() {
+            WitnessDecoderError(WitnessDecoderErrorInner::UnexpectedEof(inner)) => inner,
+            err => panic!("unexpected error: {}", err),
+        };
+        assert!(!inner.to_string().is_empty());
+    }
+
+    #[test]
+    fn decode_buffer_resizing() {
+        // Create a witness with elements larger than initial 128-byte allocation.
+        let large_element = vec![0xFF; 500];
+        let mut encoded = vec![0x02];
+        encoded.extend_from_slice(&[0xFD, 0xF4, 0x01]);
+        encoded.extend_from_slice(&large_element);
+        encoded.extend_from_slice(&[0xFD, 0xF4, 0x01]);
+        encoded.extend_from_slice(&large_element);
+
+        let mut slice = encoded.as_slice();
+        let mut decoder = WitnessDecoder::new();
+        assert!(decoder.push_bytes(&mut slice).unwrap().is_ready());
+
+        let witness = decoder.end().unwrap();
+        assert_eq!(witness.len(), 2);
+        assert_eq!(&witness[0], large_element.as_slice());
+        assert_eq!(&witness[1], large_element.as_slice());
+    }
+
+    #[test]
+    fn iter_next_none_if_cursor_decode_fails() {
+        let witness = Witness { content: vec![], witness_elements: 1, indices_start: 0 };
+        assert!(witness.iter().next().is_none());
+    }
+
+    #[test]
+    fn iter_next_none_if_element_len_too_big() {
+        // Element length = 4_000_001 which is larger than MAX_VEC_SIZE (4_000_000).
+        let mut content = vec![0xFE];
+        content.extend_from_slice(&4_000_001u32.to_le_bytes());
+        let indices_start = content.len();
+        content.extend_from_slice(&u32::to_ne_bytes(0));
+
+        let witness = Witness { content, witness_elements: 1, indices_start };
+        assert!(witness.iter().next().is_none());
+    }
+
+    #[test]
+    fn witness_debug() {
+        let witness = Witness::from_slice(&[&[0xAAu8][..]]);
+        let s = format!("{:?}", witness);
+        assert!(!s.is_empty());
+    }
+
+    #[test]
+    fn size_matches_encoding_length() {
+        let empty = Witness::new();
+        assert_eq!(empty.size(), encoding::encode_to_vec(&empty).len());
+
+        let mut witness = Witness::new();
+        witness.push([0u8; 0]);
+        assert_eq!(witness.size(), encoding::encode_to_vec(&witness).len());
+        witness.push([0u8; 252]);
+        assert_eq!(witness.size(), encoding::encode_to_vec(&witness).len());
+        witness.push([0u8; 253]);
+        assert_eq!(witness.size(), encoding::encode_to_vec(&witness).len());
+    }
+
+    #[test]
+    fn decode_value_1_byte() {
+        // Check lower bound, upper bound.
+        for v in [0x00, 0x01, 0x02, 0xFA, 0xFB, 0xFC] {
+            let raw = [v];
+            let mut slice = raw.as_slice();
+            let got = decode_unchecked(&mut slice);
+            assert_eq!(got, u64::from(v));
+            assert!(slice.is_empty());
+        }
+    }
+
+    macro_rules! check_decode {
+        ($($test_name:ident, $size:expr, $want:expr, $encoded:expr);* $(;)?) => {
+            $(
+                #[test]
+                fn $test_name() {
+                    let mut slice = $encoded.as_slice();
+                    let got = decode_unchecked(&mut slice);
+                    assert_eq!(got, $want);
+                    assert_eq!(slice.len(), $encoded.len() - $size);
+                }
+            )*
+        }
+    }
+
+    check_decode! {
+        // 3 byte encoding.
+        decode_from_3_byte_slice_lower_bound, 3, 0xFD, [0xFD, 0xFD, 0x00];
+        decode_from_3_byte_slice_three_over_lower_bound, 3, 0x0100, [0xFD, 0x00, 0x01];
+        decode_from_3_byte_slice_endianness, 3, 0xABCD, [0xFD, 0xCD, 0xAB];
+        decode_from_3_byte_slice_upper_bound, 3, 0xFFFF, [0xFD, 0xFF, 0xFF];
+
+        // 5 byte encoding.
+        decode_from_5_byte_slice_lower_bound, 5, 0x0001_0000, [0xFE, 0x00, 0x00, 0x01, 0x00];
+        decode_from_5_byte_slice_endianness, 5, 0x0123_4567, [0xFE, 0x67, 0x45, 0x23, 0x01];
+        decode_from_5_byte_slice_upper_bound, 5, 0xFFFF_FFFF, [0xFE, 0xFF, 0xFF, 0xFF, 0xFF];
+        // 9 byte encoding.
+        decode_from_9_byte_slice_lower_bound, 9, 0x0000_0001_0000_0000, [0xFF, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00];
+        decode_from_9_byte_slice_endianness, 9, 0x0123_4567_89AB_CDEF, [0xFF, 0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01];
+        decode_from_9_byte_slice_upper_bound, 9, u64::MAX, [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+
+        // Check slices that are bigger than the actual encoding.
+        decode_1_byte_from_bigger_slice, 1, 32, [0x20, 0xAB, 0xBC];
+        decode_3_byte_from_bigger_slice, 3, 0xFFFF, [0xFD, 0xFF, 0xFF, 0xAB, 0xBC];
+        decode_5_byte_from_bigger_slice, 5, 0xFFFF_FFFF, [0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xAB, 0xBC];
+        decode_9_byte_from_bigger_slice, 9, u64::MAX, [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xAB, 0xBC];
+    }
+
+    #[test]
+    #[should_panic(expected = "tried to decode an empty slice")]
+    fn decode_from_empty_slice_panics() {
+        let mut slice = [].as_slice();
+        let _ = decode_unchecked(&mut slice);
+    }
+
+    #[test]
+    #[should_panic(expected = "slice too short, expected at least 5 bytes")]
+    // Non-minimal is referred to as non-canonical in Core (`bitcoin/src/serialize.h`).
+    fn decode_non_minimal_panics() {
+        let mut slice = [0xFE, 0xCD, 0xAB].as_slice();
+        let _ = decode_unchecked(&mut slice);
+    }
+
+    #[test]
+    fn test_dos_protection() {
+        let mut encoded = Vec::new();
+        encoded.extend_from_slice(&[0xFE, 0x00, 0x09, 0x3D, 0x00]); // 4_000_000 (witness count)
+        encoded.extend_from_slice(&[0xFE, 0x00, 0x09, 0x3D, 0x00]); // 4_000_000 (1st element length)
+
+        let mut slice = encoded.as_slice();
+        let mut dec = WitnessDecoder::new();
+
+        assert!(dec.push_bytes(&mut slice).unwrap().needs_more());
+
+        // Only the 1st element length prefix has been written to the content area.
+        // No massive allocation occurred.
+        assert_eq!(dec.content.len(), 5);
+        assert!(dec.content.capacity() < 100_000);
+    }
+}