Struct ContractAnalyzer 

pub struct ContractAnalyzer { /* private fields */ }

Contract analyzer for EVM-based contracts

Implementations

impl ContractAnalyzer

pub fn new(evm: Arc<Evm>) -> Self

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

Retrieves comprehensive contract information

Example

use ethers::types::Address;
use std::str::FromStr;

let analyzer = ContractAnalyzer::new(evm_client);
let address = Address::from_str("0x742d35Cc6634C0532925a3b8D6B6f7C93D5A7A7A")?;
let contract_info = analyzer.get_contract_info(address).await?;
println!("Contract bytecode length: {}", contract_info.bytecode.len());

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

Retrieves contract bytecode from the blockchain

Example

let bytecode = analyzer.get_contract_bytecode(address).await?;
println!("Bytecode length: {} bytes", bytecode.len());

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

Retrieves deployed bytecode (runtime bytecode)

pub async fn get_storage_at( &self, address: Address, slot: H256, ) -> Result<Option<H256>, EvmError>

Retrieves storage value at specific slot

Example

let slot = H256::zero();
let value = analyzer.get_storage_at(address, slot).await?;
if let Some(storage_value) = value {
    println!("Storage value: {:?}", storage_value);
}

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

Analyzes storage layout of a contract

Example

let layout = analyzer.analyze_storage_layout(address).await?;
println!("Total storage size: {} bytes", layout.total_size);
for slot in layout.slots {
    println!("Slot {:?}: value {:?}, size {}", slot.slot, slot.value, slot.size);
}

pub fn extract_function_selectors(&self, bytecode: &Bytes) -> Vec<H256>

Extracts potential function selectors from bytecode

Example

let bytecode = analyzer.get_contract_bytecode(address).await?;
let selectors = analyzer.extract_function_selectors(&bytecode);
println!("Found {} potential function selectors", selectors.len());
for selector in selectors {
    println!("Selector: {:?}", selector);
}

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

Analyzes bytecode features and characteristics

Example

let features = analyzer.analyze_bytecode_features(address).await?;
println!("Is proxy: {}", features.is_proxy);
println!("Has selfdestruct: {}", features.has_selfdestruct);
println!("Bytecode length: {}", features.bytecode_length);

pub async fn compare_contracts( &self, address1: Address, address2: Address, ) -> Result<ContractSimilarity, EvmError>

Compares two contracts for similarity

Example

async fn example() -> Result<(), Box<dyn std::error::Error>> {
let similarity = analyzer.compare_contracts(address1, address2).await?;
println!("Bytecode similarity: {:.2}%", similarity.bytecode_similarity * 100.0);
println!("Common function selectors: {}", similarity.common_function_selectors.len());
Ok(())
}

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

Retrieves transaction statistics for a contract

Example

let stats = analyzer.get_transaction_stats(address).await?;
println!("Total transactions: {}", stats.total_transactions);
println!("First seen block: {}", stats.first_seen_block);
println!("Last seen block: {}", stats.last_seen_block);