Struct bitcoins::types::witness::WitnessTx

pub struct WitnessTx { /* fields omitted */ }

A witness transaction. Any transaction that contains 1 or more witnesses.

Implementations

impl WitnessTx

pub fn from_legacy(legacy_tx: LegacyTx) -> Self

Consumes a LegacyTx and instantiates a new WitnessTx with empty witnesses

Trait Implementations

impl BitcoinTransaction for WitnessTx

fn as_legacy(&self) -> &LegacyTx

Returns a reference to the tx as a legacy tx.

fn into_witness(self) -> WitnessTx

Consume the tx and convert it to a legacy tx. Useful for when you have dyn BitcoinTransaction or impl BitcoinTransaction types.

fn into_legacy(self) -> LegacyTx

Consume the tx and convert it to a legacy tx. Useful for when you have dyn BitcoinTransaction or impl BitcoinTransaction types, but into_witness should be preferred, as it will never drop information.

fn witnesses(&self) -> &[Witness]

Return a reference to a slice of witnesses. For legacy txins this will ALWAYS be length 0. For witness txns, this will ALWAYS be the same length as the input vector.

fn txout_from_outpoint(&self, outpoint: &BitcoinOutpoint) -> Option<&TxOut>

Get a reference to the output by

impl ByteFormat for WitnessTx

type Error = TxError

An associated error type

fn serialized_length(&self) -> usize

Returns the byte-length of the serialized data structure.

fn read_from<R>(reader: &mut R) -> Result<Self, Self::Error> where
    R: Read,
    Self: Sized, 

Deserializes an instance of Self from a std::io::Read. The limit argument is used only when deserializing collections, and specifies a maximum number of instances of the underlying type to read.

fn write_to<W>(&self, writer: &mut W) -> Result<usize, Self::Error> where
    W: Write, 

Serializes self to a std::io::Write. Following Write trait conventions, its Ok type must be a usize denoting the number of bytes written.

fn read_seq_from<R>(
    reader: &mut R,
    mode: ReadSeqMode
) -> Result<Vec<Self, Global>, Self::Error> where
    R: Read, 

Read a sequence of exactly limit objects from the reader.

fn write_seq_to<'a, W, E, Iter, Item>(
    writer: &mut W,
    iter: Iter
) -> Result<usize, Self::Error> where
    W: Write,
    E: Into<Self::Error> + From<SerError> + From<Error> + Error,
    Item: 'a + ByteFormat<Error = E>,
    Iter: IntoIterator<Item = &'a Item>, 

Write a sequence of ByteFormat objects to a writer. The iter argument may be any object that implements IntoIterator<Item = &Item>. This means we can seamlessly use vectors, slices, etc.

fn deserialize_hex(s: &str) -> Result<Self, Self::Error>

Decodes a hex string to a Vec<u8>, deserializes an instance of Self from that vector.

fn deserialize_base64(s: &str) -> Result<Self, Self::Error>

Serialize self to a base64 string, using standard RFC4648 non-url safe characters

fn serialize_hex(&self) -> String

Serializes self to a vector, returns the hex-encoded vector

fn serialize_base64(&self) -> String

Serialize self to a base64 string, using standard RFC4648 non-url safe characters

impl Clone for WitnessTx

fn clone(&self) -> WitnessTx

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WitnessTx

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

Formats the value using the given formatter.

impl Default for WitnessTx

fn default() -> WitnessTx

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for WitnessTx

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

Deserialize this value from the given Serde deserializer.

impl From<WitnessTx> for BitcoinTx

fn from(w: WitnessTx) -> Self

Performs the conversion.

impl PartialEq<WitnessTx> for WitnessTx

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Serialize for WitnessTx

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

Serialize this value into the given Serde serializer.

impl Transaction for WitnessTx

type TxError = TxError

An associated error type, used in Results returned by the Transaction.

type TxIn = BitcoinTxIn

The Input type for the transaction

type TxOut = TxOut

The Output type for the transaction

type SighashArgs = WitnessSighashArgs

A type describing arguments for the sighash function for this transaction.

type TXID = TXID

A marked hash (see crate::hashes::marked) to be used as the transaction ID type.

type HashWriter = Hash256

A type that implements HashWriter. Used to generate the TXID and Sighash.

fn new<I, O>(
    version: u32,
    vin: I,
    vout: O,
    locktime: u32
) -> Result<Self, Self::TxError> where
    I: Into<Vec<Self::TxIn>>,
    O: Into<Vec<Self::TxOut>>,
    Self: Sized, 

Instantiate a new Transaction by specifying inputs and outputs.

fn inputs(&self) -> &[Self::TxIn]

Returns a reference to the transaction input vector

fn outputs(&self) -> &[Self::TxOut]

Returns a reference the the transaction output vector

fn version(&self) -> u32

Returns the transaction version number

fn locktime(&self) -> u32

Returns the transaction’s nLocktime field

fn txid(&self) -> Self::TXID

Calculates and returns the transaction’s ID. The default TXID is simply the digest of the serialized transaction.

fn write_sighash_preimage<W: Write>(
    &self,
    writer: &mut W,
    args: &Self::SighashArgs
) -> TxResult<()>

Generate the digest that must be signed to authorize inputs. For Bitcoin transactions this is a function of the transaction, and the input’s prevout.

fn sighash(
    &self,
    args: &Self::SighashArgs
) -> Result<GenericArray<u8, <Self::HashWriter as Digest>::OutputSize>, Self::TxError>

Calls write_sighash_preimage with the provided arguments and a new HashWriter. Returns the sighash digest which should be signed.

impl WitnessTransaction for WitnessTx

fn new<I, O, W>(
    version: u32,
    vin: I,
    vout: O,
    witnesses: W,
    locktime: u32
) -> Result<Self, Self::TxError> where
    I: Into<Vec<Self::TxIn>>,
    O: Into<Vec<Self::TxOut>>,
    W: Into<Vec<Self::Witness>>,
    Self: Sized, 

Create a new WitnessTx. Since witnesses correspond to inputs, ensure that there are the same number of witnesses as inputs. The number of witnesses will be trimmed if there are too many and will be filled with empty witnesses if too few.

type WTXID = WTXID

The MarkedDigest type for the Transaction’s Witness TXID

type WitnessSighashArgs = WitnessSighashArgs

The BIP143 sighash args needed to sign an input

type Witness = Witness

A type that represents this transactions per-input Witness.

fn wtxid(&self) -> Self::WTXID

Calculates the witness txid of the transaction.

fn write_legacy_sighash_preimage<W: Write>(
    &self,
    writer: &mut W,
    args: &LegacySighashArgs
) -> Result<(), Self::TxError>

Writes the Legacy sighash preimage to the provider writer.

fn write_witness_sighash_preimage<W>(
    &self,
    writer: &mut W,
    args: &WitnessSighashArgs
) -> TxResult<()> where
    W: Write, 

Writes the BIP143 sighash preimage to the provided writer. See the WitnessSighashArgsSigh documentation for more in-depth discussion of sighash.

fn legacy_sighash(
    &self,
    args: &LegacySighashArgs
) -> Result<DigestOutput<Self::HashWriter>, Self::TxError>

Calculates the Legacy sighash preimage given the sighash args.

fn witness_sighash(
    &self,
    args: &Self::WitnessSighashArgs
) -> Result<DigestOutput<Self::HashWriter>, Self::TxError>

Calculates the BIP143 sighash given the sighash args. See the WitnessSighashArgsSigh documentation for more in-depth discussion of sighash.

impl Eq for WitnessTx

impl StructuralEq for WitnessTx

impl StructuralPartialEq for WitnessTx