Prop AMM Network

Hunting and the judge

What to submit, how it is protected, how the judge builds and replays it, and what a PASS pays.

What you submit

  • A Rust crate as a zip or tar.gz, at most 5 MB, that builds into the target program.
  • A payout wallet, which signs a message to bind the submission to it (the wallet opens only when you click).
  • The snapshot you target: the page preselects the latest one.

The payout wallet signs this text, which binds the target, the snapshot, the source commitment and the wallet together:

propamm:submit:<program>:<snapshot slot>:<source sha256>:<wallet>:<time in ISO 8601, UTC>
I submit this source for replay against the snapshot above and ask that any payout go to this wallet. On PASS the source is published.

Your source stays sealed until the verdict

The browser encrypts the archive before it leaves your machine: AES-256-GCM with a random key, and that key sealed to the judge's X25519 public key (tweetnacl box with an ephemeral key). Only the ciphertext is uploaded. The sha256 of the plaintext archive is the public source commitment: it is shown with the attempt and written in the proof record. The judge's private key lives only in the judge machine's secrets.

Rules checked before the build

  • Rust only.
  • No asm! or global_asm!; no include_bytes! or include_str! of anything over 4 KB; no build.rs.
  • Procedural macro crates only from the allow-list: the solana-program family, borsh, bytemuck, thiserror, num-derive, anchor-lang and anchor-attribute-*, pinocchio.
  • Cargo.lock present and used (--locked); dependencies from crates.io only.
  • The build uses one of the pinned Agave cargo build-sbf versions of the judge image.

The judge compiles your crate itself; a submitted binary is never trusted. Builds run with no secrets in the environment, on an ephemeral machine, with a 10 minute cap.

The replay

The original binary (from the snapshot) and your candidate are loaded in two identical local SVMs (LiteSVM). Both receive exactly the same inputs: recent successful mainnet transactions that invoked the program, replayed whole, and then fuzzed variants of the program's own instruction from those transactions. Every program those transactions call is loaded too. Both binaries run under the same compute limit, so an interpreter that embeds the original bytecode as data cannot pass.

The replay environment

A prop AMM reads the clock, its own oracle accounts and the trader's token accounts, so a replay is only fair if those match what the program saw on mainnet. The snapshot follows the program's pool token accounts live and, for every swap that lands, reads the state of every account the transaction references within seconds of it. Each real case carries that state and the Clock sysvar of that read (slot and unix time).

  • A real case is the whole transaction: every top-level instruction in order, so the aggregator around the program, its CPI signers and the instructions sysvar are those of mainnet.
  • Both binaries get the same compute limit, 1,400,000 units (the transaction maximum), so the original is not cut short by cost differences between LiteSVM and a validator. The limit is set on the SVM, with the heap the transaction requested, so the transaction's own instructions stay byte for byte as they ran and the instructions sysvar the program reads is the mainnet one.
  • The SOL and token balances of the transaction's signers are set, on both sides, to what they held right before it ran (from the transaction's own pre-balances), since a trader may have spent the input since.

None of this changes the comparison, which stays byte for byte. A case is on the success path when the original program returns success in it, even if the route around it fails later (an aggregator's slippage check, for example); every output after that point is still compared.

Each snapshot replays the original alone on its own corpus and records the counts: cases on the success path, budget_bound cases and the total. A prop AMM with fewer than 100 success-path cases shows replay calibrating on the board and is never chosen as target of the week, because no rebuild could reach a PASS on it.

For every case the judge compares:

  • success, or the exact error, custom codes included;
  • every byte of every account the transaction may write, when it succeeds: data, lamports, owner;
  • return data;
  • the program logs line for line, with the consumed N of M compute units lines removed;
  • every CPI, in order: program, depth, instruction data (by hash) and accounts.

You can run this exact replay on your own computer before submitting, for free and as often as you like: see Dry run.

The verdict

PASS when every case matches and the corpus exercises the program for real: at least 100 cases where the original succeeds, so a corpus of pure errors cannot pass. Otherwise FAIL, with the share of matching cases as the attempt's match. The verdict is a JSON report with its sha256, the source commitment, the corpus hash and both binary hashes.

The corpus holds up to 1,000 real mainnet transactions and 10,000 fuzzed variants. A snapshot captures swaps for a few minutes, so a busy prop AMM fills hundreds of cases and a quiet one fewer; every page prints the real number, and the success-path count decides whether a program is ready for hunting.

What the board shows

Each attempt appears on the target page with its match, its hashes and its status. No code is shown before the verdict. The best match so far is printed on the target's tile, and the lock on the program's print dissolves as it rises.

On a PASS

  • The source is published on the target page the same day. Always: the point is to rebuild in the open.
  • 90% of the pot is paid to the payout wallet by the keeper, in USDC.
  • 10% is bought into $PROPNET on Jupiter and burned; until the token exists it is held in the vault.
  • The keeper records the verdict on Solana as a Memo: propamm:proof:<target>:<submission>:<source sha256>:<report sha256>:<matched>/<total>. Until the keeper holds SOL the page says "Memo record pending", and every pending verdict is recorded in one run once it does.

House agents

The project can run its own AI hunters: a loop that reads a target's teardown kit, writes a Rust candidate, runs the local replayer and submits when it passes locally. They run only behind an inference key (INFERENCE_API_KEY); until it is connected the house agents are offline until inference is connected, and nothing they would produce is shown. The teardown kits, snapshots and the judge run without AI.

Previous: Chipping inNext: Dry run