Genesis-bound distributed ledger

Run WebAssembly contracts on a ledger that finalizes without blocks.

Transactions are ordered in a mempool, executed in a sandboxed WebAssembly virtual machine under a fuel budget, and finalized by a committee that signs a notary certificate. Follow one all the way through.

Follow a transaction Read the genesis document

Finality: Notarized quorum
Quorum: 2/3 of committee
Contracts: WebAssembly
Supply cap: 21,000,000 SLI

The published genesis declares chain 1, environment mainnet, created 2025-12-14, and a bootstrap committee of five named notaries that hands over to VRF selection once six are active. No public RPC endpoint is published on this site.

mempool
committee
execute
notarize
surfaces
genesis

01 — Submit and order

A transaction is ordered before anyone votes on it.

It enters through the public JSON-RPC surface. The mempool orders it, drops duplicates, and evicts what it cannot hold, so the set a committee sees is already deterministic rather than whatever arrived first.

mempool — demonot a live node

submit in any order:

arrival order

empty

what the committee sees

empty

Submit a few and compare the two columns.

Anything still pending after 300s is evicted, and one address may hold at most 256 pending entries — both fixed in the genesis document, so a node cannot quietly widen them. The senders are real addresses from state.accounts; the transactions are not, because this chain is still at epoch 0 and has none.

fee — demonot a live node

Priority above is fee per weighted byte. This is what sets that fee: a smart.exec transaction carries up to 32 operations, each with its own price.

operations

transfer20001
emit.event8000
assert.balance6000
assert.compare6000
assert.time4000

signing-view bytes320 Bmax 65,536

effective minimum fee

max(min_fee 10000, base 10000): 10,000
20 × 320 B: 6,40035%
Σ per_op (1 op): 2,00011%
total: 18,400
in SLI: 0.000184
fee per byte: 57.5

Size dominates here. Because ordering is fee per weighted byte, padding a transaction raises its fee without improving its position.

This is the minimum a transaction must pay to be admitted, not a market price — the document fixes these constants, so the floor cannot be raised by congestion.

02 — Draw the committee

Membership is drawn, not appointed.

Committee membership for the epoch comes from a verifiable random function over the registered notaries. The draw is reproducible from the epoch seed, so anyone holding the same state can check that nobody chose the set by hand. Admission to that pool is a separate question: the registry requires a 1,000 SLI bond held for three days, slashes 5% for double-signing, and lets at most 8% of the committee turn over per epoch. The draw is verifiable; entry is permissioned.

committee — demonot a live node

active notaries in the registry5genesis: 5 · cap: 256

committee: 5
quorum (2/3, up): 4
selection: all active

Below the cap nothing is drawn. mode is all-active-notaries and committee_size is null, so every bonded notary serves and 4 of 5 signatures notarize. The VRF exists for the case on the right of 256.

the five in the signed genesis

gncGHD…52tH1,000 SLI bondedsigns #1
gYjDnc…g6Hu1,000 SLI bondedsigns #2
ghJejx…qMrv1,000 SLI bondedsigns #3
gpcr2U…T2L91,000 SLI bondedsigns #4
gohgoW…qDMo1,000 SLI bondedspare

epoch seed — reorders who is asked first

All five stake equally, so the ordering is the VRF alone. It changes who is asked first, not who is eligible — with the committee at five, every one of them serves either way.

Addresses are the real ones from state.accounts in the published genesis. The registry is at epoch 0 with bootstrap: true, so there is no committee history to read yet.

03 — Execute under fuel

A contract cannot spend more than it was given.

Contracts are WebAssembly components on Wasmtime, reached through a typed interface rather than raw host calls. A contract sees the key-value store and ledger access that interface grants and nothing else — no filesystem, no sockets — and every call runs against a fuel budget.

fuel — demonot a live VM

fuel consumed0 / 1000

Pick a workload.

04 — Notarize

Final in one step, at two thirds.

Two-thirds of the committee sign the outcome into a notary certificate, and execution produces a receipt. Finality is that certificate. There is no depth to count and no reorg window to survive — which trades that reorg window for a liveness dependency: without two-thirds of signatures there is no certificate, so the result is not applied and not lost. The path stalls rather than forking.

finality — demonot a live node

Click the squares to add or remove committee signatures.

4 of 9 signed · threshold 6not final

Below the threshold the result simply is not final. It does not become "probably final" as signatures accumulate; it flips in one step at 6.

05 — Reachability

Exposing the port does not expose the privileged methods.

The JSON-RPC server splits its methods into surfaces. Reads and transaction submission are public. Contract deployment, contract calls, the notary registry, and key registration require an admin token or a loopback connection, and raw writes sit behind the same gate.

rpc — demonot a live node

caller

Call a method.

06 — Genesis binding

The rules come from a signed document, not from the node.

Consensus, monetary, and execution parameters are fixed in a genesis document with threshold signatures. The tooling validates a candidate against the published schema and verifies those signatures before import. Change one value and the document no longer hashes to what was signed:

content hash — livesha-256 in your browser

chain_idquorumsupply_capdecimals

sha256: …

Edit any value above. The digest is computed here, in your browser, over exactly this JSON.

This panel demonstrates the property; it does not verify the real artifact, whose signature covers its own canonical hashing scope. The published document and its signature are where that check happens.

Transaction pathidle

What the design is for

Settlement that has to be citable: A result is a signed certificate over a hash, so an auditor can be handed the entry rather than a screenshot of a balance.
Rules that outlive the operator: Consensus and monetary parameters are fixed in a signed document that every node validates before import, so changing them is not a deploy.
Contracts you can bound: Every call runs against a fuel budget in a sandbox with no filesystem and no sockets, so one deployment cannot starve the rest.
Not a general compute platform: State is one ordered stream and there is no ambient I/O. Work that needs parallel throughput or arbitrary network access belongs outside it.

Check the document now, run a node when it ships

Everything above is declared in the published genesis, so every claim on this page can be read against the artifact today — the document and its detached signature are below.

The node itself is not published yet. Confirming the execution and finality behaviour end to end means running a node against this genesis, and that is not something you can do from here today. Ask for access at [email protected].

Read the genesis document

Field by field: consensus and committee selection, monetary policy, governance and upgrade thresholds, security, transaction rules, and the signed parameter set — plus the recorded supply and fee model.

Review questions: [email protected]