Struct zksync_web3_rs::contract::FunctionCall

pub struct FunctionCall<B, M, D> {
    pub tx: TypedTransaction,
    pub function: Function,
    pub block: Option<BlockId>,
    /* private fields */
}

Helper for managing a transaction before submitting it to a node

Fields

tx: TypedTransaction

The raw transaction object

function: Function

The ABI of the function being called

block: Option<BlockId>

Optional block number to be used when calculating the transaction’s gas and nonce

Implementations

impl<B, M, D> FunctionCall<B, M, D>where B: Borrow<M>, D: Detokenize,

pub fn from<T>(self, from: T) -> FunctionCall<B, M, D>where T: Into<H160>,

Sets the from field in the transaction to the provided value

pub fn legacy(self) -> FunctionCall<B, M, D>

Uses a Legacy transaction instead of an EIP-1559 one to execute the call

pub fn gas<T>(self, gas: T) -> FunctionCall<B, M, D>where T: Into<U256>,

Sets the gas field in the transaction to the provided value

pub fn gas_price<T>(self, gas_price: T) -> FunctionCall<B, M, D>where T: Into<U256>,

Sets the gas_price field in the transaction to the provided value If the internal transaction is an EIP-1559 one, then it sets both max_fee_per_gas and max_priority_fee_per_gas to the same value

pub fn value<T>(self, value: T) -> FunctionCall<B, M, D>where T: Into<U256>,

Sets the value field in the transaction to the provided value

pub fn block<T>(self, block: T) -> FunctionCall<B, M, D>where T: Into<BlockId>,

Sets the block field for sending the tx to the chain

pub fn nonce<T>(self, nonce: T) -> FunctionCall<B, M, D>where T: Into<U256>,

Sets the nonce field in the transaction to the provided value

impl<B, M, D> FunctionCall<B, M, D>where B: Borrow<M>, M: Middleware, D: Detokenize,

pub fn calldata(&self) -> Option<Bytes>

Returns the underlying transaction’s ABI encoded data

pub async fn estimate_gas( &self ) -> impl Future<Output = Result<U256, ContractError<M>>>

Returns the estimated gas cost for the underlying transaction to be executed

pub async fn call(&self) -> impl Future<Output = Result<D, ContractError<M>>>

Queries the blockchain via an eth_call for the provided transaction.

If executed on a non-state mutating smart contract function (i.e. view, pure) then it will return the raw data from the chain.

If executed on a mutating smart contract function, it will do a “dry run” of the call and return the return type of the transaction without mutating the state

Note: this function does not send a transaction from your account

pub fn call_raw( &self ) -> impl RawCall<'_> + Future<Output = Result<D, ContractError<M>>> + Debug

Returns an implementer of [RawCall] which can be .awaitd to query the blockchain via eth_call, returning the deoded return data.

The returned call can also be used to override the input parameters to eth_call.

Note: this function does not send a transaction from your account

pub fn call_raw_bytes(&self) -> CallBuilder<'_, <M as Middleware>::Provider>

Returns a [CallBuilder] which can be .awaitd to query the blochcain via eth_call, returning the raw bytes from the transaction.

The returned call can also be used to override the input parameters to eth_call.

Note: this function does not send a transaction from your account

pub async fn send( &self ) -> impl Future<Output = Result<PendingTransaction<'_, <M as Middleware>::Provider>, ContractError<M>>>

Signs and broadcasts the provided transaction

Trait Implementations

impl<B, M, D> Clone for FunctionCall<B, M, D>where B: Clone,

fn clone(&self) -> FunctionCall<B, M, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B, M, D> Debug for FunctionCall<B, M, D>where B: Debug, M: Debug, D: Debug,

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

Formats the value using the given formatter.

impl<B, M, D> IntoFuture for FunctionCall<B, M, D>where FunctionCall<B, M, D>: 'static, B: Borrow<M> + Send + Sync, M: Middleware, D: Detokenize + Send + Sync,

FunctionCall can be turned into Future automatically with .await. Defaults to calling FunctionCall::call.

type Output = Result<D, ContractError<M>>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <FunctionCall<B, M, D> as IntoFuture>::Output> + Send, Global>>

Which kind of future are we turning this into?

fn into_future(self) -> <FunctionCall<B, M, D> as IntoFuture>::IntoFuture

Creates a future from a value.