Basic Setup

Complete provider setup with connection verification

This example demonstrates how to create Seismic providers in both signed and unsigned variants, verify the connection, and query basic chain state.

Balance RPC migration: On reth with PR #502, provider.get_balance() returns a compatibility placeholder, not native or sUSDC holdings. This applies even to signed providers. See Balance RPCs for explicit native queries.

Prerequisites

# Install Rust 1.82+
rustup update stable

# Set environment variables
export PRIVATE_KEY="0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
export RPC_URL="https://testnet-1.seismictest.net/rpc"

Cargo.toml — see Installation for the full template including the required [patch.crates-io] block:

[package]
name = "basic-setup"
version = "0.1.0"
edition = "2021"
rust-version = "1.82"

[dependencies]
seismic-prelude        = { git = "https://github.com/SeismicSystems/seismic-alloy" }
seismic-alloy-network  = { git = "https://github.com/SeismicSystems/seismic-alloy" }
seismic-alloy-provider = { git = "https://github.com/SeismicSystems/seismic-alloy" }
alloy-provider         = "1.1"
alloy-signer-local     = "1.1"
alloy-primitives       = "1.1"
tokio                  = { version = "1", features = ["full"] }
reqwest                = "0.12"

# [patch.crates-io] block required — see Installation.

Signed Provider (Full Capabilities)

A signed provider can send shielded writes, perform signed reads, and execute all standard Alloy provider operations.

use seismic_prelude::client::*;
use seismic_alloy_network::reth::SeismicReth;
use alloy_provider::Provider;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load private key from environment
    let signer: PrivateKeySigner = std::env::var("PRIVATE_KEY")?.parse()?;
    let address = signer.address();
    let wallet = SeismicWallet::<SeismicReth>::from(signer);
    let url: reqwest::Url = std::env::var("RPC_URL")?.parse()?;

    // Create signed provider (fetches TEE pubkey automatically)
    let provider = SeismicProviderBuilder::new()
        .wallet(wallet)
        .connect_http(url)
        .await?;

    // Verify connection
    let block_number = provider.get_block_number().await?;
    println!("Block number: {block_number}");

    // Get chain ID
    let chain_id = provider.get_chain_id().await?;
    println!("Chain ID: {chain_id}");

    // Get TEE public key (cached from construction)
    let tee_pubkey = provider.get_tee_pubkey().await?;
    println!("TEE public key: {:?}", tee_pubkey);

    // Compatibility balance on updated reth, not spendable funds
    let balance = provider.get_balance(address).await?;
    println!("Address: {address}");
    println!("Balance: {balance} wei");

    Ok(())
}

Unsigned Provider (Read-Only)

An unsigned provider does not require a private key. It can query chain state, read public data, and subscribe to events (via WebSocket), but cannot send transactions or perform signed reads.

use seismic_prelude::client::*;
use alloy_provider::Provider;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url: reqwest::Url = std::env::var("RPC_URL")?.parse()?;

    // Create unsigned provider (no private key needed)
    // connect_http is synchronous for unsigned providers
    let provider = SeismicProviderBuilder::new().connect_http(url);

    // Verify connection
    let block_number = provider.get_block_number().await?;
    println!("Block number: {block_number}");

    // Get chain ID
    let chain_id = provider.get_chain_id().await?;
    println!("Chain ID: {chain_id}");

    // Get TEE public key
    let tee_pubkey = provider.get_tee_pubkey().await?;
    println!("TEE public key: {:?}", tee_pubkey);

    // Ordinary balance requests return a placeholder on updated reth
    let address = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266".parse()?;
    let balance = provider.get_balance(address).await?;
    println!("Balance: {balance} wei");

    Ok(())
}

Network Selection

The builder defaults to SeismicReth (production). Use .foundry() for local development:

use seismic_prelude::client::*;
use seismic_alloy_network::foundry::SeismicFoundry;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let signer: PrivateKeySigner = std::env::var("PRIVATE_KEY")?.parse()?;

    // For production / testnet (SeismicReth — default)
    let wallet = SeismicWallet::from(signer.clone());
    let url: reqwest::Url = std::env::var("RPC_URL")?.parse()?;
    let provider = SeismicProviderBuilder::new()
        .wallet(wallet)
        .connect_http(url)
        .await?;
    println!("Production block: {}", provider.get_block_number().await?);

    // For local development (SeismicFoundry)
    // let local_wallet = SeismicWallet::<SeismicFoundry>::from(signer);
    // let provider = SeismicProviderBuilder::new()
    //     .foundry()
    //     .wallet(local_wallet)
    //     .connect_http("http://127.0.0.1:8545".parse()?)
    //     .await?;

    Ok(())
}

Local Development with Sanvil

For local testing using Sanvil (Seismic Anvil):

use seismic_prelude::client::*;
use seismic_alloy_network::foundry::SeismicFoundry;
use alloy_node_bindings::Anvil;
use alloy_provider::Provider;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Spawn a local Sanvil instance
    let anvil = Anvil::at("sanvil").spawn();

    // Use one of the pre-funded accounts
    let signer: PrivateKeySigner = anvil.keys()[0].clone().into();
    let wallet = SeismicWallet::<SeismicFoundry>::from(signer);

    // Connect to the local instance
    let provider = SeismicProviderBuilder::new()
        .foundry()
        .wallet(wallet)
        .connect_http(anvil.endpoint_url())
        .await?;

    let block = provider.get_block_number().await?;
    println!("Local Sanvil block: {block}");

    let chain_id = provider.get_chain_id().await?;
    println!("Chain ID: {chain_id}");

    Ok(())
}

Anvil::at("sanvil") requires sanvil to be installed and available on your PATH. See the Seismic Foundry documentation for installation instructions.

Error Handling

use seismic_prelude::client::*;
use seismic_alloy_network::reth::SeismicReth;
use alloy_provider::Provider;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let signer: PrivateKeySigner = std::env::var("PRIVATE_KEY")?.parse()?;
    let wallet = SeismicWallet::<SeismicReth>::from(signer);
    let url: reqwest::Url = std::env::var("RPC_URL")?.parse()?;

    // Provider creation can fail if the node is unreachable
    // or the TEE pubkey fetch times out
    let provider = match SeismicProviderBuilder::new()
        .wallet(wallet)
        .connect_http(url)
        .await
    {
        Ok(p) => {
            println!("Provider created successfully");
            p
        }
        Err(e) => {
            eprintln!("Failed to create provider: {e}");
            eprintln!("Check that RPC_URL is reachable and the node is running");
            return Err(e.into());
        }
    };

    // Verify the connection is healthy
    match provider.get_block_number().await {
        Ok(block) => println!("Connected. Block number: {block}"),
        Err(e) => {
            eprintln!("Connection check failed: {e}");
            return Err(e.into());
        }
    }

    Ok(())
}

Expected Output

Block number: 12345
Chain ID: 5124
TEE public key: PublicKey(028e76821eb4d77fd30223ca971c49738eb5b5b71eabe93f96b348fdce788ae5a0)
Address: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
Balance: <compatibility placeholder on updated reth> wei

Next Steps

Shielded Write Complete - Send encrypted transactions
Signed Read Pattern - Execute authenticated calls
Contract Deployment - Deploy and interact with contracts