How it works

Five contracts, five actors, one certificate. This page follows a single certificate from creation to the moment someone proves it was a lie.

The actors

Those are the demo accounts on testnet. In production each role is whoever holds the keys — the roles are enforced by contract authorization, not by identity.

1. Lock the reserve

The operator deposits USDC into the ReserveVault. The deposit sets an unlock_at equal to the certificate's expiry, and release_to_operator() reverts with reserve_still_locked until that time passes. The money is not a balance the operator happens to have — it is money they cannot take back.

await bound.depositReserve(operatorKeypair, 1_500_0000000n); // $1,500

2. Publish the certificate

The operator calls publish on the Registry with the agent's address, the bound, the claimed reserve, the expiry, and the addresses of the vault and staking contracts. The certificate is created with status Pending — it exists, but nobody has vouched for it, and verify().valid is still false.

3. An auditor vouches — with their own money

An auditor first stakes into AuditorStaking. A stake at or above min_stake is what "registered" means; there is no allowlist.

When the auditor calls attest(cert_id), the Registry checks they are registered, moves the certificate to Verified, and — in the same transaction — calls AuditorStaking.lock(auditor, expires_at). From that moment the auditor cannot withdraw their stake until the certificate expires. release(auditor) reverts with stake_locked.

That lock is the entire security model. An auditor who vouches for a certificate has put money somewhere they cannot reach it, and where a challenger can take it.

The FeeEscrow releases the audit fee to the auditor on attestation. It sits alongside the security path and plays no part in a slash.

4. Read before you transact

Any counterparty — no keypair, no signature, no permission — calls verify(agent):

const result = await bound.verifyCertificate(agentAddress);
// { valid, status, bound, reserve, auditorStake, auditor, expiresAt }

valid is true only when the status is Verified and the certificate has not expired. The status moves Pending → Verified → Invalid; Invalid is terminal and means a challenge succeeded.

5. Anyone can catch a lie

Suppose the certificate claims a $1,500 reserve and the vault holds $200. A challenger posts a bond and calls challenge(cert_id, "InsufficientReserve", victim). Then anyone — the call is permissionless — calls resolve(challenge_id), and the contract checks the claim against reality:

let claimed: i128 = Registry.get_cert_reserve(cert_id);   // what the cert claims
let actual:  i128 = ReserveVault.get_balance();           // what is really locked
let fraud = actual < claimed;                             // math, not opinion

If fraud is true, one transaction does all of this:

If fraud is false, the challenger forfeits their bond. That is what stops the challenge path from being free to spam.

Why the honest path is the profitable one

Look at it from each seat:

• The operator cannot fake the reserve, because the vault balance is the number the contract reads. Overstating it is a slash waiting to happen.
• The auditor earns a fee for attesting and loses their stake for attesting to a lie. They will only vouch when they have checked the vault themselves — which anyone can do, for free, in one read call.
• The challenger is paid 20% of a stake for running a comparison anyone can run. Fraud does not stay undiscovered when finding it is profitable.
• The counterparty gets a number instead of a reputation score.

Nobody has to be trusted for the arithmetic to hold. That is the point.