implement Encode/Decode for Transaction

Author: apoelstra

src/lib.rs

@@ -98,11 +98,12 @@ pub use crate::transaction::{
     AssetIssuance, AssetIssuanceDecoder, AssetIssuanceDecoderError, AssetIssuanceEncoder,
     EcdsaSighashType, OutPoint, PeginData, PeginDataDecoder, PeginDataEncoder, PeginWitness,
     PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder, PegoutData, Sequence,
-    SequenceDecoder, SequenceDecoderError, SequenceEncoder, Transaction, TxIn, TxInDecoder,
-    TxInDecoderError, TxInEncoder, TxInWitness, TxInWitnessDecoder, TxInWitnessDecoderError,
-    TxInWitnessEncoder, TxOut, TxOutDecoder, TxOutDecoderError, TxOutEncoder, TxOutWitness,
-    TxOutWitnessDecoder, TxOutWitnessDecoderError, TxOutWitnessEncoder, Witness, WitnessDecoder,
-    WitnessDecoderError, WitnessEncoder,
+    SequenceDecoder, SequenceDecoderError, SequenceEncoder, Transaction, TransactionDecoder,
+    TransactionDecoderError, TransactionEncoder, TxIn, TxInDecoder, 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/locktime.rs

@@ -22,6 +22,7 @@ use std::cmp::{PartialOrd, Ordering};
 use std::convert::TryFrom;
 use std::str::FromStr;
 use std::io::{Read, Write};
+use crate::encoding;
 use crate::error::ParseIntError;
 use crate::parse;
 
@@ -274,6 +275,36 @@ impl fmt::Display for LockTime {
     }
 }
 
+encoding::encoder_newtype_exact! {
+    /// Encoder for the [`LockTime`] type.
+    pub struct LockTimeEncoder<'e>(encoding::ArrayEncoder<4>);
+}
+
+impl encoding::Encode for LockTime {
+    type Encoder<'e> = LockTimeEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        LockTimeEncoder::new(encoding::ArrayEncoder::without_length_prefix(self.to_consensus_u32().to_le_bytes()))
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`LockTime`] type.
+    #[derive(Default)]
+    pub struct LockTimeDecoder(encoding::ArrayDecoder<4>);
+
+    /// Decoder error for the [`LockTime`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct LockTimeDecoderError(encoding::UnexpectedEofError);
+    const ERROR_DISPLAY = "failed to decode locktime";
+
+    impl Decode for LockTime {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(LockTime::from_consensus(u32::from_le_bytes(bytes)))
+        }
+    }
+}
+
 impl Encodable for LockTime {
     #[inline]
     fn consensus_encode<W: Write>(&self, w: W) -> Result<usize, encode::Error> {

src/transaction/decoders.rs

@@ -8,13 +8,15 @@
 use core::fmt;
 
 use super::{
-    AssetIssuance, OutPoint, Script, Sequence, TxIn, TxInWitness, TxOut, TxOutWitness, Txid,
+    AssetIssuance, OutPoint, Script, Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutWitness,
+    Txid,
 };
 use crate::confidential::{RangeProofDecoder, RangeProofDecoderError};
 use crate::encoding::{
     ArrayDecoder, Decode, Decoder, Decoder2, Decoder2Error, Decoder3, Decoder4, Decoder4Error,
-    DecoderStatus, UnexpectedEofError,
+    DecoderStatus, UnexpectedEofError, VecDecoder,
 };
+use crate::locktime::{LockTime, LockTimeDecoder};
 use crate::{PeginWitnessDecoder, PeginWitnessDecoderError, WitnessDecoder, WitnessDecoderError};
 
 /// Decoder for the [`OutPoint`] type.
@@ -130,9 +132,6 @@ impl std::error::Error for AssetIssuanceDecoderError {
     }
 }
 
-fn vout_is_pegin(vout: u32) -> bool { vout != 0xffff_ffff && vout & (1 << 30) != 0 }
-fn vout_has_issuance(vout: u32) -> bool { vout != 0xffff_ffff && vout & (1 << 31) != 0 }
-
 decoder_state_machine! {
     /// Decoder for the [`TxIn`] type.
     pub struct TxInDecoder(enum TxInDecoderInner {
@@ -146,17 +145,25 @@ decoder_state_machine! {
             >,
             => transition_initial(output, ...) -> Result {
                 let (mut outpoint, script_sig, sequence) = output;
-                if vout_has_issuance(outpoint.vout) {
+                let (is_pegin, has_issuance) = if outpoint.vout == 0xffff_ffff {
+                    (false, false)
+                } else {
+                    let vout = outpoint.vout;
+                    outpoint.vout &= !((1 << 30) | (1 << 31));
+                    (vout & (1 << 30) != 0, vout & (1 << 31) != 0)
+                };
+                if has_issuance {
                     Ok(TxInDecoderInner::AssetIssuance {
                         decoder: AssetIssuanceDecoder::default(),
-                        outpoint, script_sig, sequence,
+                        outpoint, script_sig, sequence, is_pegin,
                     })
                 } else {
-                    let orig_vout = outpoint.vout;
-                    outpoint.vout &= !((1 << 30) | (1 << 31));
+                    if outpoint.vout != 0xffff_ffff {
+                        outpoint.vout &= !((1 << 30) | (1 << 31));
+                    }
                     Ok(TxInDecoderInner::Done(TxIn {
                         previous_output: outpoint,
-                        is_pegin: vout_is_pegin(orig_vout),
+                        is_pegin,
                         script_sig,
                         sequence,
                         asset_issuance: AssetIssuance::null(),
@@ -169,18 +176,16 @@ decoder_state_machine! {
             decoder: AssetIssuanceDecoder,
             outpoint: OutPoint,
             script_sig: Script,
-            sequence: Sequence
+            sequence: Sequence,
+            is_pegin: bool
             => transition_asset_issuance(asset_issuance, ...) -> Result {
                 if asset_issuance.is_null() {
                     return Err(TxInDecoderErrorInner::SuperfluousIssuance);
                 }
 
-                let orig_vout = outpoint.vout;
-                let mut outpoint = outpoint;
-                outpoint.vout &= !((1 << 30) | (1 << 31));
                 Ok(TxInDecoderInner::Done(TxIn {
                     previous_output: outpoint,
-                    is_pegin: vout_is_pegin(orig_vout),
+                    is_pegin,
                     script_sig,
                     sequence,
                     asset_issuance,
@@ -292,7 +297,6 @@ struct TxInWitnessesDecoder {
 }
 
 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 } }
 }
 
@@ -369,7 +373,6 @@ struct TxOutWitnessesDecoder {
 }
 
 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 } }
 }
 
@@ -437,3 +440,107 @@ decoder_newtype! {
         }
     }
 }
+
+decoder_state_machine! {
+    /// Decoder for the [`Transaction`] type.
+    pub struct TransactionDecoder(enum TransactionDecoderInner {
+        Done(Transaction),
+        Errored,
+        DecodingNonWitness {
+            decoder: Decoder4<
+                ArrayDecoder<4>,
+                ArrayDecoder<1>,
+                Decoder2<
+                    VecDecoder<TxIn>,
+                    VecDecoder<TxOut>,
+                >,
+                LockTimeDecoder,
+            >,
+            => transition_non_witness(output, ...) -> Result {
+                let (version, wit_flag, (input, output), lock_time) = output;
+                match wit_flag {
+                    [0] => Ok(TransactionDecoderInner::Done(Transaction {
+                        version: u32::from_le_bytes(version),
+                        lock_time,
+                        input,
+                        output,
+                    })),
+                    [1] => Ok(TransactionDecoderInner::DecodingWitnesses {
+                        decoder: Decoder2::new(
+                            TxInWitnessesDecoder::new(input),
+                            TxOutWitnessesDecoder::new(output),
+                        ),
+                        version: u32::from_le_bytes(version),
+                        lock_time,
+                    }),
+                    [x] => Err(TransactionDecoderErrorInner::InvalidWitnessFlag(x)),
+                }
+            }
+        },
+        DecodingWitnesses {
+            decoder: Decoder2<
+                TxInWitnessesDecoder,
+                TxOutWitnessesDecoder,
+            >,
+            version: u32,
+            lock_time: LockTime
+            => transition_witnesses(output, ...) -> Result {
+                let (input, output) = output;
+                if input.iter().all(|input| input.witness.is_empty()) &&
+                    output.iter().all(|output| output.witness.is_empty()) {
+                    Err(TransactionDecoderErrorInner::NoWitnesses)
+                } else {
+                    Ok(TransactionDecoderInner::Done(Transaction {
+                        version,
+                        lock_time,
+                        input,
+                        output,
+                    }))
+                }
+            }
+        },
+    });
+
+    /// Decoder error for the [`Transaction`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TransactionDecoderError(enum TransactionDecoderErrorInner {
+        [macro-inserted decoder variants]
+        InvalidWitnessFlag(u8),
+        NoWitnesses,
+    });
+}
+
+impl Default for TransactionDecoder {
+    fn default() -> Self {
+        Self(TransactionDecoderInner::DecodingNonWitness { decoder: Decoder4::default() })
+    }
+}
+
+impl fmt::Display for TransactionDecoderError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use TransactionDecoderErrorInner as Inner;
+
+        match self.0 {
+            Inner::DecodingNonWitness(..) =>
+                f.write_str("failed to decode non-witness part of transaction"),
+            Inner::DecodingWitnesses(..) => f.write_str("failed to decode transaction witnesses"),
+            Inner::InvalidWitnessFlag(flag) => {
+                write!(f, "invalid witness flag {flag} (must be 0 or 1)")
+            }
+            Inner::NoWitnesses => f.write_str("witness flag set but all witnesses were empty"),
+        }
+    }
+}
+
+impl std::error::Error for TransactionDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TransactionDecoderErrorInner as Inner;
+
+        match self.0 {
+            Inner::DecodingNonWitness(ref e) => Some(e),
+            Inner::DecodingWitnesses(ref e) => Some(e),
+            Inner::InvalidWitnessFlag(_) => None,
+            Inner::NoWitnesses => None,
+        }
+    }
+}

src/transaction/encoders.rs

@@ -5,12 +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, TxInWitness, TxOut, TxOutWitness};
+use super::{AssetIssuance, Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutWitness};
 use crate::confidential::RangeProofEncoder;
 use crate::encoding::{
-    encoder_newtype_exact, ArrayEncoder, ArrayRefEncoder, Encode, Encoder, Encoder2, Encoder4,
-    EncoderStatus,
+    encoder_newtype, encoder_newtype_exact, ArrayEncoder, ArrayRefEncoder, Encode, Encoder,
+    Encoder2, Encoder4, Encoder6, EncoderStatus, PrefixedSliceEncoder,
 };
+use crate::locktime::LockTimeEncoder;
 use crate::{PeginWitnessEncoder, WitnessEncoder};
 
 // While we define an [`OutPointEncoder`] struct, we don't actually implement `Encode` or `Decode`
@@ -115,7 +116,6 @@ struct TxInWitnessesEncoder<'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()) }
     }
@@ -202,7 +202,6 @@ struct TxOutWitnessesEncoder<'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()) }
     }
@@ -260,3 +259,39 @@ impl Encode for TxOut {
         ))
     }
 }
+
+encoder_newtype! {
+    /// Encoder for the [`Transaction`] type.
+    pub struct TransactionEncoder<'e>(Encoder6<
+        ArrayEncoder<4>,
+        ArrayEncoder<1>,
+        PrefixedSliceEncoder<'e, TxIn>,
+        PrefixedSliceEncoder<'e, TxOut>,
+        LockTimeEncoder<'e>,
+        Option<Encoder2<
+            TxInWitnessesEncoder<'e>,
+            TxOutWitnessesEncoder<'e>,
+        >>
+    >);
+}
+
+impl Encode for Transaction {
+    type Encoder<'e> = TransactionEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        let witness_flag = self.has_witness();
+        TransactionEncoder::new(Encoder6::new(
+            ArrayEncoder::without_length_prefix(self.version.to_le_bytes()),
+            ArrayEncoder::without_length_prefix([u8::from(witness_flag)]),
+            PrefixedSliceEncoder::new(&self.input),
+            PrefixedSliceEncoder::new(&self.output),
+            self.lock_time.encoder(),
+            witness_flag.then(|| {
+                Encoder2::new(
+                    TxInWitnessesEncoder::new(&self.input),
+                    TxOutWitnessesEncoder::new(&self.output),
+                )
+            }),
+        ))
+    }
+}

src/transaction/mod.rs

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