Struct RootProvider 

pub struct RootProvider<N: Network = Ethereum> { /* private fields */ }

The root provider manages the RPC client and the heartbeat. It is at the base of every provider stack.

Implementations

impl<N: Network> RootProvider<N>

pub fn new_http(url: Url) -> Self

Available on crate feature reqwest only.

Creates a new HTTP root provider from the given URL.

pub fn new(client: RpcClient) -> Self

Creates a new root provider from the given RPC client.

pub async fn connect(s: &str) -> Result<Self, TransportError>

Creates a new root provider from the provided string.

See BuiltInConnectionString for more information.

pub async fn connect_with<C: TransportConnect>( conn: C, ) -> Result<Self, TransportError>

Connects to a transport with the given connector.

impl<N: Network> RootProvider<N>

pub async fn get_subscription<R: RpcRecv>( &self, id: B256, ) -> TransportResult<Subscription<R>>

Available on crate feature pubsub only.

Gets the subscription corresponding to the given RPC subscription ID.

pub fn unsubscribe(&self, id: B256) -> TransportResult<()>

Available on crate feature pubsub only.

Unsubscribes from the subscription corresponding to the given RPC subscription ID.

Trait Implementations

impl<N: Network> Clone for RootProvider<N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Network> Debug for RootProvider<N>

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

Formats the value using the given formatter.

impl<N: Network> Provider<N> for RootProvider<N>

fn root(&self) -> &Self

Returns the root provider.

fn client(&self) -> ClientRef<'_>

Returns the RPC client used to send requests.

fn weak_client(&self) -> WeakClient

Returns a Weak RPC client used to send requests.

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

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

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

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

where Self: Sized,

Returns the ProviderBuilder to build on.

fn erased(self) -> DynProvider<N>

where Self: Sized + 'static,

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

fn get_accounts(&self) -> ProviderCall<NoParams, 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<NoParams, U128, u128>

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

fn get_block_number(&self) -> ProviderCall<NoParams, U64, BlockNumber>

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 = TransportResult<Option<BlockNumber>>> + Send + 'async_trait>>

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

Get the block number for a given block identifier.

fn call(&self, tx: N::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 Bundles 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::BlockResponse>>>

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

fn get_chain_id(&self) -> ProviderCall<NoParams, U64, u64>

Gets the chain ID.

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

Create an EIP-2930 access list.

fn estimate_gas(&self, tx: N::TransactionRequest) -> EthCall<N, U64, 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 = TransportResult<Eip1559Estimation>> + Send + 'async_trait>>

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

Estimates the EIP-1559 maxFeePerGas and maxPriorityFeePerGas fields.

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

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

Estimates the EIP-1559 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 = TransportResult<FeeHistory>> + Send + 'async_trait>>

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

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

fn get_gas_price(&self) -> ProviderCall<NoParams, U128, 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 (TrieAccount) for the given Address at the particular BlockId.

fn get_balance(&self, address: Address) -> RpcWithBlock<Address, U256, U256>

Gets the balance of the account.

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

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

fn get_block_by_hash(&self, hash: BlockHash) -> EthGetBlock<N::BlockResponse>

Gets a block by its BlockHash

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

Gets a block by its BlockNumberOrTag

fn get_block_transaction_count_by_hash<'life0, 'async_trait>( &'life0 self, hash: BlockHash, ) -> Pin<Box<dyn Future<Output = TransportResult<Option<u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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 = TransportResult<Option<u64>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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::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 = TransportResult<FilterPollerBuilder<B256>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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 = TransportResult<WatchBlocks<N::BlockResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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 = TransportResult<FilterPollerBuilder<B256>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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 = TransportResult<FilterPollerBuilder<Log>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 = TransportResult<FilterPollerBuilder<N::TransactionResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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: U256, ) -> Pin<Box<dyn Future<Output = TransportResult<Vec<R>>> + Send + 'async_trait>>

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

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

fn get_filter_changes_dyn<'life0, 'async_trait>( &'life0 self, id: U256, ) -> Pin<Box<dyn Future<Output = TransportResult<FilterChanges>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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: U256, ) -> Pin<Box<dyn Future<Output = TransportResult<Vec<Log>>> + Send + 'async_trait>>

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

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

fn uninstall_filter<'life0, 'async_trait>( &'life0 self, id: U256, ) -> Pin<Box<dyn Future<Output = TransportResult<bool>> + Send + 'async_trait>>

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

Request provider to uninstall the filter with the given ID.

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

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

Retrieves a Vec<Log> with the given Filter.

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

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

fn get_storage_at( &self, address: Address, key: U256, ) -> RpcWithBlock<(Address, U256), StorageValue>

Gets the specified storage value from Address.

fn get_transaction_by_sender_nonce( &self, sender: Address, nonce: u64, ) -> ProviderCall<(Address, U64), Option<N::TransactionResponse>>

Gets a transaction by its sender and nonce.

fn get_transaction_by_hash( &self, hash: TxHash, ) -> ProviderCall<(TxHash,), Option<N::TransactionResponse>>

Gets a transaction by its TxHash.

fn get_transaction_by_block_hash_and_index( &self, block_hash: B256, index: usize, ) -> ProviderCall<(B256, Index), Option<N::TransactionResponse>>

Gets a transaction by block hash and transaction index position.

fn get_raw_transaction_by_block_hash_and_index( &self, block_hash: B256, index: usize, ) -> ProviderCall<(B256, 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::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: TxHash, ) -> ProviderCall<(TxHash,), Option<Bytes>>

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

fn get_transaction_count( &self, address: Address, ) -> RpcWithBlock<Address, U64, u64, fn(U64) -> u64>

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

fn get_transaction_receipt( &self, hash: TxHash, ) -> ProviderCall<(TxHash,), Option<N::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 = TransportResult<Option<N::BlockResponse>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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 = TransportResult<u64>> + Send + 'async_trait>>

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

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

fn get_max_priority_fee_per_gas(&self) -> ProviderCall<NoParams, U128, u128>

Returns a suggestion for the current maxPriorityFeePerGas in wei.

fn new_block_filter<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportResult<U256>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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 = TransportResult<U256>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 = TransportResult<U256>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: '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 = TransportResult<PendingTransactionBuilder<N>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 = TransportResult<N::ReceiptResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 = TransportResult<PendingTransactionBuilder<N>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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::TransactionRequest, ) -> Pin<Box<dyn Future<Output = TransportResult<PendingTransactionBuilder<N>>> + Send + 'async_trait>>

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

Broadcasts a transaction to the network.

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

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

Broadcasts a transaction envelope to the network.

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

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

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

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

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

Signs a transaction that can be submitted to the network later using send_raw_transaction.

fn fill_transaction<'life0, 'async_trait>( &'life0 self, tx: N::TransactionRequest, ) -> Pin<Box<dyn Future<Output = TransportResult<FillTransaction<N::TxEnvelope>>> + Send + 'async_trait>>

where N::TxEnvelope: RpcRecv, Self: 'async_trait, 'life0: 'async_trait,

Fills a transaction with missing fields using default values.

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

Available on crate feature pubsub only.

Subscribe to a stream of new block headers.

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

Available on crate feature pubsub only.

Subscribe to a stream of full block bodies.

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

Available on crate feature pubsub only.

Subscribe to a stream of pending transaction hashes.

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

Available on crate feature pubsub only.

Subscribe to a stream of pending transaction bodies.

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

Available on crate feature pubsub only.

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,

Available on crate feature pubsub only.

Subscribe to an RPC event.

fn subscribe_to<R>(&self, method: &'static str) -> GetSubscription<NoParams, R>

where R: RpcRecv, Self: Sized,

Available on crate feature pubsub only.

Subscribe to a non-standard subscription method without parameters.

fn unsubscribe<'life0, 'async_trait>( &'life0 self, id: B256, ) -> Pin<Box<dyn Future<Output = TransportResult<()>> + Send + 'async_trait>>

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

Available on crate feature pubsub only.

Cancels a subscription given the subscription ID.

fn syncing(&self) -> ProviderCall<NoParams, SyncStatus>

Gets syncing info.

fn get_client_version(&self) -> ProviderCall<NoParams, String>

Gets the client version.

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

Gets the Keccak-256 hash of the given data.

fn get_net_version(&self) -> ProviderCall<NoParams, U64, 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 = TransportResult<R>> + Send + 'async_trait>>

where P: RpcSend + 'async_trait, R: RpcRecv + 'async_trait, Self: Sized + 'async_trait, 'life0: '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 = TransportResult<Box<RawValue>>> + Send + 'async_trait>>

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

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

fn transaction_request(&self) -> N::TransactionRequest

Creates a new TransactionRequest.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes