implement Encode/Decode for TxOutWitness

Author: apoelstra

src/lib.rs

@@ -98,7 +98,8 @@ pub use crate::transaction::{
     AssetIssuance, EcdsaSighashType, OutPoint, PeginData, PeginDataDecoder, PeginDataEncoder,
     PeginWitness, PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder, PegoutData,
     Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutDecoder, TxOutDecoderError, TxOutEncoder,
-    TxOutWitness, Witness, WitnessDecoder, WitnessDecoderError, WitnessEncoder,
+    TxOutWitness, TxOutWitnessDecoder, TxOutWitnessDecoderError, TxOutWitnessEncoder, Witness,
+    WitnessDecoder, WitnessDecoderError, WitnessEncoder,
 };
 
 // Encode a compact size to a slice without allocating

src/transaction/decoders.rs

@@ -8,7 +8,86 @@
 use core::fmt;
 
 use super::{TxOut, TxOutWitness};
-use crate::encoding::{Decoder4, Decoder4Error};
+use crate::encoding::{
+    Decode, Decoder, Decoder2, Decoder2Error, Decoder4, Decoder4Error, DecoderStatus,
+};
+
+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 {
+    #[allow(dead_code)] // will be used in the Transaction Encode/Decode commit
+    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.

src/transaction/encoders.rs

@@ -5,8 +5,71 @@
 //! 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::TxOut;
-use crate::encoding::{encoder_newtype_exact, Encode, Encoder4};
+use super::{TxOut, TxOutWitness};
+use crate::encoding::{encoder_newtype_exact, Encode, Encoder, Encoder2, Encoder4, EncoderStatus};
+
+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> {
+    #[allow(dead_code)] // will be used in the Transaction Encode/Decode commit
+    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.

src/transaction/mod.rs

@@ -39,8 +39,8 @@ use secp256k1_zkp::{
     Tweak, ZERO_TWEAK,
 };
 
-pub use self::decoders::{TxOutDecoder, TxOutDecoderError};
-pub use self::encoders::TxOutEncoder;
+pub use self::decoders::{TxOutDecoder, TxOutDecoderError, TxOutWitnessDecoder, TxOutWitnessDecoderError};
+pub use self::encoders::{TxOutEncoder, TxOutWitnessEncoder};
 pub use self::pegin_witness::{
     PeginData, PeginDataDecoder, PeginDataEncoder,
     PeginWitness, PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder};