Struct Tx

pub struct Tx {
    pub version: TxVer,
    pub inputs: Confined<Vec<TxIn>, 0, bc::::coding::VarIntArray::{constant#1}>,
    pub outputs: Confined<Vec<TxOut>, 0, bc::::coding::VarIntArray::{constant#1}>,
    pub lock_time: LockTime,
}

Fields

version: TxVer

inputs: Confined<Vec<TxIn>, 0, bc::::coding::VarIntArray::{constant#1}>

outputs: Confined<Vec<TxOut>, 0, bc::::coding::VarIntArray::{constant#1}>

lock_time: LockTime

Implementations

impl Tx

pub fn inputs(&self) -> Iter<'_, TxIn>

pub fn outputs(&self) -> Iter<'_, TxOut>

pub fn is_segwit(&self) -> bool

pub fn to_unsigned_tx(&self) -> Tx

pub fn ntxid(&self) -> [u8; 32]

Computes a “normalized TXID” which does not include any signatures.

This gives a way to identify a transaction that is “the same” as another in the sense of having same inputs and outputs.

pub fn txid(&self) -> Txid

Computes the Txid.

Hashes the transaction excluding the segwit data (i.e. the marker, flag bytes, and the witness fields themselves). For non-segwit transactions which do not have any segwit data, this will be equal to Tx::wtxid().

pub fn wtxid(&self) -> Wtxid

Computes the segwit version of the transaction id.

Hashes the transaction including all segwit data (i.e. the marker, flag bytes, and the witness fields themselves). For non-segwit transactions which do not have any segwit data, this will be equal to [Transaction::txid()].

Trait Implementations

impl Clone for Tx

fn clone(&self) -> Tx

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConsensusDecode for Tx

fn consensus_decode(reader: &mut impl Read) -> Result<Tx, ConsensusDecodeError>

fn consensus_deserialize( bytes: impl AsRef<[u8]>, ) -> Result<Self, ConsensusDecodeError>

impl ConsensusEncode for Tx

fn consensus_encode(&self, writer: &mut impl Write) -> Result<usize, IoError>

fn consensus_serialize(&self) -> Vec<u8>

impl ConvolveCommit<Commitment, TapretProof, TapretFirst> for Tx

type Commitment = Tx

Commitment type produced as a result of Self::convolve_commit procedure.

type CommitError = TapretError

Error type that may be reported during Self::convolve_commit procedure. It may also be returned from ConvolveCommitProof::verify in case the proof data are invalid and the commitment can’t be re-created.

fn convolve_commit( &self, supplement: &TapretProof, msg: &Commitment, ) -> Result<(Tx, TapretProof), <Tx as ConvolveCommit<Commitment, TapretProof, TapretFirst>>::CommitError>

Takes the supplement to unparse the content of this container (self) (“convolves” these two data together) and uses them to produce a final Self::Commitment to the message msg.

impl Debug for Tx

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tx

fn deserialize<__D>( __deserializer: __D, ) -> Result<Tx, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Tx

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl EmbedCommitVerify<Commitment, OpretFirst> for Tx

type Proof = OpretProof

The proof of the commitment produced as a result of Self::embed_commit procedure. This proof is later used for verification.

type CommitError = OpretError

Error type that may be reported during Self::embed_commit procedure. It may also be returned from Self::verify (wrapped into EmbedVerifyError in case the proof data are invalid and the commitment can’t be re-created.

fn embed_commit( &mut self, msg: &Commitment, ) -> Result<<Tx as EmbedCommitVerify<Commitment, OpretFirst>>::Proof, <Tx as EmbedCommitVerify<Commitment, OpretFirst>>::CommitError>

Creates a commitment to a message and embeds it into the provided container (self) by mutating it and returning commitment proof.

fn verify( &self, msg: &Msg, proof: &Self::Proof, ) -> Result<(), EmbedVerifyError<Self::CommitError>>

where Self: VerifyEq, Self::Proof: VerifyEq,

Verifies commitment with commitment proof against the message.

impl FromStr for Tx

type Err = BlockDataParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Tx, <Tx as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Tx

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for Tx

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Tx

fn eq(&self, other: &Tx) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D> PublishedWitness<TxoSeal<D>> for Tx

where D: Proof,

type PubId = Txid

Publication id that may be used for referencing publication of witness data in the medium. By default, set (), so SingleUseSeal may not implement publication id and related functions.

type Error = <D as Proof>::Error

fn pub_id(&self) -> Txid

fn verify_commitment( &self, proof: Proof<D>, ) -> Result<(), <Tx as PublishedWitness<TxoSeal<D>>>::Error>

impl Serialize for Tx

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StrictDecode for Tx

fn strict_decode(reader: &mut impl TypedRead) -> Result<Tx, DecodeError>

fn strict_read(reader: impl ReadRaw) -> Result<Self, DecodeError>

impl StrictDumb for Tx

fn strict_dumb() -> Tx

impl StrictEncode for Tx

fn strict_encode<W>(&self, writer: W) -> Result<W, Error>

where W: TypedWrite,

fn strict_write(&self, writer: impl WriteRaw) -> Result<(), Error>

impl StrictStruct for Tx

const ALL_FIELDS: &'static [&'static str]

fn strict_check_fields()

fn strict_type_info() -> TypeInfo<Self>

impl StrictType for Tx

const STRICT_LIB_NAME: &'static str = LIB_NAME_BITCOIN

fn strict_name() -> Option<TypeName>

impl Weight for Tx

fn weight_units(&self) -> WeightUnits

fn vbytes(&self) -> VBytes

impl Eq for Tx

impl StrictProduct for Tx

impl StructuralPartialEq for Tx