Crate ethers_providers

Expand description

Clients for interacting with Ethereum nodes

This crate provides asynchronous Ethereum JSON-RPC compliant clients.

For more documentation on the available calls, refer to the Provider struct.

Examples

use ethers_core::types::Address;
use ethers_providers::{Provider, Http, Middleware};
use std::convert::TryFrom;

let provider = Provider::<Http>::try_from(
    "https://mainnet.infura.io/v3/YOUR_API_KEY"
)?;

let block = provider.get_block(100u64).await?;
println!("Got block: {}", serde_json::to_string(&block)?);

let addr = "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359".parse::<Address>()?;
let code = provider.get_code(addr, None).await?;
println!("Got code: {}", serde_json::to_string(&code)?);

Websockets

The crate has support for WebSockets via Tokio. Please ensure that you have the “ws” and “rustls” / “openssl” features enabled if you wish to use WebSockets.

let ws = Ws::connect("ws://localhost:8545").await?;

The provider may also be used to resolve Ethereum Name Service (ENS) names to addresses (and vice versa). The default ENS address is mainnet and can be overriden by calling the ens method on the provider.

// Resolve ENS name to Address
let name = "vitalik.eth";
let address = provider.resolve_name(name).await?;

// Lookup ENS name given Address
let resolved_name = provider.lookup_address(address).await?;
assert_eq!(name, resolved_name);

/// Lookup ENS field
let url = "https://vitalik.ca".to_string();
let resolved_url = provider.resolve_field(name, "url").await?;
assert_eq!(url, resolved_url);

/// Lookup and resolve ENS avatar
let avatar = "https://ipfs.io/ipfs/QmSP4nq9fnN9dAiCj42ug9Wa79rqmQerZXZch82VqpiH7U/image.gif".to_string();
let resolved_avatar = provider.resolve_avatar(name).await?;
assert_eq!(avatar, resolved_avatar.to_string());

Re-exports

pub use test_provider::GOERLI;

pub use test_provider::MAINNET;

pub use test_provider::ROPSTEN;

Modules

call_raw

Overrides for the eth_call rpc method

ens

Ethereum Name Service support Adapted from https://github.com/hhatto/rust-ens/blob/master/src/lib.rs

erc

ERC related utilities. Only supporting NFTs for now.

test_provider

Pre-instantiated Infura HTTP clients which rotate through multiple API keys to prevent rate limits

Structs

DevRpcMiddleware

EscalatingPending

An EscalatingPending is a pending transaction that increases its own gas price over time, by broadcasting successive versions with higher gas prices.

FilterWatcher

Streams data from an installed filter via eth_getFilterChanges

Http

A low-level JSON-RPC Client over HTTP.

HttpRateLimitRetryPolicy

Implements RetryPolicy that will retry requests that errored with status code 429 i.e. TOO_MANY_REQUESTS

Ipc

Unix Domain Sockets (IPC) transport.

LogQuery

MockProvider

Mock transport used in test environments.

PendingTransaction

A pending transaction is a transaction which has been submitted but is not yet mined. await’ing on a pending transaction will resolve to a transaction receipt once the transaction has enough confirmations. The default number of confirmations is 1, but may be adjusted with the confirmations method. If the transaction does not have enough confirmations or is not mined, the future will stay in the pending state.

Provider

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

QuorumProvider

A provider that bundles multiple providers and only returns a value to the caller once the quorum has been reached.

RetryClient

RetryClient presents as a wrapper around JsonRpcClient that will retry requests based with an exponential backoff and filtering based on RetryPolicy.

RetryClientBuilder

RwClient

A client contains two clients.

SubscriptionStream

Streams data from an installed filter via eth_subscribe

TransactionStream

Drains a stream of transaction hashes and yields entire Transaction.

WeightedProvider