CWC-1
Cryptographic World Computer Not deployed
DatasheetRev A2026 · 09Demonstration

CWC-1

Cryptographic World Computer

A world of 512 by 512 cells that Ethereum orders and verifies but never runs. Every day it lives through 256 generations of Conway's Life, and every live cell belongs to someone. The work happens in nodes, this tab included. If anyone disagrees with what a node posts, a dispute narrows the argument to a single 8 by 8 tile, and the chain checks that tile once.

  • Verification instead of execution. 67,108,864 cell updates a day off chain; a dispute costs the chain 1 tile.
  • Every buy is a transaction on the world computer. A buy of 0.01 ETH or more launches a glider you own.
  • Only order lives on chain. Writes do not commute, so the chain keeps their order and nothing else.
  • Paid by sampling. Each day 16 live cells are drawn with drand and their owners are paid from the pool's toll.
  • No owner, no key, no upgrade. Hashes only: nothing in the protocol depends on a signature scheme.
CWC-1
512 × 512
gen 0epoch 0
Epoch
0
Cells alive
0
Owners
0
Computed in this tab
0
Executed by Ethereum
0
Hover a cell to read it. Drag to pan, scroll to zoom.
2

Functional block diagram

On chain: order, claims, one tile
Off chain: everything else
ETHEREUM · ON CHAIN OFF CHAIN · ANY NODE, THIS TAB INCLUDED Uniswap v4 poolETH / CWC · 0.30% SEQUENCERhook · 0x1044 Pot1% ETH side Burn1% CWC side WORLD ORDER · every write, in the order it landed CLAIMS · one word per epoch, against a bond MONEY · the pot, and what it owes Youburn CWC to write VERIFIER bisect 1,280 steps to one descend 4,096 tiles to one run that tile once The draw drand round, cutoff + 60 s 16 live cells, their owners paid Node replay every write, then 256 generations 67,108,864 cell updates, 1 commitment Watcher every node checks every claim one honest node is enough swap glider, buys of 0.01 ETH or more write the ordered writes claim dispute kill finalize prizes
Figure 1. Everything inside the solid border is a contract. Everything below the dashed line is arithmetic anyone can redo. The only arrow from off chain to on chain that carries computation is a single word per epoch.
3

Your node

Runs in this tab
In a Web Worker

A light client used to take the chain's word for what happened. This one does not. It reads the ordered writes of the epoch, replays them, runs 256 generations, builds the tree over 4,096 tiles, and compares its own commitment with the one the chain was told.

If they match, nothing needs to happen, and nothing does. If they do not, this tab can open a dispute and play it to the end.

Note 1The protocol is safe while one honest node is watching. Every visitor who leaves this page open is one.
Note 2Snapshots this tab keeps between visits are trusted only after their commitment is recomputed and found equal to the one finalized on chain.
Node · this tabidle
WAITING
Epoch
-
Writes
-
This tab computes
-
The chain was told
-
Cells alive
-
4

The verifier, played

A real game
computed by the engine

A liar takes the world in the die above, runs the epoch honestly, and at one generation plants four cells that were never there. From then on it computes faithfully, so its world is consistent with itself and wrong. Press play and watch an honest node find the exact step and the exact tile, while the chain does almost nothing.

Steps of the epoch · writes, then 256 generations
Press play.
Interval
-
Moves
0
Chain work
0 tiles
The 4,096 tiles of the disputed world
The liar's tile
What the chain computes from the nine agreed tiles
5

Write to the world

Burns CWC
Fills only dead cells
Pattern · one 8 × 8 tile
Tile
click the world to choose one
Cells
0
Burns
-
Preview: 5 × 5 tiles around yours, 0 generations on, with every write pending this epoch.
Note 3A write fills only dead cells. Anything alive where you draw stays whose it was. The only way to take ground is through the physics.
Note 4The price per cell doubles for every 2,048 cells written in an epoch, and the base moves 12.5% a day toward that pace. Up to 32 tiles per call.
6

The draw

16 cells a day
drand quicknet

When an epoch finalizes, the pot releases 10%. The proposer is paid 5% of that for posting the truth, and the rest becomes 16 prizes. Prize j goes to the owner of live cell number keccak256(seed, j) mod live, counted through the tree, so every live cell has the same chance and a dead one has none.

The seed is the drand round one minute after cutoff. Nobody can know it early and nobody can choose it. Anyone may settle a prize; it is always paid to the cell's owner.

Note 5This is the sampling idea behind PeerDAS turned into a lottery: a few random openings of a committed world, each checked against its root.
jCellOwnerPrizeState
Nothing drawn yet.
7

Timing diagram

One epoch
1 day, UTC
WRITES, EPOCH e WRITES, EPOCH e+1 DRAND ROUND CLAIM e WINDOW DISPUTE MOVES FINAL, DRAW CUTOFF FINALIZE 24 h12 h+60 s1 h each, at most 13
Figure 2. Epochs overlap: while epoch e is being claimed, disputed and finalized, epoch e+1 is already collecting writes. Epochs finalize strictly in order; if nobody proposes, the pot waits and grows.
8

Pin configuration

Every external call
Hover a pin
ContractRoleAddress
Hover or tap a pin for what it does and who may call it.
9

Electrical characteristics

Gas, measured
Prague mainnet fork
ParameterConditionsTypUnit
Table 1. Measured by sim_cwc.js against the real Uniswap v4 PoolManager on a mainnet fork, 85 checks passing. The whole of a challenger's worst game is the sum of its moves; the 0.03 ETH bond covers it up to about 30 gwei.
10

Application notes

How to use it
without this page
AN-1

Launch a glider

Buy CWC on the ETH/CWC pool with 0.01 ETH or more. The hook launches one glider owned by your address, at a place the swap's own hash picks. The first time costs about 115,000 more gas, once; after that about 49,000.

Gliders go to the transaction's origin. If you trade through a relayer or a smart-wallet bundler, the glider is the relayer's. Write directly instead.

AN-2

Write a pattern

Approve the World to burn CWC, then call write(tiles, masks) with up to 32 tiles. Bit i of a mask is cell i = row * 8 + col. quote(cells) gives the exact burn first.

A block is four cells that live for ever unless something hits them. A glider is five that travel. Both are in the editor above.

AN-3

Run a node

The same logic as this page, as a program that never sleeps. It verifies every claim, proposes the truth, disputes a lie and plays every move, finalizes, and settles its own prizes.

node cwc_node.js                 # watch only
node cwc_node.js --act           # propose, dispute, defend

The key goes in through a masked prompt into an environment variable, never a file. The file's header says how.

AN-4

Propose an epoch

After cutoff, compute the epoch and call propose(e, rootHash, rootCount, drandSignature) with 0.03 ETH. After 12 undisputed hours anyone calls finalize(e). You get the bond back and 5% of the release.

AN-5

Dispute a claim

challenge(claimId) with 0.03 ETH, then answer each move within the hour: pick the first segment you dispute, choose the first node that is wrong, and finish with resolveGeneration or resolveWrite. Win, and you take back your bond and the liar's.

AN-6

Collect a prize

sampleIndex(e, j) names the live cell; walk the tree's counts to its tile and call collect(e, j, tile, words, proof). Anyone may; the owner is paid. Then the owner calls withdraw(). Prizes wait 30 days, then return to the pot.

11

Absolute maximum ratings & errata

Stated plainly

Absolute maximum ratings

RatingLimit
Owner ids, ever65,535
Gliders launched per epoch512
Direct writes per epoch512
Tiles per write call32
Steps in one epoch1,280
Moves in one dispute13
Time per move1 h
Claim window12 h
Claim and dispute bond0.03 ETH
Prize life30 days

Errata

No.Description
E1A false claim nobody disputes within 12 hours becomes the world. Every node checks every claim, and winning a dispute pays the liar's bond. The window is sized to daily prizes, not to billions.
E2Only the proposer can defend a claim. A proposer who walks away loses to anyone, even someone who is wrong. The truth can always be proposed again; that proposer's bond cannot be recovered.
E3The last writer before cutoff sees every earlier write of the epoch. That is what ordering is worth. The price of a cell rises with demand inside the epoch.
E4Gliders from buys go to the transaction's origin. Trades through relayers and bundlers launch the relayer's glider.
E5The verifier is optimistic: it catches a lie if one honest node objects in time. It is not a validity proof. It needs no trusted setup, no prover farm, and nothing but hashes.
E6Not audited. A fork simulation, an economics model and an adversarial review are not an audit.