Rust

1use web3::Web3;
2use web3::types::{Address, H256, TransactionParameters, U256};
3use std::str::FromStr;
4 
5struct EthereumClient {
6    web3: Web3<web3::transports::Http>,
7}
8 
9impl EthereumClient {
10    pub async fn new(url: &str) -> Result<Self, web3::Error> {
11        let transport = web3::transports::Http::new(url)?;
12        let web3 = Web3::new(transport);
13        Ok(Self { web3 })
14    }
15 
16    pub async fn get_balance(&self, address: &str) -> Result<U256, web3::Error> {
17        let address = Address::from_str(address)
18            .map_err(|_| web3::Error::InvalidAddress)?;
19 
20        self.web3.eth().balance(address, None).await
21    }
22 
23    pub async fn send_transaction(
24        &self,
25        from: Address,
26        to: Address,
27        value: U256,
28    ) -> Result<H256, web3::Error> {
29        let tx = TransactionParameters {
30            to: Some(to),
31            value,
32            from,
33            ..Default::default()
34        };
35 
36        self.web3.eth().send_transaction(tx).await
37    }
38}

1use web3::contract::{Contract, Options};
2use web3::types::{Address, U256};
3 
4struct SmartContract {
5    contract: Contract<web3::transports::Http>,
6}
7 
8impl SmartContract {
9    pub async fn new(
10        web3: Web3<web3::transports::Http>,
11        address: Address,
12        abi: &[u8],
13    ) -> Result<Self, web3::Error> {
14        let contract = Contract::from_json(
15            web3.eth(),
16            address,
17            abi,
18        )?;
19 
20        Ok(Self { contract })
21    }
22 
23    pub async fn call_method<T: serde::de::DeserializeOwned>(
24        &self,
25        method: &str,
26        params: &[web3::contract::tokens::Tokenize],
27    ) -> Result<T, web3::Error> {
28        let result = self.contract.query(
29            method,
30            params,
31            None,
32            Options::default(),
33            None,
34        ).await?;
35 
36        Ok(result)
37    }
38}

1use thiserror::Error;
2 
3#[derive(Error, Debug)]
4pub enum EthereumError {
5    #[error("Web3 error: {0}")]
6    Web3Error(#[from] web3::Error),
7 
8    #[error("Invalid address: {0}")]
9    InvalidAddress(String),
10 
11    #[error("Contract error: {0}")]
12    ContractError(String),
13 
14    #[error("Transaction failed: {0}")]
15    TransactionError(String),
16}
17 
18impl EthereumClient {
19    pub async fn safe_get_balance(&self, address: &str) -> Result<f64, EthereumError> {
20        let wei = self.get_balance(address).await?;
21        let eth = wei.as_u128() as f64 / 1e18;
22        Ok(eth)
23    }
24}

1use futures::StreamExt;
2 
3impl EthereumClient {
4    pub async fn monitor_blocks(&self) -> Result<(), web3::Error> {
5        let mut stream = self.web3.eth_subscribe().subscribe_new_heads().await?;
6 
7        while let Some(block) = stream.next().await {
8            match block {
9                Ok(header) => {
10                    println!("New block: {}", header.number.unwrap_or_default());
11                }
12                Err(e) => {
13                    eprintln!("Error: {}", e);
14                }
15            }
16        }
17 
18        Ok(())
19    }
20}

1#[cfg(test)]
2mod tests {
3    use super::*;
4    use tokio;
5 
6    #[tokio::test]
7    async fn test_balance_query() {
8        let client = EthereumClient::new("http://localhost:8545")
9            .await
10            .expect("Failed to create client");
11 
12        let balance = client
13            .get_balance("0x742d35Cc6634C0532925a3b844Bc454e4438f44e")
14            .await
15            .expect("Failed to get balance");
16 
17        assert!(balance > U256::zero());
18    }
19}