Struct ethers_etherscan::Client

pub struct Client { /* private fields */ }

The Etherscan.io API client.

Implementations

impl Client

pub async fn get_ether_balance_single(
    &self,
    address: &Address,
    tag: Option<Tag>
) -> Result<AccountBalance, EtherscanError>

Returns the Ether balance of a given address.

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let balance = client
        .get_ether_balance_single(&"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap(),
        None).await.unwrap();

pub async fn get_ether_balance_multi(
    &self,
    addresses: &[&Address],
    tag: Option<Tag>
) -> Result<Vec<AccountBalance>, EtherscanError>

Returns the balance of the accounts from a list of addresses.

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let balances = client
        .get_ether_balance_multi(&vec![&"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap()],
        None).await.unwrap();

pub async fn get_transactions(
    &self,
    address: &Address,
    params: Option<TxListParams>
) -> Result<Vec<NormalTransaction>, EtherscanError>

Returns the list of transactions performed by an address, with optional pagination.

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let txs = client
        .get_transactions(&"0x58eB28A67731c570Ef827C365c89B5751F9E6b0a".parse().unwrap(),
        None).await.unwrap();

pub async fn get_internal_transactions(
    &self,
    tx_query_option: InternalTxQueryOption,
    params: Option<TxListParams>
) -> Result<Vec<InternalTransaction>, EtherscanError>

Returns the list of internal transactions performed by an address or within a transaction, with optional pagination.

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let txs = client
        .get_internal_transactions(
            InternalTxQueryOption::ByAddress(
                "0x2c1ba59d6f58433fb1eaee7d20b26ed83bda51a3".parse().unwrap()), None).await.unwrap();

pub async fn get_erc20_token_transfer_events(
    &self,
    event_query_option: TokenQueryOption,
    params: Option<TxListParams>
) -> Result<Vec<ERC20TokenTransferEvent>, EtherscanError>

Returns the list of ERC-20 tokens transferred by an address, with optional filtering by token contract.

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let txs = client
        .get_erc20_token_transfer_events(
            TokenQueryOption::ByAddress(
                "0x4e83362442b8d1bec281594cea3050c8eb01311c".parse().unwrap()), None).await.unwrap();

pub async fn get_erc721_token_transfer_events(
    &self,
    event_query_option: TokenQueryOption,
    params: Option<TxListParams>
) -> Result<Vec<ERC721TokenTransferEvent>, EtherscanError>

Returns the list of ERC-721 ( NFT ) tokens transferred by an address, with optional filtering by token contract.

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let txs = client
        .get_erc721_token_transfer_events(
            TokenQueryOption::ByAddressAndContract(
                "0x6975be450864c02b4613023c2152ee0743572325".parse().unwrap(),
                "0x06012c8cf97bead5deae237070f9587f8e7a266d".parse().unwrap(),
         ), None).await.unwrap();

pub async fn get_mined_blocks(
    &self,
    address: &Address,
    block_type: Option<BlockType>,
    page_and_offset: Option<(u64, u64)>
) -> Result<Vec<MinedBlock>, EtherscanError>

Returns the list of blocks mined by an address.

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let blocks = client
        .get_mined_blocks(&"0x9dd134d14d1e65f84b706d6f205cd5b1cd03a46b".parse().unwrap(), None, None)
        .await.unwrap();

impl Client

pub async fn submit_contract_verification(
    &self,
    contract: &VerifyContract
) -> Result<Response<String>, EtherscanError>

Submit Source Code for Verification

pub async fn check_contract_verification_status(
    &self,
    guid: impl AsRef<str>
) -> Result<Response<String>, EtherscanError>

Check Source Code Verification Status with receipt received from [Self::submit_contract_verification]

pub async fn contract_abi(&self, address: Address) -> Result<Abi, EtherscanError>

Returns the contract ABI of a verified contract

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let abi = client
        .contract_abi("0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413".parse().unwrap())
        .await.unwrap();

pub async fn contract_source_code(
    &self,
    address: Address
) -> Result<ContractMetadata, EtherscanError>

Get Contract Source Code for Verified Contract Source Codes

    let client = Client::new(Chain::Mainnet, "API_KEY").unwrap();
    let meta = client
        .contract_source_code("0xBB9bc244D798123fDe783fCc1C72d3Bb8C189413".parse().unwrap())
        .await.unwrap();
    let code = meta.source_code();

impl Client

pub async fn gas_estimate(&self, gas_price: U256) -> Result<u32, EtherscanError>

Returns the estimated time, in seconds, for a transaction to be confirmed on the blockchain for the specified gas price

pub async fn gas_oracle(&self) -> Result<GasOracle, EtherscanError>

Returns the current Safe, Proposed and Fast gas prices Post EIP-1559 changes:

• Safe/Proposed/Fast gas price recommendations are now modeled as Priority Fees.
• New field suggestBaseFee, the baseFee of the next pending block
• New field gasUsedRatio, to estimate how busy the network is

impl Client

pub async fn check_contract_execution_status(
    &self,
    tx_hash: impl AsRef<str>
) -> Result<(), EtherscanError>

Returns the status of a contract execution

pub async fn check_transaction_receipt_status(
    &self,
    tx_hash: impl AsRef<str>
) -> Result<(), EtherscanError>

Returns the status of a transaction execution: false for failed and true for successful

impl Client

pub fn builder() -> ClientBuilder

Creates a ClientBuilder to configure a Client. This is the same as ClientBuilder::default().

Example

use ethers_core::types::Chain;
use ethers_etherscan::Client;
let client = Client::builder().with_api_key("<API KEY>").chain(Chain::Mainnet).unwrap().build().unwrap();

pub fn new_cached(
    chain: Chain,
    api_key: impl Into<String>,
    cache_root: Option<PathBuf>,
    cache_ttl: Duration
) -> Result<Self, EtherscanError>

Creates a new instance that caches etherscan requests

pub fn new(
    chain: Chain,
    api_key: impl Into<String>
) -> Result<Self, EtherscanError>

Create a new client with the correct endpoints based on the chain and provided API key

pub fn new_from_env(chain: Chain) -> Result<Self, EtherscanError>

Create a new client with the correct endpoints based on the chain and API key from ETHERSCAN_API_KEY environment variable

pub fn etherscan_api_url(&self) -> &Url

pub fn etherscan_url(&self) -> &Url

pub fn block_url(&self, block: u64) -> String

Return the URL for the given block number

pub fn address_url(&self, address: Address) -> String

Return the URL for the given address

pub fn transaction_url(&self, tx_hash: H256) -> String

Return the URL for the given transaction hash

pub fn token_url(&self, token_hash: Address) -> String

Return the URL for the given token hash

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Client

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

Formats the value using the given formatter.