instruction set

The record has four instructions. Everything else it exposes is a view that reads state and writes nothing.¹ The four are mark, advance, lapse and sweep.

All four are permissionless. None checks the caller against an allowlist, a role, or a balance, because no such structure exists in the contract.

No instruction takes an argument capable of changing what happens. Arguments that would let a caller select an interval, a threshold, a recipient or an amount are absent by construction rather than restricted by a check.

Each of the four is described below in the same terms: who may call it, what it reads, what it writes, and what it pays.

Callable by any address. Reads the fast clock, the slow clock, and the pair stored by the previous mark.

Writes the interval it can prove, crediting the proven span to witnessed and the remainder to dark, then stores the new pair and appends a row to the register with the caller address.

Pays a bounty from the treasury, computed as a pure function of the fast blocks since the last mark landed. If the treasury is empty the bounty is zero and the call still succeeds.

It is the only instruction that adds an observation. The other three consume state that marks have already produced.

Callable by any address. Reads witnessed, the bands array, and the current form index.

Valid only once witnessed has crossed the next entry in bands. Otherwise it reverts and nothing is written.

Writes the rerolled trait bits, the incremented form index, and the crossing itself with the fast block and the address that landed it.

Pays nothing. There is no reward for advancing and no penalty for leaving a crossed threshold unconsumed.

Callable by any address. Reads both clocks, the quiet window constant, and the running interval.

Valid only once no mark has landed inside the quiet window. Until then it reverts.

Writes the running interval closed at its proven length, the remainder to dark, and an increment to the lapse count. The form index does not move and nothing is destroyed.

Pays nothing. Lapse is how the record admits a gap instead of guessing across it, and it is the only instruction whose purpose is to record absence.

Callable by any address. Reads the treasury balance and the destination written in the record.

Writes the moved balance under the rule the record holds. It takes no argument that changes the amount or the destination.

Pays nothing to the caller. A caller who sweeps spends gas and receives attribution in the transaction and nothing further.

It exists so that the treasury does not require an operator, which would be an owner under a different name.

There is no owner. No address holds privileged write access, and no function checks for one.

There is no upgrade path. The contract sits behind no proxy, exposes no implementation slot, and has no migration hook.

There is no admin key and no pause. There is no circuit breaker, no emergency withdraw, and no parameter a caller can set.

What the record holds at any moment is written in a single struct and nowhere else, which means nothing with hands can revise it, reorder it, or clear it.