Struct risc0_steel::CallBuilder

pub struct CallBuilder<S, E> { /* private fields */ }

A builder for calling an Ethereum contract.

Once configured, call with CallBuilder::call.

Implementations

impl<S, N, P, H, C> CallBuilder<S, &mut EvmEnv<ProofDb<ProviderDb<N, P>>, H, HostCommit<C>>>

where N: Network, P: Provider<N> + Send + 'static, S: SolCall + Send + 'static, <S as SolCall>::Return: Send, H: EvmBlockHeader + Clone + Send + 'static,

pub async fn prefetch_access_list(self, access_list: AccessList) -> Result<Self>

Available on crate feature host only.

Fetches all the EIP-1186 storage proofs from the access_list. This can help to drastically reduce the number of RPC calls required during execution, as eth_getStorageAt calls are then only required for storage accesses not included in the list. This does not set the access list as part of the transaction (as specified in EIP-2930), and thus can only be specified during preflight on the host.

Usage

This method is typically used when you have a pre-computed access list and want to optimize preflight time. For automatic access list generation, consider using CallBuilder::call_with_prefetch which combines this method with eth_createAccessList RPC.

Example

let mut contract = Contract::preflight(contract_address, &mut env);
let result =
    contract.call_builder(&call).prefetch_access_list(access_list).await?.call().await?;

pub async fn call(self) -> Result<S::Return>

Available on crate feature host only.

Executes the call using an EvmEnv constructed with Contract::preflight.

This uses [tokio::task::spawn_blocking] to run the blocking revm execution.

pub async fn call_with_prefetch(self) -> Result<S::Return>

Available on crate feature host only.

Automatically prefetches the access list before executing the call using an EvmEnv constructed with Contract::preflight.

As the number of SLOAD operations in a call grows, the preflight time with Steel can become quite long due to the large number of RPC calls needed for individual storage queries. This method uses eth_createAccessList to greatly reduce the number of RPC calls and improve pre-flight time.

How it works

This method is equivalent to calling CallBuilder::prefetch_access_list with the EIP-2930 access list as returned by the corresponding eth_createAccessList RPC, followed by CallBuilder::call. The access list contains all storage slots that would be accessed during the execution of the call, allowing them to be fetched in a single RPC call.

Trade-offs

• On certain node software, the underlying eth_createAccessList RPC actually checks to see if there are enough funds for the gas cost (in most cases, this can be fixed by using CallBuilder::from to set the caller to the deposit contract, e.g. 0x00000000219ab540356cBB839Cbe05303d7705Fa on mainnet. However, this is rather arbitrary and ugly).
• This eth_createAccessList RPC is not available on all node software versions or chains.

Example

let mut contract = Contract::preflight(contract_address, &mut env);
// This will automatically fetch the access list and execute the call
let result = contract.call_builder(&call).call_with_prefetch().await?;

impl<S, E> CallBuilder<S, E>

pub fn from(self, from: Address) -> Self

Sets the caller of the function call.

pub fn gas(self, gas: u64) -> Self

Sets the gas limit of the function call.

pub fn gas_price(self, gas_price: U256) -> Self

Sets the gas price of the function call.

pub fn value(self, value: U256) -> Self

Sets the value field of the function call.

impl<S, H> CallBuilder<S, &EvmEnv<StateDb, H, Commitment>>

where S: SolCall, H: EvmBlockHeader,

pub fn try_call(self) -> Result<S::Return, String>

Executes the call and returns an error if the call fails.

In general, it’s recommended to use CallBuilder::call unless explicit error handling is required.

pub fn call(self) -> S::Return

Executes the call and panics on failure.

A convenience wrapper for CallBuilder::try_call, panicking if the call fails. Useful when success is expected.

Trait Implementations

impl<S: Clone, E: Clone> Clone for CallBuilder<S, E>

fn clone(&self) -> CallBuilder<S, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, E: Debug> Debug for CallBuilder<S, E>

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

Formats the value using the given formatter.