Struct ethers_providers::Provider

pub struct Provider<P> { /* fields omitted */ }

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

impl<P: JsonRpcClient> Provider<P>

pub fn new(provider: P) -> Self

Instantiate a new provider with a backend.

pub async fn node_client(&self) -> Result<NodeClient, ProviderError>

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.

pub fn with_sender(self, address: impl Into<Address>) -> Self

impl<P: JsonRpcClient> Provider<P>

pub fn ens<T: Into<Address>>(self, ens: T) -> Self

Sets the ENS Address (default: mainnet)

pub fn interval<T: Into<Duration>>(self, interval: T) -> Self

Sets the default polling interval for event filters and pending transactions (default: 7 seconds)

pub fn get_interval(&self) -> Duration

Gets the polling interval which the provider currently uses for event filters and pending transactions (default: 7 seconds)

impl<T: JsonRpcClientWrapper> Provider<QuorumProvider<T>>

pub fn quorum(inner: QuorumProvider<T>) -> Self

Provider that uses a quorum

impl Provider<MockProvider>

pub fn mocked() -> (Self, MockProvider)

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

impl<P> AsRef<P> for Provider<P>

fn as_ref(&self) -> &P

Performs the conversion.

impl<P: Clone> Clone for Provider<P>

fn clone(&self) -> Provider<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Provider<P>

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

Formats the value using the given formatter.

impl<P: JsonRpcClient> Middleware for Provider<P>

fn client_version<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

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, 

Gets the latest block number via the eth_BlockNumber API

fn get_block<'life0, 'async_trait, T: Into<BlockId> + Send + Sync>(
    &'life0 self,
    block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<Option<Block<TxHash>>, Self::Error>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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, 

Gets the block at block_hash_or_number (full transactions included)

fn get_uncle_count<'life0, 'async_trait, T: Into<BlockId> + Send + Sync>(
    &'life0 self,
    block_hash_or_number: T
) -> Pin<Box<dyn Future<Output = Result<U256, Self::Error>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Gets the block uncle count at block_hash_or_number

fn get_uncle<'life0, 'async_trait, T: Into<BlockId> + Send + Sync>(
    &'life0 self,
    block_hash_or_number: T,
    idx: U64
) -> Pin<Box<dyn Future<Output = Result<Option<Block<H256>>, ProviderError>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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, 

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, 

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, 

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, 

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, 

Gets the current gas price as estimated by the node

fn estimate_eip1559_fees<'life0, 'async_trait>(
    &'life0 self,
    estimator: Option<fn(_: U256, _: Vec<Vec<U256>>) -> (U256, U256)>
) -> Pin<Box<dyn Future<Output = Result<(U256, U256), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

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, 

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, 

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, 

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, 

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, 

Returns the network version.

fn call<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 TypedTransaction,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<Bytes, ProviderError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

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, 

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, 

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, 

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.

fn is_signer<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

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.

fn sign<'life0, 'life1, 'async_trait, T: Into<Bytes> + Send + Sync>(
    &'life0 self,
    data: T,
    from: &'life1 Address
) -> Pin<Box<dyn Future<Output = Result<Signature, ProviderError>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Signs data using a specific account. This account needs to be unlocked.

fn sign_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    _tx: &'life1 TypedTransaction,
    _from: Address
) -> Pin<Box<dyn Future<Output = Result<Signature, Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Sign a transaction via RPC call

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

Returns an array (possibly empty) of logs that match the filter

fn watch<'a, 'life0, 'async_trait>(
    &'a self,
    filter: &'life0 Filter
) -> Pin<Box<dyn Future<Output = Result<FilterWatcher<'a, P, Log>, ProviderError>> + Send + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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, 

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, 

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, 

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.

fn uninstall_filter<'life0, 'async_trait, T: Into<U256> + Send + Sync>(
    &'life0 self,
    id: T
) -> Pin<Box<dyn Future<Output = Result<bool, ProviderError>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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, 

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 hashes
• eth_newPendingTransactionFilter: H256, returns transaction hashes
• eth_newFilter: Log, returns raw logs

If one of these types is not used, decoding will fail and the method will return an error.

fn get_storage_at<'life0, 'async_trait, T: Into<NameOrAddress> + Send + Sync>(
    &'life0 self,
    from: T,
    location: H256,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<H256, ProviderError>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Get the storage of an address for a particular slot location

fn get_code<'life0, 'async_trait, T: Into<NameOrAddress> + Send + Sync>(
    &'life0 self,
    at: T,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<Bytes, ProviderError>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

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, 

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, 

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, 

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, 

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, 

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, 

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, 

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, 

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, 

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, 

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, 

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, 

Return traces matching the given filter

fn trace_get<'life0, 'async_trait, T: Into<U64> + Send + Sync>(
    &'life0 self,
    hash: H256,
    index: Vec<T>
) -> Pin<Box<dyn Future<Output = Result<Trace, ProviderError>> + Send + 'async_trait>> where
    T: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns trace at the given position

fn trace_transaction<'life0, 'async_trait>(
    &'life0 self,
    hash: H256
) -> Pin<Box<dyn Future<Output = Result<Vec<Trace>, ProviderError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns all traces of a given transaction

type Error = ProviderError

type Provider = P

type Inner = Self

fn inner(&self) -> &Self::Inner

The next middleware in the stack

fn provider(&self) -> &Provider<Self::Provider>

The HTTP or Websocket provider.

fn default_sender(&self) -> Option<Address>

fn fill_transaction<'life0, 'life1, 'async_trait>(
    &'life0 self,
    tx: &'life1 mut TypedTransaction,
    block: Option<BlockId>
) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Fill necessary details of a transaction for dispatch

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, 

Send a transaction with a simple escalation policy.

impl TryFrom<&'_ str> for Provider<HttpProvider>

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(src: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for Provider<HttpProvider>

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(src: String) -> Result<Self, Self::Error>

Performs the conversion.