Testnet: tokens have no value, and the vulnerable contracts are our own test fixtures. Limits

Practice program in fork mode — a tutorial (testnet)

The practice program in fork mode: its vaults exist only inside the verifier, which deploys them from the manifest on the anchor's state.

Try the practice program (14)

Practice program in fork mode: a tutorialOpenround 0light-client confirmedstaging run, 2026-11-03
The staging run of 2026-11-03, on the same contracts before the lock: its results file records near-antibody with locked: false. The recorded run on the locked deployment (2026-11-04) is programs 5 (Acme Lend), 6 (practice) and 7 (fork mode).

Overview

The program as near-antibody stores it. Its manifest hash commits the anchor, the targets, the rules and the terms; once it is open, the deployment's owner can change nothing it depends on.
Project
antibody.testnet · ours
Description
TUTORIAL TARGET deployed only inside the verifier (fork mode): 24 vaults with one textbook bug (docs/fork-mode.md).
as written in the committed manifest
Program key
bounty.antibody.testnet/3
Phase
Open round 0this round since
Created
Opened
3wSMtaFV…
Terms sha256
2a714747a7fe11e7…
Manifest sha256
5c0fe5c6afb48740…Uploaded in NEAR transaction GJSxJH4aUM… by antibody.testnet
Sealing key
888d0fb0a5a26cc2…Proofs are sealed to it. It counts only once its activation run (run 25) is attested on NEAR: b8Xo1cCF…

Its record

At stake
0.029wNEAR available now
Verified attempts
1
Paid findings
1
First claim
12 minafter it opened
Claimed in the first hour
3.33%of the escrow
Open for
147.2 h
view bounty.antibody.testnet.get_program({"program_id":3})

Holds if: the manifest hash shown here, as near-antibody stores it

antibody judge --program 3

Try it

A tutorial: its bug and its proof are public. Anyone can run the whole loop on testnet in a few minutes, with no account and no key; nothing here is a real vulnerability.

One rule, one textbook bug

Each of 24 small vaults holds a little ether, and its sweep(to) has no access check: anyone can send a vault's ether anywhere. The proof is one call to your vault; at the anchor the vault loses its ether, so vault_keeps_its_ether breaks. Each vault is its own target, so each try is its own finding.

Try the practice program (14) docs/practice.md 
antibody try --name <you>

The browser try and the CLI use the practice vending contract's program, program 14.

Fork mode: the vaults exist only inside the verifier

The manifest commits the transactions that deploy the factory, its 24 vaults and the rule. The verifier runs them in its own copy of the chain, on the anchor's state, before any proof: no staging deployment. So a vault's address has no code on Sepolia, and the proof was still verified, attested on NEAR and paid.

eth_getCode on chain 11155111

Holds if: "0x": no code at 0xfa35e1e9… on Sepolia

curl -s https://ethereum-sepolia-rpc.publicnode.com -H 'content-type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"eth_getCode","params":["0xfa35e1e99bd69719f57045409e19555f0147cf44","latest"]}'
How fork mode works: docs/fork-mode.md

The rules as code

Each rule is one bit of the program's invariants contract. After a proof's calls, at the anchor, the verifier runs its check(): a set bit is a broken rule, paid by its severity. The verifier never reads a report.
RuleSeverityPayoutBudget per roundSource
vault_keeps_its_etherbit 0

No practice vault loses its ether.

Low
0.001 wNEAR
0.03 wNEAR
PracticeInvariants, line 63

The budget caps what one rule pays per round, so many entry points into one root cause cannot drain the escrow. A finding's key is the rule and the entry point that broke it (by default, the target and function): the first proof of each key is paid.

The targets (25) on Sepolia: deployed only inside the verifier
  • factory0x69eca311…909e
  • vault-00xc1bd97d2…22fa
  • vault-10x6924428a…f906
  • vault-20x6f4c61b8…d7fa
  • vault-30xfa35e1e9…cf44
  • vault-40x85cef399…0d5c
  • vault-50x74a5e315…4a5f
  • vault-60x888ce025…932c
  • vault-70xbb5c4d1a…3ad7
  • vault-80x5c3eee84…9c36
  • vault-90x61bfd687…8ef3
  • vault-100x3f6285d8…887e
  • vault-110xd6205af7…14d5
  • vault-120x92fb6550…602c
  • vault-130x70a753fb…da72
  • vault-140xb6b41dce…6b04
  • vault-150xea9c9ee0…2fe0
  • vault-160xe1ca474b…7708
  • vault-170xa80baf4c…754a
  • vault-180x59143608…6a2e
  • vault-190x8894e2cc…29d8
  • vault-200x02854dcd…d68d
  • vault-210x43b6d414…325d
  • vault-220x0c6a6715…586d
  • vault-230x8707a59a…0dea

The terms

Committed in the manifest with the rules, their text fixed by the terms sha256, and enforced by near-antibody: no person decides a payout.

Payouts

SeverityPayoutRules
Criticalnonenone
Highnonenone
Mediumnonenone
Low0.001 wNEARvault_keeps_its_ether
Bond per commit
0.0001 wNEAR · refunded, or forfeited to this program's escrow when the proof breaks nothing
Instant payments
up to 0.001 wNEAR
When a payout is instant

Paid in seconds when the verdict is attested on NEAR, within 0.024 wNEAR per 1 h. Otherwise a payout waits the challenge window; above the cap it also needs an agreeing second run.

Challenge bond
0.001 wNEAR
Protocol fee
none · pinned at 0 for this program
Release fee
none · pinned at 0 for this program
Verification deposit
0.03 NEAR per run, paid by whoever asks for it; OutLayer refunds the unused part

The escrow against the largest payout

29×the largest payout
0.029 available / 0.001 wNEAR largest

The available escrow over the largest payout. Below 1× the status page raises an alert; a payout the escrow cannot cover is queued as debt, in commit order.

Pauses
No rule pauses anything.
Known issues
None allowed.
Gap lane
Off.
Unevaluable
A proof the rules cannot evaluate (check() reverts or runs out of gas) is refunded.

The windows

WindowLengthWhat it bounds
Reveal
10 min
A commit is revealed within this, or it expires and its bond goes to the escrow.
Challenge window
60 s
A verdict that is not paid instantly is final after this; anyone may challenge it within it, with the challenge bond.
Resolve
5 min
A challenge with no attested result within this voids the verdict; both bonds are refunded.
Run timeout
4 min
A run that never answered is void after this.
Infrastructure grace
10 min
An infrastructure failure is retried this long, then the commit closes with a refund.
Round minimum
2 min
A round runs at least this long before the next one opens.
Re-run window
10 min
Re-runs at a proposed fix may be asked for within this of its confirmed check.
Disclosure delay
10 min
A paid proof becomes public at most this long after its claim.
Exit grace
60 s
After the deadline plus this, anyone may settle the program (exit).
Deadline
No commit is accepted after it.

The anchor

Every proof runs on the state proven at one block. A pause ticket, and the verdict guard, act only on an anchor the light client confirmed: on a project-attested anchor a verdict is about state the project chose.
Chain
Sepolia (11155111)
Block
12055610
Hash
0x7abf2c838e6b13585937c0373c749dfebb710e8f02415fafe380ff087bb29d08
Its check
confirmed by the light clientnear-antibody compared the hash with client-eth2.sepolia.testnet when the program was created.
Base witness
The anchor state the rules and the round-0 checks read, proven against the anchor and pinned at activation.b8ec861518480974…Uploaded in NEAR transaction HMkZzsf76u… by antibody.testnet

Check the hash yourself

view client-eth2.sepolia.testnet.block_hash_safe(12055610 as 8 little-endian bytes: 0x3af4b70000000000)

Expected: byte 0 is 1 (the client holds the block), then 32 bytes equal to the anchor hash.

The same check from a terminal, and the one that also hashes the block header from a Sepolia RPC:

antibody judge --program 3
antibody anchor-check --block 12055610

Known issues

Declared sealed before open; a later proof with the same tag is not paid again. Their count, rules and severities are public; their content stays sealed for good.
0 sealed
No known issue declared: every key this program prices was open to the first proof.

The chains

Per chain: the program's adapter, the proxies it may pause or upgrade, and every permit near-guardian asked the MPC network to sign, with the transaction that carried it there.

The sealed feed

Every commit in order: who, when, the state, the verdict and the payout; never the proof. A proof stays sealed until disclosure, and the project reads only the proofs it pays for.
Zero-knowledge proofs: none yet
CommitWhoWhenStateVerdictKeysPayout
Commit 10#0 · round 0
agent-c.antibody.testnetour fixture agent C
HGUuP6Tx…
Paid
ViolationAttested on NEAR
vault_keeps_its_ether6d9e7d2a…
0.001 wNEAR7eyjnMNv…

A key is a rule and the entry point that broke it: the first proof of each key is paid; a later one is a duplicate that keeps its own proof record. Each commit's page shows its proof card and how to check it.

antibody status --program 3

Rounds and the release gate

A round ships a fix as code overrides at the same anchor. The enclave checks it, every paid proof is re-run against it, and a release permit is signed only for code that every paid proof fails against.
No round yet: this program still runs its round-0 code. A round is how a fix ships, and only a fix every paid proof fails against is released.

The ledger

Every movement of the escrow keeps funded equal to available + reserved + paid + fees + returned. Amounts in wNEAR, which has no value on testnet.
balances

Where the escrow is

Available0.029
Reserved0.000
Paid0.001
Fees0.000
Returned0.000
Funded0.030

What came in

Deposits0.030
Forfeited bonds0.000
Challenge bonds0.000
Funded0.030

Forfeited bonds go to this program's escrow, where they pay future findings: never to us.

The audit

Accounted
0.03
Reservations
0 · held by the commits; equals reserved when it balances
Debt
0 · owed and not yet funded, queued in commit order
Defaulted
0
view bounty.antibody.testnet.audit({"program_id":3})

Holds if: ok: true (funded equals accounted, and reserved equals the commits' reservations)

antibody view --contract bounty.antibody.testnet --method audit --args '{"program_id":3}'