implement Encode/Decode for TxIn

apoelstra · apoelstra · commit d72094a622c6 · 2026-07-17T13:47:05.000Z
diff --git a/src/lib.rs b/src/lib.rs
@@ -95,11 +95,13 @@ pub use crate::schnorr::{SchnorrSig, SchnorrSigError};
 pub use crate::script::Script;
 pub use crate::sighash::SchnorrSighashType;
 pub use crate::transaction::{
-    AssetIssuance, EcdsaSighashType, OutPoint, PeginData, PeginDataDecoder, PeginDataEncoder,
-    PeginWitness, PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder, PegoutData,
-    Sequence, Transaction, TxIn, TxInWitness, TxOut, TxOutDecoder, TxOutDecoderError, TxOutEncoder,
-    TxOutWitness, TxOutWitnessDecoder, TxOutWitnessDecoderError, TxOutWitnessEncoder, Witness,
-    WitnessDecoder, WitnessDecoderError, WitnessEncoder,
+    AssetIssuance, AssetIssuanceDecoder, AssetIssuanceDecoderError, AssetIssuanceEncoder,
+    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,
 };
 
 // Encode a compact size to a slice without allocating
diff --git a/src/transaction/decoders.rs b/src/transaction/decoders.rs
@@ -7,11 +7,222 @@
 
 use core::fmt;
 
-use super::{TxOut, TxOutWitness};
+use super::{
+    AssetIssuance, OutPoint, Script, Sequence, TxIn, TxInWitness, TxOut, TxOutWitness, Txid,
+};
 use crate::encoding::{
-    Decode, Decoder, Decoder2, Decoder2Error, Decoder4, Decoder4Error, DecoderStatus,
+    ArrayDecoder, Decode, Decoder, Decoder2, Decoder2Error, Decoder3, Decoder4, Decoder4Error,
+    DecoderStatus, UnexpectedEofError,
 };
 
+/// Decoder for the [`OutPoint`] type.
+///
+/// This is a non-public struct and we do not implement [`Decode`] for [`OutPoint`]
+/// because we can't actually encode/decode outpoints independently of the rest of
+/// a [`TxIn`]. This is because we mask bits into the vout of the outpoint.
+#[derive(Default)]
+struct OutPointDecoder {
+    inner: Decoder2<ArrayDecoder<32>, ArrayDecoder<4>>,
+}
+
+/// Decoder error for the [`OutPoint`] type.
+#[derive(Clone, PartialEq, Eq, Debug)]
+struct OutPointDecoderError(Decoder2Error<UnexpectedEofError, UnexpectedEofError>);
+
+impl fmt::Display for OutPointDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("error decoding outpoint")
+    }
+}
+
+impl std::error::Error for OutPointDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { Some(&self.0) }
+}
+
+impl Decoder for OutPointDecoder {
+    type Output = OutPoint;
+    type Error = OutPointDecoderError;
+
+    fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<DecoderStatus, Self::Error> {
+        self.inner.push_bytes(bytes).map_err(OutPointDecoderError)
+    }
+
+    fn end(self) -> Result<Self::Output, Self::Error> {
+        let (txid, vout) = self.inner.end().map_err(OutPointDecoderError)?;
+        Ok(OutPoint { txid: Txid::from_byte_array(txid), vout: u32::from_le_bytes(vout) })
+    }
+
+    fn read_limit(&self) -> usize { self.inner.read_limit() }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`Sequence`] type.
+    #[derive(Default)]
+    pub struct SequenceDecoder(ArrayDecoder<4>);
+
+    /// Decoder error for the [`Sequence`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct SequenceDecoderError(UnexpectedEofError);
+    const ERROR_DISPLAY = "error decoding sequence";
+
+    impl Decode for Sequence {
+        fn convert_inner(bytes) -> Result<_, UnexpectedEofError> {
+            Ok(Sequence::from_consensus(u32::from_le_bytes(bytes)))
+        }
+    }
+}
+
+decoder_newtype! {
+    /// Decoder for the [`AssetIssuance`] type.
+    #[derive(Default)]
+    pub struct AssetIssuanceDecoder(Decoder4<
+        ArrayDecoder<32>,
+        ArrayDecoder<32>,
+        crate::confidential::ValueDecoder,
+        crate::confidential::ValueDecoder,
+    >);
+    /// Decoder error for the [`AssetIssuance`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct AssetIssuanceDecoderError(enum AssetIssuanceDecoderErrorInner {
+        Decode(Decoder4Error<
+            UnexpectedEofError,
+            UnexpectedEofError,
+            crate::confidential::ValueDecoderError,
+            crate::confidential::ValueDecoderError,
+        >),
+        InvalidTweak(secp256k1_zkp::Error),
+    });
+
+    impl Decode for AssetIssuance {
+        fn convert_inner(output) -> Result<_, AssetIssuanceDecoderError> {
+            let (asset_blinding_nonce, asset_entropy, amount, inflation_keys) = output;
+            Ok(AssetIssuance {
+                asset_blinding_nonce: secp256k1_zkp::Tweak::from_inner(asset_blinding_nonce)
+                    .map_err(AssetIssuanceDecoderErrorInner::InvalidTweak)
+                    .map_err(AssetIssuanceDecoderError)?,
+                asset_entropy,
+                amount,
+                inflation_keys,
+            })
+        }
+    }
+}
+
+impl fmt::Display for AssetIssuanceDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use AssetIssuanceDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(_) => f.write_str("error decoding asset issuance"),
+            Inner::InvalidTweak(_) => f.write_str("asset issuance had out-of-range blinding nonce"),
+        }
+    }
+}
+
+impl std::error::Error for AssetIssuanceDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use AssetIssuanceDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Decode(ref e) => Some(e),
+            Inner::InvalidTweak(ref e) => Some(e),
+        }
+    }
+}
+
+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 {
+        Done(TxIn),
+        Errored,
+        Initial {
+            decoder: Decoder3<
+                OutPointDecoder,
+                crate::script::ScriptDecoder,
+                SequenceDecoder,
+            >,
+            => transition_initial(output, ...) -> Result {
+                let (mut outpoint, script_sig, sequence) = output;
+                if vout_has_issuance(outpoint.vout) {
+                    Ok(TxInDecoderInner::AssetIssuance {
+                        decoder: AssetIssuanceDecoder::default(),
+                        outpoint, script_sig, sequence,
+                    })
+                } else {
+                    let orig_vout = outpoint.vout;
+                    outpoint.vout &= !((1 << 30) | (1 << 31));
+                    Ok(TxInDecoderInner::Done(TxIn {
+                        previous_output: outpoint,
+                        is_pegin: vout_is_pegin(orig_vout),
+                        script_sig,
+                        sequence,
+                        asset_issuance: AssetIssuance::null(),
+                        witness: TxInWitness::default(),
+                    }))
+                }
+            }
+        },
+        AssetIssuance {
+            decoder: AssetIssuanceDecoder,
+            outpoint: OutPoint,
+            script_sig: Script,
+            sequence: Sequence
+            => 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),
+                    script_sig,
+                    sequence,
+                    asset_issuance,
+                    witness: TxInWitness::default(),
+                }))
+            }
+        },
+    });
+
+    /// Decoder error for the [`TxIn`] type.
+    #[derive(Clone, PartialEq, Eq, Debug)]
+    pub struct TxInDecoderError(enum TxInDecoderErrorInner {
+        [macro-inserted decoder variants]
+        SuperfluousIssuance,
+    });
+}
+
+impl Default for TxInDecoder {
+    fn default() -> Self { Self(TxInDecoderInner::Initial { decoder: Decoder3::default() }) }
+}
+
+impl fmt::Display for TxInDecoderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use TxInDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Initial(..) => f.write_str("error decoding outpoint, scriptsig or sequence"),
+            Inner::AssetIssuance(..) => f.write_str("error decoding asset issuance"),
+            Inner::SuperfluousIssuance =>
+                f.write_str("input had issuance flag set, but null issuance"),
+        }
+    }
+}
+
+impl std::error::Error for TxInDecoderError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        use TxInDecoderErrorInner as Inner;
+        match self.0 {
+            Inner::Initial(ref e) => Some(e),
+            Inner::AssetIssuance(ref e) => Some(e),
+            Inner::SuperfluousIssuance => None,
+        }
+    }
+}
+
 decoder_newtype! {
     /// Decoder for the [`TxOutWitness`] type.
     #[derive(Default)]
diff --git a/src/transaction/encoders.rs b/src/transaction/encoders.rs
@@ -5,8 +5,105 @@
 //! 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, TxOutWitness};
-use crate::encoding::{encoder_newtype_exact, Encode, Encoder, Encoder2, Encoder4, EncoderStatus};
+use super::{AssetIssuance, Sequence, TxIn, TxOut, TxOutWitness};
+use crate::encoding::{
+    encoder_newtype_exact, ArrayEncoder, ArrayRefEncoder, Encode, Encoder, Encoder2, Encoder4,
+    EncoderStatus,
+};
+
+// 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
+// the txin. We just use it as a private building block.
+
+encoder_newtype_exact! {
+    /// Encoder for the [`OutPoint`] type.
+    #[derive(Clone, Debug)]
+    struct OutPointEncoder<'e>(Encoder2<
+        ArrayRefEncoder<'e, 32>,
+        ArrayEncoder<4>,
+    >);
+}
+
+impl<'e> OutPointEncoder<'e> {
+    fn from_txin(txin: &'e TxIn) -> Self {
+        let mut vout = txin.previous_output.vout;
+        if txin.is_pegin {
+            vout |= 1 << 30;
+        }
+        if txin.has_issuance() {
+            vout |= 1 << 31;
+        }
+
+        Self::new(Encoder2::new(
+            ArrayRefEncoder::without_length_prefix(txin.previous_output.txid.as_byte_array()),
+            ArrayEncoder::without_length_prefix(vout.to_le_bytes()),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`Sequence`] type.
+    #[derive(Clone, Debug)]
+    pub struct SequenceEncoder<'e>(ArrayEncoder<4>);
+}
+
+impl Encode for Sequence {
+    type Encoder<'e> = SequenceEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        SequenceEncoder::new(ArrayEncoder::without_length_prefix(
+            self.to_consensus_u32().to_le_bytes(),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`AssetIssuance`] type.
+    #[derive(Clone, Debug)]
+    pub struct AssetIssuanceEncoder<'e>(Encoder4<
+        ArrayRefEncoder<'e, 32>,
+        ArrayRefEncoder<'e, 32>,
+        crate::confidential::ValueEncoder<'e>,
+        crate::confidential::ValueEncoder<'e>,
+    >);
+}
+
+impl Encode for AssetIssuance {
+    type Encoder<'e> = AssetIssuanceEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        AssetIssuanceEncoder::new(Encoder4::new(
+            ArrayRefEncoder::without_length_prefix(self.asset_blinding_nonce.as_ref()),
+            ArrayRefEncoder::without_length_prefix(&self.asset_entropy),
+            self.amount.encoder(),
+            self.inflation_keys.encoder(),
+        ))
+    }
+}
+
+encoder_newtype_exact! {
+    /// Encoder for the [`TxIn`] type.
+    #[derive(Clone, Debug)]
+    pub struct TxInEncoder<'e>(Encoder4<
+        OutPointEncoder<'e>,
+        crate::script::ScriptEncoder<'e>,
+        SequenceEncoder<'e>,
+        Option<AssetIssuanceEncoder<'e>>,
+    >);
+}
+
+impl Encode for TxIn {
+    type Encoder<'e> = TxInEncoder<'e>;
+
+    fn encoder(&self) -> Self::Encoder<'_> {
+        TxInEncoder::new(Encoder4::new(
+            OutPointEncoder::from_txin(self),
+            self.script_sig.encoder(),
+            self.sequence.encoder(),
+            self.has_issuance().then(|| self.asset_issuance.encoder()),
+        ))
+    }
+}
 
 encoder_newtype_exact! {
     /// Encoder for the [`TxOutWitness`] type.
diff --git a/src/transaction/mod.rs b/src/transaction/mod.rs
@@ -39,8 +39,8 @@ use secp256k1_zkp::{
     Tweak, ZERO_TWEAK,
 };
 
-pub use self::decoders::{TxOutDecoder, TxOutDecoderError, TxOutWitnessDecoder, TxOutWitnessDecoderError};
-pub use self::encoders::{TxOutEncoder, TxOutWitnessEncoder};
+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::pegin_witness::{
     PeginData, PeginDataDecoder, PeginDataEncoder,
     PeginWitness, PeginWitnessDecoder, PeginWitnessDecoderError, PeginWitnessEncoder};
@@ -367,7 +367,6 @@ impl std::error::Error for RelativeLockTimeError {
     }
 }
 
-
 /// Transaction input witness
 #[derive(Clone, PartialEq, Eq, Debug, Hash, PartialOrd, Ord)]
 pub struct TxInWitness {
