Struct web30::client::Web3

pub struct Web3 { /* fields omitted */ }

An instance of Web3Client.

Implementations

impl Web3

pub fn new(url: &str, timeout: Duration) -> Self

pub fn get_timeout(&self) -> Duration

pub fn get_url(&self) -> String

pub async fn eth_accounts(&self) -> Result<Vec<Address>, Web3Error>

pub async fn eth_chainid(&self) -> Result<Option<Uint256>, Web3Error>

Returns the EIP155 chain ID used for transaction signing at the current best block. Null is returned if not available.

pub async fn net_version(&self) -> Result<u64, Web3Error>

pub async fn eth_new_filter(
    &self,
    new_filter: NewFilter
) -> Result<Uint256, Web3Error>

pub async fn eth_get_filter_changes(
    &self,
    filter_id: Uint256
) -> Result<Vec<Log>, Web3Error>

pub async fn eth_uninstall_filter(
    &self,
    filter_id: Uint256
) -> Result<bool, Web3Error>

pub async fn eth_get_logs(
    &self,
    new_filter: NewFilter
) -> Result<Vec<Log>, Web3Error>

pub async fn eth_get_transaction_count(
    &self,
    address: Address
) -> Result<Uint256, Web3Error>

pub async fn eth_gas_price(&self) -> Result<Uint256, Web3Error>

pub async fn eth_estimate_gas(
    &self,
    transaction: TransactionRequest
) -> Result<Uint256, Web3Error>

pub async fn eth_get_balance(
    &self,
    address: Address
) -> Result<Uint256, Web3Error>

pub async fn eth_send_transaction(
    &self,
    transactions: Vec<TransactionRequest>
) -> Result<Uint256, Web3Error>

pub async fn eth_call(
    &self,
    transaction: TransactionRequest
) -> Result<Data, Web3Error>

pub async fn eth_call_at_height(
    &self,
    transaction: TransactionRequest,
    block: Uint256
) -> Result<Data, Web3Error>

pub async fn eth_block_number(&self) -> Result<Uint256, Web3Error>

pub async fn eth_get_block_by_number(
    &self,
    block_number: Uint256
) -> Result<Block, Web3Error>

pub async fn xdai_get_block_by_number(
    &self,
    block_number: Uint256
) -> Result<XdaiBlock, Web3Error>

pub async fn eth_get_concise_block_by_number(
    &self,
    block_number: Uint256
) -> Result<ConciseBlock, Web3Error>

pub async fn xdai_get_concise_block_by_number(
    &self,
    block_number: Uint256
) -> Result<ConciseXdaiBlock, Web3Error>

pub async fn eth_get_latest_block(&self) -> Result<ConciseBlock, Web3Error>

pub async fn xdai_get_latest_block(&self) -> Result<ConciseXdaiBlock, Web3Error>

pub async fn eth_get_latest_block_full(&self) -> Result<Block, Web3Error>

pub async fn xdai_get_latest_block_full(&self) -> Result<XdaiBlock, Web3Error>

pub async fn eth_send_raw_transaction(
    &self,
    data: Vec<u8>
) -> Result<Uint256, Web3Error>

pub async fn eth_get_transaction_by_hash(
    &self,
    hash: Uint256
) -> Result<Option<TransactionResponse>, Web3Error>

pub async fn evm_snapshot(&self) -> Result<Uint256, Web3Error>

pub async fn evm_revert(
    &self,
    snapshot_id: Uint256
) -> Result<Uint256, Web3Error>

pub async fn send_transaction(
    &self,
    to_address: Address,
    data: Vec<u8>,
    value: Uint256,
    own_address: Address,
    secret: PrivateKey,
    options: Vec<SendTxOption>
) -> Result<Uint256, Web3Error>

Sends a transaction which changes blockchain state. options takes a vector of SendTxOption for configuration unlike the lower level eth_send_transaction() this call builds the transaction abstracting away details like chain id, gas, and network id. WARNING: you must specify networkID in situations where a single node is operating no more than one chain. Otherwise it is possible for the full node to trick the client into signing transactions on unintended chains potentially to their benefit

pub async fn contract_call(
    &self,
    contract_address: Address,
    sig: &str,
    tokens: &[Token],
    own_address: Address,
    height: Option<Uint256>
) -> Result<Vec<u8>, Web3Error>

Sends a transaction which does not change blockchain state, usually to get information. optionally this data can come from some historic block

pub async fn wait_for_transaction(
    &self,
    tx_hash: Uint256,
    timeout: Duration,
    blocks_to_wait: Option<Uint256>
) -> Result<TransactionResponse, Web3Error>

Waits for a transaction with the given hash to be included in a block it will wait for at most timeout time and optionally can wait for n blocks to have passed

impl Web3

pub async fn check_erc20_approved(
    &self,
    erc20: Address,
    own_address: Address,
    target_contract: Address
) -> Result<bool, Web3Error>

Checks if any given contract is approved to spend money from any given erc20 contract using any given address. What exactly this does can be hard to grok, essentially when you want contract A to be able to spend your erc20 contract funds you need to call ‘approve’ on the ERC20 contract with your own address and A’s address so that in the future when you call contract A it can manipulate your ERC20 balances. This function checks if that has already been done.

pub async fn approve_erc20_transfers(
    &self,
    erc20: Address,
    eth_private_key: EthPrivateKey,
    target_contract: Address,
    timeout: Option<Duration>,
    options: Vec<SendTxOption>
) -> Result<Uint256, Web3Error>

Approves a given contract to spend erc20 funds from the given address from the erc20 contract provided. What exactly this does can be hard to grok, essentially when you want contract A to be able to spend your erc20 contract funds you need to call ‘approve’ on the ERC20 contract with your own address and A’s address so that in the future when you call contract A it can manipulate your ERC20 balances. This function performs that action and waits for it to complete for up to Timeout duration options takes a vector of SendTxOption for configuration unlike the lower level eth_send_transaction() this call builds the transaction abstracting away details like chain id, gas, and network id.

pub async fn erc20_send(
    &self,
    amount: Uint256,
    recipient: Address,
    erc20: Address,
    sender_private_key: EthPrivateKey,
    wait_timeout: Option<Duration>,
    options: Vec<SendTxOption>
) -> Result<Uint256, Web3Error>

Send an erc20 token to the target address, optionally wait until it enters the blockchain options takes a vector of SendTxOption for configuration unlike the lower level eth_send_transaction() this call builds the transaction abstracting away details like chain id, gas, and network id. WARNING: you must specify networkID in situations where a single node is operating no more than one chain. Otherwise it is possible for the full node to trick the client into signing transactions on unintended chains potentially to their benefit

pub async fn get_erc20_balance(
    &self,
    erc20: Address,
    target_address: Address
) -> Result<Uint256, Web3Error>

pub async fn get_erc20_name(
    &self,
    erc20: Address,
    caller_address: Address
) -> Result<String, Web3Error>

pub async fn get_erc20_symbol(
    &self,
    erc20: Address,
    caller_address: Address
) -> Result<String, Web3Error>

pub async fn get_erc20_decimals(
    &self,
    erc20: Address,
    caller_address: Address
) -> Result<Uint256, Web3Error>

impl Web3

pub async fn wait_for_event_alt<F: Fn(Log) -> bool + 'static>(
    &self,
    wait_time: Duration,
    contract_address: Vec<Address>,
    event: &str,
    topics: Vec<Vec<[u8; 32]>>,
    local_filter: F
) -> Result<Log, Web3Error>

Waits for a single event but instead of creating a filter and checking for changes this function waits for the provided wait time before checking if the event has occurred. This function will wait for at

pub async fn wait_for_event<F: Fn(Log) -> bool + 'static>(
    &self,
    wait_for: Duration,
    contract_address: Vec<Address>,
    event: &str,
    topics: Vec<Vec<[u8; 32]>>,
    local_filter: F
) -> Result<Log, Web3Error>

Sets up an event filter, waits for a single event to happen, then removes the filter. Includes a local filter. If a captured event does not pass this filter, it is ignored. This differs from wait_for_event_alt in that it will check for filter changes every second and potentially exit earlier than the wait_for time provided by the user.

pub async fn check_for_events(
    &self,
    start_block: Uint256,
    end_block: Option<Uint256>,
    contract_address: Vec<Address>,
    events: Vec<&str>
) -> Result<Vec<Log>, Web3Error>

Checks for multiple events as defined by their signature strings over a block range. If no ending block is provided the latest will be used. This function will not wait for events to occur.

pub async fn check_for_arbitrary_events(
    &self,
    start_block: Uint256,
    end_block: Option<Uint256>,
    contract_address: Vec<Address>,
    topics: Vec<Vec<[u8; 32]>>
) -> Result<Vec<Log>, Web3Error>

Checks for multiple events as defined by arbitrary user input over a block range. If no ending block is provided the latest will be used. This function will not wait for events to occur

impl Web3

pub async fn get_uniswap_price(
    &self,
    caller_address: Address,
    token_in: Address,
    token_out: Address,
    fee_uint24: Uint256,
    amount: Uint256,
    sqrt_price_limit_x96_uint160: Uint256,
    uniswap_quoter: Option<Address>
) -> Result<Uint256, Web3Error>

Trait Implementations

impl Clone for Web3

fn clone(&self) -> Web3

Returns a copy of the value.

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

Performs copy-assignment from source.