Struct fuels_programs::script_calls::ScriptCallHandler

pub struct ScriptCallHandler<T: Account, D> {
    pub script_call: ScriptCall,
    pub tx_parameters: TxParameters,
    pub account: T,
    pub provider: Provider,
    pub datatype: PhantomData<D>,
    pub log_decoder: LogDecoder,
    /* private fields */
}

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

Fields

script_call: ScriptCall

tx_parameters: TxParameters

account: T

provider: Provider

datatype: PhantomData<D>

log_decoder: LogDecoder

Implementations

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

pub fn new( script_binary: Vec<u8>, encoded_args: UnresolvedBytes, account: T, provider: Provider, log_decoder: LogDecoder ) -> Self

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 };
instance.main(...).tx_params(params).call()

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

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

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

pub fn set_contracts(self, contracts: &[&dyn SettableContract]) -> Self

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

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

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

Call a script 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> ) -> Result<TransactionCost>

Get a scripts’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 ScriptCallHandler<T, D>

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

Formats the value using the given formatter.