Enum fuel_tx::Transaction

pub enum Transaction {
    Script {
        gas_price: Word,
        gas_limit: Word,
        byte_price: 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,
        byte_price: Word,
        maturity: Word,
        bytecode_witness_index: u8,
        salt: Salt,
        static_contracts: Vec<ContractId>,
        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

byte_price: 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

byte_price: Word

maturity: Word

bytecode_witness_index: u8

salt: Salt

static_contracts: Vec<ContractId>

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_coin_predicate_offset(&self, index: usize) -> Option<usize>

For a transaction of type Create, return the offset of the data relative to the serialized transaction for a given index of inputs, if this input is of type Coin.

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

impl Transaction

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

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

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

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,
    byte_price: Word,
    maturity: Word,
    script: Vec<u8>,
    script_data: Vec<u8>,
    inputs: Vec<Input>,
    outputs: Vec<Output>,
    witnesses: Vec<Witness>
) -> Self

pub const fn create(
    gas_price: Word,
    gas_limit: Word,
    byte_price: Word,
    maturity: Word,
    bytecode_witness_index: u8,
    salt: Salt,
    static_contracts: Vec<ContractId>,
    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 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 byte_price(&self) -> Word

pub fn set_byte_price(&mut self, price: 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 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,
    maturity: Word,
    predicate: Vec<u8>,
    predicate_data: Vec<u8>
)

Append a new unsigned 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, 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

Trait Implementations

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 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 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