05Roadmap

What has to happen, in order

Stages with exit criteria instead of dates, so progress is something you can verify rather than something we assert.

The order things have to happen in

  1. 01

    Devnet

    Live
    • Six programs deployed on Solana devnet — settlement, data availability, forced inclusion, dispute game, bridge, and the sequencer bond — redeployed on 2026-09-05 as the beta chain, with the 48-hour window, the dispute game's enforcer as dispute authority, and a sparse state tree
    • The L2 node publishes every batch and commits every root to devnet, checkable from Solana's public RPC
    • A deposit credited on the L2 in the next block on both chains, and on the beta chain two withdrawals proven against final roots and paid out by the vault on Solana; the beta bridge's air-gap guardian is a key the operator's cannot be
    • A restarted node rebuilds byte-identical roots and receipts from published data alone
  2. 02

    Testnet

    In progress
    • Public RPC endpoint live and documented
    • Withdrawals proven end to end on devnet (deposits are credited there already)
    • SDK quickstart runs from a clean machine
  3. 03

    Mainnet beta

    Planned
    • External audits complete and published
    • Upgrade-key multisig composition and timelock published
    • Withdrawal limits and circuit breakers in place
  4. 04

    Fast exits, team-fronted

    Planned
    • A float we put up ourselves, its size and its remaining headroom readable on-chain
    • It refuses at the point of use when the float is exhausted, rather than queueing silently
    • The canonical exit stays available and unchanged — taking the fast one is a choice, never the default
    • Described as our balance sheet advancing you money, not as the network settling faster
  5. 05

    Proofs enforcing

    Planned
    • Fraud proofs gate finalisation in production
    • Independent challengers running outside the team
    • Permissionless exit exercised by an unaffiliated user
  6. 06

    Fast exits, underwritten

    Planned
    • A liquidity provider fills exits against roots still inside the window, at a published spread
    • One fill reclaimed end to end from the finalised root by a provider with no relationship to the team
    • Presented as its own trust domain — the provider's risk, not a shorter challenge window
  7. 07

    Staked sequencer set

    Planned
    • Rotating sequencer set with signed hand-offs; receipts verifiable against the advertised identity
    • Sequencers bonded in stake and slashed for provable equivocation
    • Ordering decentralised; finality stays with Solana — no validator set of our own decides state
  8. 08

    Reduced trust

    Planned
    • Upgrade timelock exceeds the withdrawal window
    • Proposing opened beyond the founding operator
    • Emergency powers narrowed and time-boxed
  9. 09

    Ephemeral lanes

    Planned
    • A decision record first: what may be handed to a fast sequencer, what a user reclaims if it stops mid-session, and whether the forced-inclusion queue still reaches an account while it is handed over
    • The lane's trust statement published beside it, not after: for the length of a session the fraud proof and the published data do not cover that sequencer, so the protection is the hand-off's own exit rather than the dispute game
    • Never called secured by Solana for the duration of a session, because for that duration it is not

Two stages here are about the exit experience rather than about trust, and they are not the same stage twice. Fast exits, team-fronted is our own balance sheet advancing you money against a root still inside its window: it removes the wait and adds no evidence, because the party telling you the chain is honest is the party running it. It is capped by what we can afford and it says so at the point of use. Fast exits, underwritten is a stranger taking that risk at a price they set, which is why it comes after proofs enforce — an operator's word prices worse than a proof anyone can check, and a spread nobody will quote is information. Neither stage shortens the challenge window. It stays 48 hours plus the 24-hour air gap — about three days, and seven on the devnet chain that predates that decision — and it stays the thing both of them are relying on.

◆Exit criteria

What would show each stage met

The conditions above say what has to be true. This list says what would show it — an instruction that refuses, a field an RPC returns, a drill with its transaction signatures published, a document anyone can read — and whether it shows it today. A stage is claimed when every one of its criteria is met, and a criterion is met only when the named mechanism shows it: designed, decided in principle, or built but not switched on all count as not met, and the status says which. Status as read on 2026-09-26.

  1. 01

    Devnet

    LiveStage 0 — a single trusted operator. Seven nodes on one laptop, one hot key holding every upgrade authority, no standby, no audit, no verifier outside the team. These are the reads the word live rests on; every stage below is about leaving this state.

    • MetState roots are posted to Solana. submit_root on the settlement program; getSettlement reads the head and the finalized root.Head 301, finalized 298 on the gamma chain at the fleet read of 2026-09-26.
    • MetThe inputs to every state transition are posted to Solana. The data-availability program's seal_batch refuses a batch whose bytes do not match its commitment; forced entries land on the inbox program.Every gamma batch sealed under that check.
    • MetA dispute's verdict binds settlement. getSettlement.disputes_enforceable reads true; the dispute game's enforcer is the settlement program's dispute authority.True on gamma. What the game cannot yet do is authenticate the signed transaction inside a step, so a forged step could still win a dispute — stage 05's first criteria.
    • MetThe bridge pays a proven withdrawal and refuses one the vault could not honour. prove_withdrawal and finalize_withdrawal on the portal; getBridge reads the total outstanding; the solvency guard refuses at admission with nothing debited.Three deposits in, three withdrawals proven, finalized and paid, outstanding 0; the guard live on gamma since 2026-09-12. Every payee so far a team address.
    • MetA node rebuilds the chain from what Solana holds, and nothing else. solieum-node verify replays the published batches and reproduces every root byte for byte; exit code 0.Done for gamma by the team on 2026-09-12 and 13. Reproducible by no one else yet, because the repository is private — stage 02's criterion.
  2. 02

    Testnet

    In progressInfrastructure stages A and B — a public devnet, then a public testnet — and the first verifier criterion, the repository public. Stage B's failover drill and the two node conditions it rests on are here too.

    • Not metA public RPC endpoint answers from a hosted machine and is documented. The hostname in the node README; getChainInfo answered over it from outside the team; the fleet off the laptop.None exists: nothing is served publicly, and every devnet chain runs on one laptop. What would serve one is built, after the read above, and exercised on a local machine only — a Linux build of the node from a gated commit, and a server kit whose gateway routes the /solana path wallets use to an allow-listed proxy, with the node's units, an alarm relay and a preflight beside it. No hosted machine runs any of it; promised with the public testnet.
    • MetWithdrawals proven end to end on devnet. getWithdrawalProof on the node; prove_withdrawal and finalize_withdrawal paid by the vault on Solana; getBridge outstanding 0 afterwards.Three on the gamma chain, proven, finalized and paid, outstanding 0 — all to team addresses. An exit by someone unaffiliated is stage 05's last criterion.
    • Not metThe repository is public, with a one-command verifier image, so anyone can rebuild the chain from Solana alone. The public repository URL; the image digest in the node README; a run on a clean machine, recorded.Not done, and a decision rather than a build: the verifier exists and has rebuilt gamma, and since 2026-10-10 the one-command image of it exists too — built twice from the same gated commit to the same digest, held in no registry, and named by the verifier kit as the route that needs no toolchain. Until the repository is public, Stage 0 is a description of the trust model, not something an outsider can check from source.
    • Not metThe SDK quickstart runs from a clean machine. A run from a clean machine against the public endpoint, recorded with the drill records in the repository.Rehearsed on 2026-10-10 in clean containers against a local chain. The quickstart as published failed at six points: no install or run line, a recipient never defined, the node's own path instead of /solana, a key nobody funded, a send that signs over a finalized blockhash, and a confirmation that waits for a websocket the node does not serve. The corrected text then ran on Node 20, 22 and 24, and is what the developers page shows. Since then a node started with --ws-port serves the websocket a confirmation waits on, web3.js's own send-and-confirm has passed against one, and the server kit routes /solana the same way — all on one machine. Not yet run against a public endpoint, because none exists.
    • Not metThe chain's two Solana readers are on genuinely different infrastructure, at least one keyed, so the byte-for-byte quorum can catch a lying provider. getSettlement.alarms.l1Readers naming two hosts; a rate-limit burst accounted differently by each; the keyed URL only in the start script.Two names on one infrastructure today: the quorum is checking a provider against itself.
    • Not metFailover drill: the primary stopped, the standby promoted with the identity file, blocks continuing, and afterwards no pair of receipts that contradict each other. check-sequencer-keys.py over both data directories; solieum-node slash judging every receipt pair and finding none; getSequencerBond reading slashed: false; the drill published.Not run for the testnet. Rehearsed on 2026-10-09, after the read above, on throwaway test chains: the primary told to stop signing, the standby promoted by a hand-off command, blocks continuing, and an audit of every receipt finding no slot signed twice; the control, an identity file copied without the hand-off, was caught signing twice. Since then the guards that check a copy against the data-availability feed fail closed when the feed cannot be read, in a gated build not yet on any running chain, and a fuller drill against a local Solana validator — the fence, the hand-off, a crash mid-batch, the receipt audit with its control, and a reader that disagrees — is written and its preflight passes, but it has not been run. Not yet on two machines settling to Solana, and a standby still cannot take over from a primary nobody can reach.
    • MetA stale copy refuses to sign: a data directory behind the data-availability feed is refused by name at start. The node's refusal line in a drill log.Drilled on 2026-09-27, after the read above: against a local Solana validator, a node started from an empty data directory while the feed was ahead of it was refused by name at start and signed nothing. The failover rehearsal of 2026-10-09 also refused, by name, a standby whose copy was behind the primary.
    • MetA restart with admissions pending restores the same receipts into the same slots and signs nothing twice. An admission surviving a restart with the same receipt bytes; a journal naming another batch refusing to open — the tests of ADR-0024.Built, and in every node build the devnet chains have run since 2026-09-30, after the read above: a node keeps the admissions it has not yet sealed in a journal and restores them when it starts again. Its tests restore the same receipt bytes into the same slots and refuse a journal that names another batch. In the failover rehearsal of 2026-10-09, a primary stopped without warning had its two receipts restored on the standby with the same signatures, and the next transaction took the next slot.
  3. 03

    Mainnet beta

    PlannedThe audits; step E, keys held by more than one hand; the bridge's per-asset limits; the standby the mainnet topology needs. Infrastructure stage C.

    • Not metExternal audits complete and published, the proof system's among them. The reports, with the findings and what was done about each.None yet.
    • Not metThe upgrade authority of all six programs is a multisig with hardware signers, its signer set and timelock published. solana program show for each of the six ids printing the multisig vault as upgrade authority; solieum-node keys exiting 0; the set and the threshold on the security page.One hot key on the fleet laptop holds every authority. The devnet interim — moving it to a key off that machine — is an open owner item.
    • Not metThe guardian is a 2-of-3 separate from the upgrade authority and the payer, and can only deny a root. initialize_guard refusing a guardian equal to the admin; keys confirming the guardian differs; the guardian multisig's own configuration.Partly: gamma has a separate single guardian key. The 2-of-3, and the mainnet guardian, do not exist.
    • Not metOne key, one job, three machines: the receipt key on the sequencer host only, the settlement payer a bounded hot key, the authority offline. solieum-node keys exit 0 for the separation the chain can show; a ceremony record for the locations it cannot.keys exits 1 on gamma today. On 2026-10-10, against a local Solana validator, it exited 0 twice: on a chain cut by the fresh-chain kit, whose inbox queue was initialized by its own key before the node first started, and on a chain whose every key with a setter had been rotated and read back. No testnet chain is cut yet.
    • Not metThe two key drills run and logged: a display-and-confirm check against a deliberately mismatched payload before any mainnet signing, and a rotation of a provider key. The drill logs; the rotation recorded with the new key's fingerprint.Never run. One provider key's rotation is pending now.
    • Not metTwo-person rule for production changes, no standing production access, dependency review in CI. The CI configuration in the repository; the written policy.Not built.
    • Not metThe bridge's per-asset limits are initialized, so a verifier's alarm can precede a drain rather than follow it. getBridge.limits non-null for SOL and each mint; the portal matching the build that carries them, byte for byte.Built, not deployed: getBridge.limits reads none, and the bridge is unlimited.
    • Not metA standby sequencer on a second machine at a second provider, its data directory replicated and no identity file on it. The standby's getChainInfo reporting a boot-generated sequencer that does not match genesis until it is promoted.None exists; the fleet is one laptop.
  4. 04

    Fast exits, team-fronted

    PlannedThe devnet demonstration of the trusted-provider path, hardened into a service. It changes nothing about who is trusted, and the demonstration is not the stage arriving early.

    • Not metThe float's size and remaining headroom are readable from outside. getFastExits on the node RPC and an explorer row: float, headroom, open fills, median fill latency, median reclaim age.Not built. The demonstration's ledger is a file the operator holds.
    • MetIt refuses at the point of use when the float is exhausted, and never queues. The fast-exit command's fail-closed refusals, each with its reason; a refusal observed in a run.Built and shown: one fail-closed refusal in the alpha run of 2026-09-04. A devnet demonstration with the operator's own SOL.
    • MetThe canonical exit stays available and unchanged. A fill is an ordinary withdrawal naming the provider as recipient; prove_withdrawal and finalize_withdrawal untouched; no new program.Holds by construction: the demonstration added no on-chain code.
    • Not metAn obligation cannot be forgotten or lost: a rolling cap on exposure, the float wired to the alarms, and a guard that refuses a fill it could not reclaim before the root's proving deadline. The cap and the guard in the fast-exit command; the alarm sink carrying the float.Not built — the hardening the scoping note calls Phase 1. The ledger survives a restart; the cap, the alarm and the deadline guard do not exist.
    • MetDescribed at the point of use as our balance sheet advancing money, not as the network settling faster. The label wherever a fill surfaces: a demonstration, the liquidity ours, no claim about mainnet.In place for the demonstration. The service's own disclosure — with the float's size and owner beside it — waits on the readable float above.
  5. 05

    Proofs enforcing

    PlannedStep A, defendable roots — every witnessed step bound to the signed transaction it claims to execute, active on a chain; step C, verifiers outside the team able to challenge; and the first half of step D, a challenger who is bonded and paid.

    • Not metThe proof-system specialist has ratified the bound-step design in writing, item by item — what a step authenticates, how a leaf proves its position, the compute figures, the packet ceiling, and the limit of the evidence. A dated sign-off note in the protocol's notes, by that role, naming each item and its verdict.Not done. The pre-audit ratified the specification; the build exists for the specialist to read. This is the first unmet criterion on the whole sequence.
    • Not metThe packet-ceiling decision is taken: a transaction with two signers cannot be bound within one Solana packet, so either that is accepted and stated before activation, the record rebuilds the bytes from the precompiles, or two-signer transactions are refused at admission. The decision in the design note and ADR-0021; if the first, the site's wording restated before activation.Not decided.
    • Not metOn a throwaway chain at commitment version 11 with nothing of value on it, a deliberately lying root is challenged, the bound step is verified on Solana by the watchtower's own transactions, and enforce_verdict removes the root. The chain's genesis at commitment 11; the dispute account on the cluster; the root's status in getSettlement; the transaction signatures published.Impossible before the sign-off: the node refuses a genesis above the commitment version it ships with, and raising that constant is the activation. Evidence so far: host tests, node tests, a compute-unit gate, and on 2026-10-10 a dispute carried to a verdict against a local Solana validator — a deliberately wrong root challenged under bond by the watchtower, removed by enforce_verdict through the enforcer, the head rolled back and the honest roots untouched. That verdict came by the proposer's timeout, at commitment 10, and verified no step: it shows the game's enforcement, not the bound step this criterion needs.
    • Not metThe dispute game and the bond program redeployed to the bound-step build with no dispute open at the upgrade, both matching source byte for byte. solieum-node verify-program exit 0 for both program ids; getSettlement showing no open dispute at the upgrade slot.Not done. The bond half is affordable now (a refundable buffer of about 2.2 SOL); the game needs about 5.5 SOL more on the authority than it holds.
    • Not metThe layout rule is a gate test: every program that reads a record it did not write reads it leniently or refuses by name, failing against the old bytes and passing against the new. The gate log naming the test for the settlement program's finalize and for the game's two reading contexts.Partly: one test covers the settlement program; the game's fix is gated green and not deployed.
    • Not metThe chain that will carry value is cut at commitment version 11 or later — gamma cannot move in place — with the withdrawal leaf bound to its chain and portal, and the launch scope on. The commitment version in genesis.json; the launch scope in the node banner; the portal's chain-binding account.Not done; the bound withdrawal leaf (ADR-0023) is design only, sequenced behind the sign-off.
    • Not metAt least one watchtower run by someone who is not the operator, on Solana readers the operator does not use, with an alarm sink that person controls. Their verify --watch state line and alarm sink; their reader hosts differing from the fleet's; the operator holding none of their keys.None. The number it takes is not decided.
    • Not metTheir challenge lands: on a throwaway chain with a deliberate divergence, open_challenge signed by their own payer, the game played from their re-derived trace, and enforce_verdict removing the root. The signatures of the challenge, each move, the one-step and the verdict, all from a key that is not the operator's, published beside the drill script.Never done; no dispute has been played on any public cluster.
    • Not metThe escape hatch walked by an unaffiliated user with public tooling: a withdrawal initiated on the L2, proven with getWithdrawalProof, and paid by prove_withdrawal and finalize_withdrawal from a key with no relationship to the team. The two transactions' signatures and the payer key, published.Never done. Both instructions are permissionless and three withdrawals were paid on gamma — by the team. The steps an outsider would follow are written and were corrected against the source on 2026-10-11, not yet rehearsed end to end; no public proof-building tooling is published.
    • Not metChallenging is permissionless and costs a bond sized against value at risk, re-derived at every milestone in value locked. open_challenge on the settlement program taking the bond from any signer; the sizes published with their derivation from the fee module's bond floor, and the review trigger that re-opens them.The mechanism exists — any signer, 50,000 lamports on devnet — and the sizes are placeholders, not derived.
    • Not metA challenger who wins is paid: the proposer's bond, and a reward on top, or the non-transferable points reserved before the native coin is issued on a network of value. claim_bond on the settlement program for the bond; a reward ledger keyed by root number, or a points record, when either exists.The bond path built; the reward path not built. ADR-0025 names the native coin, SEU, as what pays for settlement work.
  6. 06

    Fast exits, underwritten

    PlannedTrust model B — an escrow on the L2 side, or a hash-time-locked pair — after step A. Which of the two, and who may run a provider, are the owner's choices, not yet made.

    • Not metA provider can claim a withdrawal only if it has paid the user: an escrow on the L2 side, or a hash-time-locked pair, releases the withdrawal to the provider against proof of payment. The escrow or lock instruction in the program set; a fill that pays out through it on a throwaway chain.Not built. The escrow was chosen over a trusted provider for anything of value (2026-09-20); its shape is the open choice, and nothing fills through either yet.
    • Not metThe spread is published. The provider's quote readable beside the fill, in the listing an exit is offered through.No provider, no quote. The demonstration's cut is the operator's configuration under a hard 5% ceiling on the total deduction.
    • Not metOne fill reclaimed end to end from the finalised root by a provider with no relationship to the team. The provider's prove_withdrawal and finalize_withdrawal signatures from a key that is not the operator's, published.Never done; every fill so far was the operator filling and reclaiming its own.
    • Not metPresented as its own trust domain — the provider's risk, not a shorter challenge window. The window unchanged in the settlement program, 48 hours plus the 24-hour air gap; the disclosure beside the fill naming the provider and what the user is trusting.The window is untouched by design; the disclosure exists only for the demonstration, and names the operator.
  7. 07

    Staked sequencer set

    PlannedStep G, entered after steps B, D and F. Step B — the hand-off between the operator's own nodes — is listed here because a set of sequencers is that hand-off generalised, and the slashing follow-ups of step D sit with it.

    • Not metA batch is claimed on Solana before its first receipt is signed, so two honest nodes under one key at the same height cannot both sign: the second's open_batch fails and it accepts nothing. The decision in ADR-0020 naming the mechanism — a claim at open, or a lease with expiry — and its cost of one more Solana transaction per block; a gate test; a drill on two throwaway nodes whose logs show the refusal.Not decided, so not built.
    • Not metThe settlement program refuses a root from a slashed sequencer. submit_root refusing when the proposer's bond reads slashed: true.Not built: the settlement program makes no reference to the bond program (checked 2026-09-26); the only slashing it knows is its own proposer bond moving to a challenger.
    • Not metA receipt the published batch does not honour is slashable on-chain, not only a double-signing. A slash_batch_contradiction instruction on the bond program, judged against the transaction tree.Not built. Equivocation — two receipts from one key for one slot — is slashable today, and a slash has been demonstrated.
    • Not metA sequencer registry with stake, admission and removal, slashable for double-signing or censorship. The registry program and its accounts; membership governed as the native coin's records (ADR-0018, ADR-0025) set out.Not built; none exists.
    • Not metSigned hand-offs between sequencers, receipts verifiable against the advertised identity. getChainInfo.sequencer and sequencerMatchesGenesis generalised to a rotating identity; the claim on Solana generalised to a set.Not built; a single identity today.
    • Not metThe admission gate re-derived for hand-off: its one-executor property stops holding when a transaction may be handed to the next sequencer. ADR-0014's reversal trigger executed — a new decision record, and the gate either re-derived across a hand-off or disabled across one.Not done.
    • MetOrdering only: no vote among sequencers reaches finality. finalize on the settlement program reading only the window and the dispute state — an invariant checkable by reading the program.Holds by construction, and must survive the registry when it exists.
    • Not metThe receipt bond stays SOL; the membership stake is the native coin, SEU. The bond program unchanged in asset; the registry's stake asset.The design is fixed, and ADR-0028 fixes the coin's supply, emissions and allocation; the coin was issued on Solana mainnet on 19 November 2026.
  8. 08

    Reduced trust

    PlannedThe timelock of step E; step F, a permissionless proposer; and the guardian question the public Stage 2 definition turns on.

    • Not metThe upgrade timelock is longer than the exit: at least seven days against the 48-hour window plus the 24-hour air gap. The multisig's on-chain timelock configuration; a drill — an upgrade proposed, visible, and executable only after the delay.Not done. Whether it should be thirty days rather than seven is not decided.
    • MetThe chain record carries no permissioned proposer. The settlement chain account's permissioned_proposer reading none; submit_root no longer refusing a proposer that is not the operator.Met on every chain the node initializes — gamma and 9232 accept a bonded root from any key, in code. Nobody but the operator has ever proposed one.
    • Not metA root proposed by a key that is not the operator's is accepted under bond and finalizes. That key's submit_root signature and the root's finalize on the cluster.Never done.
    • Not metA proposer who commits a bad root loses the bond to the challenger, on a public cluster. Stage 05's challenge drill played against a non-operator proposer; claim_bond to the challenger.Never done on a public cluster, or against a proposer who is not the operator. The mechanism has paid: on a local Solana validator on 2026-10-10 the operator's own wrong root lost its bond to the watchtower that challenged it.
    • Not metProposers are paid for roots that survive their window, claimable only after it closes clean. A reward ledger keyed by root number.Not built. The asset is decided: SEU, from the pre-minted rewards pool of ADR-0028, which exists only once the coin is issued.
    • MetEmergency powers narrowed to one: the guardian can deny a root and nothing else, on a key that is neither the upgrade authority's nor the payer's. The guard program's instruction set; initialize_guard refusing a guardian equal to the admin; solieum-node keys confirming the separation.Holds on gamma with a single guardian key (ADR-0015). Whether the power should lapse on its own, and when it should be removed, is not decided: the record leaves that to after audits and mainnet history, or to a second prover that removes the failure it exists for.
  9. 09

    Ephemeral lanes

    PlannedOutside the decentralisation sequence until a decision record exists, as the stage's own first condition says.

    • Not metA decision record for the lane: what may be handed to a fast sequencer, what a user reclaims if it stops mid-session, and whether forced inclusion still reaches an account while it is handed over. A numbered record on the decisions page.None. The roadmap document itself lists this stage as out of its scope until that record exists.

The first unmet criterion on the whole sequence is the specialist's written sign-off on the bound-step design, in stage 05. Everything that changes who has to be trusted sits behind it: the throwaway chain that would play a dispute over a bound step cannot be cut before it, a challenger outside the team should not be asked to bond against a game that is not yet sound, and an untrusted proposer is the case the gap exists for. Open in parallel and blocked by nothing: the two owner decisions listed above — the packet ceiling and the claim before signing — the bond program's redeploy, a second reader on different infrastructure, the bridge limits, and moving the upgrade authority off the payer key.

◆Chain generations

Three chains so far

Each devnet chain is a genesis, and a genesis is an identity: the hash covers the parameters and the L1 program ids, so changing what an account leaf commits to is a new chain rather than an upgrade. This is the record of which chain carried what.

ChainInitializedState commitmentWindowWhat it introducedNow
alphasolieum-testnet-alpha · chain 7788 · genesis 2PU6Fj3c…2026-09-021 · sorted state tree7 days (ADR-0003)Settlement, DA, forced inclusion, the dispute game and the bridge on devnet for the first timestopped
betasolieum-testnet-beta · chain 7789 · genesis AtxMy5BY…2026-09-051 · sparse state tree48 h (ADR-0016)The 48-hour window, the sparse tree, the enforcer as settlement authority, the air-gap guardian, the sequencer bond, fees kept from block 100, the first paid withdrawalsstopped 2026-09-12
gammasolieum-testnet-gamma · chain 7790 · genesis HURAAxUv…2026-09-112 · account data by page-tree root48 h (ADR-0016)Account data committed by root so a slice proves without the account; a commitment version in genesis that a mismatched node refuses; its own sequencer key; the vault solvency checkcurrent

The commitment version is what made gamma necessary. The beta chain's leaves hash account data inline; the current node hashes a page-tree root over it instead, so no node that speaks one can replay a chain written under the other. Beta ran its last day on a pinned binary and stopped on 2026-09-12 with every root final and nothing owed. The next such change will be a fourth chain, and the genesis now records the version so the node says which side it is on rather than computing a root that silently differs.

What each chain is running today →

◆Readiness

Explorer readiness

The explorer is part of the node: every node serves its own on its RPC port. That is what makes it trustworthy — it reads the chain it is serving, not a copy — and it is also why there is no public one yet.

  1. 01

    Served by every node

    Live
    • Blocks, transactions, accounts, receipts, settlement, the bridge and the forced-inclusion queue, all read from the node's own state
    • Registered programs listed with their size and SHA-256, and marked as registered rather than on-chain, because on this chain a program is a file the node was started with and not an account
    • Whether the chain's genesis commits that program set (ADR-0019, 2026-09-13). A chain that commits it refuses to start under any other set. A chain that commits none, which is every local example chain that registers programs, runs only under an explicit --uncommitted-programs flag, and its banner and programs page say so: the chain's identity does not determine its behaviour. Gamma commits no programs and starts none
    • Per-block timing — admission, receipt, execution, root committed — kept beside the chain data and restored across restarts
    • Gamma on port 8895; beta had 8896 until it stopped on 2026-09-12
  2. 02

    Reachable without running a node

    In progress
    • A public endpoint, which arrives with the public testnet
    • The same pages, read from a node the team runs, with the caveat stated on the page that a hosted explorer is a copy of the chain and a local node is the chain
  3. 03

    Program verification and review

    Live
    • A program's page takes a wallet-signed statement that rebuilding a named commit reproduces the exact file the node loaded, with the project's website, repository and social links, and says whether a wallet other than the operator's has made one that matches
    • A token's page takes its name, symbol, logo and links, signed by the mint's current authority and by no one else
    • A node started with admin wallets holds both until an admin approves that exact submission, from an admin console that runs apart from the explorer and is never exposed publicly; a key that cannot sign is refused when the node starts
    • Gamma has run with the owner's wallet as its admin since 2026-09-15. It takes token-info submissions for review; program statements are not turned on there yet, so none of its programs is attested
  4. 04

    Program code visible on the chain

    Planned
    • The set of programs a chain executes committed in its genesis, so a verifier learns it from the chain and not from the operator — ADR-0019, built in the node on 2026-09-13 and live on no chain yet: it takes a new genesis, and gamma's predates it
    • An EVM-style view of a program's code and its hash, which depends on the above: today the hash the explorer shows is of a file, and the chain does not attest to it
  5. 05

    Retired chains still readable

    Planned
    • Alpha's and beta's history browsable after their nodes have stopped
    • Today that takes the archived data directory and a binary from before the commitment change, run by hand; a chain that has stopped has no explorer

◆Readiness

Bridge readiness

The bridge releases funds only against proofs — no signer set does — and each stage below is something that has been exercised on devnet or has not. The bar the site holds itself to is the one it has not met: an exit by someone with no relationship to the team.

  1. 01

    Deposits

    Live
    • Lamports locked in a program-owned vault, enqueued on the inbox by the portal's relay, credited on the L2 in the next block — on all three devnet chains
  2. 02

    Withdrawals

    Live
    • On beta, two withdrawals proven against final roots and paid by the vault on Solana, on 2026-09-07 and 2026-09-10; two more proven and paid on 2026-09-12, the same morning, 6,000,000 lamports between them. On gamma, the first withdrawal, 1,900,000 lamports, proven at 13:08 IST on 2026-09-12 and paid an hour later at the first attempt, the payout sent on the cluster's own clock rather than the wall clock, the vault landing on its rent floor plus the 100,000 lamports nobody claimed
    • Every one of them a team address — see the stage below
  3. 03

    Air gap and guardian

    Live
    • A guardian on its own key, not the operator's, on beta and gamma; it can deny a settlement root and nothing else (ADR-0015)
    • 3,600 s on devnet so the drill is observable; 86,400 s recommended for mainnet, which puts a full exit at about three days
  4. 04

    Vault solvency

    Live
    • The node refuses a withdrawal the vault cannot honour: what Solana still owes to earlier exits, plus this one, must fit inside what the vault can pay above its rent floor, or the exit is refused at admission with nothing debited (ADR-0013 D2). Live on gamma since 2026-09-12, when a 500,000-lamport exit asked for against 100,000 of headroom was refused and the chain did not move; after that day's payout the guard re-derived its ceiling from the new balance with nothing telling it to, reading 100,000 payable against nothing outstanding. Never on beta, whose pinned binary predates it
    • The reason it exists: every devnet chain mints its genesis supply on the L2 with nothing behind it on Solana, so a withdrawal larger than what was deposited fails at payout. Beta's vault was found 1,000,000 lamports short of its two committed exits on 2026-09-11 and topped up; the check would have said so at commit time
  5. 05

    An exit by someone unaffiliated

    Planned
    • A withdrawal initiated, proven and paid by a party with no relationship to the team, in a drill anyone can watch
    • Until then every payout on this page is the team paying itself, and the page says so
  6. 06

    Token deposits

    Planned
    • SPL token deposits credited on the L2; not credited yet
  7. 07

    Fast exits

    Planned
    • Team-fronted, then underwritten — stages 04 and 06 of the main roadmap, and a different trust model from the canonical exit rather than a shorter window

Why conditions instead of dates

A date is a claim about the future made with today's information; it decays the moment it is published. A condition is checkable forever: either three independent challengers have each won a dispute on mainnet, or they have not. Dates also create the wrong incentive — a team racing a quarter it announced will ship the checkbox, not the property. The previous version of this roadmap had quarters on it. They passed. This one cannot go stale the same way.

What could set this back

A roadmap that only lists progress is advertising. These are the known ways the sequence above slips, and what each would mean.

  • The proof system takes longer than planned

    It is the hardest component and the industry's graveyard of quiet deferrals. If it slips, the network stays Stage 0 longer — visibly, on the security page — rather than shipping a proof system that exists but does not enforce.

  • Audit findings force redesign

    The point of an external audit is to be wrong in private before being wrong in public. Material findings will delay mainnet and be published with the fixes, including any we accept as residual risk.

  • Solana base-layer changes

    Settlement programs and the one-step verifier depend on L1 limits that change across releases. Each upgrade re-runs the feasibility arithmetic; a breaking change could force parameter or design revisions.

  • Pressure to decentralise the sequencer early

    A staked sequencer set before proofs enforce is decentralisation theatre: it spreads the power to order transactions while leaving the operator's word as the only thing standing behind state. It is sequenced after proofs on purpose, and the order will not be swapped for optics.

  • Nobody shows up to verify

    Stage 1 requires challengers outside the team. If funding independent verifiers fails to attract them, the stage is not claimed — the roadmap waits on the fact, not the intention.

  • Nobody underwrites the fast exit

    A provider fronting an exit is betting that a root inside its window will finalise honestly, and it prices that bet. If the spread is wide enough that nobody uses it, or no provider takes the risk at all, then the window is not the backstop behind the exit — it is the exit, for everyone. That is the honest failure mode, and it is the one that decides whether the window is a property users tolerate or a reason they never arrive. Shortening the window to 48 hours (ADR-0016) narrows the gap but does not close it, and it was done against the dispute game's own arithmetic rather than to look faster — a distinction worth holding, because trading the guarantee for the appearance of speed is the one response that would not be honest.

  • The team-fronted float becomes the thing people trust

    Advancing our own money is the fastest way to make the exit feel solved, and that is exactly what makes it dangerous. A float that is always there stops reading as our balance sheet and starts reading as the network's, and by the time it is exhausted or withdrawn, users will have built on an assumption we never made. Two things keep it honest: it refuses at the point of use rather than queueing, so its limit is visible on a normal day and not only on the worst one; and it is a bridge to a stage where someone unrelated to us takes the risk, not a substitute for it. If that later stage never arrives, the correct move is to say the fast exit is ours and stays ours — not to keep quiet and let it be mistaken for a property of the chain.

Building something the base layer can't hold?

Tell us the workload. If Solieum is the wrong answer for it, we would rather say so early than have you find out at launch.