Struct L1Client 

pub struct L1Client {
    pub provider: L1Provider,
    pub transport: SwitchingTransport,
    pub(crate) state: Arc<Mutex<L1State>>,
    pub(crate) sender: Sender<L1Event>,
    pub(crate) receiver: InactiveReceiver<L1Event>,
    pub(crate) update_task: Arc<L1UpdateTask>,
}

An Ethereum provider and configuration to interact with the L1.

This client runs asynchronously, updating an in-memory snapshot of the relevant L1 information each time a new L1 block is published. The main advantage of this is that we can update the L1 state at the pace of the L1, instead of the much faster pace of HotShot consensus.This makes it easy to use a subscription instead of polling for new blocks, vastly reducing the number of L1 RPC calls we make.

Fields

provider: L1Provider

The alloy provider used for L1 communication with wallet and default fillers

transport: SwitchingTransport

Actual transport used in self.provider i.e. the t variable in ProviderBuilder::new().on_client(RpcClient::new(t, is_local))

state: Arc<Mutex<L1State>>

Shared state updated by an asynchronous task which polls the L1.

sender: Sender<L1Event>

Channel used by the async update task to send events to clients.

receiver: InactiveReceiver<L1Event>

Receiver for events from the async update task.

update_task: Arc<L1UpdateTask>

Async task which updates the shared state.

Implementations

impl L1Client

fn with_transport(transport: SwitchingTransport) -> Self

pub fn new(url: Vec<Url>) -> Result<Self>

Construct a new L1 client with the default options.

pub fn anvil(anvil: &AnvilInstance) -> Result<Self>

test only

pub async fn spawn_tasks(&self)

Start the background tasks which keep the L1 client up to date.

pub async fn shut_down_tasks(&self)

Shut down background tasks associated with this L1 client.

The L1 client will still be usable, but will stop updating until start is called again.

fn update_loop(&self) -> impl Future<Output = ()>

pub async fn snapshot(&self) -> L1Snapshot

Get a snapshot from the l1.

pub async fn wait_for_block(&self, number: u64)

Wait until the highest L1 block number reaches at least number.

This function does not return any information about the block, since the block is not necessarily finalized when it returns. It is only used to guarantee that some block at height number exists, possibly in the unsafe part of the L1 chain.

pub async fn wait_for_finalized_block(&self, number: u64) -> L1BlockInfo

Get information about the given block.

If the desired block number is not finalized yet, this function will block until it becomes finalized.

pub async fn wait_for_finalized_block_with_timestamp( &self, timestamp: U256, ) -> L1BlockInfo

Get information about the first finalized block with timestamp greater than or equal timestamp.

async fn fetch_finalized_block_by_number<'a>( &'a self, state: MutexGuard<'a, L1State>, number: u64, ) -> (MutexGuard<'a, L1State>, L1BlockInfo)

async fn load_and_cache_finalized_block<'a>( &'a self, state: MutexGuard<'a, L1State>, id: BlockId, ) -> (MutexGuard<'a, L1State>, L1BlockInfoWithParent)

pub async fn get_finalized_deposits( &self, fee_contract_address: Address, prev_finalized: Option<u64>, new_finalized: u64, ) -> Vec<FeeInfo>

Get fee info for each Deposit occurring between prev and new. Returns Vec<FeeInfo>

pub async fn is_proxy_contract(&self, proxy_address: Address) -> Result<bool>

Check if the given address is a proxy contract.

pub async fn retry_on_all_providers<Fut>( &self, op: impl Fn() -> Fut, ) -> Result<Fut::Ok, Fut::Error>

where Fut: TryFuture,

pub(crate) fn options(&self) -> &L1ClientOptions

fn metrics(&self) -> &L1ClientMetrics

async fn retry_delay(&self)

Methods from Deref<Target = L1Provider>

pub async fn fill( &self, tx: <N as Network>::TransactionRequest, ) -> Result<SendableTx<N>, RpcError<TransportErrorKind>>

Fills the transaction request, using the configured fillers

Example

async fn example() -> Result<(), Box<dyn std::error::Error>> {
    // Create transaction request
    let tx_request = TransactionRequest::default()
        .with_from(address!("d8dA6BF26964aF9D7eEd9e03E53415D37aA96045"))
        .with_value(U256::from(1000));

    let provider = ProviderBuilder::new().connect_anvil_with_wallet();

    // Fill transaction with provider data
    let filled_tx = provider.fill(tx_request).await?;

    // Build unsigned transaction
    let typed_tx =
        filled_tx.as_builder().expect("filled tx is a builder").clone().build_unsigned()?;

    // Encode, e.g. for offline signing
    let mut encoded = Vec::new();
    typed_tx.encode_for_signing(&mut encoded);

    // Decode unsigned transaction
    let decoded = TypedTransaction::decode_unsigned(&mut encoded.as_slice())?;

    Ok(())
}

pub fn prepare_call( &self, tx: <N as Network>::TransactionRequest, ) -> Result<<N as Network>::TransactionRequest, RpcError<TransportErrorKind>>

Prepares a transaction request for eth_call operations using the configured fillers

Trait Implementations

impl Clone for L1Client

fn clone(&self) -> L1Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for L1Client

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

Formats the value using the given formatter.

impl Deref for L1Client

type Target = FillProvider<JoinFill<Identity, <Ethereum as RecommendedFillers>::RecommendedFillers>, RootProvider>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Provider for L1Client

fn root(&self) -> &RootProvider

Returns the root provider.

fn builder() -> ProviderBuilder<Identity, Identity, N>

where Self: Sized,

Returns the [ProviderBuilder] to build on.

fn client(&self) -> &RpcClientInner

Returns the RPC client used to send requests.

fn weak_client(&self) -> Weak<RpcClientInner>

Returns a Weak RPC client used to send requests.

fn erased(self) -> DynProvider<N>

where Self: Sized + 'static,

Returns a type erased provider wrapped in Arc. See [DynProvider].

fn get_accounts(&self) -> ProviderCall<[(); 0], Vec<Address>>

Gets the accounts in the remote node. This is usually empty unless you’re using a local node.

fn get_blob_base_fee(&self) -> ProviderCall<[(); 0], Uint<128, 2>, u128>

Returns the base fee per blob gas (blob gas price) in wei.

fn get_block_number(&self) -> ProviderCall<[(); 0], Uint<64, 1>, u64>

Get the last block number available.

fn get_block_number_by_id<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Get the block number for a given block identifier.

fn call(&self, tx: <N as Network>::TransactionRequest) -> EthCall<N, Bytes>

Execute a smart contract call with a transaction request and state overrides, without publishing a transaction.

fn call_many<'req>( &self, bundles: &'req [Bundle], ) -> EthCallMany<'req, N, Vec<Vec<EthCallResponse>>>

Execute a list of [Bundle] against the provided StateContext and StateOverride, without publishing a transaction.

fn multicall(&self) -> MulticallBuilder<Empty, &Self, N>

where Self: Sized,

Execute a multicall by leveraging the [MulticallBuilder].

fn simulate<'req>( &self, payload: &'req SimulatePayload, ) -> RpcWithBlock<&'req SimulatePayload, Vec<SimulatedBlock<<N as Network>::BlockResponse>>>

Executes an arbitrary number of transactions on top of the requested state.

fn get_chain_id(&self) -> ProviderCall<[(); 0], Uint<64, 1>, u64>

Gets the chain ID.

fn create_access_list<'a>( &self, request: &'a <N as Network>::TransactionRequest, ) -> RpcWithBlock<&'a <N as Network>::TransactionRequest, AccessListResult>

Create an EIP-2930 access list.

fn estimate_gas( &self, tx: <N as Network>::TransactionRequest, ) -> EthCall<N, Uint<64, 1>, u64>

Create an [EthCall] future to estimate the gas required for a transaction.

fn estimate_eip1559_fees_with<'life0, 'async_trait>( &'life0 self, estimator: Eip1559Estimator, ) -> Pin<Box<dyn Future<Output = Result<Eip1559Estimation, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Estimates the EIP1559 maxFeePerGas and maxPriorityFeePerGas fields.

fn estimate_eip1559_fees<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Eip1559Estimation, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Estimates the EIP1559 maxFeePerGas and maxPriorityFeePerGas fields.

fn get_fee_history<'life0, 'life1, 'async_trait>( &'life0 self, block_count: u64, last_block: BlockNumberOrTag, reward_percentiles: &'life1 [f64], ) -> Pin<Box<dyn Future<Output = Result<FeeHistory, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Returns a collection of historical gas information [FeeHistory] which can be used to calculate the EIP1559 fields maxFeePerGas and maxPriorityFeePerGas. block_count can range from 1 to 1024 blocks in a single request.

fn get_gas_price(&self) -> ProviderCall<[(); 0], Uint<128, 2>, u128>

Gets the current gas price in wei.

fn get_account_info( &self, address: Address, ) -> RpcWithBlock<Address, AccountInfo>

Retrieves account information (Account) for the given [Address] at the particular [BlockId].

fn get_account(&self, address: Address) -> RpcWithBlock<Address, TrieAccount>

Retrieves account information (Account) for the given [Address] at the particular [BlockId].

fn get_balance(&self, address: Address) -> RpcWithBlock<Address, Uint<256, 4>>

Gets the balance of the account.

fn get_block( &self, block: BlockId, ) -> EthGetBlock<<N as Network>::BlockResponse>

Gets a block by either its hash, tag, or number

fn get_block_by_hash( &self, hash: FixedBytes<32>, ) -> EthGetBlock<<N as Network>::BlockResponse>

Gets a block by its [BlockHash]

fn get_block_by_number( &self, number: BlockNumberOrTag, ) -> EthGetBlock<<N as Network>::BlockResponse>

Gets a block by its [BlockNumberOrTag]

fn get_block_transaction_count_by_hash<'life0, 'async_trait>( &'life0 self, hash: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Returns the number of transactions in a block from a block matching the given block hash.

fn get_block_transaction_count_by_number<'life0, 'async_trait>( &'life0 self, block_number: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = Result<Option<u64>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Returns the number of transactions in a block matching the given block number.

fn get_block_receipts( &self, block: BlockId, ) -> ProviderCall<(BlockId,), Option<Vec<<N as Network>::ReceiptResponse>>>

Gets the selected block [BlockId] receipts.

fn get_code_at(&self, address: Address) -> RpcWithBlock<Address, Bytes>

Gets the bytecode located at the corresponding [Address].

fn watch_blocks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PollerBuilder<(Uint<256, 4>,), Vec<FixedBytes<32>>>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Watch for new blocks by polling the provider with eth_getFilterChanges.

fn watch_full_blocks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WatchBlocks<<N as Network>::BlockResponse>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Watch for new blocks by polling the provider with eth_getFilterChanges and transforming the returned block hashes into full blocks bodies.

fn watch_pending_transactions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PollerBuilder<(Uint<256, 4>,), Vec<FixedBytes<32>>>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Watch for new pending transaction by polling the provider with eth_getFilterChanges.

fn watch_logs<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 Filter, ) -> Pin<Box<dyn Future<Output = Result<PollerBuilder<(Uint<256, 4>,), Vec<Log>>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Watch for new logs using the given filter by polling the provider with eth_getFilterChanges.

fn watch_full_pending_transactions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PollerBuilder<(Uint<256, 4>,), Vec<<N as Network>::TransactionResponse>>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Watch for new pending transaction bodies by polling the provider with eth_getFilterChanges.

fn get_filter_changes<'life0, 'async_trait, R>( &'life0 self, id: Uint<256, 4>, ) -> Pin<Box<dyn Future<Output = Result<Vec<R>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sized + 'async_trait, R: 'async_trait + RpcRecv,

Get a list of values that have been added since the last poll.

fn get_filter_changes_dyn<'life0, 'async_trait>( &'life0 self, id: Uint<256, 4>, ) -> Pin<Box<dyn Future<Output = Result<FilterChanges, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Get a list of values that have been added since the last poll.

fn get_filter_logs<'life0, 'async_trait>( &'life0 self, id: Uint<256, 4>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Log>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Retrieves a Vec<Log> for the given filter ID.

fn uninstall_filter<'life0, 'async_trait>( &'life0 self, id: Uint<256, 4>, ) -> Pin<Box<dyn Future<Output = Result<bool, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Request provider to uninstall the filter with the given ID.

fn watch_pending_transaction<'life0, 'async_trait>( &'life0 self, config: PendingTransactionConfig, ) -> Pin<Box<dyn Future<Output = Result<PendingTransaction, PendingTransactionError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Watch for the confirmation of a single pending transaction with the given configuration.

fn get_logs<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 Filter, ) -> Pin<Box<dyn Future<Output = Result<Vec<Log>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Retrieves a Vec<Log> with the given [Filter].

fn get_proof( &self, address: Address, keys: Vec<FixedBytes<32>>, ) -> RpcWithBlock<(Address, Vec<FixedBytes<32>>), EIP1186AccountProofResponse>

Get the account and storage values of the specified account including the merkle proofs.

fn get_storage_at( &self, address: Address, key: Uint<256, 4>, ) -> RpcWithBlock<(Address, Uint<256, 4>), Uint<256, 4>>

Gets the specified storage value from [Address].

fn get_transaction_by_sender_nonce( &self, sender: Address, nonce: u64, ) -> ProviderCall<(Address, Uint<64, 1>), Option<<N as Network>::TransactionResponse>>

Gets a transaction by its sender and nonce.

fn get_transaction_by_hash( &self, hash: FixedBytes<32>, ) -> ProviderCall<(FixedBytes<32>,), Option<<N as Network>::TransactionResponse>>

Gets a transaction by its [TxHash].

fn get_transaction_by_block_hash_and_index( &self, block_hash: FixedBytes<32>, index: usize, ) -> ProviderCall<(FixedBytes<32>, Index), Option<<N as Network>::TransactionResponse>>

Gets a transaction by block hash and transaction index position.

fn get_raw_transaction_by_block_hash_and_index( &self, block_hash: FixedBytes<32>, index: usize, ) -> ProviderCall<(FixedBytes<32>, Index), Option<Bytes>>

Gets a raw transaction by block hash and transaction index position.

fn get_transaction_by_block_number_and_index( &self, block_number: BlockNumberOrTag, index: usize, ) -> ProviderCall<(BlockNumberOrTag, Index), Option<<N as Network>::TransactionResponse>>

Gets a transaction by block number and transaction index position.

fn get_raw_transaction_by_block_number_and_index( &self, block_number: BlockNumberOrTag, index: usize, ) -> ProviderCall<(BlockNumberOrTag, Index), Option<Bytes>>

Gets a raw transaction by block number and transaction index position.

fn get_raw_transaction_by_hash( &self, hash: FixedBytes<32>, ) -> ProviderCall<(FixedBytes<32>,), Option<Bytes>>

Returns the EIP-2718 encoded transaction if it exists, see also Decodable2718.

fn get_transaction_count( &self, address: Address, ) -> RpcWithBlock<Address, Uint<64, 1>, u64>

Gets the transaction count (AKA “nonce”) of the corresponding address.

fn get_transaction_receipt( &self, hash: FixedBytes<32>, ) -> ProviderCall<(FixedBytes<32>,), Option<<N as Network>::ReceiptResponse>>

Gets a transaction receipt if it exists, by its [TxHash].

fn get_uncle<'life0, 'async_trait>( &'life0 self, tag: BlockId, idx: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<<N as Network>::BlockResponse>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Gets an uncle block through the tag [BlockId] and index u64.

fn get_uncle_count<'life0, 'async_trait>( &'life0 self, tag: BlockId, ) -> Pin<Box<dyn Future<Output = Result<u64, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Gets the number of uncles for the block specified by the tag [BlockId].

fn get_max_priority_fee_per_gas( &self, ) -> ProviderCall<[(); 0], Uint<128, 2>, u128>

Returns a suggestion for the current maxPriorityFeePerGas in wei.

fn new_block_filter<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Notify the provider that we are interested in new blocks.

fn new_filter<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 Filter, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Notify the provider that we are interested in logs that match the given filter.

fn new_pending_transactions_filter<'life0, 'async_trait>( &'life0 self, full: bool, ) -> Pin<Box<dyn Future<Output = Result<Uint<256, 4>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Notify the provider that we are interested in new pending transactions.

fn send_raw_transaction<'life0, 'life1, 'async_trait>( &'life0 self, encoded_tx: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<PendingTransactionBuilder<N>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Broadcasts a raw transaction RLP bytes to the network.

fn send_raw_transaction_sync<'life0, 'life1, 'async_trait>( &'life0 self, encoded_tx: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<<N as Network>::ReceiptResponse, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Broadcasts a raw transaction RLP bytes to the network and returns the transaction receipt after it has been mined.

fn send_raw_transaction_conditional<'life0, 'life1, 'async_trait>( &'life0 self, encoded_tx: &'life1 [u8], conditional: TransactionConditional, ) -> Pin<Box<dyn Future<Output = Result<PendingTransactionBuilder<N>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Broadcasts a raw transaction RLP bytes with a conditional [TransactionConditional] to the network.

fn send_transaction<'life0, 'async_trait>( &'life0 self, tx: <N as Network>::TransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<PendingTransactionBuilder<N>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Broadcasts a transaction to the network.

fn send_tx_envelope<'life0, 'async_trait>( &'life0 self, tx: <N as Network>::TxEnvelope, ) -> Pin<Box<dyn Future<Output = Result<PendingTransactionBuilder<N>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Broadcasts a transaction envelope to the network.

fn send_transaction_sync<'life0, 'async_trait>( &'life0 self, tx: <N as Network>::TransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<<N as Network>::ReceiptResponse, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Sends a transaction and waits for its receipt in a single call.

fn sign_transaction<'life0, 'async_trait>( &'life0 self, tx: <N as Network>::TransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<Bytes, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Signs a transaction that can be submitted to the network later using [Provider::send_raw_transaction].

fn subscribe_blocks( &self, ) -> GetSubscription<(SubscriptionKind,), <N as Network>::HeaderResponse>

Subscribe to a stream of new block headers.

fn subscribe_full_blocks(&self) -> SubFullBlocks<N>

Subscribe to a stream of full block bodies.

fn subscribe_pending_transactions( &self, ) -> GetSubscription<(SubscriptionKind,), FixedBytes<32>>

Subscribe to a stream of pending transaction hashes.

fn subscribe_full_pending_transactions( &self, ) -> GetSubscription<(SubscriptionKind, Params), <N as Network>::TransactionResponse>

Subscribe to a stream of pending transaction bodies.

fn subscribe_logs( &self, filter: &Filter, ) -> GetSubscription<(SubscriptionKind, Params), Log>

Subscribe to a stream of logs matching given filter.

fn subscribe<P, R>(&self, params: P) -> GetSubscription<P, R>

where P: RpcSend, R: RpcRecv, Self: Sized,

Subscribe to an RPC event.

fn subscribe_to<R>(&self, method: &'static str) -> GetSubscription<[(); 0], R>

where R: RpcRecv, Self: Sized,

Subscribe to a non-standard subscription method without parameters.

fn unsubscribe<'life0, 'async_trait>( &'life0 self, id: FixedBytes<32>, ) -> Pin<Box<dyn Future<Output = Result<(), RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Cancels a subscription given the subscription ID.

fn syncing(&self) -> ProviderCall<[(); 0], SyncStatus>

Gets syncing info.

fn get_client_version(&self) -> ProviderCall<[(); 0], String>

Gets the client version.

fn get_sha3(&self, data: &[u8]) -> ProviderCall<(String,), FixedBytes<32>>

Gets the Keccak-256 hash of the given data.

fn get_net_version(&self) -> ProviderCall<[(); 0], Uint<64, 1>, u64>

Gets the network ID. Same as eth_chainId.

fn raw_request<'life0, 'async_trait, P, R>( &'life0 self, method: Cow<'static, str>, params: P, ) -> Pin<Box<dyn Future<Output = Result<R, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, P: RpcSend + 'async_trait, R: RpcRecv + 'async_trait, Self: Sized + 'async_trait,

Sends a raw JSON-RPC request.

fn raw_request_dyn<'life0, 'life1, 'async_trait>( &'life0 self, method: Cow<'static, str>, params: &'life1 RawValue, ) -> Pin<Box<dyn Future<Output = Result<Box<RawValue>, RpcError<TransportErrorKind>>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Sends a raw JSON-RPC request with type-erased parameters and return.

fn transaction_request(&self) -> <N as Network>::TransactionRequest

Creates a new TransactionRequest.