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 fn with_variable_output_policy( self, variable_outputs: VariableOutputPolicy, ) -> Self

If this method is not called, the default policy is to not add any variable outputs.

Parameters

• variable_outputs: The VariableOutputPolicy to apply for the contract multi-call.

Returns

• Self: The updated SDK configuration.

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_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 determine_missing_contracts<'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 contract outputs. Forwards the received error if it cannot be fixed.