confidential: implement Encode and Decode for rangeproof/surjectionproof

Introduces the decoder_newtype! macro. As with the other macro, this one
was hand-written based on multiple examples of hand-written code, but I
let Claude write the doccomment (which I made some minor touchups to).

There is a similarly-named macro in rust-bitcoin `primitives` but this
is *not* that macro.

A later PR will elaborate this macro, but this is all we need for now.

Author: apoelstra

src/confidential/mod.rs

@@ -36,8 +36,14 @@ pub use self::asset::{
 pub use self::nonce::{
     Decoder as NonceDecoder, DecoderError as NonceDecoderError, Encoder as NonceEncoder, Nonce,
 };
-pub use self::range_proof::RangeProof;
-pub use self::surjection_proof::SurjectionProof;
+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,
@@ -88,6 +94,52 @@ impl encoding::ExactSizeEncoder for CommitmentEncoder<'_> {
     }
 }
 
+/// 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)]
 pub enum TweakHexDecodeError {
@@ -191,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 = [

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),
+        }
+    }
+}

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),
+        }
+    }
+}

src/internal_macros.rs

@@ -785,3 +785,158 @@ macro_rules! decoder_state_machine {
         }
     };
 }
+
+/// 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
+///
+/// ```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
+///         }
+///     }
+/// }
+/// ```
+///
+/// # 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
+///
+/// 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.
+///
+/// # 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>`
+/// - Is called automatically when the inner decoder completes
+/// - Can return custom errors defined in the error enum
+///
+/// # 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
+///
+/// ```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 {
+    (
+        $(#[$($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;
+        }
+    };
+}