Struct CallHandler

pub struct CallHandler<A, C, T> {
    pub account: A,
    pub call: C,
    pub tx_policies: TxPolicies,
    pub log_decoder: LogDecoder,
    pub datatype: PhantomData<T>,
    /* private fields */
}

Helper that handles submitting a call to a client and formatting the response

Fields

account: A

call: C

tx_policies: TxPolicies

log_decoder: LogDecoder

datatype: PhantomData<T>

Implementations

impl<A, C, T> CallHandler<A, C, T>

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, i.e. use it as a chain:

let tx_policies = TxPolicies::default().with_gas_price(100);
my_contract_instance.my_method(...).with_tx_policies(tx_policies).call()

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

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

Returns

• Self: The updated SDK configuration.

impl<A, C, T> CallHandler<A, C, T>

where A: Account, C: TransactionTuner, T: Tokenizable + Parameterize + Debug,

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

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

Returns the script that executes the contract call

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

Get a call’s estimated cost

impl<A, C, T> CallHandler<A, C, T>

where A: Account, C: ContractDependencyConfigurator + TransactionTuner + ResponseParser, T: Tokenizable + Parameterize + Debug,

pub fn with_contract_ids(self, contract_ids: &[Bech32ContractId]) -> Self

Sets external contracts as dependencies to this contract’s call. Effectively, this will be used to create 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:

my_contract_instance.my_method(...).with_contract_ids(&[another_contract_id]).call()

pub fn with_contracts(self, contracts: &[&dyn ContractDependency]) -> Self

Sets external contract instances as dependencies to this contract’s call. Effectively, this will be used to: merge LogDecoders and create 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:

my_contract_instance.my_method(...).with_contracts(&[another_contract_instance]).call()

pub async fn call(self) -> Result<CallResponse<T>>

Call a contract’s method on the node, in a state-modifying manner.

pub async fn submit(self) -> Result<SubmitResponse<A, C, T>>

pub async fn simulate( &mut self, execution: Execution, ) -> Result<CallResponse<T>>

Call a contract’s method on the node, in a simulated manner, meaning the state of the blockchain is not modified but simulated.

pub fn get_response(&self, receipts: Vec<Receipt>) -> Result<CallResponse<T>>

Create a CallResponse from call receipts

pub fn get_response_from(&self, tx_status: TxStatus) -> Result<CallResponse<T>>

Create a CallResponse from TxStatus

pub async fn determine_missing_contracts( self, max_attempts: Option<u64>, ) -> Result<Self>

impl<A, T> CallHandler<A, ContractCall, T>

where A: Account, T: Tokenizable + Parameterize + Debug,

pub fn new_contract_call( contract_id: Bech32ContractId, account: A, encoded_selector: Selector, args: &[Token], log_decoder: LogDecoder, is_payable: bool, encoder_config: EncoderConfig, ) -> Self

pub fn add_custom_asset( self, asset_id: AssetId, amount: u64, to: Option<Bech32Address>, ) -> Self

Adds a custom asset_id with its amount and an optional address to be used for generating outputs to this contract’s call.

Parameters

• asset_id: The unique identifier of the asset being added.
• amount: The amount of the asset being added.
• address: The optional account address that the output amount will be sent to. If not provided, the asset will be sent to the users account address.

Note that this is a builder method, i.e. use it as a chain:

let asset_id = AssetId::from([3u8; 32]);
let amount = 5000;
my_contract_instance.my_method(...).add_custom_asset(asset_id, amount, None).call()

pub fn is_payable(&self) -> bool

pub fn call_params(self, params: CallParameters) -> Result<Self>

Sets the call parameters for a given contract call. Note that this is a builder method, i.e. use it as a chain:

let params = CallParameters { amount: 1, asset_id: AssetId::zeroed() };
my_contract_instance.my_method(...).call_params(params).call()

impl<A, T> CallHandler<A, ScriptCall, T>

where A: Account, T: Parameterize + Tokenizable + Debug,

pub fn new_script_call( script_binary: Vec<u8>, encoded_args: Result<Vec<u8>>, account: A, log_decoder: LogDecoder, ) -> Self

pub fn with_outputs(self, outputs: Vec<Output>) -> Self

pub fn with_inputs(self, inputs: Vec<Input>) -> Self

impl<A> CallHandler<A, Vec<ContractCall>, ()>

where A: Account,

pub fn new_multi_call(account: A) -> Self

pub fn add_call( self, call_handler: CallHandler<impl Account, ContractCall, impl Tokenizable>, ) -> Self

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

pub async fn call<T: Tokenizable + Debug>(self) -> Result<CallResponse<T>>

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

pub async fn submit(self) -> Result<SubmitResponse<A, Vec<ContractCall>, ()>>

pub async fn simulate<T: Tokenizable + Debug>( &mut self, execution: Execution, ) -> Result<CallResponse<T>>

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 fn get_response<T: Tokenizable + Debug>( &self, receipts: Vec<Receipt>, ) -> Result<CallResponse<T>>

Create a CallResponse from call receipts

pub async fn determine_missing_contracts( self, max_attempts: Option<u64>, ) -> Result<Self>

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

Trait Implementations

impl<A: Clone, C: Clone, T: Clone> Clone for CallHandler<A, C, T>

fn clone(&self) -> CallHandler<A, C, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, C: Debug, T: Debug> Debug for CallHandler<A, C, T>

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

Formats the value using the given formatter.