Security is a superposition.

A deployed contract is in one of two states — sound, or exploitable — and from the outside you cannot tell which until someone observes it. Hilbert is a market that prices that uncertainty, and a machine that collapses it by proof rather than by vote.

${''}

The observation

A protocol puts one of its own invariants up for observation. An invariant is a predicate — a small, deployed, view-only contract that states one thing that must always be true, and reads the live system to check it. “The vault never holds less than was deposited.” “Total shares equal the sum of balances.” “The oracle price is within bounds.”

The subject funds two pots: a bounty, paid to whoever can prove the invariant false, and a premium, streamed to the underwriters who stand behind it for the term. From that moment the invariant is superposed — carried on the books as neither sound nor broken.

Underwriting

Anyone can stake coverage behind an invariant they believe holds, and earn the premium for as long as it does. The total coverage that gathers per unit of bounty is the only honest security rating a contract can have: it is quoted by people who lose the money if they are wrong.

Stepping back is deliberately slow. An underwriter who wants out enters decohere, and the stake stays slashable for a day afterward — so nobody can duck out a block ahead of a proof already in flight.

The Prover

A claim is never argued. A hunter commits to a sequence of calls, waits, then reveals it. The Prover deploys a fresh, unprivileged witness account, optionally funds it from the hunter's own balance, runs the sequence against real state — and then discards the entire frame.

Only the outcome survives, returned through a revert: did the invariant hold before, does it hold after, is the predicate contract still the one underwriters read. If the invariant was true at the start and false at the end, the exploit is real. The coverage pays the subject, the hunter takes the bounty plus a tenth of the coverage, and any working capital is refunded in full.

${''}

Why discard the frame? Because the proof has to touch live balances to be real, but must leave nothing drained and nothing replayable. The state the attempt touched never existed, so there is no path for an observer to copy and no value to extract — only the verdict.

Writing invariants

A predicate implements three view functions:

// what must always be true
interface IInvariant {
    function subject() external view returns (address);
    function statement() external view returns (string memory);
    function check() external view returns (bool);
}

Keep check() cheap and total. A predicate that reverts, runs out of gas, or returns junk is read as broken, not sound — an invariant nobody can evaluate protects nobody. And once an observation is open, swapping the predicate's code voids it: underwriters are always covering the statement they read.

Contracts

ObservatoryThe market. Opens observations, streams premium, settles proofs. No owner, no pause, no upgrade.

ProverRuns a candidate exploit against live state and reverts with the outcome.

WitnessThe disposable, unprivileged account each attempt runs from.

HilbertTokenFixed-supply HILB. The unit coverage, premiums and bounties are denominated in.

HilbertLensRead side — the whole registry in one call, so the app needs no indexer.

Addresses publish here when Hilbert goes live on Ethereum.