Struct PodProvider 

pub struct PodProvider { /* private fields */ }

A provider tailored for pod, extending capabilities of alloy Provider with pod-specific features.

Implementations

impl PodProvider

pub fn new(provider: impl Provider<PodNetwork> + 'static) -> Self

Create a new PodProvider using the underlying alloy Provider.

pub async fn get_committee(&self) -> TransportResult<Committee>

Gets the current committee members

pub async fn get_verifiable_logs( &self, filter: &LogFilter, ) -> TransportResult<Vec<VerifiableLog>>

pub async fn websocket_subscribe<Params, Resp>( &self, method: &str, params: Params, ) -> TransportResult<Subscription<Resp>>

where Params: RpcSend, Resp: RpcRecv,

pub async fn subscribe_verifiable_logs( &self, filter: &LogFilter, ) -> TransportResult<Subscription<VerifiableLog>>

pub async fn wait_past_perfect_time( &self, timestamp: Timestamp, ) -> TransportResult<()>

pub async fn subscribe_receipts( &self, address: Option<Address>, since: Timestamp, ) -> TransportResult<Subscription<MetadataWrappedItem<TransactionReceipt, RegularReceiptMetadata>>>

Subscribe to continuously receive TX receipts as they are created on the node.

The parameters address and since allow to optionally filter receipts. Pass None and Timestamp::zero() respectively for wildcards.

pub async fn get_receipts( &self, address: Option<Address>, since_micros: u64, paginator: Option<CursorPaginationRequest>, ) -> TransportResult<ApiPaginatedResult<<PodNetwork as Network>::ReceiptResponse>>

pub async fn transfer( &self, to: Address, amount: U256, ) -> Result<<PodNetwork as Network>::ReceiptResponse, Box<dyn Error>>

Transfer specified amount funds to the to account.

Trait Implementations

impl Clone for PodProvider

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Provider<PodNetwork> for PodProvider

fn root(&self) -> &RootProvider<PodNetwork>

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_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 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 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.