Struct ethers_providers::Provider [−][src]
pub struct Provider<P> { /* fields omitted */ }
Expand description
An abstract provider for interacting with the Ethereum JSON RPC
API. Must be instantiated
with a data transport which implements the JsonRpcClient
trait
(e.g. HTTP, Websockets etc.)
Example
use ethers_providers::{Middleware, Provider, Http};
use std::convert::TryFrom;
let provider = Provider::<Http>::try_from(
"https://mainnet.infura.io/v3/c60b0bb42f8a4c6481ecd229eddaca27"
).expect("could not instantiate HTTP Provider");
let block = provider.get_block(100u64).await?;
println!("Got block: {}", serde_json::to_string(&block)?);
Implementations
Returns the type of node we’re connected to, while also caching the value for use in other node-specific API calls, such as the get_block_receipts call.
Sets the default polling interval for event filters and pending transactions (default: 7 seconds)
Gets the polling interval which the provider currently uses for event filters and pending transactions (default: 7 seconds)
Provider that uses a quorum
Returns a Provider
instantiated with an internal “mock” transport.
Example
use ethers_core::types::U64;
use ethers_providers::{Middleware, Provider};
// Instantiate the provider
let (provider, mock) = Provider::mocked();
// Push the mock response
mock.push(U64::from(12))?;
// Make the call
let blk = provider.get_block_number().await.unwrap();
// The response matches
assert_eq!(blk.as_u64(), 12);
// and the request as well!
mock.assert_request("eth_blockNumber", ()).unwrap();
Trait Implementations
Returns the current client version using the web3_clientVersion
RPC.
fn get_block_number<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U64, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_block_number<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U64, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Gets the latest block number via the eth_BlockNumber
API
Gets the block at block_hash_or_number
(transaction hashes only)
fn get_block_with_txs<'life0, 'async_trait, T: Into<BlockId> + Send + Sync>(
&'life0 self,
block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<Option<Block<Transaction>>, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn get_block_with_txs<'life0, 'async_trait, T: Into<BlockId> + Send + Sync>(
&'life0 self,
block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<Option<Block<Transaction>>, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Gets the block at block_hash_or_number
(full transactions included)
Gets the block uncle count at block_hash_or_number
Gets the block uncle at block_hash_or_number
and idx
fn get_transaction<'life0, 'async_trait, T: Send + Sync + Into<TxHash>>(
&'life0 self,
transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<Transaction>, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn get_transaction<'life0, 'async_trait, T: Send + Sync + Into<TxHash>>(
&'life0 self,
transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<Transaction>, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Gets the transaction with transaction_hash
fn get_transaction_receipt<'life0, 'async_trait, T: Send + Sync + Into<TxHash>>(
&'life0 self,
transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<TransactionReceipt>, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn get_transaction_receipt<'life0, 'async_trait, T: Send + Sync + Into<TxHash>>(
&'life0 self,
transaction_hash: T
) -> Pin<Box<dyn Future<Output = Result<Option<TransactionReceipt>, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Gets the transaction receipt with transaction_hash
fn get_block_receipts<'life0, 'async_trait, T: Into<BlockNumber> + Send + Sync>(
&'life0 self,
block: T
) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionReceipt>, Self::Error>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn get_block_receipts<'life0, 'async_trait, T: Into<BlockNumber> + Send + Sync>(
&'life0 self,
block: T
) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionReceipt>, Self::Error>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Returns all receipts for a block.
Note that this uses the eth_getBlockReceipts
RPC, which is
non-standard and currently supported by Erigon.
fn parity_block_receipts<'life0, 'async_trait, T: Into<BlockNumber> + Send + Sync>(
&'life0 self,
block: T
) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionReceipt>, Self::Error>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn parity_block_receipts<'life0, 'async_trait, T: Into<BlockNumber> + Send + Sync>(
&'life0 self,
block: T
) -> Pin<Box<dyn Future<Output = Result<Vec<TransactionReceipt>, Self::Error>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Returns all receipts for that block. Must be done on a parity node.
fn get_gas_price<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_gas_price<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Gets the current gas price as estimated by the node
Gets a heuristic recommendation of max fee per gas and max priority fee per gas for EIP-1559 compatible transactions.
fn get_accounts<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<Address>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_accounts<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<Address>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Gets the accounts on the node
fn get_transaction_count<'life0, 'async_trait, T: Into<NameOrAddress> + Send + Sync>(
&'life0 self,
from: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn get_transaction_count<'life0, 'async_trait, T: Into<NameOrAddress> + Send + Sync>(
&'life0 self,
from: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Returns the nonce of the address
fn get_balance<'life0, 'async_trait, T: Into<NameOrAddress> + Send + Sync>(
&'life0 self,
from: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn get_balance<'life0, 'async_trait, T: Into<NameOrAddress> + Send + Sync>(
&'life0 self,
from: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Returns the account’s balance
fn get_chainid<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_chainid<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Returns the currently configured chain id, a value used in replay-protected transaction signing as introduced by EIP-155.
fn get_net_version<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U64, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn get_net_version<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<U64, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Returns the network version.
Sends the read-only (constant) transaction to a single Ethereum node and return the result (as bytes) of executing it. This is free, since it does not change any state on the blockchain.
fn estimate_gas<'life0, 'life1, 'async_trait>(
&'life0 self,
tx: &'life1 TypedTransaction
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn estimate_gas<'life0, 'life1, 'async_trait>(
&'life0 self,
tx: &'life1 TypedTransaction
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
Sends a transaction to a single Ethereum node and return the estimated amount of gas required (as a U256) to send it This is free, but only an estimate. Providing too little gas will result in a transaction being rejected (while still consuming all provided gas).
fn send_transaction<'life0, 'async_trait, T: Into<TypedTransaction> + Send + Sync>(
&'life0 self,
tx: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, P>, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn send_transaction<'life0, 'async_trait, T: Into<TypedTransaction> + Send + Sync>(
&'life0 self,
tx: T,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'_, P>, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Sends the transaction to the entire Ethereum network and returns the transaction’s hash This will consume gas from the account that signed the transaction.
fn send_raw_transaction<'a, 'async_trait>(
&'a self,
tx: Bytes
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'a, P>, ProviderError>> + Send + 'async_trait>> where
'a: 'async_trait,
Self: 'async_trait,
fn send_raw_transaction<'a, 'async_trait>(
&'a self,
tx: Bytes
) -> Pin<Box<dyn Future<Output = Result<PendingTransaction<'a, P>, ProviderError>> + Send + 'async_trait>> where
'a: 'async_trait,
Self: 'async_trait,
Send the raw RLP encoded transaction to the entire Ethereum network and returns the transaction’s hash This will consume gas from the account that signed the transaction.
The JSON-RPC provider is at the bottom-most position in the middleware stack. Here we check
if it has the key for the sender address unlocked, as well as supports the eth_sign
call.
Signs data using a specific account. This account needs to be unlocked.
Sign a transaction via RPC call
Returns an array (possibly empty) of logs that match the filter
Streams matching filter logs
fn watch_blocks<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'_, P, H256>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn watch_blocks<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'_, P, H256>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Streams new block hashes
fn watch_pending_transactions<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'_, P, H256>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn watch_pending_transactions<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'_, P, H256>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Streams pending transactions
fn new_filter<'life0, 'life1, 'async_trait>(
&'life0 self,
filter: FilterKind<'life1>
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn new_filter<'life0, 'life1, 'async_trait>(
&'life0 self,
filter: FilterKind<'life1>
) -> Pin<Box<dyn Future<Output = Result<U256, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
Creates a filter object, based on filter options, to notify when the state changes (logs).
To check if the state has changed, call get_filter_changes
with the filter id.
Uninstalls a filter
fn get_filter_changes<'life0, 'async_trait, T, R>(
&'life0 self,
id: T
) -> Pin<Box<dyn Future<Output = Result<Vec<R>, ProviderError>> + Send + 'async_trait>> where
T: Into<U256> + Send + Sync,
R: Serialize + DeserializeOwned + Send + Sync + Debug,
T: 'async_trait,
R: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn get_filter_changes<'life0, 'async_trait, T, R>(
&'life0 self,
id: T
) -> Pin<Box<dyn Future<Output = Result<Vec<R>, ProviderError>> + Send + 'async_trait>> where
T: Into<U256> + Send + Sync,
R: Serialize + DeserializeOwned + Send + Sync + Debug,
T: 'async_trait,
R: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Polling method for a filter, which returns an array of logs which occurred since last poll.
This method must be called with one of the following return types, depending on the filter type:
eth_newBlockFilter
:H256
, returns block hasheseth_newPendingTransactionFilter
:H256
, returns transaction hasheseth_newFilter
:Log
, returns raw logs
If one of these types is not used, decoding will fail and the method will return an error.
Get the storage of an address for a particular slot location
Returns the deployed code at a given address
fn get_proof<'life0, 'async_trait, T: Into<NameOrAddress> + Send + Sync>(
&'life0 self,
from: T,
locations: Vec<H256>,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<EIP1186ProofResponse, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn get_proof<'life0, 'async_trait, T: Into<NameOrAddress> + Send + Sync>(
&'life0 self,
from: T,
locations: Vec<H256>,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<EIP1186ProofResponse, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Returns the EIP-1186 proof response https://github.com/ethereum/EIPs/issues/1186
fn resolve_name<'life0, 'life1, 'async_trait>(
&'life0 self,
ens_name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Address, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn resolve_name<'life0, 'life1, 'async_trait>(
&'life0 self,
ens_name: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Address, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
Returns the address that the ens_name
resolves to (or None if not configured).
Panics
If the bytes returned from the ENS registrar/resolver cannot be interpreted as an address. This should theoretically never happen.
fn lookup_address<'life0, 'async_trait>(
&'life0 self,
address: Address
) -> Pin<Box<dyn Future<Output = Result<String, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn lookup_address<'life0, 'async_trait>(
&'life0 self,
address: Address
) -> Pin<Box<dyn Future<Output = Result<String, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Returns the ENS name the address
resolves to (or None if not configured).
Panics
If the bytes returned from the ENS registrar/resolver cannot be interpreted as a string. This should theoretically never happen.
fn txpool_content<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolContent, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn txpool_content<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolContent, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Returns the details of all transactions currently pending for inclusion in the next block(s), as well as the ones that are being scheduled for future execution only. Ref: Here
fn txpool_inspect<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolInspect, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn txpool_inspect<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolInspect, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Returns a summary of all the transactions currently pending for inclusion in the next block(s), as well as the ones that are being scheduled for future execution only. Ref: Here
fn txpool_status<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolStatus, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn txpool_status<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<TxpoolStatus, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Returns the number of transactions currently pending for inclusion in the next block(s), as well as the ones that are being scheduled for future execution only. Ref: Here
fn trace_call<'life0, 'async_trait, T: Into<TypedTransaction> + Send + Sync>(
&'life0 self,
req: T,
trace_type: Vec<TraceType>,
block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn trace_call<'life0, 'async_trait, T: Into<TypedTransaction> + Send + Sync>(
&'life0 self,
req: T,
trace_type: Vec<TraceType>,
block: Option<BlockNumber>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, ProviderError>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Executes the given call and returns a number of possible traces for it
fn trace_raw_transaction<'life0, 'async_trait>(
&'life0 self,
data: Bytes,
trace_type: Vec<TraceType>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn trace_raw_transaction<'life0, 'async_trait>(
&'life0 self,
data: Bytes,
trace_type: Vec<TraceType>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Traces a call to eth_sendRawTransaction
without making the call, returning the traces
fn trace_replay_transaction<'life0, 'async_trait>(
&'life0 self,
hash: H256,
trace_type: Vec<TraceType>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn trace_replay_transaction<'life0, 'async_trait>(
&'life0 self,
hash: H256,
trace_type: Vec<TraceType>
) -> Pin<Box<dyn Future<Output = Result<BlockTrace, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Replays a transaction, returning the traces
fn trace_replay_block_transactions<'life0, 'async_trait>(
&'life0 self,
block: BlockNumber,
trace_type: Vec<TraceType>
) -> Pin<Box<dyn Future<Output = Result<Vec<BlockTrace>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn trace_replay_block_transactions<'life0, 'async_trait>(
&'life0 self,
block: BlockNumber,
trace_type: Vec<TraceType>
) -> Pin<Box<dyn Future<Output = Result<Vec<BlockTrace>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Replays all transactions in a block returning the requested traces for each transaction
fn trace_block<'life0, 'async_trait>(
&'life0 self,
block: BlockNumber
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn trace_block<'life0, 'async_trait>(
&'life0 self,
block: BlockNumber
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Returns traces created at given block
fn trace_filter<'life0, 'async_trait>(
&'life0 self,
filter: TraceFilter
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
fn trace_filter<'life0, 'async_trait>(
&'life0 self,
filter: TraceFilter
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace>, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
Self: 'async_trait,
Return traces matching the given filter
Returns trace at the given position
Returns all traces of a given transaction
type Error = ProviderError
type Provider = P
type Inner = Self
Fill necessary details of a transaction for dispatch Read more
fn create_access_list<'life0, 'life1, 'async_trait>(
&'life0 self,
tx: &'life1 TypedTransaction,
block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<AccessListWithGasUsed, ProviderError>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn subscribe<'life0, 'async_trait, T, R>(
&'life0 self,
params: T
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'_, P, R>, ProviderError>> + Send + 'async_trait>> where
T: Debug + Serialize + Send + Sync,
R: DeserializeOwned + Send + Sync,
P: PubsubClient,
T: 'async_trait,
R: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn unsubscribe<'life0, 'async_trait, T>(
&'life0 self,
id: T
) -> Pin<Box<dyn Future<Output = Result<bool, ProviderError>> + Send + 'async_trait>> where
T: Into<U256> + Send + Sync,
P: PubsubClient,
T: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn subscribe_blocks<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'_, P, Block<TxHash>>, ProviderError>> + Send + 'async_trait>> where
P: PubsubClient,
'life0: 'async_trait,
Self: 'async_trait,
fn subscribe_pending_txs<'life0, 'async_trait>(
&'life0 self
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'_, P, TxHash>, ProviderError>> + Send + 'async_trait>> where
P: PubsubClient,
'life0: 'async_trait,
Self: 'async_trait,
fn subscribe_logs<'a, 'life0, 'async_trait>(
&'a self,
filter: &'life0 Filter
) -> Pin<Box<dyn Future<Output = Result<SubscriptionStream<'a, P, Log>, ProviderError>> + Send + 'async_trait>> where
P: PubsubClient,
'a: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn fee_history<'life0, 'life1, 'async_trait, T: Into<U256> + Send + Sync>(
&'life0 self,
block_count: T,
last_block: BlockNumber,
reward_percentiles: &'life1 [f64]
) -> Pin<Box<dyn Future<Output = Result<FeeHistory, Self::Error>> + Send + 'async_trait>> where
T: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn send_escalating<'a, 'life0, 'async_trait>(
&'a self,
tx: &'life0 TypedTransaction,
escalations: usize,
policy: EscalationPolicy
) -> Pin<Box<dyn Future<Output = Result<EscalatingPending<'a, Self::Provider>, Self::Error>> + Send + 'async_trait>> where
'a: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
fn send_escalating<'a, 'life0, 'async_trait>(
&'a self,
tx: &'life0 TypedTransaction,
escalations: usize,
policy: EscalationPolicy
) -> Pin<Box<dyn Future<Output = Result<EscalatingPending<'a, Self::Provider>, Self::Error>> + Send + 'async_trait>> where
'a: 'async_trait,
'life0: 'async_trait,
Self: 'async_trait,
Send a transaction with a simple escalation policy. Read more
Auto Trait Implementations
impl<P> !RefUnwindSafe for Provider<P>
impl<P> !UnwindSafe for Provider<P>
Blanket Implementations
Mutably borrows from an owned value. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more