Struct ScriptCallHandler

pub struct ScriptCallHandler<D> {
    pub script_call: ScriptCall,
    pub tx_parameters: TxParameters,
    pub wallet: WalletUnlocked,
    pub provider: Provider,
    pub output_param: ParamType,
    pub datatype: PhantomData<D>,
    pub log_decoder: LogDecoder,
}

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

Fields

script_call: ScriptCall

tx_parameters: TxParameters

wallet: WalletUnlocked

provider: Provider

output_param: ParamType

datatype: PhantomData<D>

log_decoder: LogDecoder

Implementations

impl<D> ScriptCallHandler<D>

where D: Tokenizable + Debug,

pub fn new( script_binary: Vec<u8>, encoded_args: UnresolvedBytes, wallet: WalletUnlocked, provider: Provider, output_param: ParamType, 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 async fn call(self) -> Result<FuelCallResponse<D>, Error>

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

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

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 fn get_response( &self, receipts: Vec<Receipt>, ) -> Result<FuelCallResponse<D>, Error>

Create a FuelCallResponse from call receipts

Trait Implementations

impl<D: Debug> Debug for ScriptCallHandler<D>

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

Formats the value using the given formatter.