Struct fuels_programs::contract::ContractCallHandler

pub struct ContractCallHandler<T: Account, D> {
    pub contract_call: ContractCall,
    pub tx_parameters: TxParameters,
    pub account: T,
    pub datatype: PhantomData<D>,
    pub log_decoder: LogDecoder,
    /* private fields */
}

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

Fields

contract_call: ContractCall

tx_parameters: TxParameters

account: T

datatype: PhantomData<D>

log_decoder: LogDecoder

Implementations

impl<T, D> ContractCallHandler<T, D>where T: Account, D: Tokenizable + Debug,

pub fn set_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(...).set_contract_ids(&[another_contract_id]).call()

pub fn set_contracts(self, contracts: &[&dyn SettableContract]) -> 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(...).set_contracts(&[another_contract_instance]).call()

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 append_contract(self, contract_id: Bech32ContractId) -> Self

Appends additional external contracts as dependencies to this contract’s 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:

my_contract_instance.my_method(...).append_contracts(additional_contract_id).call()

pub fn is_payable(&self) -> bool

pub fn tx_params(self, params: TxParameters) -> Self

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

let params = TxParameters { gas_price: 100, gas_limit: 1000000 };
my_contract_instance.my_method(...).tx_params(params).call()

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: BASE_ASSET_ID };
my_contract_instance.my_method(...).call_params(params).call()

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

my_contract_instance.my_method(...).add_variable_outputs(num).call()

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

Returns the script that executes the contract call

pub async fn call(self) -> Result<FuelCallResponse<D>>

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

pub async fn simulate(&mut self) -> Result<FuelCallResponse<D>>

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

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

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

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

Get a contract’s estimated cost

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

Create a FuelCallResponse from call receipts

Trait Implementations

impl<T: Debug + Account, D: Debug> Debug for ContractCallHandler<T, D>

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

Formats the value using the given formatter.