Rust

rust-web3 is the long-standing crate for talking to Ethereum from Rust, and it's what the examples here use. (The newer ethers-rs and alloy crates have taken over much new development, so check them if you're starting fresh — but rust-web3 still works and the patterns carry over.) It's built on Tokio, so the async runtime isn't optional: add tokio = { version = "1", features = ["full"] } alongside web3 = "0.19" in your Cargo.toml, and every call to chain 1 becomes an .await inside a Tokio task.

rust-web3 leans on Tokio for its async machinery, so the runtime is a hard dependency. Add tokio = { version = "1", features = ["full"] } and web3 = "0.19" to your Cargo.toml before connecting to Ethereum.

Web3-rs

Connecting is two steps: build an HTTP transport with web3::transports::Http::new(url) pointing at the Ethereum endpoint, then wrap it in Web3::new(transport). The transport constructor itself returns a Result, and so does every network call — eth().balance(...) gives you Result<U256, web3::Error>. Lean on the ? operator inside your async fn to propagate those errors up rather than unwrapping; a dropped connection or a bad address becomes a typed error your caller handles, not a panic mid-request.

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}

GitHub: https://github.com/tomusdrw/rust-web3
Docs: https://docs.rs/web3
Fully async, built on Tokio
Type-safe interfaces with U256, Address, and H256 primitives
Contract interaction loaded from a Solidity ABI
Transaction construction, signing, and submission
ENS resolution for .eth names
WebSocket transport for streaming Ethereum subscriptions

Contract Integration

Contract::from_json takes the eth() handle, an address, and the ABI bytes, and returns a Contract bound to that deployment on Ethereum. The two verbs to keep straight: contract.query(...) runs a read as an eth_call and decodes the return into the Rust type you ask for — perfect for an ERC-20 balanceOf — while contract.call(...) submits a state-changing transaction and returns its hash. Mixing them up is the most common beginner slip; query never touches the chain's state, call always does.

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}

Error Handling

Rather than pass web3::Error around everywhere, derive a domain error enum with thiserror and fold the library error in through #[from], as the EthereumError below does. That gives you one error type to match on, with variants for invalid addresses and failed transactions that read clearly in a Result. Pair it with safe_ wrappers that do the wei-to-ether conversion at the boundary: a balance comes back as U256 wei, and dividing by 1e18 into an f64 is fine for display — just remember that f64 loses precision, so never feed that float back into anything that signs or settles on Ethereum.

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}

Async Event Handling

subscribe_new_heads hands back a Stream of block headers, which means you need the WebSocket transport — eth_subscribe doesn't ride HTTP, so connect over wss://ethereum.therpc.io/YOUR_API_KEY rather than the HTTPS URL. Bring futures::StreamExt into scope and drain the stream with while let Some(block) = stream.next().await, matching each item as Ok(header) or an error. Since Ethereum produces a header roughly every 12 seconds, the loop spends most of its time parked on .await rather than spinning.

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}

Testing

Mark async tests with #[tokio::test] so each one gets its own runtime — a plain #[test] can't .await. Point those tests at a local node on http://localhost:8545 (anvil or a geth dev chain) or a mainnet fork, not the production endpoint. Hammering the live Ethereum connection from a test suite burns CUs on every CI run and makes assertions flaky, since real chain 1 state moves with each block; a forked or local chain stays deterministic.

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}