implement Encode/Decode for TxInWitness

Author: apoelstra

src/lib.rs

@@ -99,9 +99,10 @@ pub use crate::transaction::{
     EcdsaSighashType, OutPoint, PeginData, PeginDataDecoder, PeginDataEncoder, PeginWitness,
     PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder, PegoutData, Sequence,
     SequenceDecoder, SequenceDecoderError, SequenceEncoder, Transaction, TxIn, TxInDecoder,
-    TxInDecoderError, TxInEncoder, TxInWitness, TxOut, TxOutDecoder, TxOutDecoderError,
-    TxOutEncoder, TxOutWitness, TxOutWitnessDecoder, TxOutWitnessDecoderError, TxOutWitnessEncoder,
-    Witness, WitnessDecoder, WitnessDecoderError, WitnessEncoder,
+    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

src/transaction/decoders.rs

@@ -10,10 +10,12 @@ use core::fmt;
 use super::{
     AssetIssuance, OutPoint, Script, Sequence, TxIn, TxInWitness, TxOut, TxOutWitness, Txid,
 };
+use crate::confidential::{RangeProofDecoder, RangeProofDecoderError};
 use crate::encoding::{
     ArrayDecoder, Decode, Decoder, Decoder2, Decoder2Error, Decoder3, Decoder4, Decoder4Error,
     DecoderStatus, UnexpectedEofError,
 };
+use crate::{PeginWitnessDecoder, PeginWitnessDecoderError, WitnessDecoder, WitnessDecoderError};
 
 /// Decoder for the [`OutPoint`] type.
 ///
@@ -223,6 +225,113 @@ impl std::error::Error for TxInDecoderError {
     }
 }
 
+/// 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 {
+    #[allow(dead_code)] // will be used in the Transaction Encode/Decode commit
+    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)]

src/transaction/encoders.rs

@@ -5,11 +5,13 @@
 //! 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, TxIn, TxOut, TxOutWitness};
+use super::{AssetIssuance, Sequence, TxIn, TxInWitness, TxOut, TxOutWitness};
+use crate::confidential::RangeProofEncoder;
 use crate::encoding::{
     encoder_newtype_exact, ArrayEncoder, ArrayRefEncoder, Encode, Encoder, Encoder2, Encoder4,
     EncoderStatus,
 };
+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
@@ -81,6 +83,73 @@ impl Encode for AssetIssuance {
     }
 }
 
+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> {
+    #[allow(dead_code)] // will be used in the Transaction Encode/Decode commit
+    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)]

src/transaction/mod.rs

@@ -39,8 +39,8 @@ use secp256k1_zkp::{
     Tweak, ZERO_TWEAK,
 };
 
-pub use self::decoders::{AssetIssuanceDecoder, AssetIssuanceDecoderError, SequenceDecoder, SequenceDecoderError, TxInDecoder, TxInDecoderError, TxOutDecoder, TxOutDecoderError, TxOutWitnessDecoder, TxOutWitnessDecoderError};
-pub use self::encoders::{AssetIssuanceEncoder, SequenceEncoder, TxInEncoder, TxOutEncoder, TxOutWitnessEncoder};
+pub use self::decoders::{AssetIssuanceDecoder, AssetIssuanceDecoderError, SequenceDecoder, SequenceDecoderError, TxInDecoder, TxInDecoderError, TxInWitnessDecoder, TxInWitnessDecoderError, TxOutDecoder, TxOutDecoderError, TxOutWitnessDecoder, TxOutWitnessDecoderError};
+pub use self::encoders::{AssetIssuanceEncoder, SequenceEncoder, TxInEncoder, TxInWitnessEncoder, TxOutEncoder, TxOutWitnessEncoder};
 pub use self::pegin_witness::{
     PeginData, PeginDataDecoder, PeginDataEncoder,
     PeginWitness, PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder};