Enum fuel_tx::Transaction

pub enum Transaction {
    Script {
        gas_price: Word,
        gas_limit: Word,
        maturity: Word,
        receipts_root: Bytes32,
        script: Vec<u8>,
        script_data: Vec<u8>,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        witnesses: Vec<Witness>,
        metadata: Option<Metadata>,
    },
    Create {
        gas_price: Word,
        gas_limit: Word,
        maturity: Word,
        bytecode_length: Word,
        bytecode_witness_index: u8,
        salt: Salt,
        storage_slots: Vec<StorageSlot>,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        witnesses: Vec<Witness>,
        metadata: Option<Metadata>,
    },
}

Variants

Script

Fields

gas_price: Word

gas_limit: Word

maturity: Word

receipts_root: Bytes32

script: Vec<u8>

script_data: Vec<u8>

inputs: Vec<Input>

outputs: Vec<Output>

witnesses: Vec<Witness>

metadata: Option<Metadata>

Create

Fields

gas_price: Word

gas_limit: Word

maturity: Word

bytecode_length: Word

bytecode_witness_index: u8

salt: Salt

storage_slots: Vec<StorageSlot>

inputs: Vec<Input>

outputs: Vec<Output>

witnesses: Vec<Witness>

metadata: Option<Metadata>

Implementations

impl Transaction

pub fn precompute_metadata(&mut self)

impl Transaction

pub const fn script_offset() -> usize

For a serialized transaction of type Script, return the bytes offset of the script

pub fn script_data_offset(&self) -> Option<usize>

For a serialized transaction of type Script, return the bytes offset of the script data

pub fn input_predicate_offset(&self, index: usize) -> Option<(usize, usize)>

Return the offset/length tuple for an input predicate indexed by index.

Return None either if index is invalid, or if its not a [Input::CoinPredicate]

pub fn input_offset(&self, index: usize) -> Option<usize>

Return the serialized bytes offset of the input with the provided index

Return None if index is invalid

pub fn output_offset(&self, index: usize) -> Option<usize>

Return the serialized bytes offset of the output with the provided index

Return None if index is invalid

pub fn witness_offset(&self, index: usize) -> Option<usize>

Return the serialized bytes offset of the witness with the provided index

Return None if index is invalid

pub const fn receipts_root_offset(&self) -> Option<usize>

For a serialized transaction of type Script, return the bytes offset of the receipts root

impl Transaction

pub fn validate(
    &self,
    block_height: Word,
    parameters: &ConsensusParameters
) -> Result<(), ValidationError>

Validate the transaction.

This function will reflect the stateful property of Output::validate

pub fn validate_input_signature(&self) -> Result<(), ValidationError>

pub fn validate_without_signature(
    &self,
    block_height: Word,
    parameters: &ConsensusParameters
) -> Result<(), ValidationError>

Validate the transaction.

This function will reflect the stateful property of Output::validate

impl Transaction

pub fn id(&self) -> Bytes32

impl Transaction

pub fn try_from_bytes(bytes: &[u8]) -> Result<(usize, Self)>

impl Transaction

pub const fn script(
    gas_price: Word,
    gas_limit: Word,
    maturity: Word,
    script: Vec<u8>,
    script_data: Vec<u8>,
    inputs: Vec<Input>,
    outputs: Vec<Output>,
    witnesses: Vec<Witness>
) -> Self

pub fn create(
    gas_price: Word,
    gas_limit: Word,
    maturity: Word,
    bytecode_witness_index: u8,
    salt: Salt,
    storage_slots: Vec<StorageSlot>,
    inputs: Vec<Input>,
    outputs: Vec<Output>,
    witnesses: Vec<Witness>
) -> Self

pub fn input_asset_ids(&self) -> impl Iterator<Item = &AssetId>

pub fn input_asset_ids_unique(&self) -> impl Iterator<Item = &AssetId>

pub fn input_contracts(&self) -> impl Iterator<Item = &ContractId>

pub fn check_predicate_owners(&self) -> bool

pub fn check_predicate_owner(&self, idx: usize) -> bool

pub const fn gas_price(&self) -> Word

pub fn set_gas_price(&mut self, price: Word)

pub const fn gas_limit(&self) -> Word

pub fn set_gas_limit(&mut self, limit: Word)

pub const fn maturity(&self) -> Word

pub fn set_maturity(&mut self, mat: Word)

pub const fn is_script(&self) -> bool

pub const fn metadata(&self) -> Option<&Metadata>

pub const fn salt(&self) -> Option<&Salt>

pub fn inputs(&self) -> &[Input]

pub fn outputs(&self) -> &[Output]

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

pub fn set_witnesses(&mut self, new_witnesses: Vec<Witness>)

pub const fn receipts_root(&self) -> Option<&Bytes32>

pub fn set_receipts_root(&mut self, root: Bytes32) -> Option<Bytes32>

pub fn add_unsigned_coin_input(
    &mut self,
    utxo_id: UtxoId,
    owner: &PublicKey,
    amount: Word,
    asset_id: AssetId,
    tx_pointer: TxPointer,
    maturity: Word
)

Append a new unsigned coin input to the transaction.

When the transaction is constructed, Transaction::sign_inputs should be called for every secret key used with this method.

The production of the signatures can be done only after the full transaction skeleton is built because the input of the hash message is the ID of the final transaction.

pub fn add_unsigned_message_input(
    &mut self,
    sender: Address,
    recipient: Address,
    nonce: Word,
    owner: &PublicKey,
    amount: Word,
    data: Vec<u8>
)

Append a new unsigned message input to the transaction.

When the transaction is constructed, Transaction::sign_inputs should be called for every secret key used with this method.

The production of the signatures can be done only after the full transaction skeleton is built because the input of the hash message is the ID of the final transaction.

pub fn sign_inputs(&mut self, secret: &SecretKey)

For all inputs of type coin or message, check if its owner equals the public counterpart of the provided key. Sign all matches.

pub fn metered_bytes_size(&self) -> usize

Used for accounting purposes when charging byte based fees

pub fn prepare_init_script(&mut self) -> Result<&mut Self>

Prepare the transaction for VM initialization for script execution

note: Fields dependent on storage/state such as balance and state roots, or tx pointers, should already set by the client beforehand.

pub fn prepare_init_predicate(&mut self) -> &mut Self

Prepare the transaction for VM initialization for predicate verification

pub fn script_len(&self) -> Option<usize>

pub fn script_data_len(&self) -> Option<usize>

pub const fn bytecode_length(&self) -> Option<Word>

pub const fn bytecode_witness_index(&self) -> Option<u8>

pub fn storage_slots(&self) -> Option<&[StorageSlot]>

pub const fn salt_offset(&self) -> Option<usize>

pub fn storage_slot_offset(&self, idx: usize) -> Option<usize>

pub fn find_output_contract(&self, input: usize) -> Option<(usize, &Output)>

impl Transaction

pub fn check(
    self,
    block_height: Word,
    params: &ConsensusParameters
) -> Result<CheckedTransaction, ValidationError>

Fully verify transaction, including signatures.

For more info, check CheckedTransaction::check.

pub fn check_without_signature(
    self,
    block_height: Word,
    params: &ConsensusParameters
) -> Result<CheckedTransaction, ValidationError>

Verify transaction, without signature checks.

For more info, check CheckedTransaction::check_unsigned.

Trait Implementations

impl AsRef<Transaction> for CheckedTransaction

fn as_ref(&self) -> &Transaction

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<Transaction> for CheckedTransaction

fn borrow(&self) -> &Transaction

Immutably borrows from an owned value.

impl Clone for Transaction

fn clone(&self) -> Transaction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transaction

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

Formats the value using the given formatter.

impl Default for Transaction

fn default() -> Self

Returns the “default value” for a type.

impl From<&Transaction> for TransactionRepr

fn from(tx: &Transaction) -> Self

Converts to this type from the input type.

impl From<CheckedTransaction> for Transaction

fn from(tx: CheckedTransaction) -> Self

Converts to this type from the input type.

impl Hash for Transaction

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq<Transaction> for Transaction

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

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

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

This method tests for !=.

impl Read for Transaction

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adapter which will read at most limit bytes from it.

impl SizedBytes for Transaction

fn serialized_size(&self) -> usize

Return the expected serialized size for an instance of the type.

impl TryFrom<&Transaction> for Contract

type Error = ValidationError

The type returned in the event of a conversion error.

fn try_from(tx: &Transaction) -> Result<Self, Self::Error>

Performs the conversion.

impl Write for Transaction

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

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

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adapter for this instance of Write.

impl Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction