From ethers-rs
to Alloy.

Migrate one read before the whole application.

The ethers-rs repository is archived and its maintainers direct users to Alloy. Existing applications do not automatically stop working, but a migration needs more than a dependency rename. Read the ethers-rs notice.

Our suggested first milestone is a separate executable that reads a block number. Keep the old application running while you compare one feature at a time. This makes it easier to distinguish a migration regression from an RPC outage.

The API cheat sheet

Mappings checked against Alloy's migration reference. Some middleware has no planned direct replacement; inventory your dependencies before removing ethers.

Your first Alloy provider

Create a small binary project with cargo new alloy-read-check, then open its folder. Add these dependencies to its existing Cargo.toml. Keep default features enabled for this first example.

Cargo.toml — dependencies

[dependencies]
alloy = "=2.4.2"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

src/main.rs

use alloy::providers::{Provider, ProviderBuilder};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let endpoint = std::env::var("RPC_URL")?;
    let client = ProviderBuilder::new().connect_http(endpoint.parse()?);
    let height = client.get_block_number().await?;
    println!("Connected. Latest block: {height}");
    Ok(())
}

Set RPC_URL to an Ethereum HTTP endpoint that you can access. These examples use a public endpoint; availability and rate limits can vary.

Linux / macOS shell

RPC_URL=https://ethereum-rpc.publicnode.com cargo run

Windows PowerShell

$env:RPC_URL = "https://ethereum-rpc.publicnode.com"
cargo run

The expected result is a block height, not a fixed number. This program reads chain data and sends no transaction. The exact version pin makes the initial migration target explicit; review upgrades separately.

API shape checked against the official HTTP example and installation guide. These snippets have been documentation-reviewed, not compiled by Ether.rs. Run cargo check in your own toolchain before integrating them.

Preserve amounts as integers.

Replace src/main.rs temporarily with this separate conversion example. A decimal string lets you express 0.001 ETH without first introducing floating-point rounding.

Standalone unit conversion

use alloy::primitives::utils::{parse_ether, format_ether};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let amount = parse_ether("0.001")?;
    println!("Wei: {amount}");
    println!("ETH: {}", format_ether(amount));
    Ok(())
}

The Wei value should be 1000000000000000. Compare it with the Wei → ETH converter. For gas, remember that a price in Gwei is a price per unit of gas; use the gas calculator to check a complete fee scenario.

Formatting helpers are exposed under Alloy's primitive utilities. Do not assume every ERC-20 token uses ETH's 18 decimals.

When the first compile fails

A practical migration checkpoint

• Confirm the RPC endpoint uses the intended chain.
• Compare a read against a fixed block so moving chain state does not obscure differences.
• Check integer amounts, ABI inputs and returned values at module boundaries.
• Test a failed RPC call and a reverted contract call, not only successful reads.
• Move signing and transaction submission only after the read path passes; exercise writes on a local fork or test network first.
• Run your project tests and inspect the dependency tree before removing ethers.

Commit Cargo.lock for your application and retain your comparison fixtures. A migration is complete when the behaviors your application relies on agree—not simply when the imports compile.