Three contracts, and none of them can be paused.
The game is not one contract with an admin key. It is three, each doing one job, each with the parts that decide your payout written where you can read them. This page is what they will be. None of them are deployed.
SEAM
Where a rig stands, which ticker it is bound to, and what a shift costs it. SEAM is the only contract that reads the price feeds, and it reads them once per shift, at the boundary, so the price of a shift cannot move while you are buying it.
Binding is free and can be changed between runs. Standing on a floor whose seam matches your rig is worth ×1.20 against ×0.90 elsewhere — roughly a third more — which is the entire reason the floor is a decision.
> // bind a rig to a floor > bind(uint256 rigId, uint8 floorId) // 0..5 > > // buy shifts, bonding grit up front > buyShifts(uint256 rigId, uint8[] shifts, uint256 bond) > > // what a shift charged this rig, last close > lastCharge(uint256 rigId) → uint256 > > // anyone can roll a stale shift after 2h > rollStale() → bool
Reading the feed once per shift means a rig cannot be re-priced mid-run, and it means nobody can sandwich the read. The cost is that the price you get is the price at the boundary, whether that suited you or not.
PRESS
Two rigs of the same tier in, one of the next out. The lower id survives with its traits intact; the higher one is burned. There is no fee, no cooldown and no unlock date.
PRESS refuses any rig that is working or owes grit, which is what stops a half-finished run from being laundered into a fresh tier. It is also why the answer to “why can’t I merge?” is always the same one: that rig is busy.
> // two of the same tier, both idle > press(uint256 keepId, uint256 burnId) > requires tierOf(keep) == tierOf(burn) > requires idle(keep) && idle(burn) > requires owed(burn) == 0 > > // what the pair would become, before you press > quote(uint256 a, uint256 b) → (tier, orePerGrit) > > // fee > PRESS_FEE → 0
LEDGER
The pool, the split, and the payout. LEDGER divides one twenty-eighth of the pool across everything that worked the shift, pro-rata by ore pulled, and pays it out in the tokenized stock your rig was bound to — or in ETH, if you asked for that instead.
The fee split has no owner and no setter. Half the creator fee goes to the pool, half to us, and neither side can be redirected after deployment, including by us. That is not a promise, it is the absence of a function.
> // close a shift and divide its pool > settle(uint32 shiftId) > payout = pool / 28 > share = ore[rig] / totalOre[shift] > > // take it in stock, with a floor you set > claim(uint256 rigId, uint256 minOut) > > // or take ETH instead > claimEth(uint256 rigId, uint256 minOut) > > // there is no setFeeRecipient > // there is no pause()
If no rig works a shift, LEDGER pays nothing and burns nothing. The money stays in the pool for the next one.
The functions we did not write.
A protocol is defined as much by what it cannot do. These are the four things people usually ask for, and the reason each one is absent.
Not implemented
If we could stop the mine we could stop it on a day that suited us. rollStale exists instead: two hours after a missed roll, anybody can push the shift forward.
Not implemented
Trait and tier multipliers are constants in the bytecode. Changing one would mean a new contract and a migration you could refuse.
Not ours
$GRIT is created by a public launchpad, not by us. We never hold a supply, so there is no allocation table to publish and none to hide.
Not implemented
The split is fixed at deployment. Half the creator fee to the pool, half to us, and no function on either contract can move it afterwards.
None of this is verifiable yet, because none of it is deployed. Every claim on this page becomes checkable the moment the contracts go up, and until then it is a description of intent. Treat it as one.