Merge rust-bitcoin#4978: primitives: Implement Encodable for &Script<T>

c2c567b Implement new Encodable trait for Script<T> (Tobin C. Harding)
816cd96 consenus_encoding: Make encoding functions use unsized (Tobin C. Harding)
9d5ff8a Add prefix support to BytesEncoder (Tobin C. Harding)
e0b9d39 internals: Make compact_size::MAX_ENCODING_SIZE public (Tobin C. Harding)
3c01d81 Add units tests for the BytesEncoder (Tobin C. Harding)
7d2c670 Remove lifetime from encoder_newtype macro (Tobin C. Harding)

Pull request description:

  Includes a bunch of preparatory clean up as well as a patch to add support to `BytesEncoder` to encode with length prefix.


ACKs for top commit:
  apoelstra:
    ACK c2c567b; successfully ran local tests
  nyonson:
    ACK c2c567b


Tree-SHA512: bdea310d2de42ed51897e1c4737c7ceb6d141ae7028e938d052beb2d8b48ff222824549417aa739719b1086f434b5e0b48dd3eaef0973a93da654c06beb60147

Author: apoelstra

Cargo-minimal.lock

@@ -209,6 +209,7 @@ dependencies = [
 name = "consensus-encoding"
 version = "0.0.0"
 dependencies = [
+ "bitcoin-internals",
  "bitcoin_hashes 0.16.0",
 ]
 

Cargo-recent.lock

@@ -211,6 +211,7 @@ dependencies = [
 name = "consensus-encoding"
 version = "0.0.0"
 dependencies = [
+ "bitcoin-internals",
  "bitcoin_hashes 0.16.0",
 ]
 

consensus_encoding/Cargo.toml

@@ -14,11 +14,12 @@ exclude = ["tests", "contrib"]
 
 [features]
 default = ["std"]
-std = ["alloc"]
-alloc = []
+std = ["alloc", "internals/std"]
+alloc = ["internals/alloc"]
 
 [dependencies]
 hashes = { package = "bitcoin_hashes", path = "../hashes", default-features = false }
+internals = { package = "bitcoin-internals", path = "../internals" }
 
 [package.metadata.docs.rs]
 all-features = true

consensus_encoding/src/encode/encoders.rs

@@ -11,24 +11,49 @@
 //! For implementing these newtypes, we provide the [`encoder_newtype`] macro.
 //!
 
+use internals::array_vec::ArrayVec;
+use internals::compact_size;
+
 use super::Encoder;
 
+/// The maximum length of a compact size encoding.
+const SIZE: usize = compact_size::MAX_ENCODING_SIZE;
+
 /// An encoder for a single byte slice.
 pub struct BytesEncoder<'sl> {
     sl: Option<&'sl [u8]>,
+    compact_size: Option<ArrayVec<u8, SIZE>>,
 }
 
 impl<'sl> BytesEncoder<'sl> {
     /// Constructs a byte encoder which encodes the given byte slice, with no length prefix.
-    pub fn without_length_prefix(sl: &'sl [u8]) -> Self { Self { sl: Some(sl) } }
+    pub fn without_length_prefix(sl: &'sl [u8]) -> Self {
+        Self { sl: Some(sl), compact_size: None }
+    }
+
+    /// Constructs a byte encoder which encodes the given byte slice, with the length prefix.
+    pub fn with_length_prefix(sl: &'sl [u8]) -> Self {
+        Self { sl: Some(sl), compact_size: Some(compact_size::encode(sl.len())) }
+    }
 }
 
 impl<'e, 'sl> Encoder<'e> for BytesEncoder<'sl> {
-    fn current_chunk(&self) -> Option<&[u8]> { self.sl }
+    fn current_chunk(&self) -> Option<&[u8]> {
+        if let Some(compact_size) = self.compact_size.as_ref() {
+            Some(compact_size)
+        } else {
+            self.sl
+        }
+    }
 
     fn advance(&mut self) -> bool {
-        self.sl = None;
-        false
+        if self.compact_size.is_some() {
+            self.compact_size = None;
+            true
+        } else {
+            self.sl = None;
+            false
+        }
     }
 }
 
@@ -155,3 +180,63 @@ impl<
     fn current_chunk(&self) -> Option<&[u8]> { self.inner.current_chunk() }
     fn advance(&mut self) -> bool { self.inner.advance() }
 }
+
+#[cfg(test)]
+#[cfg(feature = "alloc")]
+mod tests {
+    use alloc::vec::Vec;
+
+    use super::*;
+
+    // Run the encoder i.e., use it to encode into a vector.
+    fn run_encoder<'e>(mut encoder: impl Encoder<'e>) -> Vec<u8> {
+        let mut vec = Vec::new();
+        while let Some(chunk) = encoder.current_chunk() {
+            vec.extend_from_slice(chunk);
+            encoder.advance();
+        }
+        vec
+    }
+
+    #[test]
+    fn encode_byte_slice_without_prefix() {
+        let obj = [1u8, 2, 3];
+
+        let encoder = BytesEncoder::without_length_prefix(&obj);
+        let got = run_encoder(encoder);
+
+        assert_eq!(got, obj);
+    }
+
+    #[test]
+    fn encode_empty_byte_slice_without_prefix() {
+        let obj = [];
+
+        let encoder = BytesEncoder::without_length_prefix(&obj);
+        let got = run_encoder(encoder);
+
+        assert_eq!(got, obj);
+    }
+
+    #[test]
+    fn encode_byte_slice_with_prefix() {
+        let obj = [1u8, 2, 3];
+
+        let encoder = BytesEncoder::with_length_prefix(&obj);
+        let got = run_encoder(encoder);
+
+        let want = [3u8, 1, 2, 3];
+        assert_eq!(got, want);
+    }
+
+    #[test]
+    fn encode_empty_byte_slice_with_prefix() {
+        let obj = [];
+
+        let encoder = BytesEncoder::with_length_prefix(&obj);
+        let got = run_encoder(encoder);
+
+        let want = [0u8];
+        assert_eq!(got, want);
+    }
+}

consensus_encoding/src/encode/mod.rs

@@ -55,7 +55,7 @@ macro_rules! encoder_newtype{
         $(#[$($struct_attr)*])*
         pub struct $name$(<$lt>)?($encoder);
 
-        impl<'e $(, $lt)?> $crate::Encoder<'e> for $name$(<$lt>)? {
+        impl<'e> $crate::Encoder<'e> for $name$(<$lt>)? {
             #[inline]
             fn current_chunk(&self) -> Option<&[u8]> { self.0.current_chunk() }
 
@@ -69,7 +69,11 @@ macro_rules! encoder_newtype{
 ///
 /// Consumes and returns the hash engine to make it easier to call
 /// [`hashes::HashEngine::finalize`] directly on the result.
-pub fn encode_to_hash_engine<T: Encodable, H: hashes::HashEngine>(object: &T, mut engine: H) -> H {
+pub fn encode_to_hash_engine<T, H>(object: &T, mut engine: H) -> H
+where
+    T: Encodable + ?Sized,
+    H: hashes::HashEngine,
+{
     let mut encoder = object.encoder();
     while let Some(sl) = encoder.current_chunk() {
         engine.input(sl);
@@ -80,7 +84,10 @@ pub fn encode_to_hash_engine<T: Encodable, H: hashes::HashEngine>(object: &T, mu
 
 /// Encodes an object into a vector.
 #[cfg(feature = "alloc")]
-pub fn encode_to_vec<T: Encodable>(object: &T) -> Vec<u8> {
+pub fn encode_to_vec<T>(object: &T) -> Vec<u8>
+where
+    T: Encodable + ?Sized,
+{
     let mut encoder = object.encoder();
     let mut vec = Vec::new();
     while let Some(chunk) = encoder.current_chunk() {
@@ -103,10 +110,11 @@ pub fn encode_to_vec<T: Encodable>(object: &T) -> Vec<u8> {
 ///
 /// Returns any I/O error encountered while writing to the writer.
 #[cfg(feature = "std")]
-pub fn encode_to_writer<T: Encodable, W: std::io::Write>(
-    object: &T,
-    mut writer: W,
-) -> Result<(), std::io::Error> {
+pub fn encode_to_writer<T, W>(object: &T, mut writer: W) -> Result<(), std::io::Error>
+where
+    T: Encodable + ?Sized,
+    W: std::io::Write,
+{
     let mut encoder = object.encoder();
     while let Some(chunk) = encoder.current_chunk() {
         writer.write_all(chunk)?;

internals/src/compact_size.rs

@@ -18,7 +18,7 @@ use crate::ToU64;
 pub const MAX_ENCODABLE_VALUE: u64 = 0x0200_0000;
 
 /// The maximum length of an encoding.
-const MAX_ENCODING_SIZE: usize = 9;
+pub const MAX_ENCODING_SIZE: usize = 9;
 
 /// Returns the number of bytes used to encode this `CompactSize` value.
 ///

primitives/src/script/borrowed.rs

@@ -7,6 +7,7 @@ use core::ops::{
 
 #[cfg(feature = "arbitrary")]
 use arbitrary::{Arbitrary, Unstructured};
+use encoding::{BytesEncoder, Encodable};
 
 use super::ScriptBuf;
 use crate::prelude::{Box, ToOwned, Vec};
@@ -152,6 +153,22 @@ impl<T> Script<T> {
     pub fn to_hex(&self) -> alloc::string::String { alloc::format!("{:x}", self) }
 }
 
+encoding::encoder_newtype! {
+    /// The encoder for the [`Script<T>`] type.
+    pub struct ScriptEncoder<'e>(BytesEncoder<'e>);
+}
+
+impl<T> Encodable for Script<T> {
+    type Encoder<'a>
+        = ScriptEncoder<'a>
+    where
+        Self: 'a;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        ScriptEncoder(BytesEncoder::with_length_prefix(self.as_bytes()))
+    }
+}
+
 #[cfg(feature = "arbitrary")]
 impl<'a, T> Arbitrary<'a> for &'a Script<T> {
     #[inline]
@@ -248,4 +265,18 @@ mod tests {
         assert_eq!(script[1..=3].as_bytes(), &[2, 3, 4]);
         assert_eq!(script[..=2].as_bytes(), &[1, 2, 3]);
     }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn encode() {
+        // Consensus encoding includes the length of the encoded data
+        // (compact size encoded length prefix).
+        let consensus_encoded: [u8; 6] = [0x05, 1, 2, 3, 4, 5];
+
+        // `from_bytes` does not expect the prefix.
+        let script = Script::from_bytes(&consensus_encoded[1..]);
+
+        let got = encoding::encode_to_vec(script);
+        assert_eq!(got, consensus_encoded);
+    }
 }

primitives/src/script/mod.rs

@@ -26,7 +26,7 @@ use crate::prelude::{Borrow, BorrowMut, Box, Cow, ToOwned, Vec};
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
 pub use self::{
-    borrowed::Script,
+    borrowed::{Script, ScriptEncoder},
     owned::ScriptBuf,
     tag::{Tag, RedeemScriptTag, ScriptPubKeyTag, ScriptSigTag, TapScriptTag, WitnessScriptTag},
 };