Enum fuel_indexer_utils::prelude::fuel::ClientTransaction

pub enum ClientTransaction {
    Script(Script),
    Create(Create),
    Mint(Mint),
}

The fuel transaction entity https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/tx_format/transaction.md#transaction.

Variants

Script(Script)

Create(Create)

Mint(Mint)

Implementations

impl Transaction

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

impl Transaction

pub fn default_test_tx() -> Transaction

Return default valid transaction useful for tests.

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

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

pub fn mint(tx_pointer: TxPointer, outputs: Vec<Output>) -> Mint

pub fn to_json(&self) -> String

Convert the type into a JSON string

This is implemented as infallible because serde_json will fail only if the type can’t serialize one of its attributes. We don’t have such case with the transaction because all of its attributes are trivially serialized.

If an error happens, a JSON string with the error description will be returned

pub fn from_json<J>(json: J) -> Option<Transaction>

where J: AsRef<str>,

Attempt to deserialize a transaction from a JSON string, returning None if it fails

pub const fn is_script(&self) -> bool

pub const fn is_create(&self) -> bool

pub const fn is_mint(&self) -> bool

pub const fn as_script(&self) -> Option<&Script>

pub fn as_script_mut(&mut self) -> Option<&mut Script>

pub const fn as_create(&self) -> Option<&Create>

pub fn as_create_mut(&mut self) -> Option<&mut Create>

pub const fn as_mint(&self) -> Option<&Mint>

pub fn as_mint_mut(&mut self) -> Option<&mut Mint>

Trait Implementations

impl Cacheable for Transaction

fn is_computed(&self) -> bool

The cache is already computed.

fn precompute(&mut self, chain_id: &ChainId) -> Result<(), CheckError>

Computes the cache for the entity.

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<(), Error>

Formats the value using the given formatter.

impl Default for Transaction

fn default() -> Transaction

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Transaction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EnumCount for Transaction

const COUNT: usize = 3usize

impl EstimatePredicates for Transaction

fn estimate_predicates( &mut self, params: &ConsensusParameters, gas_costs: &GasCosts ) -> Result<(), CheckError>

Estimates predicates of the transaction.

fn estimate_predicates_async<'life0, 'life1, 'life2, 'async_trait, E>( &'life0 mut self, params: &'life1 ConsensusParameters, gas_costs: &'life2 GasCosts ) -> Pin<Box<dyn Future<Output = Result<(), CheckError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, E: 'async_trait + ParallelExecutor, Transaction: 'async_trait,

Estimates predicates of the transaction in parallel.

impl FormatValidityChecks for Transaction

fn check_signatures(&self, chain_id: &ChainId) -> Result<(), CheckError>

Validates that all required signatures are set in the transaction and that they are valid.

fn check_without_signatures( &self, block_height: BlockHeight, parameters: &ConsensusParameters ) -> Result<(), CheckError>

Validates the transactions according to rules from the specification: https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/tx_format/transaction.md#transaction

fn check( &self, block_height: BlockHeight, parameters: &ConsensusParameters ) -> Result<(), CheckError>

Performs all stateless transaction validity checks. This includes the validity of fields according to rules in the specification and validity of signatures.

impl From<&Transaction> for TransactionRepr

fn from(tx: &Transaction) -> TransactionRepr

Converts to this type from the input type.

impl From<Create> for Transaction

fn from(create: Create) -> Transaction

Converts to this type from the input type.

impl From<CreateTransaction> for Transaction

fn from(tx: CreateTransaction) -> Transaction

Converts to this type from the input type.

impl From<Mint> for Transaction

fn from(mint: Mint) -> Transaction

Converts to this type from the input type.

impl From<Script> for Transaction

fn from(script: Script) -> Transaction

Converts to this type from the input type.

impl From<ScriptTransaction> for Transaction

fn from(tx: ScriptTransaction) -> Transaction

Converts to this type from the input type.

impl From<TransactionType> for Transaction

fn from(value: TransactionType) -> Transaction

Converts to this type from the input type.

impl Hash for Transaction

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 IntoChecked for Transaction

type Metadata = CheckedMetadata

Metadata produced during the check.

fn into_checked_basic( self, block_height: BlockHeight, params: &ConsensusParameters ) -> Result<Checked<Transaction>, CheckError>

Returns transaction that passed only Checks::Basic.

fn into_checked( self, block_height: BlockHeight, params: &ConsensusParameters, gas_costs: &GasCosts ) -> Result<Checked<Self>, CheckError>

where Checked<Self>: CheckPredicates,

Returns transaction that passed all Checks.

impl PartialEq 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: &Rhs) -> bool

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

impl Read for Transaction

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

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>) -> 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: BorrowedCursor<'_>) -> 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, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill cursor.

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

where Self: Sized,

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

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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

impl Serialize for Transaction

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

The type returned in the event of a conversion error.

fn try_from( tx: &Transaction ) -> Result<Contract, <Contract as TryFrom<&Transaction>>::Error>

Performs the conversion.

impl UniqueIdentifier for Transaction

fn id(&self, chain_id: &ChainId) -> Bytes32

The unique identifier of the transaction is based on its content.

fn cached_id(&self) -> Option<Bytes32>

The cached unique identifier of the transaction. Returns None if transaction was not precomputed.

impl Write for Transaction

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

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

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

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

where Self: Sized,

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

impl Eq for Transaction

impl StructuralEq for Transaction

impl StructuralPartialEq for Transaction