Struct Evm 

pub struct Evm {
    pub client: EvmClient,
}

EVM Client for interacting with various EVM chains

Fields

client: EvmClient

Implementations

impl Evm

pub async fn get_block_by_number( &self, block_number: BlockNumber, ) -> Result<Option<Block<H256>>, EvmError>

Get block by number (height) - returns block with transaction hashes

pub async fn get_block_by_hash( &self, block_hash: H256, ) -> Result<Option<Block<H256>>, EvmError>

Get block by hash - returns block with transaction hashes

pub async fn get_block_with_txs( &self, block_number: BlockNumber, ) -> Result<Option<Block<Transaction>>, EvmError>

Get block with full transaction details

pub async fn get_block_with_txs_by_hash( &self, block_hash: H256, ) -> Result<Option<Block<Transaction>>, EvmError>

Get block with full transaction details by hash

pub async fn new(evm_type: EvmType) -> Result<Self, EvmError>

Create a new EVM client without wallet

Example

use evm_utils::Evm;
use evm_client::EvmType;

async fn example() -> Result<(), Box<dyn std::error::Error>> {
let evm = Evm::new(EvmType::Ethereum).await?;
let chain_id = evm.get_chain_id().await?;
println!("Connected to chain ID: {}", chain_id);
Ok(())
}

pub async fn with_wallet( evm_type: EvmType, private_key: &str, ) -> Result<Self, EvmError>

Create a new EVM client with wallet

Example

use evm_utils::Evm;
use evm_client::EvmType;

async fn example() -> Result<(), Box<dyn std::error::Error>> {
let private_key = "your_private_key_here";
let evm = Evm::with_wallet(EvmType::Ethereum, private_key).await?;
let balance = evm.get_wallet_balance().await?;
println!("Wallet balance: {}", balance);
Ok(())
}

pub async fn get_chain_id(&self) -> Result<u64, EvmError>

Get chain ID

Example

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let chain_id = evm.get_chain_id().await?;
println!("Chain ID: {}", chain_id);
Ok(())
}

pub async fn get_block_number(&self) -> Result<u64, EvmError>

Get block number

Example

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let block_number = evm.get_block_number().await?;
println!("Current block number: {}", block_number);
Ok(())
}

pub async fn get_balance(&self, address: Address) -> Result<U256, EvmError>

Get balance of an address

Example

use ethers::types::Address;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let address: Address = "0x742d35Cc6634C0532925a3b8D6B5d7a4C03a3a7d".parse()?;
let balance = evm.get_balance(address).await?;
println!("Balance: {}", balance);
Ok(())
}

pub async fn get_transaction_count( &self, address: Address, ) -> Result<u64, EvmError>

Get transaction count (nonce) for an address

Example

use ethers::types::Address;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let address: Address = "0x742d35Cc6634C0532925a3b8D6B5d7a4C03a3a7d".parse()?;
let nonce = evm.get_transaction_count(address).await?;
println!("Nonce: {}", nonce);
Ok(())
}

pub async fn get_gas_price(&self) -> Result<U256, EvmError>

Get gas price

Example

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let gas_price = evm.get_gas_price().await?;
println!("Gas price: {}", gas_price);
Ok(())
}

pub async fn send_transaction( &self, tx: TransactionRequest, ) -> Result<H256, EvmError>

Send a raw transaction

Example

use ethers::types::{TransactionRequest, Address, U256};

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let to_address: Address = "0x742d35Cc6634C0532925a3b8D6B5d7a4C03a3a7d".parse()?;
let tx = TransactionRequest::new()
    .to(to_address)
    .value(U256::from(1000000000000000u64));
     
let tx_hash = evm.send_transaction(tx).await?;
println!("Transaction sent: {:?}", tx_hash);
Ok(())
}

pub async fn get_transaction_receipt( &self, tx_hash: H256, ) -> Result<Option<TransactionReceipt>, EvmError>

Get transaction receipt

Example

use ethers::types::H256;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let tx_hash: H256 = "0x...".parse()?;
let receipt = evm.get_transaction_receipt(tx_hash).await?;
if let Some(receipt) = receipt {
    println!("Transaction status: {}", receipt.status);
}
Ok(())
}

pub async fn get_logs(&self, filter: Filter) -> Result<Vec<Log>, EvmError>

Get logs by filter

Example

use ethers::types::Filter;
use ethers::types::Address;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let contract_address: Address = "0x...".parse()?;
let filter = Filter::new()
    .address(contract_address)
    .from_block(1000000)
    .to_block(1000100);
     
let logs = evm.get_logs(filter).await?;
println!("Found {} logs", logs.len());
Ok(())
}

pub async fn get_wallet_balance(&self) -> Result<U256, EvmError>

Get native token balance for the wallet

Example

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let balance = evm.get_wallet_balance().await?;
println!("Wallet balance: {}", balance);
Ok(())
}

pub fn get_trade_service(self: Arc<Self>) -> Trade

Get trade service for executing trades

Example

use std::sync::Arc;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let evm_arc = Arc::new(evm);
let trade_service = evm_arc.clone().get_trade_service();
Ok(())
}

pub fn get_trade_listener(self: Arc<Self>) -> TradeEventListener

Get trade event listener for monitoring trade events

Example

use std::sync::Arc;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let evm_arc = Arc::new(evm);
let trade_listener = evm_arc.clone().get_trade_listener();
Ok(())
}

pub fn get_mempool_service(self: Arc<Self>) -> MempoolService

Get mempool service for mempool interactions

Example

use std::sync::Arc;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let evm_arc = Arc::new(evm);
let mempool_service = evm_arc.clone().get_mempool_service();
Ok(())
}

pub fn get_mempool_listener(self: Arc<Self>) -> MempoolListener

Get mempool listener for monitoring mempool activities

Example

use std::sync::Arc;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
let evm_arc = Arc::new(evm);
let mempool_listener = evm_arc.clone().get_mempool_listener();
Ok(())
}

pub fn get_block_service(self: Arc<Self>) -> BlockService

Get block service for block-related operations

Example

use std::sync::Arc;

async fn example(evm: Evm) -> Result<(), Box<dyn std::error::Error>> {
    let evm_arc = Arc::new(evm);
    let block_service = evm_arc.clone().get_block_service();
     
    let latest_block = block_service.get_latest_block().await?;
    if let Some(block) = latest_block {
        println!("Latest block: #{}", block.number.unwrap_or_default());
    }
    Ok(())
}

pub async fn listen_latest_blocks( &self, ) -> Result<Receiver<Block<H256>>, EvmError>

Listen to the latest block (listen to newly generated blocks in real time)

Example

let mut block_receiver = trade_service.listen_latest_blocks().await?;

while let Some(block) = block_receiver.recv().await {
    println!("New block: #{}", block.number.unwrap_or_default());
}

Trait Implementations

impl Clone for Evm

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.