Struct fuels_programs::script_calls::ScriptCallHandler

pub struct ScriptCallHandler<T: Account, D> {
    pub script_call: ScriptCall,
    pub tx_policies: TxPolicies,
    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_policies: TxPolicies

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 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);
instance.main(...).with_tx_policies(tx_policies).call()

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

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

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

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

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

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

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

Returns the transaction that executes the script call

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

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

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

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

pub async fn simulate(&mut 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

pub fn get_response_from( &self, tx_status: TxStatus ) -> Result<FuelCallResponse<D>>

Create a FuelCallResponse from TxStatus

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.

impl<T, D> TxDependencyExtension for ScriptCallHandler<T, D>

where T: Account, D: Tokenizable + Parameterize + Debug + Send + Sync,

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.