Replace uses of Encoder2 with prefixed encoders

diff --git a/consensus_encoding/examples/encoder.rs b/consensus_encoding/examples/encoder.rs
index e8415f0e..bcc1c573 100644
--- a/consensus_encoding/examples/encoder.rs
+++ b/consensus_encoding/examples/encoder.rs
@@ -3,7 +3,7 @@
 //! Example of creating an encoder that encodes a slice of encodable objects.
 
 use bitcoin_consensus_encoding as encoding;
-use encoding::{ArrayEncoder, BytesEncoder, CompactSizeEncoder, Encode, Encoder2, SliceEncoder};
+use encoding::{ArrayEncoder, BytesEncoder, Encode, Encoder2, PrefixedSliceEncoder};
 
 fn main() {
     let v = vec![Inner::new(0xcafe_babe), Inner::new(0xdead_beef)];
@@ -29,7 +29,7 @@ impl Adt {
 
 encoding::encoder_newtype! {
     /// The encoder for the [`Adt`] type.
-    pub struct AdtEncoder<'e>(Encoder2<Encoder2<CompactSizeEncoder, SliceEncoder<'e, Inner>>, BytesEncoder<'e>>);
+    pub struct AdtEncoder<'e>(Encoder2<PrefixedSliceEncoder<'e, Inner>, BytesEncoder<'e>>);
 }
 
 impl Encode for Adt {
@@ -39,10 +39,7 @@ impl Encode for Adt {
         Self: 'e;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        let a = Encoder2::new(
-            CompactSizeEncoder::new(self.v.len()),
-            SliceEncoder::without_length_prefix(&self.v),
-        );
+        let a = PrefixedSliceEncoder::new(&self.v);
         let b = BytesEncoder::without_length_prefix(self.b.as_ref());
 
         AdtEncoder::new(Encoder2::new(a, b))
diff --git a/p2p/src/bip152.rs b/p2p/src/bip152.rs
index cc52cd33..a23ef006 100644
--- a/p2p/src/bip152.rs
+++ b/p2p/src/bip152.rs
@@ -11,7 +11,7 @@ use core::convert;
 use arbitrary::{Arbitrary, Unstructured};
 use encoding::{
     ArrayDecoder, ArrayEncoder, CompactSizeDecoder, CompactSizeEncoder, Decoder2, Decoder4,
-    Encoder2, Encoder4, SliceEncoder, VecDecoder,
+    Encoder2, Encoder4, PrefixedSliceEncoder, VecDecoder,
 };
 use hashes::{sha256, siphash24, HashEngine};
 use internals::array::ArrayExt as _;
@@ -229,8 +229,8 @@ pub struct HeaderAndShortIds {
 type HeaderAndShortIdsInnerEncoder<'e> = Encoder4<
     HeaderEncoder<'e>,
     ArrayEncoder<8>,
-    Encoder2<CompactSizeEncoder, SliceEncoder<'e, ShortId>>,
-    Encoder2<CompactSizeEncoder, SliceEncoder<'e, PrefilledTransaction>>,
+    PrefixedSliceEncoder<'e, ShortId>,
+    PrefixedSliceEncoder<'e, PrefilledTransaction>,
 >;
 
 encoding::encoder_newtype! {
@@ -251,14 +251,8 @@ impl encoding::Encode for HeaderAndShortIds {
         HeaderAndShortIdsEncoder::new(Encoder4::new(
             self.header.encoder(),
             ArrayEncoder::without_length_prefix(self.nonce.to_le_bytes()),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.short_ids.len()),
-                SliceEncoder::without_length_prefix(&self.short_ids),
-            ),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.prefilled_txs.len()),
-                SliceEncoder::without_length_prefix(&self.prefilled_txs),
-            ),
+            PrefixedSliceEncoder::new(&self.short_ids),
+            PrefixedSliceEncoder::new(&self.prefilled_txs),
         ))
     }
 }
@@ -475,7 +469,7 @@ encoding::encoder_newtype! {
     pub struct BlockTransactionsRequestEncoder<'e>(
         Encoder2<
             BlockHashEncoder<'e>,
-            Encoder2<CompactSizeEncoder, SliceEncoder<'e, Offset>>
+            PrefixedSliceEncoder<'e, Offset>,
         >
     );
 }
@@ -486,10 +480,7 @@ impl encoding::Encode for BlockTransactionsRequest {
     fn encoder(&self) -> Self::Encoder<'_> {
         BlockTransactionsRequestEncoder::new(Encoder2::new(
             self.block_hash.encoder(),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.offsets.len()),
-                SliceEncoder::without_length_prefix(&self.offsets),
-            ),
+            PrefixedSliceEncoder::new(&self.offsets),
         ))
     }
 }
@@ -529,7 +520,7 @@ encoding::encoder_newtype! {
     pub struct BlockTransactionsEncoder<'e>(
         Encoder2<
             BlockHashEncoder<'e>,
-            Encoder2<CompactSizeEncoder, SliceEncoder<'e, Transaction>>
+            PrefixedSliceEncoder<'e, Transaction>
         >
     );
 }
@@ -543,10 +534,7 @@ impl encoding::Encode for BlockTransactions {
     fn encoder(&self) -> Self::Encoder<'_> {
         BlockTransactionsEncoder::new(Encoder2::new(
             self.block_hash.encoder(),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.transactions.len()),
-                SliceEncoder::without_length_prefix(&self.transactions),
-            ),
+            PrefixedSliceEncoder::new(&self.transactions),
         ))
     }
 }
diff --git a/p2p/src/merkle_tree.rs b/p2p/src/merkle_tree.rs
index dc22f238..5a705748 100644
--- a/p2p/src/merkle_tree.rs
+++ b/p2p/src/merkle_tree.rs
@@ -16,7 +16,7 @@ use alloc::vec::Vec;
 use arbitrary::{Arbitrary, Unstructured};
 use encoding::{
     ArrayDecoder, ArrayEncoder, ByteVecDecoder, CompactSizeEncoder, Decoder2, Decoder3, Encoder2,
-    Encoder3, EncoderStatus, SliceEncoder, VecDecoder,
+    Encoder3, EncoderStatus, PrefixedSliceEncoder, VecDecoder,
 };
 use primitives::block::{self, Block, Checked, Header, HeaderDecoder, HeaderEncoder};
 use primitives::merkle_tree::TxMerkleNode;
@@ -473,7 +473,7 @@ encoding::encoder_newtype! {
     pub struct PartialMerkleTreeEncoder<'e>(
         Encoder3<
             ArrayEncoder<4>,
-            Encoder2<CompactSizeEncoder, SliceEncoder<'e, TxMerkleNode>>,
+            PrefixedSliceEncoder<'e, TxMerkleNode>,
             Encoder2<CompactSizeEncoder, BitVecEncoder>,
         >
     );
@@ -485,10 +485,7 @@ impl encoding::Encode for PartialMerkleTree {
     fn encoder(&self) -> Self::Encoder<'_> {
         PartialMerkleTreeEncoder::new(Encoder3::new(
             ArrayEncoder::without_length_prefix(self.num_transactions.to_le_bytes()),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.hashes.len()),
-                SliceEncoder::without_length_prefix(&self.hashes),
-            ),
+            PrefixedSliceEncoder::new(&self.hashes),
             Encoder2::new(
                 CompactSizeEncoder::new(self.bits.len().div_ceil(8)),
                 BitVecEncoder::new(&self.bits),
diff --git a/p2p/src/message.rs b/p2p/src/message.rs
index 7b5e2130..a1d9e967 100644
--- a/p2p/src/message.rs
+++ b/p2p/src/message.rs
@@ -13,8 +13,8 @@ use core::{fmt, mem};
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use encoding::{
-    self, ArrayDecoder, ArrayEncoder, BytesEncoder, CompactSizeEncoder, Decoder2, Encoder2,
-    EncoderStatus, SliceEncoder, VecDecoder, VecDecoderError,
+    self, ArrayDecoder, ArrayEncoder, BytesEncoder, Decoder2, Encoder2, EncoderStatus,
+    PrefixedSliceEncoder, VecDecoder, VecDecoderError,
 };
 use hashes::{sha256d, HashEngine};
 use primitives::block::{self, Header, HeaderDecoder, HeaderEncoder};
@@ -298,20 +298,17 @@ pub struct InventoryPayload(pub Vec<message_blockdata::Inventory>);
 encoding::encoder_newtype! {
     /// The encoder for an [`InventoryPayload`].
     #[derive(Debug, Clone)]
-    pub struct InventoryPayloadEncoder<'e>(Encoder2<CompactSizeEncoder, SliceEncoder<'e, message_blockdata::Inventory>>);
+    pub struct InventoryPayloadEncoder<'e>(PrefixedSliceEncoder<'e, message_blockdata::Inventory>);
 }
 
 impl encoding::Encode for InventoryPayload {
     type Encoder<'e>
-        = Encoder2<CompactSizeEncoder, SliceEncoder<'e, message_blockdata::Inventory>>
+        = InventoryPayloadEncoder<'e>
     where
         Self: 'e;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        Encoder2::new(
-            CompactSizeEncoder::new(self.0.len()),
-            SliceEncoder::without_length_prefix(&self.0),
-        )
+        InventoryPayloadEncoder::new(PrefixedSliceEncoder::new(&self.0))
     }
 }
 
@@ -340,17 +337,14 @@ pub struct AddrPayload(pub Vec<AddrV1Message>);
 encoding::encoder_newtype! {
     /// The encoder for an [`AddrPayload`].
     #[derive(Debug, Clone)]
-    pub struct AddrPayloadEncoder<'e>(Encoder2<CompactSizeEncoder, SliceEncoder<'e, AddrV1Message>>);
+    pub struct AddrPayloadEncoder<'e>(PrefixedSliceEncoder<'e, AddrV1Message>);
 }
 
 impl encoding::Encode for AddrPayload {
     type Encoder<'e> = AddrPayloadEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        AddrPayloadEncoder::new(Encoder2::new(
-            CompactSizeEncoder::new(self.0.len()),
-            SliceEncoder::without_length_prefix(&self.0),
-        ))
+        AddrPayloadEncoder::new(PrefixedSliceEncoder::new(&self.0))
     }
 }
 
@@ -379,20 +373,17 @@ pub struct AddrV2Payload(pub Vec<AddrV2Message>);
 encoding::encoder_newtype! {
     /// The encoder for an [`AddrV2Payload`].
     #[derive(Debug, Clone)]
-    pub struct AddrV2PayloadEncoder<'e>(Encoder2<CompactSizeEncoder, SliceEncoder<'e, AddrV2Message>>);
+    pub struct AddrV2PayloadEncoder<'e>(PrefixedSliceEncoder<'e, AddrV2Message>);
 }
 
 impl encoding::Encode for AddrV2Payload {
     type Encoder<'e>
-        = Encoder2<CompactSizeEncoder, SliceEncoder<'e, AddrV2Message>>
+        = AddrV2PayloadEncoder<'e>
     where
         Self: 'e;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        Encoder2::new(
-            CompactSizeEncoder::new(self.0.len()),
-            SliceEncoder::without_length_prefix(&self.0),
-        )
+        AddrV2PayloadEncoder::new(PrefixedSliceEncoder::new(&self.0))
     }
 }
 
@@ -1603,17 +1594,14 @@ impl HeadersMessage {
 encoding::encoder_newtype! {
     /// The encoder type for a [`HeadersMessage`].
     #[derive(Debug, Clone)]
-    pub struct HeadersMessageEncoder<'e>(Encoder2<CompactSizeEncoder, SliceEncoder<'e, NetworkHeader>>);
+    pub struct HeadersMessageEncoder<'e>(PrefixedSliceEncoder<'e, NetworkHeader>);
 }
 
 impl encoding::Encode for HeadersMessage {
     type Encoder<'e> = HeadersMessageEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        HeadersMessageEncoder::new(Encoder2::new(
-            CompactSizeEncoder::new(self.0.len()),
-            SliceEncoder::without_length_prefix(&self.0),
-        ))
+        HeadersMessageEncoder::new(PrefixedSliceEncoder::new(&self.0))
     }
 }
 
diff --git a/p2p/src/message_blockdata.rs b/p2p/src/message_blockdata.rs
index 29a3814d..7c6c8e57 100644
--- a/p2p/src/message_blockdata.rs
+++ b/p2p/src/message_blockdata.rs
@@ -10,8 +10,8 @@ use alloc::vec::Vec;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use encoding::{
-    ArrayDecoder, ArrayEncoder, CompactSizeEncoder, Decoder2, Decoder3, Encoder2, Encoder3,
-    SliceEncoder, VecDecoder,
+    ArrayDecoder, ArrayEncoder, Decoder2, Decoder3, Encoder2, Encoder3, PrefixedSliceEncoder,
+    VecDecoder,
 };
 use primitives::block::{BlockHashDecoder, BlockHashEncoder};
 use primitives::transaction::{Txid, Wtxid};
@@ -179,7 +179,7 @@ impl From<BlockLocator> for Vec<BlockHash> {
     fn from(locator: BlockLocator) -> Self { locator.0 }
 }
 
-type BlockLocatorInnerEncoder<'e> = Encoder2<CompactSizeEncoder, SliceEncoder<'e, BlockHash>>;
+type BlockLocatorInnerEncoder<'e> = PrefixedSliceEncoder<'e, BlockHash>;
 
 encoding::encoder_newtype! {
     /// The encoder for [`BlockLocator`].
@@ -191,10 +191,7 @@ impl encoding::Encode for BlockLocator {
     type Encoder<'e> = BlockLocatorEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        BlockLocatorEncoder::new(Encoder2::new(
-            CompactSizeEncoder::new(self.0.len()),
-            SliceEncoder::without_length_prefix(&self.0),
-        ))
+        BlockLocatorEncoder::new(PrefixedSliceEncoder::new(&self.0))
     }
 }
 
diff --git a/p2p/src/message_bloom.rs b/p2p/src/message_bloom.rs
index c2057375..393fd1c0 100644
--- a/p2p/src/message_bloom.rs
+++ b/p2p/src/message_bloom.rs
@@ -9,8 +9,7 @@ use alloc::vec::Vec;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use encoding::{
-    ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder4,
-    Encoder2, Encoder3,
+    ArrayDecoder, ArrayEncoder, ByteVecDecoder, Decoder4, Encoder2, Encoder3, PrefixedBytesEncoder,
 };
 
 #[rustfmt::skip]                // Keep public re-exports separate.
@@ -35,7 +34,7 @@ encoding::encoder_newtype_exact! {
     #[derive(Debug, Clone)]
     pub struct FilterLoadEncoder<'e>(
         Encoder2<
-            Encoder2<CompactSizeEncoder, BytesEncoder<'e>>,
+            PrefixedBytesEncoder<'e>,
             Encoder3<
                 ArrayEncoder<4>,
                 ArrayEncoder<4>,
@@ -50,10 +49,7 @@ impl encoding::Encode for FilterLoad {
 
     fn encoder(&self) -> Self::Encoder<'_> {
         FilterLoadEncoder::new(Encoder2::new(
-            Encoder2::new(
-                CompactSizeEncoder::new(self.filter.len()),
-                BytesEncoder::without_length_prefix(&self.filter),
-            ),
+            PrefixedBytesEncoder::new(&self.filter),
             Encoder3::new(
                 ArrayEncoder::without_length_prefix(self.hash_funcs.to_le_bytes()),
                 ArrayEncoder::without_length_prefix(self.tweak.to_le_bytes()),
@@ -159,17 +155,14 @@ pub struct FilterAdd {
 encoding::encoder_newtype_exact! {
     /// The encoder of the [`FilterAdd`] message.
     #[derive(Debug, Clone)]
-    pub struct FilterAddEncoder<'e>(Encoder2<CompactSizeEncoder, BytesEncoder<'e>>);
+    pub struct FilterAddEncoder<'e>(PrefixedBytesEncoder<'e>);
 }
 
 impl encoding::Encode for FilterAdd {
     type Encoder<'e> = FilterAddEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        FilterAddEncoder::new(Encoder2::new(
-            CompactSizeEncoder::new(self.data.len()),
-            BytesEncoder::without_length_prefix(&self.data),
-        ))
+        FilterAddEncoder::new(PrefixedBytesEncoder::new(&self.data))
     }
 }
 
diff --git a/p2p/src/message_filter.rs b/p2p/src/message_filter.rs
index 19994639..10c5a595 100644
--- a/p2p/src/message_filter.rs
+++ b/p2p/src/message_filter.rs
@@ -9,8 +9,8 @@ use alloc::vec::Vec;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use encoding::{
-    ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder2,
-    Decoder3, Decoder4, Encoder2, Encoder3, Encoder4, SliceEncoder, VecDecoder,
+    ArrayDecoder, ArrayEncoder, ByteVecDecoder, Decoder2, Decoder3, Decoder4, Encoder2, Encoder3,
+    Encoder4, PrefixedBytesEncoder, PrefixedSliceEncoder, VecDecoder,
 };
 use hashes::{sha256d, HashEngine};
 use primitives::block::{BlockHashDecoder, BlockHashEncoder};
@@ -191,7 +191,7 @@ encoding::encoder_newtype_exact! {
         Encoder3<
             ArrayEncoder<1>,
             BlockHashEncoder<'e>,
-            Encoder2<CompactSizeEncoder, BytesEncoder<'e>>,
+            PrefixedBytesEncoder<'e>,
         >
     );
 }
@@ -206,10 +206,7 @@ impl encoding::Encode for CFilter {
         CFilterEncoder::new(Encoder3::new(
             ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
             self.block_hash.encoder(),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.filter.len()),
-                BytesEncoder::without_length_prefix(&self.filter),
-            ),
+            PrefixedBytesEncoder::new(&self.filter),
         ))
     }
 }
@@ -302,7 +299,7 @@ encoding::encoder_newtype! {
             ArrayEncoder<1>,
             BlockHashEncoder<'e>,
             FilterHeaderEncoder<'e>,
-            Encoder2<CompactSizeEncoder, SliceEncoder<'e, FilterHash>>
+            PrefixedSliceEncoder<'e, FilterHash>
         >
     );
 }
@@ -315,10 +312,7 @@ impl encoding::Encode for CFHeaders {
             ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
             self.stop_hash.encoder(),
             self.previous_filter_header.encoder(),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.filter_hashes.len()),
-                SliceEncoder::without_length_prefix(&self.filter_hashes),
-            ),
+            PrefixedSliceEncoder::new(&self.filter_hashes),
         ))
     }
 }
@@ -415,7 +409,7 @@ encoding::encoder_newtype! {
         Encoder3<
             ArrayEncoder<1>,
             BlockHashEncoder<'e>,
-            Encoder2<CompactSizeEncoder, SliceEncoder<'e, FilterHeader>>
+            PrefixedSliceEncoder<'e, FilterHeader>
         >
     );
 }
@@ -430,10 +424,7 @@ impl encoding::Encode for CFCheckpt {
         CFCheckptEncoder::new(Encoder3::new(
             ArrayEncoder::without_length_prefix(self.filter_type.to_le_bytes()),
             self.stop_hash.encoder(),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.filter_headers.len()),
-                SliceEncoder::without_length_prefix(&self.filter_headers),
-            ),
+            PrefixedSliceEncoder::new(&self.filter_headers),
         ))
     }
 }
diff --git a/p2p/src/message_network.rs b/p2p/src/message_network.rs
index e8ccd5d9..48ec51cf 100644
--- a/p2p/src/message_network.rs
+++ b/p2p/src/message_network.rs
@@ -13,8 +13,7 @@ use alloc::vec::Vec;
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
 use encoding::{
-    ArrayDecoder, ArrayEncoder, ByteVecDecoder, BytesEncoder, CompactSizeEncoder, Decoder4,
-    Encoder2, Encoder4,
+    ArrayDecoder, ArrayEncoder, ByteVecDecoder, Decoder4, Encoder4, PrefixedBytesEncoder,
 };
 use hashes::sha256d;
 
@@ -199,17 +198,14 @@ pub struct UserAgent {
 encoding::encoder_newtype_exact! {
     /// The encoder for a [`UserAgent`] string.
     #[derive(Debug, Clone)]
-    pub struct UserAgentEncoder<'e>(Encoder2<CompactSizeEncoder, BytesEncoder<'e>>);
+    pub struct UserAgentEncoder<'e>(PrefixedBytesEncoder<'e>);
 }
 
 impl encoding::Encode for UserAgent {
     type Encoder<'e> = UserAgentEncoder<'e>;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        UserAgentEncoder::new(Encoder2::new(
-            CompactSizeEncoder::new(self.user_agent.len()),
-            BytesEncoder::without_length_prefix(self.user_agent.as_bytes()),
-        ))
+        UserAgentEncoder::new(PrefixedBytesEncoder::new(self.user_agent.as_bytes()))
     }
 }
 
@@ -470,9 +466,9 @@ encoding::encoder_newtype_exact! {
     #[derive(Debug, Clone)]
     pub struct RejectEncoder<'e>(
         Encoder4<
-            Encoder2<CompactSizeEncoder, BytesEncoder<'e>>,
+            PrefixedBytesEncoder<'e>,
             RejectReasonEncoder<'e>,
-            Encoder2<CompactSizeEncoder, BytesEncoder<'e>>,
+            PrefixedBytesEncoder<'e>,
             ArrayEncoder<32>,
         >
     );
@@ -483,15 +479,9 @@ impl encoding::Encode for Reject {
 
     fn encoder(&self) -> Self::Encoder<'_> {
         RejectEncoder::new(Encoder4::new(
-            Encoder2::new(
-                CompactSizeEncoder::new(self.message.len()),
-                BytesEncoder::without_length_prefix(self.message.as_bytes()),
-            ),
+            PrefixedBytesEncoder::new(self.message.as_bytes()),
             self.ccode.encoder(),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.reason.len()),
-                BytesEncoder::without_length_prefix(self.reason.as_bytes()),
-            ),
+            PrefixedBytesEncoder::new(self.reason.as_bytes()),
             ArrayEncoder::without_length_prefix(self.hash.to_byte_array()),
         ))
     }
@@ -566,18 +556,13 @@ impl Alert {
 encoding::encoder_newtype_exact! {
     /// The encoder type for an [`Alert`] message.
     #[derive(Debug, Clone)]
-    pub struct AlertEncoder<'e>(Encoder2<CompactSizeEncoder, BytesEncoder<'e>>);
+    pub struct AlertEncoder<'e>(PrefixedBytesEncoder<'e>);
 }
 
 impl encoding::Encode for Alert {
     type Encoder<'e> = AlertEncoder<'e>;
 
-    fn encoder(&self) -> Self::Encoder<'_> {
-        AlertEncoder::new(Encoder2::new(
-            CompactSizeEncoder::new(self.0.len()),
-            BytesEncoder::without_length_prefix(&self.0),
-        ))
-    }
+    fn encoder(&self) -> Self::Encoder<'_> { AlertEncoder::new(PrefixedBytesEncoder::new(&self.0)) }
 }
 
 type AlertInnerDecoder = ByteVecDecoder;
diff --git a/primitives/src/block.rs b/primitives/src/block.rs
index c917da06..d3c49484 100644
--- a/primitives/src/block.rs
+++ b/primitives/src/block.rs
@@ -15,7 +15,7 @@ use core::marker::PhantomData;
 use arbitrary::{Arbitrary, Unstructured};
 use encoding::{ArrayDecoder, Decoder6};
 #[cfg(feature = "alloc")]
-use encoding::{CompactSizeEncoder, Decoder2, Encoder2, SliceEncoder, VecDecoder};
+use encoding::{Decoder2, Encoder2, PrefixedSliceEncoder, VecDecoder};
 use hashes::sha256d;
 #[cfg(feature = "alloc")]
 use hashes::HashEngine as _;
@@ -336,10 +336,7 @@ where
     fn encoder(&self) -> Self::Encoder<'_> {
         BlockEncoder::new(Encoder2::new(
             self.header.encoder(),
-            Encoder2::new(
-                CompactSizeEncoder::new(self.transactions.len()),
-                SliceEncoder::without_length_prefix(&self.transactions),
-            ),
+            PrefixedSliceEncoder::new(&self.transactions),
         ))
     }
 }
@@ -354,7 +351,7 @@ encoding::encoder_newtype! {
     /// The encoder for the [`Block`] type.
     #[derive(Debug, Clone)]
     pub struct BlockEncoder<'e>(
-        Encoder2<HeaderEncoder<'e>, Encoder2<CompactSizeEncoder, SliceEncoder<'e, Transaction>>>
+        Encoder2<HeaderEncoder<'e>, PrefixedSliceEncoder<'e, Transaction>>
     );
 }
 
diff --git a/primitives/src/script/borrowed.rs b/primitives/src/script/borrowed.rs
index 9bb94fc2..37e3193a 100644
--- a/primitives/src/script/borrowed.rs
+++ b/primitives/src/script/borrowed.rs
@@ -10,7 +10,7 @@ use core::ops::{
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
-use encoding::{BytesEncoder, CompactSizeEncoder, Encode, Encoder2};
+use encoding::{Encode, PrefixedBytesEncoder};
 
 use super::{ScriptBuf, P2A_PROGRAM};
 use crate::opcodes::all::{OP_CHECKSIG, OP_DUP, OP_EQUAL, OP_EQUALVERIFY, OP_HASH160, OP_RETURN};
@@ -322,17 +322,14 @@ impl<T> Encode for Script<T> {
         Self: 'e;
 
     fn encoder(&self) -> Self::Encoder<'_> {
-        ScriptEncoder::new(Encoder2::new(
-            CompactSizeEncoder::new(self.as_bytes().len()),
-            BytesEncoder::without_length_prefix(self.as_bytes()),
-        ))
+        ScriptEncoder::new(PrefixedBytesEncoder::new(self.as_bytes()))
     }
 }
 
 encoding::encoder_newtype_exact! {
     /// The encoder for the [`Script<T>`] type.
     #[derive(Debug, Clone)]
-    pub struct ScriptEncoder<'e>(Encoder2<CompactSizeEncoder, BytesEncoder<'e>>);
+    pub struct ScriptEncoder<'e>(PrefixedBytesEncoder<'e>);
 }
 
 #[cfg(feature = "arbitrary")]
diff --git a/primitives/src/transaction.rs b/primitives/src/transaction.rs
index f5e133d2..ac0e2972 100644
--- a/primitives/src/transaction.rs
+++ b/primitives/src/transaction.rs
@@ -22,8 +22,8 @@ use encoding::FromHexError;
 use encoding::{ArrayEncoder, BytesEncoder, Encoder2};
 #[cfg(feature = "alloc")]
 use encoding::{
-    CompactSizeEncoder, Decoder2, Decoder3, DecoderStatus, Encode as _, Encoder3, Encoder6,
-    EncoderStatus, SliceEncoder, VecDecoder,
+    Decoder2, Decoder3, DecoderStatus, Encode as _, Encoder3, Encoder6, EncoderStatus,
+    PrefixedSliceEncoder, VecDecoder,
 };
 #[cfg(feature = "alloc")]
 use hashes::sha256d;
@@ -379,14 +379,8 @@ impl encoding::Encode for Transaction {
 
     fn encoder(&self) -> Self::Encoder<'_> {
         let version = self.version.encoder();
-        let inputs = Encoder2::new(
-            CompactSizeEncoder::new(self.inputs.len()),
-            SliceEncoder::without_length_prefix(self.inputs.as_ref()),
-        );
-        let outputs = Encoder2::new(
-            CompactSizeEncoder::new(self.outputs.len()),
-            SliceEncoder::without_length_prefix(self.outputs.as_ref()),
-        );
+        let inputs = PrefixedSliceEncoder::new(self.inputs.as_ref());
+        let outputs = PrefixedSliceEncoder::new(self.outputs.as_ref());
         let lock_time = self.lock_time.encoder();
 
         if self.uses_segwit_serialization() {
@@ -415,8 +409,8 @@ impl encoding::Decode for Transaction {
 type TransactionEncoderInner<'e> = Encoder6<
     VersionEncoder<'e>,
     Option<ArrayEncoder<2>>,
-    Encoder2<CompactSizeEncoder, SliceEncoder<'e, TxIn>>,
-    Encoder2<CompactSizeEncoder, SliceEncoder<'e, TxOut>>,
+    PrefixedSliceEncoder<'e, TxIn>,
+    PrefixedSliceEncoder<'e, TxOut>,
     Option<WitnessesEncoder<'e>>,
     LockTimeEncoder<'e>,
 >;