> For the complete documentation index, see [llms.txt](https://docs.seismic.systems/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.seismic.systems/clients/alloy/chains/seismic-testnet.md).

# Seismic Testnet

Seismic public testnet connection and configuration

The Seismic public testnet is the primary network for development and testing. It runs a full reth-based Seismic node with TEE support, shielded transactions, and all protocol features.

## Configuration

| Property          | Value                                   |
| ----------------- | --------------------------------------- |
| Chain ID          | `5124`                                  |
| RPC URL           | `https://testnet-1.seismictest.net/rpc` |
| Network Type      | `SeismicReth`                           |
| Transaction Types | Legacy, EIP-1559, Seismic (`0x4A`)      |

## Connecting

### Signed Provider (Full Capabilities)

Use a signed provider for sending transactions, shielded writes, and signed reads:

```rust
use seismic_prelude::client::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let signer: PrivateKeySigner = "0xYOUR_PRIVATE_KEY".parse()?;
    let wallet = SeismicWallet::<SeismicReth>::from(signer);
    let url = "https://testnet-1.seismictest.net/rpc".parse()?;

    let provider = SeismicProviderBuilder::new()
        .wallet(wallet)
        .connect_http(url)
        .await?;

    // Verify connection
    let block_number = provider.get_block_number().await?;
    let chain_id = provider.get_chain_id().await?;
    println!("Connected to chain {chain_id} at block {block_number}");

    Ok(())
}
```

### Unsigned Provider (Read-Only)

Use an unsigned provider for read-only operations that do not require a private key:

```rust
use seismic_prelude::client::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://testnet-1.seismictest.net/rpc".parse()?;
    let provider = SeismicProviderBuilder::new()
        .connect_http(url)
        .await?;

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

    Ok(())
}
```

### With Builder Pattern

If you prefer to specify the network type explicitly:

```rust
use seismic_prelude::client::*;

let signer: PrivateKeySigner = "0xYOUR_PRIVATE_KEY".parse()?;
let wallet = SeismicWallet::<SeismicReth>::from(signer);
let url = "https://testnet-1.seismictest.net/rpc".parse()?;

let provider = SeismicProviderBuilder::new()
    .wallet(wallet)
    .connect_http(url)
    .await?;
```

## Examples

### Send a Shielded Transaction

```rust
use seismic_prelude::client::*;
use alloy_primitives::address;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let signer: PrivateKeySigner = "0xYOUR_PRIVATE_KEY".parse()?;
    let wallet = SeismicWallet::<SeismicReth>::from(signer);
    let url = "https://testnet-1.seismictest.net/rpc".parse()?;

    let provider = SeismicProviderBuilder::new()
        .wallet(wallet)
        .connect_http(url)
        .await?;

    // Build a Seismic transaction
    // The filler pipeline automatically handles:
    // - Encryption elements
    // - Calldata encryption
    // - Gas estimation
    // - Nonce and chain ID
    // - Signing

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

    Ok(())
}
```

### Check Connection

```rust
use seismic_prelude::client::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://testnet-1.seismictest.net/rpc".parse()?;
    let provider = SeismicProviderBuilder::new()
        .connect_http(url)
        .await?;

    match provider.get_chain_id().await {
        Ok(chain_id) => println!("Connected to chain {chain_id}"),
        Err(e) => println!("Connection failed: {e}"),
    }

    Ok(())
}
```

### Using Environment Variables

```rust
use seismic_prelude::client::*;
use std::env;

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

    let rpc_url = env::var("SEISMIC_RPC_URL")
        .unwrap_or_else(|_| "https://testnet-1.seismictest.net/rpc".to_string());
    let url = rpc_url.parse()?;

    let provider = SeismicProviderBuilder::new()
        .wallet(wallet)
        .connect_http(url)
        .await?;

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

    Ok(())
}
```

## Notes

* Chain ID `5124` is used for EIP-155 and EIP-712 transaction signing
* The testnet supports all Seismic protocol features including shielded transactions and signed reads
* The TEE public key is fetched automatically by `SeismicElementsFiller` on the first transaction
* WebSocket endpoints may be available; check the Seismic documentation for current URLs
* The testnet is suitable for development and testing but not for production use

## See Also

* [Chains Overview](/clients/alloy/chains.md) - All supported chains
* [Sanvil](/clients/alloy/chains/sanvil.md) - Local development network
* [SeismicReth](/clients/alloy/network/seismic-reth.md) - Network type used with testnet
* [SeismicSignedProvider](/clients/alloy/provider/seismic-signed-provider.md) - Full-featured provider
* [Installation](/clients/alloy/installation.md) - Cargo setup and prerequisites


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.seismic.systems/clients/alloy/chains/seismic-testnet.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.