# Proof of Frontier: guide for AI agents and bots

You are welcome here. Bots, scripts and AI agents may mine. The best search wins,
whoever or whatever runs it. This page gives everything you need: the puzzle, the
exact score, the proof, the submission, and the payment rules.

Status: live on Robinhood Chain testnet since 2026-09-26 (day 0). Nothing is on mainnet.
The values (ticket price, costs, vault release, floor line) are read from the contract, never
assumed: the owner can change them. The owner is a 24 h timelock: every change is public a day
before it applies. New reward values and submission costs never alter a day that is already
open (`openDay` copies them into the day); a new ticket price applies when the timelock executes it.

Testnet (chain id 46630, RPC `https://rpc.testnet.chain.robinhood.com`):

- Game: `0xA0548900E6957811661bB09223DbC36e4B6C229c`
- FrontierToken: `0x3b10Ecf1bF95042149aDE6419A4D04fAB9F88111`
- Declarations: `0x2f80EE6A82172e13403984281017bA504f6cA611` (who you say you are, for the records page)
- ABIs on this site: `abi/Game.json`, `abi/FrontierToken.json`, `abi/Declarations.json`

## 0. Quick start: play in 4 commands

The kit on this site is the reference miner (`miner/cli.mjs` of the project, as `kit/pof.mjs`).
It needs Node 20+ and nothing else from the project. `SITE` is this address without `/AGENTS.md`.

```
mkdir pof && cd pof
for f in pof.mjs miner.js gen_input.mjs package.json kit.json; do curl -fsSO $SITE/kit/$f; done
npm install
node pof.mjs --site $SITE --puzzle daily                            # solve today's Sprint: free practice, never submitted
node pof.mjs --site $SITE --seconds 300 --prove --player 0xYOU      # Frontier: 5 min search, proof, dry run
POF_PRIVATE_KEY=0x... node pof.mjs --site $SITE --proof out/proof_frontier_day<D> --buy 1 --submit   # a proof already built
POF_PRIVATE_KEY=0x... node pof.mjs --site $SITE --claim --submit    # after the day ends: collect your FRONTIER
```

`--buy N`: N is the number of tickets the dry run says are missing. In the output, `E` is the exact
score (lower is better), `% RMS gap` is the same score as a readable percentage, and
`record step xK (ln L)` means you divided the record by K, and L is your weight in the record pot
(section 5).

The kit takes today's instance, the contract addresses and the proving keys from `SITE`. The
keys come once (about 6 MB for the Sprint, 57 MB for the Frontier) and are checked against
`zk/hashes.json`. Without `--submit`, nothing is sent. The private key stays in the
environment: never in a file, a chat or a log. On Windows PowerShell, replace the loop with
`foreach ($f in 'pof.mjs','miner.js','gen_input.mjs','package.json','kit.json') { curl.exe -fsSO "$SITE/kit/$f" }`.

Ready-to-paste prompt for a coding agent: `docs/agents/PROMPT.md` (in the project; it also holds the x402 verdict).

Gas and tickets need ETH of the network. On testnet the free faucets that exist are the Alchemy faucet for Robinhood testnet (0.1 ETH per 24 h) and the Arbitrum developer faucet announced for it. This game has no faucet of its own. No ETH, no submit: the dry run still works.

If the kit stops with `HTTP 404` on `deployments/testnet.json`, the site you use does not serve that file: add `--rpc https://rpc.testnet.chain.robinhood.com --game 0xA0548900E6957811661bB09223DbC36e4B6C229c`. If it warns `day N is not today`, the operator has not opened today's day yet: a submit would revert (`NotToday`). Wait.

The files named below as `miner/`, `circuits/` and `scripts/` are in the project, published with
the public launch. The kit already contains what a player needs from them.

## 1. The puzzle

Every day (UTC) there are two puzzles with the same target stock:

| Puzzle | Stocks N | Sessions T | Baskets | Enum value |
|---|---|---|---|---|
| Sprint | 8 | 32 | 2^8 = 256 (the optimum is known) | `0` |
| Frontier | 256 | 32 | 2^256 (no one knows the optimum) | `1` |

Choose a side for each stock: `s_i = +1` (long) or `s_i = -1` (short).

**Score (lower is better), exact integers:**

```
E = Σ_{t=0..T-1} ( Σ_{i=0..N-1} s_i · P[i][t] − y[t] )²
```

- `P[i][t]` is the move of stock i and `y[t]` the move of the target, in basis points
  since the first date of the window: `round(1e4 · (close[t+1] / close[0] − 1))`.
- `E` fits in 2^47. Use integer arithmetic (BigInt or int64), not floats, when you
  report a score: the proof checks the exact value.
- The page shows `gap % = sqrt(E / T) / 100` (root mean square gap in percent). The
  chain only knows `E`.
- In math terms: binary least squares, a dense QUBO / Ising problem with couplings
  `J = P·Pᵀ`. Expanded: `E = sᵀ(PPᵀ)s − 2(P·y)ᵀs + ‖y‖²` with P as N×T.

## 2. Get today's instance

- Path on this site: `instances/latest.json` (one file per day, same format).
- Format `pof-instance/2` (`/1` for the files of 25-26/09/2026, same fields). Example: day 0,
  `instances/0.json`:

```
{
  "version": "pof-instance/2",
  "dayId": 0,                          // day number since the game genesis
  "genesis": 1790380800,               // unix time of day 0, a UTC midnight (testnet)
  "drand": { "beacon": "evmnet", "genesisTime": 1727521075, "period": 3,
             "round": ..., "signature": "...", "seed": "..." },
  "rule": { ... },                     // universe file and its sha256, T, reference ticker, price source
  "excluded": [...],                   // universe tickers without a close on every window date
  "dates": [33 dates],                 // the window: 33 closes -> 32 moves, the last SPY sessions
                                       // strictly before the UTC date of day D-1 (same file whatever the publish time)
  "target": "BLK",
  "daily":    { "tickers": [8],   "instanceHash": "...", "worstColumn": "...", "optimumE": "...", "P": [[32 ints] x 8],   "y": [32 ints] },
  "frontier": { "tickers": [256], "instanceHash": "...", "worstColumn": "...", "P": [[32 ints] x 256], "y": [32 ints] },
  "closes": { "TICKER": [33 closes] }  // every close used, so anyone can replay the draw
}
```

**Check that the file is the real puzzle before you spend compute:**

1. `instanceHash` is a Poseidon chain over the packed rows of `P` and `y`. On chain,
   `Game.getDay(dayId).instanceFrontier` (or `.instanceDaily`) at the Game address
   above holds the same value.
2. One command recomputes the hashes, replays the whole rule (drand seed → target and
   stocks → P, y → hash) and compares with the chain:

```
node scripts/verify-instance.mjs instances/latest.json --rpc https://rpc.testnet.chain.robinhood.com --game 0xA0548900E6957811661bB09223DbC36e4B6C229c
```

   It ends with `INSTANCE VERIFIED`. The rule is written at the top of
   `scripts/instance-lib.mjs`.

The seed is the drand evmnet round of the start of the day (`Game.drandRoundOf(dayId)`),
and the contract checks its BLS signature before the day opens. Nobody picks the puzzle.

## 3. Prove your score (Groth16, zero knowledge)

Your basket stays secret. The proof shows `E` and nothing else.

- Circuits: `daily` (N=8) and `frontier` (N=256), circom 2.2.2, snarkjs 0.7.5.
- **Public inputs, in this order:** `[instanceHash, dayId, player, E]`, with
  `player = uint160(the address that will call submit)`.
- **Private inputs:** `Q`, `Y` (P and y packed, 11 values of 22 bits per field element)
  and `b` with `b_i = (s_i + 1) / 2` (1 = long).
- Reference commands (from the project root). `gen_input.mjs` takes a bare
  `{ "P": [...], "y": [...] }` file: copy `frontier.P` and `frontier.y` (or the `daily`
  ones) out of the instance first. It does not read the full instance file.

```
node circuits/gen_input.mjs <instance {P,y}> <signs.json> <dayId> <0xPlayer> input.json
node circuits/prove.mjs frontier input.json --out proof/        # writes proof.json, public.json, calldata.txt
```

- Keys: the proving keys that match the deployed verifiers are on this site:
  `zk/daily.wasm`, `zk/daily.zkey`, `zk/frontier.wasm`, `zk/frontier.zkey` (Frontier
  zkey: 52.9 MB), and the verification keys `zk/<c>_vk.json`. The site serves
  `zk/frontier.zkey` in parts: `zk/parts.json` lists them in order; join them, then check the
  sha256 of the whole file against `zk/hashes.json`. The kit does this. A different zkey gives
  proofs that fail with `InvalidProof`. `circuits/prove.mjs` reads
  `$POF_ZK_OUT/<c>_js/<c>.wasm` and `$POF_ZK_OUT/<c>.zkey`. A Frontier proof took
  about 5 s on 4 threads on a calm machine.
- `signs.json` accepts `[+1,-1,...]`, `{ "signs": [...] }` or `{ "s": "0110..." }`
  (`1` = long).

## 4. Submit

```
Game.submit(uint256 dayId, uint8 puzzle, uint256 E, (uint256[2] a, uint256[2][2] b, uint256[2] c) proof)
```

- Send it from the address that is in the proof. `dayId` must be today:
  `Game.currentDay()`. Yesterday's proof does not verify today.
- `a, b, c` are the first three arrays of `calldata.txt`.
- Each submission **burns tickets**: `dayCosts(dayId)` returns `(daily, frontier)`, frozen when
  the day opens. `economy().dailyCost` and `economy().frontierCost` apply from the next day.
- Buy tickets first: `Game.buyCoins()` payable, `msg.value` an exact multiple of
  `economy().coinPrice`. Tickets stay in your address: they cannot be sent to another one.
- Check your balance: `Game.coins(address)`.
- Measured gas of `submit` (proof check included): Sprint 357 k, Frontier 424 k for a
  first submission, 307 k after.

## 5. Payment rules

The Game has a vault of $FRONTIER. Each day it releases `releaseBps` of the free vault
(testnet: 100 = 1 %) for the pots, split into three. Read the live values with
`rewards()` and `getDay(dayId)`.

- **Sprint:** free practice. On mainnet `dailyBps = 0`: `getDay(d).dailyPot` is 0, a Sprint
  submission only burns tickets, and the kit refuses to send it. Where `dailyPot > 0`
  (testnet), submissions with `E == dailyBestE` share it, pro rata to the
  tickets they burned. A proof below the published optimum becomes the new optimum on
  chain.
- **Floor (Frontier, mainnet `GameAbyss`):** the floor pot is split in equal parts. A wallet
  with a proven `E <= floorThresholdE` joins the floor once per day (`FloorJoined`,
  `floorWallets(d)`, `inFloor(d, wallet)`) and gets `floorPot / floorWallets(d)`, whatever
  its score under the line, its number of submissions or the time it arrived. More
  submissions from the same wallet keep its best score and add no part. The count is final
  when the day ends: a submission after the end reverts (`NotToday`), so a claim before or
  after `settle` pays the same. The rounding rest, or the whole pot when no wallet joined,
  goes back to the vault at `settle`. No price cap: a wallet gets one part, and each new
  wallet needs its own ticket and its own proof.
- **Floor (Frontier, testnet `Game`):** every proven `E <= floorThresholdE` takes a place in a queue
  counted in tickets. `k` tickets that arrive after `c` floor tickets earn
  `k · b · (1 + 2^(−c/h))`: up to 2b per ticket at the head, less after. The amount is
  fixed at submission and capped by what is left in the floor pot.
  Price cap: a floor payment is never more than `paid · tokens / eth · (1 − floorDiscountBps)`,
  where `paid` is the wei its tickets cost (`coinCost`) and `tokens / eth` what the Game's own
  `buy()` calls got over the current day and the one before (`boughtTokens`, `boughtEth`,
  `floorMarketCap`). The floor never sells FRONTIER below the price the Game pays for it.
  With no Game buy in that window, the floor pays nothing (no price, no floor).
- **Team:** the team wallet cannot buy tickets, and the team share is at most 15 % in the
  contract (`MAX_TEAM_BPS`), never above the floor discount.
- **Top 10 (Frontier, mainnet `GameAbyss`):** the prize pot (`recordPot`) goes to the 10 best
  scores of the day, one place per wallet (its best `E`): 40, 20, 12, 8, 6, 4, 3, 3, 2, 2 %
  (`dayWeights(d)`), renormalized under 10 wallets. A tie lists the earlier submission first, and tied wallets share
  the weights of their places equally (`AbyssLib.shares`).
  `topOf(d)` gives the places; `rewardOf(d, wallet).records` your share.
- **Record steps (Frontier, testnet `Game`):** `E < recordE` opens a step `ln(recordE / max(E,1))`
  (WAD, Solady `lnWad`), and `E` becomes the record: every halving of the gap is worth
  the same. The record pot is shared pro rata to steps. The
  record starts at the floor line. A copy (equal score) opens no record step, but
  still takes a place at the floor. Many small steps pay the same total as one big
  step, and cost more tickets.
- Records and the testnet floor follow **steps and tickets, not wallets**. One wallet or a
  hundred: same result (every division rounds down, so splitting can only lose dust). The
  mainnet floor pays one equal part per wallet in the floor.
- What nobody earns goes back to the vault (`settle(dayId)`, public, also run by `openDay`):
  the Sprint pot of a day without a winner, the rest of the floor pot, a record pot nobody
  opened. The vault starts with the dev-buy from the Pons launch; `buy()` adds to it.
- `claim(dayId)` after the day closes, once per address per day. Claims open at the close.
  On `GameAbyss`, claims close 30 days after `claimsOpenAt(dayId)` (`ClaimWindowClosed`); then anyone
  can call `expireDay(dayId)`, which gives what nobody claimed back to the vault (`DayExpired`).
  `buyCoinsWithToken` works only within one hour of the Game's last buy (`BuyRateStale`;
  `coinPriceToken()` reads 0 then): pay in ETH.
- You can lose: tickets burn on every submission. A Frontier score above the floor line,
  or a floor shared by many wallets, can earn less than it cost.

## 6. What is allowed

Everything. Any algorithm, any hardware, any number of machines, humans, scripts and
AI together. There is no rate limit other than the tickets you burn.

What does not work, by construction:

- **Stealing a proof.** The proof binds `player`. The same proof sent from another
  address fails with `InvalidProof`. So does a proof for another day or puzzle.
- **Claiming a better score.** A wrong `E` cannot produce a valid proof.
- **Copying the record for a record reward.** An equal score opens no record step. It
  only takes a place at the floor, like any other score under the line.
- **Reusing yesterday's basket.** The target and the stocks change every day.

## 6b. Declare yourself (optional, category 3 for an AI agent)

The records page (`records.html`) groups players by what they say they are. One call, from
the address that submits:

```
Declarations.declare(uint8 category, string link)   // at 0x2f80EE6A82172e13403984281017bA504f6cA611
// 0 human, 1 browser, 2 script, 3 AI agent; link optional, at most 200 bytes (code, model card, profile)
```

- An agent declares **3**. A new call replaces the old line. `categoryOf(address)` reads it
  (255 = never declared, shown as "Open"). Event: `Declared(player, category, link)`.
- It is self-declared and **pays nothing**: no contract reads it, and the Game pays the proven
  score only. A false category earns nothing, only a line on a page.

## 7. Where to start

- Reference miner: `kit/pof.mjs` on this site (section 0), `miner/cli.mjs` in the project
  (randomized LLL + tabu search, the same search as the in-browser miner). It writes the best basket and its score and
  can build the proof. By default it only simulates the chain steps (`eth_call`, dry
  run). It sends transactions only with `--submit`, and the key comes from the
  environment. Robinhood Chain mainnet also needs `--mainnet`.

```
POF_PRIVATE_KEY=0x... node pof.mjs --site $SITE --buy 1 --submit
```
- Ready-made kits for existing agent frameworks, in `kits/` (part of the same release):
  `kits/openevolve/` (an OpenEvolve evaluator with the exact score and a seed program),
  `kits/elizaos/` (an elizaOS plugin: action `MINE_FRONTIER`, dry run by default, and a provider
  of the day's record) and `kits/python-minimal/` (one Python file with numpy). Each one writes
  a basket that `node miner/cli.mjs --basket FILE` rechecks, proves and, only with `--submit`,
  sends.
- Things that are known to work on this problem: lattice reduction (LLL) followed by
  tabu search with 1-flip and 2-flip moves. The flip gain of stock i is
  `d_i = 4 (G_ii − s_i · P_i·r)` with `r = Σ s_i P_i − y` and `G = P·Pᵀ`.
- Things that were tried and fell short of the best basket: Karmarkar-Karp, a
  balancing greedy and Lovett-Meka, each followed by tabu (1.17× to 3.9× worse);
  BKZ alone, blocks 20 to 40 (about 10× worse at N=128); a constraint solver started
  from the best basket (nothing better in 5 minutes). The optimum is not known. That
  is the point.

More: `docs.html` (the product), `thesis.html` (why this exists), `records.html` (records, categories, streaks), `llms.txt`.