> ## Documentation Index
> Fetch the complete documentation index at: https://seilabs-docs-evm-cookbook.mintlify.site/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 dark:text-green-400" />
                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**

These guides show how to run, maintain, and optimize Sei network nodes. Whether you set up a validator, an RPC node, or an archive node, they give detailed instructions and best practices for 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="State sync nodes" icon="shuffle" />

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

## Network versions

<VersionTable />

*For 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={null}
    sudo apt update && sudo apt upgrade -y
    ```

    ###### 2. Install essential packages

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

    ###### 3. Synchronize system time

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

    ##### Install Go

    You need Go only if you build `seid` from source. The prebuilt binary and Docker
    install paths in the next step do not require it.

    Current `seid` releases require Go 1.25.6 or later. For the exact requirement, check the
    `go.mod` at the release tag that you check out (for example,
    [`v6.6.1`](https://github.com/sei-protocol/sei-chain/blob/v6.6.1/go.mod)).

    ###### Installation steps

    ```bash theme={null}
    # Check for existing Go installations — more than one entry means another copy
    # may still win on your PATH after this install
    which -a go
    go version

    # Bumping Go? Change these two lines only
    GO_TARBALL=go1.25.6.linux-amd64.tar.gz
    GO_SHA256=f022b6aad78e362bcba9b0b94d09ad58c5a70c6ba3b7582905fababf5fe0181a

    curl -fLO https://go.dev/dl/${GO_TARBALL}

    # Verify integrity before trusting the archive (go.dev/dl publishes a SHA256 per file
    # at ${GO_TARBALL}.sha256), then replace any previous installation — extracting over
    # one leaves stale files behind
    echo "${GO_SHA256}  ${GO_TARBALL}" | sha256sum -c - \
      && sudo rm -rf /usr/local/go \
      && sudo tar -C /usr/local -xzf ${GO_TARBALL}

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

    # Verify installation
    go version
    ```

    <Note>
      `sudo rm -rf /usr/local/go` is the replacement step that [Go's install
      docs](https://go.dev/doc/install) prescribe. It clears only a tarball install. A
      package-manager Go (`/usr/lib/go-*`, Homebrew) survives it and can still shadow
      `/usr/local/go/bin/go`. If the final `go version` reports the old release,
      `which -a go` lists every copy on your `PATH`. If the extraction itself fails, the
      verified tarball is still in your working directory. Re-run the `sudo tar` command
      instead of starting over.
    </Note>
  </Step>

  <Step title="Install Sei">
    ##### Install the `seid` binary

    For the current recommended version, see the Network Versions table above.

    <Tabs>
      <Tab title="Prebuilt binary (recommended)">
        Each release attaches a statically linked `seid` build for `linux/amd64` with no
        runtime dependencies. You do not need to install a Go toolchain or shared libraries.

        ```bash theme={null}
        VERSION=<version-tag>  # e.g. v6.6.1 — see the Network Versions table above
        FILE=sei-chain_${VERSION#v}_linux_x86_64.tar.gz  # asset filenames omit the leading v

        curl -fLO https://github.com/sei-protocol/sei-chain/releases/download/${VERSION}/${FILE}
        curl -fLO https://github.com/sei-protocol/sei-chain/releases/download/${VERSION}/checksums.txt

        # Verify integrity before trusting the binary; extract and install only if it passes
        sha256sum -c checksums.txt --ignore-missing \
          && tar -xzf ${FILE} seid \
          && sudo install -m 0755 seid /usr/local/bin/seid

        # Verify installation
        seid version
        ```

        <Info>
          Prebuilt binaries are attached from `v6.6.1` onward. For earlier versions,
          build from source or use Docker. Prebuilt binaries are `linux/amd64` only and do not
          include hardware Ledger support. On other architectures, or if you sign with a Ledger
          device, build from source or use Docker.
        </Info>

        <Note>
          If you are switching from a previous `make install` build, remove the old copy
          (`rm -f "$(go env GOPATH)/bin/seid"`). Alternatively, make sure that your service unit
          points at `/usr/local/bin/seid`. The `which -a seid` command lists every copy on your `PATH`.
        </Note>
      </Tab>

      <Tab title="Build from source">
        This method requires Go and a C toolchain (see the Environment Setup step above).

        ```bash theme={null}
        # 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
        ```

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

          Add these lines to your `~/.bashrc` or `~/.zshrc`:

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

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

          For more information, see the [Go documentation for GOPATH](https://pkg.go.dev/cmd/go#hdr-GOPATH_environment_variable).
        </Info>
      </Tab>

      <Tab title="Docker">
        Official Docker images are available in the GitHub Container Registry.

        ```bash theme={null}
        # 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.

        <Warning>
          **Never** use the testing-only image variants in production. Sei's continuous integration (CI) pipelines publish these variants to an internal registry. They are not available on `ghcr.io`. The variants are compiled with special Go build tags:

          * `mock-*`: built with the `mock_balances` build tag. It mocks account balances.
          * `mock_block_validation-*`: bypasses `AppHash` and `DataHash` block validation.
          * `mock_chain_validation-*`: swallows most halting consensus validation failures (every swallow-eligible check except `ErrLastCommitVerify`). It computes each check authentically but continues instead of halting. It is built with both the `mock_balances` and `mock_chain_validation` Go build tags. Nodes that run these non-default consensus policies emit a `sei_unsafe_validation_skipped_total` counter (attribute `validation_error`) each time a failure is swallowed. On production policies, the counter never increments.

          Production images are built with full validation enabled. The `mock_block_validation` and `mock_chain_validation` variants are intended only for testing environments that require relaxed validation checks. Running either variant on a production network is unsafe.
        </Warning>
      </Tab>
    </Tabs>

    ##### Initialize chain files

    <Info>The default init mode is **full**, in which RPC and P2P bind to all interfaces. For **validator** or **seed** nodes, use `--mode validator` or `--mode seed`. In these modes, RPC and P2P bind to localhost only. For the full validator init example, see the [Validator Operations Guide](/node/validators).</Info>

    You can find peers here:

    * Sei Mainnet (pacific-1):

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

    * Sei Testnet (atlantic-2):

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

    ```bash theme={null}
    # Initialize node (default mode is full: RPC/P2P bind to all interfaces)
    # --chain-id is required, e.g. pacific-1 or atlantic-2
    # 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.

    # For known public networks (pacific-1, atlantic-2), seid init also pre-populates
    # bootstrap-peers in config.toml with the built-in Sei Labs seed nodes, so peer
    # discovery works with no manual configuration. Devnets (arctic-1) and
    # unknown/private chains get none, and any bootstrap-peers value you already set
    # is never overwritten.

    # Optionally configure additional persistent 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={null}
    # 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>
      If you run an archive node, use this command to set `ss-keep-recent = 0` in your state-store settings:

      ```bash theme={null}
      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 keeps the complete historical record of the chain. To run one, you must disable state sync and start from a pre-existing database (a snapshot).

      **1. Disable state sync**: In `$HOME/.sei/config/config.toml`, modify the `[statesync]` section:

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

      **2. Configure archive node peers**: To sync from the height at which your snapshot was created, you need peers that keep many historical blocks. During the initial sync, the node needs these specific peers. You can change them later.

      #### Mempool configuration

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

      <Info>
        If you have performance or resource issues on your hardware, adjust these parameters.
      </Info>

      ```toml theme={null}
      # 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 = 1073741824

      # 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.
      # Zero (or unset) disables TTL purging entirely — see the mempool TTL
      # note in Node Operators before changing these.
      ttl-duration = "5s"

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

      tx-notify-threshold = 0

      check-tx-error-blacklist-enabled = true

      check-tx-error-threshold = 50

      pending-size = 5000

      max-pending-txs-bytes = 1073741824

      # Deprecated: these fields no longer have any effect and are ignored.
      pending-ttl-duration = "0s"
      pending-ttl-num-blocks = 0
      ```

      <Info>
        `pending-ttl-duration` and `pending-ttl-num-blocks` are deprecated and have no effect. They are ignored, whatever value you set.
      </Info>
    </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 that you cannot start nodes directly from the genesis file. Instead, sync to the block tip with [state sync](/node/statesync) or a [snapshot](/node/snapshot).</Danger>

    For production deployments, configure a systemd service so that your node restarts automatically:

    ```bash theme={null}
    # 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={null}
    # 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 that you have enough disk space
        * Make sure that the network connection is stable
        * Confirm that the system time is synchronized
        * Consider using state sync for the 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 the 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 the `app.toml`, `config.toml`, and `client.toml` files from 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="Giga SS store migration" icon="database" href="/node/giga-storage-migration">
    Move EVM historical state into dedicated state-store databases on supported RPC nodes.
  </Card>

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


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.