> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sei.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Node Operations on Sei

> Deploy and maintain Sei Network infrastructure with comprehensive guides for validators, RPC nodes, and archive nodes, including hardware requirements, installation steps, and operational best practices.

export const RandomPeers = ({format = 'bash', network = 'mainnet', count = 5}) => {
  const PEERS = {
    mainnet: ['d53ab7681ed0df3d3249fc0132df7c3a131c9c1a@45.250.253.40:51656', '4ee8aea5bb58e9038d72e74322e3bba755287398@202.8.8.183:11956', '81409623ae4da3ec7b400cf640dea0b0999a964b@57.128.230.96:51556', '61a5be64b5215786fe5da712584678d0626636b5@87.249.137.71:51556', 'f83c536f43df9a5d900cd3c2f702c04d7dddc7b5@136.243.67.45:11956', 'b8d600a2f568576b5a2df5ee649cf9b809389064@162.19.62.176:26756', '57860b18ed3e1bbe8901ba73f2e63c7e6fe8b3d3@57.129.54.81:26656', '04fc6bba6c5c33034811612dca31c7adda24b299@91.134.60.37:16856', 'de64b779c7f4091e6f1765f5ca4c46f9d3011732@65.108.70.106:46656', '3be6b24cf86a5938cce7d48f44fb6598465a9924@p2p.state-sync.pacific-1.seinetwork.io:26656', '70e0c91b83b5ed1beaca798267f2debdf97dac10@18.156.6.83:26656', 'dd6b1ae002a15c1c8a38e05660f49a93c75d4159@148.251.181.225:26656'],
    testnet: ['71beea83970431f55816eee5f066a611a1dc80f7@p2p.state-sync.atlantic-2.seinetwork.io:26656', '65c257f9275beb1b99ca169ef89743c034b15db0@3.76.192.224:26656', '33588592e477c5238ff2a5d8dc765f85790ef853@23.109.47.225:26656', 'babc3f3f7804933265ec9c40ad94f4da8e9e0017@testnet-seed.rhinostake.com:11956', '8542cd7e6bf9d260fef543bc49e59be5a3fa9074@seed.publicnode.com:56656']
  };
  const pickRandom = (arr, n) => {
    const shuffled = [...arr];
    for (let i = shuffled.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
    }
    return shuffled.slice(0, Math.min(n, arr.length));
  };
  const CopyIcon = ({className}) => <svg role="img" aria-label="Copy" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M7 7m0 2.667a2.667 2.667 0 0 1 2.667 -2.667h8.666a2.667 2.667 0 0 1 2.667 2.667v8.666a2.667 2.667 0 0 1 -2.667 2.667h-8.666a2.667 2.667 0 0 1 -2.667 -2.667z" />
      <path d="M4.012 16.737a2.005 2.005 0 0 1 -1.012 -1.737v-10c0 -1.1 .9 -2 2 -2h10c.75 0 1.158 .385 1.5 1" />
    </svg>;
  const CheckIcon = ({className}) => <svg role="img" aria-label="Copied" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M5 12l5 5l10 -10" />
    </svg>;
  const ShuffleIcon = ({className}) => <svg role="img" aria-label="Shuffle" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
      <path d="M16 3h5v5" />
      <path d="M4 20l16.2 -16.2" />
      <path d="M21 16v5h-5" />
      <path d="M15 15l6 6" />
      <path d="M4 4l5 5" />
    </svg>;
  const pool = PEERS[network] ?? [];
  const [peers, setPeers] = useState(() => pool.slice(0, count));
  const [copied, setCopied] = useState(false);
  const shuffle = () => {
    setPeers(pickRandom(pool, count));
  };
  useEffect(() => {
    shuffle();
  }, [network, count]);
  if (pool.length === 0) {
    return <div className="not-prose w-full">
        <pre className="m-0 p-3 rounded-md bg-neutral-100 dark:bg-neutral-800 text-sm opacity-70" style={{
      fontFamily: 'var(--sei-font-mono)'
    }}>
          No peers configured for network “{network}”.
        </pre>
      </div>;
  }
  const peerString = peers.join(',');
  const displayText = format === 'toml' ? `persistent_peers = "${peerString}"` : `PEERS="${peerString}"`;
  const handleCopy = async () => {
    try {
      await navigator.clipboard.writeText(displayText);
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    } catch {}
  };
  return <div className="not-prose w-full">
      <div className="relative">
        <pre className="m-0 px-4 py-3 pr-28 rounded-lg bg-neutral-100 dark:bg-neutral-900 text-[12.5px] leading-[1.55] whitespace-pre-wrap break-all border border-neutral-200 dark:border-neutral-700 text-neutral-900 dark:text-neutral-100" style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>
          <code style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>{displayText}</code>
        </pre>
        <div className="absolute top-2 right-2 flex items-center gap-1.5">
          <button type="button" onClick={shuffle} aria-label="Shuffle peers" title="Shuffle" className="inline-flex items-center gap-1 px-2 py-1 rounded-md text-[11px] font-semibold border border-neutral-300 dark:border-neutral-600 bg-white/80 dark:bg-neutral-800/80 text-neutral-700 dark:text-neutral-200 hover:bg-white dark:hover:bg-neutral-800 transition-colors">
            <ShuffleIcon />
            Shuffle
          </button>
          <button type="button" onClick={handleCopy} aria-label="Copy peers" title="Copy to clipboard" className="inline-flex items-center gap-1 px-2 py-1 rounded-md text-[11px] font-semibold border border-neutral-300 dark:border-neutral-600 bg-white/80 dark:bg-neutral-800/80 text-neutral-700 dark:text-neutral-200 hover:bg-white dark:hover:bg-neutral-800 transition-colors">
            {copied ? <>
                <CheckIcon className="text-green-600" />
                Copied
              </> : <>
                <CopyIcon />
                Copy
              </>}
          </button>
        </div>
      </div>
    </div>;
};

export const VersionTable = () => {
  const networks = [{
    label: 'Mainnet',
    chainId: 'pacific-1',
    rpcEndpoint: 'https://rpc.sei-apis.com',
    evmChainId: '1329'
  }, {
    label: 'Testnet',
    chainId: 'atlantic-2',
    rpcEndpoint: 'https://rpc-testnet.sei-apis.com',
    evmChainId: '1328'
  }];
  const [versions, setVersions] = useState({});
  useEffect(() => {
    const oneHour = 3600000;
    const setVersionFor = (chainId, version) => {
      setVersions(prev => ({
        ...prev,
        [chainId]: version
      }));
    };
    const fetchVersion = async (chainId, rpcEndpoint) => {
      try {
        const response = await fetch(`${rpcEndpoint}/abci_info`);
        const data = await response.json();
        const info = data && data.result && data.result.response || data && data.response || ({});
        const version = info.version;
        if (typeof version === 'string' && version) {
          setVersionFor(chainId, version);
          localStorage.setItem(`${chainId}-version`, version);
          localStorage.setItem(`${chainId}-version-timestamp`, Date.now().toString());
          return;
        }
        throw new Error('abci_info response had no version field');
      } catch (error) {
        console.error('Error fetching version:', error);
        if (!localStorage.getItem(`${chainId}-version`)) {
          setVersionFor(chainId, 'Unavailable');
        }
      }
    };
    networks.forEach(({chainId, rpcEndpoint}) => {
      const storedVersion = localStorage.getItem(`${chainId}-version`);
      const storedTimestamp = localStorage.getItem(`${chainId}-version-timestamp`);
      const isFresh = storedVersion && storedTimestamp && Date.now() - parseInt(storedTimestamp, 10) < oneHour;
      if (storedVersion) {
        setVersionFor(chainId, storedVersion);
      }
      if (!isFresh) {
        fetchVersion(chainId, rpcEndpoint);
      }
    });
  }, []);
  return <table className="min-w-full divide-y divide-neutral-200 dark:divide-neutral-800">
      <thead className="bg-neutral-50 dark:bg-neutral-900/50">
        <tr>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Network</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Version</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">Chain ID</th>
          <th className="px-4 py-3 text-left text-sm font-medium text-neutral-900 dark:text-neutral-100">EVM Chain ID</th>
        </tr>
      </thead>
      <tbody className="divide-y divide-neutral-200 dark:divide-neutral-800 bg-neutral-50 dark:bg-neutral-900/30">
        {networks.map(({label, chainId, evmChainId}) => <tr key={chainId}>
            <td className="px-4 py-3 text-sm font-medium text-neutral-900 dark:text-neutral-100">{label}</td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">
              <code style={{
    fontFamily: 'var(--sei-font-mono)'
  }}>{versions[chainId] || 'Fetching...'}</code>
            </td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">{chainId}</td>
            <td className="px-4 py-3 text-sm text-neutral-600 dark:text-neutral-400">{evmChainId}</td>
          </tr>)}
      </tbody>
    </table>;
};

**Power the Sei Network Infrastructure**

Comprehensive guides for running, maintaining, and optimizing Sei network nodes. Whether you're setting up a validator, an RPC node, or a relayer, you'll find detailed instructions and best practices to ensure optimal performance and security.

<CardGroup cols={4}>
  <Card horizontal title="RPC/API Nodes" icon="network-wired" />

  <Card horizontal title="Validator Nodes" icon="shield" />

  <Card horizontal title="Statesync Nodes" icon="shuffle" />

  <Card horizontal title="Archive Nodes" icon="database" />
</CardGroup>

## Network Versions

<VersionTable />

*Live binary versions, genesis, and seed peers — see the [technical reference](/node/technical-reference).*

## Hardware Requirements

| Component | Required                                           |
| --------- | -------------------------------------------------- |
| CPU       | 16 cores (Intel Xeon/Core i7/i9 or AMD Epyc/Ryzen) |
| RAM       | 256 GB DDR5 or better                              |
| Storage   | 2 TB NVMe SSD (high IOPS required)                 |
| Network   | 2 Gbps with low latency                            |

## Installation & Setup Steps

<Steps>
  <Step title="Environment Setup">
    ##### System Preparation

    ###### 1. Update and Upgrade System

    ```bash theme={"dark"}
    sudo apt update && sudo apt upgrade -y
    ```

    ###### 2. Install Essential Packages

    ```bash theme={"dark"}
    sudo apt install make gcc git jq chrony curl lz4 wget tar build-essential -y
    ```

    ###### 3. Synchronize System Time

    ```bash theme={"dark"}
    sudo timedatectl set-timezone UTC
    sudo systemctl enable --now chronyd
    timedatectl
    ```

    ##### Install Go

    Suggested Version: Go 1.24.x (required for seid v6.3+)

    ###### Installation Steps

    ```bash theme={"dark"}
    # Check for existing Go installation
    go version

    # Download and install Go 1.24.x
    wget https://go.dev/dl/go1.24.5.linux-amd64.tar.gz
    sudo tar -C /usr/local -xzf go1.24.5.linux-amd64.tar.gz

    # Add Go to your environment variables
    echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.bashrc
    source $HOME/.bashrc

    # Verify installation
    go version
    ```
  </Step>

  <Step title="Install Sei">
    ##### Install Sei Binary

    ```bash theme={"dark"}
    # Clone repository and install
    git clone https://github.com/sei-protocol/sei-chain.git
    cd sei-chain
    git checkout <version-tag>  # Replace with specific version
    make install

    # Verify installation
    seid version
    ```

    See Network Versions table above for current recommended version.

    <Accordion title="Alternative: Docker Image">
      Official Docker images are available at GitHub Container Registry.

      ```bash theme={"dark"}
      # Pull the latest version
      docker pull ghcr.io/sei-protocol/sei:latest

      # Or pull a specific version (recommended)
      docker pull ghcr.io/sei-protocol/sei:v6.3.1
      ```

      Available architectures: linux/amd64 and linux/arm64.
    </Accordion>

    <Info>
      If you encounter an error like `command not found: seid`, you may need to set your GOPATH environment variable.

      Add the following to your `~/.bashrc` or `~/.zshrc`:

      ```bash theme={"dark"}
      export GOPATH=$(go env GOPATH)
      export PATH=$PATH:$GOPATH/bin
      ```

      Then reload your shell with `source ~/.bashrc` or `source ~/.zshrc`.

      For more information see [here](https://pkg.go.dev/cmd/go#hdr-GOPATH_environment_variable).
    </Info>

    ##### Initialize Chain Files

    <Info>Default init mode is **full** (RPC/P2P bind to all interfaces). For **validator** or **seed** nodes, use `--mode validator` or `--mode seed` so RPC and P2P bind to localhost only. See the [Validator Operations Guide](/node/validators) for the full validator init example.</Info>

    Peers can be found here -

    * mainnet (pacific-1):

    <RandomPeers network="mainnet" format="bash" />

    * testnet (atlantic-2):

    <RandomPeers network="testnet" format="bash" />

    ```bash theme={"dark"}
    # Initialize node (default mode is full: RPC/P2P bind to all interfaces)
    # For validator nodes, use: seid init <your-moniker> --chain-id <chain-id> --mode validator
    seid init <your-moniker> --chain-id <chain-id>

    # Genesis is written automatically for known networks (mainnet and testnets); no download needed.

    # Configure peers in config.toml.
    PEERS="<comma-separated-peer-list>"

    #Set persistent peers in config.toml
    sed -i 's/persistent-peers = .*/persistent-peers = "'$PEERS'"/' ~/.sei/config/config.toml
    ```

    ##### Configure App Settings

    ```bash theme={"dark"}
    # Set minimum gas price (recommended; helps prevent spam transactions)
    # Mainnet enforces a chain-wide minimum of 0.02usei, so set at least that value
    # Use "0usei" only for local development or private networks
    sed -i -e "s/^minimum-gas-prices *=.*/minimum-gas-prices = \"0.02usei\"/" $HOME/.sei/config/app.toml

    # Tune mempool settings
    sed -i \
      -e 's/^keep-invalid-txs-in-cache = .*/keep-invalid-txs-in-cache = true/' \
      -e 's/^ttl-duration = .*/ttl-duration = "5s"/' \
      -e 's/^ttl-num-blocks = .*/ttl-num-blocks = 5/' \
      $HOME/.sei/config/config.toml

    # Set Concurrent Workers to 500 and enable occ
    sed -i -e "s/^#concurrency-workers *=.*/concurrency-workers = 500/" $HOME/.sei/config/app.toml
    sed -i -e "s/^occ-enabled *=.*/occ-enabled = true/" $HOME/.sei/config/app.toml
    ```

    <Info>
      In case of running an Archive Node, make sure to set your state-store settings to `ss-keep-recent = 0` with

      ```bash theme={"dark"}
      sed -i 's/^ss-keep-recent = [0-9]*/ss-keep-recent = 0/' ~/.sei/config/app.toml
      ```
    </Info>

    <Accordion title="Advanced Configuration">
      #### Archive Node Setup

      An archive node maintains the complete historical record of the chain. This requires disabling state sync and starting with a pre-existing database using a "snapshot".

      **1. Disable State Sync** — In \$HOME/.sei/config/config.toml , modify the \[statesync] section:

      ```toml theme={"dark"}
      # State sync configuration
      [statesync]
      enable = false
      ```

      **2. Configure Archive Node Peers** — To sync from the height your snapshot was created at, you need peers retaining a large amount of historical blocks. The node will require specific peers during initial sync, which can be changed at a later time.

      #### Mempool Configuration

      For optimal transaction handling and resource management, it is recommended to update the mempool settings in your `config.toml` file.

      <Info>
        Adjust these parameters if you encounter performance or resource issues on your specific hardware.
      </Info>

      ```toml theme={"dark"}
      # Mempool configuration settings
      [mempool]

      # Broadcast transactions to other nodes
      broadcast = true

      # Maximum number of transactions in the mempool
      size = 5000

      # Limit the total size of all txs in the mempool.
      max-txs-bytes = 10737418240

      # Size of the cache (used to filter duplicate transactions)
      cache-size = 10000

      # Do not remove invalid transactions from the cache
      keep-invalid-txs-in-cache = true

      # Maximum size of a single transaction
      max-tx-bytes = 2048576

      # Maximum size of a batch of transactions to send to a peer
      max-batch-bytes = 0

      # Maximum length of time a transaction can remain in the mempool
      ttl-duration = "3s"

      # Maximum number of blocks a transaction can remain in the mempool
      ttl-num-blocks = 5

      tx-notify-threshold = 0

      check-tx-error-blacklist-enabled = true

      check-tx-error-threshold = 50

      pending-size = 5000

      max-pending-txs-bytes = 1073741824

      pending-ttl-duration = "3s"

      pending-ttl-num-blocks = 5
      ```
    </Accordion>
  </Step>

  <Step title="Run Node">
    ##### Setting Up a systemd Service

    <Danger>If you see an error such as `panic: recovered: runtime error: integer divide by zero` it means you can’t start nodes straight from the genesis file. Instead, sync to the block tip via [state sync](/node/statesync) or using a [snapshot](/node/snapshot).</Danger>

    For production deployments, configure a systemd service to ensure your node restarts automatically:

    ```bash theme={"dark"}
    # Create the systemd service file
    sudo tee /etc/systemd/system/seid.service > /dev/null << EOF
    [Unit]
    Description=Sei Node
    After=network-online.target

    [Service]
    User=$USER
    ExecStart=$(which seid) start
    Restart=always
    RestartSec=3
    LimitNOFILE=65535

    [Install]
    WantedBy=multi-user.target
    EOF

    # Reload systemd, enable and start the service
    sudo systemctl daemon-reload
    sudo systemctl enable seid
    sudo systemctl start seid
    ```

    ##### Monitoring & Troubleshooting

    Check your node's status with these commands:

    ```bash theme={"dark"}
    # Check sync status
    seid status

    # Monitor logs in real-time
    journalctl -u seid -f -o cat

    # Check validator status (if running a validator)
    seid query staking validator $(seid keys show <your_key> --bech val -a)
    ```

    **Common Issues & Solutions**

    <CardGroup cols={2}>
      <Card horizontal title="Sync Issues">
        * Verify sufficient disk space
        * Ensure stable network connectivity
        * Confirm system time is synchronized
        * Consider using state sync for initial setup
      </Card>

      <Card horizontal title="Performance Problems">
        * Monitor system resources (CPU, RAM, I/O)
        * Evaluate disk performance and network bandwidth
        * Adjust mempool and peer settings if needed
      </Card>
    </CardGroup>
  </Step>
</Steps>

[View Complete Node Setup Guide](/node/node-operators)

## Node Resources

### Node Setup

<CardGroup cols={3}>
  <Card horizontal title="Node Operations Guide" icon="server" href="/node/node-operators">
    Complete guide to setting up and running a Sei node with hardware requirements and configuration steps.
  </Card>

  <Card horizontal title="Validator Operations Guide" icon="shield" href="/node/validators">
    Specialized instructions for validators, including staking, commission settings, and security best practices.
  </Card>

  <Card horizontal title="Default Configurations" icon="file-lines" href="/node/node-operators#default-configurations">
    Full reference for `app.toml`, `config.toml`, and `client.toml` shipped by the latest `seid` release.
  </Card>
</CardGroup>

### Advanced Operations

<CardGroup cols={3}>
  <Card horizontal title="Configuration & Monitoring" icon="gauge-simple-high" href="/node/advanced-config-monitoring">
    Optimize your node's performance with advanced settings and monitoring tools.
  </Card>

  <Card horizontal title="RocksDB Backend" icon="database" href="/node/rocksdb-backend">
    Run with RocksDB instead of the default backend.
  </Card>

  <Card horizontal title="Technical Reference" icon="terminal" href="/node/technical-reference">
    Detailed technical specifications, API endpoints, and commands for node operators.
  </Card>
</CardGroup>