Struct fuels_programs::contract::MultiContractCallHandler

pub struct MultiContractCallHandler<T: Account> {
    pub contract_calls: Vec<ContractCall>,
    pub log_decoder: LogDecoder,
    pub tx_policies: TxPolicies,
    pub account: T,
    /* private fields */
}

Helper that handles bundling multiple calls into a single transaction

Fields

contract_calls: Vec<ContractCall>

log_decoder: LogDecoder

tx_policies: TxPolicies

account: T

Implementations

impl<T: Account> MultiContractCallHandler<T>

pub fn new(account: T) -> Self

pub fn with_decoder_config( &mut self, decoder_config: DecoderConfig ) -> &mut Self

pub fn add_call( &mut self, call_handler: ContractCallHandler<impl Account, impl Tokenizable> ) -> &mut Self

Adds a contract call to be bundled in the transaction Note that this is a builder method

pub fn with_tx_policies(self, tx_policies: TxPolicies) -> Self

Sets the transaction policies for a given transaction. Note that this is a builder method

pub async fn transaction_builder(&self) -> Result<ScriptTransactionBuilder>

pub async fn build_tx(&self) -> Result<ScriptTransaction>

Returns the script that executes the contract calls

pub async fn call<D: Tokenizable + Debug>( &mut self ) -> Result<FuelCallResponse<D>>

Call contract methods on the node, in a state-modifying manner.

pub async fn submit(self) -> Result<SubmitResponseMultiple<T>>

pub async fn simulate<D: Tokenizable + Debug>( &mut self ) -> Result<FuelCallResponse<D>>

Call contract methods on the node, in a simulated manner, meaning the state of the blockchain is not modified but simulated. It is the same as the call method because the API is more user-friendly this way.

pub async fn estimate_transaction_cost( &self, tolerance: Option<f64>, block_horizon: Option<u32> ) -> Result<TransactionCost>

Get a contract’s estimated cost

pub fn get_response<D: Tokenizable + Debug>( &self, receipts: Vec<Receipt> ) -> Result<FuelCallResponse<D>>

Create a FuelCallResponse from call receipts

Trait Implementations

impl<T: Debug + Account> Debug for MultiContractCallHandler<T>

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

Formats the value using the given formatter.

impl<T> TxDependencyExtension for MultiContractCallHandler<T>

where T: Account,

fn simulate<'life0, 'async_trait>( &'life0 mut self ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn append_variable_outputs(self, num: u64) -> Self

Appends num fuel_tx::Output::Variables to the transaction. Note that this is a builder method, i.e. use it as a chain:

fn append_contract(self, contract_id: Bech32ContractId) -> Self

Appends additional external contracts as dependencies to this call. Effectively, this will be used to create additional fuel_tx::Input::Contract/fuel_tx::Output::Contract pairs and set them into the transaction. Note that this is a builder method, i.e. use it as a chain:

fn append_missing_dependencies(self, receipts: &[Receipt]) -> Self

fn estimate_tx_dependencies<'async_trait>( self, max_attempts: Option<u64> ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where Self: Send + 'async_trait,

Simulates the call and attempts to resolve missing tx dependencies. Forwards the received error if it cannot be fixed.