Getting Started

cargo add alloy

use alloy::{
    network::TransactionBuilder,
    primitives::{
        address,
        utils::{format_ether, Unit},
        U256,
    },
    providers::{Provider, ProviderBuilder},
    rpc::types::TransactionRequest,
    signers::local::PrivateKeySigner,
};
use std::error::Error;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Initialize a signer with a private key
    let signer: PrivateKeySigner =
        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80".parse()?;
 
    // Instantiate a provider with the signer and a local anvil node
    let provider = ProviderBuilder::new() 
        .wallet(signer) 
        .connect("http://127.0.0.1:8545") 
        .await?;
 
    // Prepare a transaction request to send 100 ETH to Alice
    let alice = address!("0x70997970C51812dc3A010C7d01b50e0d17dc79C8"); 
    let value = Unit::ETHER.wei().saturating_mul(U256::from(100)); 
    let tx = TransactionRequest::default() 
        .with_to(alice) 
        .with_value(value); 
 
    // Send the transaction and wait for the broadcast
    let pending_tx = provider.send_transaction(tx).await?; 
    println!("Pending transaction... {}", pending_tx.tx_hash());
 
    // Wait for the transaction to be included and get the receipt
    let receipt = pending_tx.get_receipt().await?; 
    println!(
        "Transaction included in block {}",
        receipt.block_number.expect("Failed to get block number")
    );
 
    println!("Transferred {:.5} ETH to {alice}", format_ether(value));
 
    Ok(())
}

use alloy::{
    primitives::{
        address,
        utils::{format_ether, Unit},
        U256,
    },
    providers::ProviderBuilder,
    signers::local::PrivateKeySigner,
    sol,
};
use std::error::Error;
 
// Generate bindings for the WETH9 contract
sol! { 
    #[sol(rpc)] 
    contract WETH9 { 
        function deposit() public payable; 
        function balanceOf(address) public view returns (uint256); 
        function withdraw(uint amount) public; 
    } 
} 
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Initialize a signer with a private key
    let signer: PrivateKeySigner =
        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80".parse()?;
 
    // Instantiate a provider with the signer
    let provider = ProviderBuilder::new() 
        .wallet(signer) 
        .connect_anvil_with_config(|a| a.fork("https://reth-ethereum.ithaca.xyz/rpc"));
 
    // Setup WETH contract instance
    let weth_address = address!("0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2");
    let weth = WETH9::new(weth_address, provider.clone()); 
 
    // Read initial balance
    let from_address = signer.address();
    let initial_balance = weth.balanceOf(from_address).call().await?; 
    println!("Initial WETH balance: {} WETH", format_ether(initial_balance));
 
    // Write: Deposit ETH to get WETH
    let deposit_amount = Unit::ETHER.wei().saturating_mul(U256::from(10));
    let deposit_tx = weth.deposit().value(deposit_amount).send().await?; 
    let deposit_receipt = deposit_tx.get_receipt().await?; 
    println!(
        "Deposited ETH in block {}",
        deposit_receipt.block_number.expect("Failed to get block number")
    );
 
    // Read: Check updated balance after deposit
    let new_balance = weth.balanceOf(from_address).call().await?;
    println!("New WETH balance: {} WETH", format_ether(new_balance));
 
    // Write: Withdraw some WETH back to ETH
    let withdraw_amount = Unit::ETHER.wei().saturating_mul(U256::from(5));
    let withdraw_tx = weth.withdraw(withdraw_amount).send().await?; 
    let withdraw_receipt = withdraw_tx.get_receipt().await?; 
    println!(
        "Withdrew ETH in block {}",
        withdraw_receipt.block_number.expect("Failed to get block number")
    );
 
    // Read: Final balance check
    let final_balance = weth.balanceOf(from_address).call().await?; 
    println!("Final WETH balance: {} WETH", format_ether(final_balance));
 
    Ok(())
}

default = ["std", "reqwest", "alloy-core/default", "essentials"]
 
# std
std = [
    "alloy-core/std",
    "alloy-eips?/std",
    "alloy-genesis?/std",
    "alloy-serde?/std",
    "alloy-consensus?/std",
]
# enable basic network interactions out of the box.
essentials = ["contract", "provider-http", "rpc-types", "signer-local"]

[dependencies]
alloy-primitives = { version = "1.0", default-features = false, features = ["rand", "serde", "map-foldhash"] }
alloy-provider = { version = "0.15", default-features = false, features = ["ipc"] }
# ..snip..