Sei Mainnet pacific-1 Height— Snapshot— connecting
Community snapshots for Sei nodes

A Sei mainnet node from a ~50 GB download, checked against the chain

The full memIAVL state ships without its SHA-256 hashes. Your machine recomputes them in minutes and checks every tree root against the snapshot's own commit info before the node starts. One command.

✓
Loading the latest publish…
curl -fsSL https://dev-labs.seistream.app/install.sh | bash

Snapshot live

Block height
—
published —
How old
—
— blocks behind
Download
—
— parts, fetched together
On disk after install
—
incl. recomputed hashes
Made in
—
node stopped —
Run exactly
—
seid
memIAVL · changelog · state.db · blockstore.db · wasm/state zstd -3 no state store (SS) app_hash —
/manifests/mainnet/latest.jsonlatest.json ↗

Pipeline

—
—
—
Server logwhat the machine actually printed, tailed every 5 s
…
/manifests/mainnet/pipeline.jsonlog.txt ↗

Publishes

download size, GBbuild time
/manifests/mainnet/publishes.jsonpublishes.json ↗

Machine —

Our node
—
—
Peers
—
—
Disk free
—
—
Load
—
—
Memory free
—
shared with other chains
Chain head
—
—
/manifests/mainnet/status.jsonstatus.json ↗

Install a node

Run it on the machine that will host the node. It refuses to touch a non-empty data/state_commit and never writes priv_validator_key.json or node_key.json.

curl -fsSL https://dev-labs.seistream.app/install.sh | bash -s -- --home ~/.sei --jobs 16
  1. Download. Every part is fetched in parallel; its sha256 is checked while it streams and it unpacks straight into place — no tarball on disk.
  2. Recompute. The SHA-256 hashes stripped from memIAVL nodes/leaves are rebuilt, and every tree root is compared with the snapshot's commit info. On any mismatch it stops and tells you not to start the node.
  3. Configure. Sets ss-enable = false and [state-sync] snapshot-interval = 0 in app.toml, persistent peers in config.toml. Then: seid start.

The node replays the shipped changelog up to the snapshot height (thousands of blocks per second), then catches up from peers.

seid
— — exactly this version. A different binary once corrupted the state on open.
Disk
— free in the node home (state plus recomputed hashes)
System
Linux x86_64 · curl · zstd · tar · python3 · sha256sum
Not included
state store (historical queries), wasm cache, tx index

Snapshot files

PartUnpacks toRawDownload
…
—parts are named by the sha256 of their bytes

How this works

Why it is small. Sei keeps its state in memIAVL: an IAVL tree laid out flat on disk as kvs, nodes and leaves. Every node and leaf record is 48 bytes, and 32 of them are a SHA-256 hash — random bytes that no compressor touches. They are a third of the state and pure function of the rest, so we cut them out (48 → 16 bytes per record) and your machine computes them again. The historical state store is not shipped at all; a fresh node does not need it to follow the chain.

Why you can trust it. Hashes are recomputed on your machine, not copied from ours, and every tree root must equal the store hash recorded in the snapshot's __metadata. The published height's app_hash is checked against a quorum of independent public RPCs before anything is published, and every part is verified by sha256 as it downloads.

How it is made. Once an hour the node is stopped, the immutable memIAVL snapshot is hard-linked (no bytes copied), the changelog after it and the Tendermint databases are copied, and the node starts again. The copy is stripped, split into parts and compressed while the node runs on. Parts are named by their sha256, so a part that did not change is not stored twice.

What we cannot promise. The snapshot is as old as the last capture plus its build — about an hour at best. Network upgrades need the matching seid; the manifest always names the version the data was written with.