Review complete. The findings file is written and validated, and nothing in the tree was changed beyond .imd-findings.json and the scratch proof.

Contracts read in full: src/AskSwarmRegistry.sol, src/SwarmMarket.sol, src/SwarmWager.sol, src/IIntake.sol, plus the launch brief, the three adaptation notes, the pinned protected tests and the oracle-consumer reference. Nothing in scope was unreachable. The full suite passes (209 tests, 1 fork test skipped offline). I also queried Robinhood Chain over a public RPC to check the deployment inputs rather than take the brief's word for them.

Findings written to .imd-findings.json:

• Medium, with proof: SwarmMarket has no term bound. open accepts resolveAfter = type(uint64).max (or any value centuries out). After closeAt, stake is closed and both resolve and abandon revert TooEarly at every reachable timestamp, so every stake and the fee escrow are held forever. SwarmWager already rejects this with MAX_TERM after the #2189 review finding; SwarmMarket never got the equivalent, and its tests never probe the horizon. test/scratch/SwarmMarketUnreachableTerm.t.sol fails on the current source and passes once open refuses the terms. Minimal fix: a MAX_TERM check in open, mirroring SwarmWager.
• Info: contracts/launch.json is the mainnet manifest. It lists only the registry with the Ethereum IMD address. On chain 4663 that address has no code and Intake prices it at zero, so a registry built from it could never ask. The adapter must write the root manifest from the brief, not this file.

Verified on chain 4663 (supports deploying unchanged otherwise):

• Intake at 0xa43e… is the same code as mainnet, differing only in the cached EIP-712 chain id and domain separator immutables. requests() returns the four words markLost decodes.
• IMD at 0x5f7b… is "Identity.md" / IMD, 18 decimals, a LayerZero OFT with a standard OZ ERC-20 surface, no pause and no blocklist selectors. Live price for oracle.request@oracle-1 is 0.5 IMD.
• Treasury 0x571e… is an EOA on both chains, so fee transfers cannot strand.

Trust assumptions, unchanged from earlier audits and not re-reported: the writer's pairing of answers to requests, the single oracle signer key, creators choosing question bodies (including panel size in SwarmWager, which has no floor), and the caller of resolve choosing the ask time for relative-window questions. No reentrancy, access-control, rounding, overflow or conservation defects were found; all three contracts are owner-free with no proxies, initializers or forbidden opcodes, and runtime sizes are well under the EIP-170 limit.

Done. The three AskSwarm contracts are ready for the Robinhood Chain launch, with one behaviour change required by a reproduced audit finding.

Audit findings

• f8ec801b0e44 (medium), reproduced and fixed. The supplied proof failed on the original SwarmMarket: open accepted resolveAfter = type(uint64).max, and from closeAt on neither resolve nor abandon was ever allowed, so both stakes and the fee escrow were trapped. src/SwarmMarket.sol now has MAX_TERM = 365 days (the same bound SwarmWager already had) and open reverts BadTerms for a resolveAfter past it, before any token moves. The proof passes on the fixed contract.
• e842ddc10fde (info), reproduced. The tree carried launch #2099's Ethereum manifest with the mainnet IMD. It is renamed byte for byte to contracts/launch-2099.json so it reads as history. No launch.json was written; the manifest step writes it.

Unchanged for the chain move. AskSwarmRegistry and SwarmWager are as they arrived. The registry derives its EIP-712 domain from block.chainid at construction, nothing in src/ reads block.number, and the price is read from Intake at call time, so none of them needed a change for Robinhood Chain.

Tests added

• Five MAX_TERM regressions in test/SwarmMarketReview.t.sol, including a fuzz showing every accepted term pair can be abandoned within the horizon even with the registry retired or reverting, and a fuzz showing every resolveAfter past the bound is refused.
• test/RobinhoodChainLaunch.t.sol: a factory probe deploys all three in the launch's order with the exact brief arguments on an empty chain 4663, asserting zero constructor calls to any dependency, predicted addresses, no forbidden opcodes, no owner. It also pins the registry's domain to (4663, registry), runs a full market and wager lifecycle at the real Intake and Robinhood IMD addresses with mocks etched there, shows an Ethereum-domain signature is left Unverified, and shows the mainnet IMD would make the registry inert there.

Verification. forge build passes with the project's configuration. forge test with the verifier's fuzz seed:

result	count
passed	221
failed	0
skipped	1 (pre-existing fork-only test)

Docs. Root ADAPTATION.md lists each change, the finding or rule behind it, and the launch's contracts and arguments. The README gained a Robinhood Chain section with the deployment order, constructor values and the MAX_TERM note.

No build configuration, dependency or protected path was touched, no transaction was signed, and no .imd-blocked.json was needed since the brief supplied every value.

The review is complete. The findings file is valid, both snippets match the tree, the working tree holds only the ignored output file and my scratch test, and no source or config file was changed.

Outcome: the math holds. I traced every arithmetic, cast, window and boundary in all three contracts against the Math Precision, Boundary and Numerical Gap guides and found no loss-of-funds or wrong-recipient defect. The existing suite of 220 tests passes, including the cold-stipend measurement for the registry callback and the uint128 pool maximum.

Two findings written to .imd-findings.json, neither blocking:

• Info, SwarmMarket claim rounding dust. Floor division in the pro-rata share leaves up to one wei per winning address locked in the contract with no sweep path. Reproduced: three 1-wei Yes stakes against 100 wei No leave 2 wei behind after every claim. Conservation never breaks the other way.
• Low, SwarmWager body-size asymmetry. SwarmMarket.open refuses bodies over 16 KiB because Intake can never take them, but SwarmWager.create accepts one. A matched wager on such a body can only be unwound by abandon after resolveAfter plus three days. Stakes are refunded, so this is a lockup window, not a loss.

Coverage record has a row for all 20 listed entry points (18 hold, 2 carry the findings above) plus three invariant rows: balance versus liabilities, the 200k callback stipend at the 4096-byte cap (measured 156k cold), and a note that only block.timestamp is used, so Arbitrum-style L1 block numbering on Robinhood Chain affects nothing.

Not reached in depth: the Slither reentrancy leads were checked only far enough to confirm state is written before each external call and that IMD has no transfer hooks. Access control, signature replay and the launch manifest belong to the other specialists.

Build and tests pass, and only launch.json changed. The checks I needed were the manifest validation, the build, the test run and the git status, and all four are done.

Done. I wrote launch.json for the Robinhood Chain launch and verified it.

What the manifest contains

• AskSwarmRegistry with static arguments: Intake v2, the Robinhood Chain IMD token, and the attester signer, matching the brief and the three-address constructor in src/AskSwarmRegistry.sol.
• SwarmMarket with the registry reference, the same IMD token, and the treasury wallet the brief names, written as a static address since the brief states it.
• SwarmWager with the registry reference and the same IMD token.
• Notes describing each contract's purpose, the EIP-712 domain pinned to chain 4663, and the absence of any owner, admin, upgrade path, ETH handling or external calls in constructors.

Verification

• The manifest has exactly the keys kind, contracts and notes, every argument is a string, all contract references point backward to an earlier entry, no argument is zero, and the notes fit the character limit.
• Constructor argument counts and order match each accepted contract's constructor declaration.
• The existing test in test/RobinhoodChainLaunch.t.sol already rehearses this exact deployment on an empty chain 4663 through one factory call, and it passes.

forge build: ok
forge test (FOUNDRY_FUZZ_SEED=0x2f3d…fc99): 220 passed, 0 failed, 1 skipped across 22 suites
git status: only launch.json added

No file other than launch.json was changed.

The review is complete and .imd-findings.json holds the result. Only that file and my scratch test under test/scratch/ were written.

Outcome: no critical, high or medium defects in the Access Control, Trust Gap or Asymmetry areas. The three contracts have no owner, admin, upgrade path or ETH handling, every state-changing entry point has the guard its effect needs, and the oracle hooks are restricted to Intake with Pending-only settlement. I verified the launch inputs against the live Robinhood Chain: chain id 4663, Intake v2 has code and prices the oracle action at 0.5 IMD for the brief's IMD address, that IMD token is a LayerZero OFT with plain ERC-20 transfer semantics, and the signer and treasury are plain accounts. The verified Intake source confirms the model the registry relies on: complete is writer-only, failure arguments are bound to the request id, and status-0 arguments are forwarded unchecked, which the registry's AlreadySettled guard handles.

Two low findings, both asymmetries between the sibling contracts:

• SwarmWager.create has no body-size cap while SwarmMarket.open rejects bodies over Intake's 16,384-byte limit. A creator-chosen oversized body makes every resolve revert at Intake, so a joined counterparty's stake is held until abandon opens three days after resolveAfter. Reproduced with a scratch Foundry test that fails on the current code and documents the lock; attached as proof.
• SwarmWager.settle lacks the signed-issuedAt bound SwarmMarket.settle applies, so a late answer pays the winner or refunds both depending on whether settle or the writer's delivery lands first. The contract documents this race and launch #2189 accepted it, so I flagged it as an asymmetry against the market's fixed rule, not as a new bypass.

The coverage record answers all 20 entry points plus three invariant and trust-assumption rows. The already-documented trust assumptions (writer pairing of answers to asks, single signer key, creator-written questions) were checked for unprivileged paths and none were found. The six relevant existing suites run green at 119 tests.

Review complete. The findings file is at .imd-findings.json with two substantiated findings and a coverage row for all 20 entry points plus three invariant rows.

What I checked

• All three contracts against the Economic Security, Invariant and Flow Gap guides: value flows, fee math and rounding, conservation per market and wager, state couplings, every exit path, and the three-contract flow through the registry to Intake.
• Live Robinhood Chain dependencies: Intake quotes 0.5 IMD for the Robinhood IMD and has the same writer and bytecode as mainnet apart from chain-id and domain immutables. IMD is an 18-decimal ERC-20 that returns true on transfer, with no pause. The treasury and signer are EOAs on both chains. ArbOS supports the opcodes the 0.8.26 build emits.
• The repo suite: 220 tests pass, 1 fork-only skip.

Findings (both low, both with failing scratch proofs)

1. SwarmMarket's one-hour resolve window is fragile on an Arbitrum chain. If no L2 block lands inside the window (sequencer outage, with 24h forced inclusion), a fully staked market can never be resolved and abandon voids it, refunding the side that would have lost. This is a trade-off the requester must decide, not a silent change.
2. SwarmWager's resolve has no upper bound, so after resolveAfter plus three days both resolve and abandon are legal and the would-be loser can unwind the bet first. This was recorded earlier as "for a successor" because SwarmWager was already live; this launch is that fresh deployment.

Not reported as defects: the writer-pairing trust assumption, the missing panel floor in SwarmWager, and rounding dust, all previously recorded and accepted or dust-level. No critical or high issue was found; the economics hold within the documented trust assumptions.

The review is complete and .imd-findings.json holds two substantiated findings, each with a self-contained Foundry proof that fails on the current code, plus a coverage row for all 20 entry points and two extra invariant rows.

What I found

• Medium, SwarmMarket (settle line 218, _void line 263). The IMD token at the launch's Robinhood address is not the Ethereum token's code. It is an owner-controlled LayerZero OFT with setBlocked(address,bool), and on a chain-4663 fork any transfer to or from a blocked address reverts. The Ethereum IMD has no such function, so the mainnet audits could not have seen it. The market pushes the creator's and treasury's fee before winners can claim, and pushes escrow to the creator on every void path. A blocked creator freezes every staker in their markets, and a blocked treasury freezes settle in every market in the system.
• Medium, SwarmWager (_refund lines 271-272, abandon lines 226-228). Both parties' refunds go out in one call, so a blocked party freezes the counterparty's stake with no other exit.

Both are caused only by the IMD owner's action, so I rated them medium rather than high. The minimal fix preserves the design: credit fees, escrow and refunds to a per-address owed balance that each recipient pulls, or try the push and credit on failure.

What holds

I traced all six registry entry points, the remaining market and wager entry points, and the periphery helpers against the Execution Trace, Periphery and First Principles guides. Nothing else broke. On a Robinhood Chain fork I confirmed the launch inputs directly: Intake v2 has code and prices the oracle action at 0.5 IMD, the real Intake pulls exactly the price and delivers a completion to the registry under the stipend, the real IMD moves exact amounts with no residual allowances, and the signer and treasury are EOAs on both chains so the same keys control them.

Not reached

I did not re-examine the writer-pairing trust assumption or the wager's unbounded resolve timing, both accepted in the earlier launches and outside my area. Scratch files under test/scratch/ are mine and nothing in the tree was changed.

I added a system-level test suite that runs all three contracts together on chain 4663, and the full suite passes with the verifier's seed: 222 passed, 0 failed, 1 skipped. The skipped one is an older fork test that only runs when an RPC address is supplied, so it skips here.

What I added

• test/RobinhoodSystemInvariant.t.sol deploys the registry, SwarmMarket and SwarmWager in one CREATE2 call on chain 4663, in the launch order, with the market and wager pointing at the registry. It then runs 128 random sequences of 80 calls each across all three, from four users:

  • every market and wager action, including resolving and settling at the wrong time or in the wrong state;
  • eleven kinds of oracle delivery: yes, no, a panel of 5, an answer issued right at the deadline, a bool that isn't 0 or 1, the wrong answer type, the wrong signing key, no strict majority, refused, no result, and an ask stranded and then marked lost;
  • price changes, time jumps, and steps that take one market or wager through its whole life, so decided markets show up in random runs.

  Any unexpected revert fails the run, and every expected revert is checked against its specific error.

• Checks on each settle, worked out from what was delivered rather than read back from the contract:

  • the market's Yes/No/void result;
  • the 2% fee on the losing pool, split between creator and treasury;
  • the payout each winner can claim;
  • that the wager pays the right side.

• Invariants:

  • each contract holds exactly what it owes: fee money, open stakes, minus fees and claims paid out;
  • claims never exceed what a market holds, and rounding leaves less than 1 wei per staker;
  • finished markets and wagers never reopen;
  • the registry keeps no IMD and no spending approval, and neither the market nor the wager leaves one;
  • Intake is paid exactly once per resolve;
  • the token supply stays the same.

• test_handlerReachesEveryOutcome proves the invariants aren't vacuous: it walks through Yes, No, a void for a too-small panel, a void for a late answer, a paid wager, a refunded wager, and claims.

• I added a short section on the suite to test/TESTING.md.

Findings in .imd-findings.json (all low-impact information; nothing high or critical, and no funds at risk):

1. SwarmWager's cancel and abandon return the fee but leave the fee field set, so get() reports money the contract no longer holds.
2. SwarmWager doesn't apply SwarmMarket's minimum panel of 7 or its answer deadline. A majority answer from a panel of 5 pays a wager, while the same answer voids a market. The brief says the wager is settled "the same way", so I recorded this for someone to confirm it's intended. Both sides see the panel size before staking, so it may well be a deliberate design choice.
3. SwarmMarket's rounding dust (under 1 wei per winner) stays locked forever, since there is no owner to recover it.

Still owed: a test run against the real Intake v2 and IMD on Robinhood Chain. This machine has no RPC address for that chain, so it could not be done here.

The review is complete. The findings file is written and verified against the tree.

Outcome: eight findings in .imd-findings.json, two medium, four low, two info, with a 24-row coverage record answering all 20 entry points plus the manifest, deployability, EIP-712 domain and the full test suite. No source file was changed. The existing suite passes with 222 tests.

What I confirmed on chain before keeping the top findings. The Robinhood IMD token at the launch's imd argument is an owner-controlled OFT with a blocklist. On a chain-4663 fork I had its owner block an address, and transfers to it, from it, and transferFrom pulling from it all reverted. The Ethereum IMD has no such switch, so the earlier mainnet audits never saw this.

Findings, most severe first:

1. Medium, SwarmMarket. settle pushes the creator's and treasury's fee, and _void pushes the escrow to the creator, before any staker can claim. A blocked creator freezes every staker in their markets. A blocked treasury freezes every market with a nonzero fee. My proof test fails on the current code in all three cases.
2. Medium, SwarmWager. _refund and abandon push both parties' stakes in one call. A blocked party freezes the counterparty's stake. The specialist's proof fails for the stated reason and is attached.
3. Low. The 1-hour resolve window can fall entirely inside a sequencer block gap on an Arbitrum chain, after which the market can only void. The code matches the brief, so this is a requester decision.
4. Low. SwarmWager resolve has no upper bound, so after three days it overlaps abandon and the likely loser can unwind first.
5. Low. SwarmWager create accepts bodies over Intake's 16 KiB cap, locking the counterparty until abandon. Merged from two specialists.
6. Low. SwarmWager settle lacks the market's issued-at bound and panel floor, so a late answer pays or refunds depending on transaction order. Merged from two reports.
7. Info. Rounding dust of up to one wei per winner stays locked. Merged from two reports.
8. Info. cancel and abandon leave the wager's fee field set after returning it.

Dropped or reclassified: nothing was dropped. Every specialist claim reproduced. I also checked leads they did not cover: the live Intake's requests getter returns four words as markLost expects, the treasury is an EOA on Ethereum so the same key controls it on Robinhood Chain, and the compiled runtimes' MCOPY and PUSH0 opcodes execute on the chain.

I fixed both medium findings. A blocked creator, treasury or other party can no longer freeze anyone else's IMD on Robinhood Chain. forge build succeeds, and forge test with the verifier's fuzz seed gives 236 passed, 0 failed, 1 skipped. The skip is the existing test that only runs on a fork. Both proofs the verifier holds this work to, and the earlier MAX_TERM proof, now pass.

The fix (src/SwarmMarket.sol, src/SwarmWager.sol)

• Each payment to a third party is still sent directly. If the token reverts it, as Robinhood IMD does for a blocked address, the amount is recorded in a new owed(address) balance and the call carries on. That address collects it later with a new withdraw().
• This covers:
  • Market: the creator's leftover escrow, the creator's and treasury's fee halves, and the escrow returned when a market voids.
  • Wager: the creator's leftover fee, and both sides' refunds on timeout and on abandon.
• If the token returns false or a malformed reply instead of reverting, the whole call still reverts as before. We can't tell whether the tokens moved, so recording them as owed could pay twice; the project's own fault-test token moves the balance and then returns false.
• Market claim, the wager winner's payout and cancel still send directly, because each only moves the recipient's own money.

Two smaller fixes in SwarmWager, both reproduced

• create now rejects a body over 16,384 bytes, the most Intake accepts, as SwarmMarket already does. Such a wager could be joined but never resolved.
• cancel and abandon now set the wager's fee field to zero after returning the escrow.

Tests

• New test/BlockedThirdParty.t.sol and a mock token with a blocklist (test/mocks/BlockableIMD.sol).
• Some existing tests relied on the old behaviour (a failed payment undoing the whole call, the oversized-body lock, fee left set after a refund). I replaced or updated those in SwarmMarketPayments, SwarmWagerAtomicity, SwarmWagerBoundaries and the wager invariant model.

Left unchanged, answered "disputed"

• 1-hour market resolve window: the brief sets it, and changing it changes how markets work.
• Wager resolve and abandon both allowed late: the documented, tested design from the earlier Ethereum launch.
• Wager has no late-answer or minimum-panel check: also the earlier launch's documented design.
• Rounding dust: under one wei per winner stays in a market contract. That is by design; it is now written into the contract's comments.

The first three are written up in ADAPTATION.md for the requester to decide. The answers to all eight findings are in .imd-responses.json, and ADAPTATION.md and README.md describe every change.

Runtime sizes are now 9,524 bytes for the market and 8,059 for the wager, well under the limit. The registry is unchanged. No launch.json was written.

I didn't change launch.json: the manifest from the previous round is already correct and matches the accepted source.

• Order and arguments: the three contracts appear in this order with these constructor arguments, which match both the source and the brief:
  • AskSwarmRegistry(intake, imd, signer) takes the three static addresses from the brief.
  • SwarmMarket(registry, imd, treasury) takes $contract:AskSwarmRegistry, IMD 0x5f7b…7127 and the treasury 0x571e…320c.
  • SwarmWager(registry, imd) takes $contract:AskSwarmRegistry and IMD.
• No $owner: none of the contracts has an owner or admin argument, so the manifest doesn't use $owner.
• Schema: the file has only kind, contracts and notes. The notes are 2,133 characters, under the 4,000 limit, and their description of how the registry pays Intake matches the code.
• Build and tests: forge build succeeds. forge test with the verifier's fuzz seed ran 23 suites: 230 tests passed, 0 failed and 1 was skipped.

No other file was modified.

No findings were listed for this revision, so I checked the current source against my earlier tests. After my last round, the builder changed SwarmMarket and SwarmWager. Robinhood Chain's IMD token can block an address, and the contracts now handle that: when a payment to someone else (a creator's leftover fee, a fee share, a refund) is refused because the receiver is blocked, it is recorded as owed and the receiver collects it later with withdraw. No invariant test covered that path, so I added one.

With the verifier's seed, forge test passes: 234 tests, none failing, 1 skipped. The skipped one is a fork test that only runs when an RPC is configured.

New: test/BlockedPartyInvariant.t.sol

• Setup: it runs the real registry, market and wager on the existing stand-in for the blockable token. Four users and the treasury are blocked and unblocked at random between every kind of call, including oracle answers, refusals and withdraw. It does 96 runs of 64 calls.
• What each call should do:
  • A payment to someone other than the caller arrives if they are free, or is added to their owed if they are blocked.
  • The caller's own payout (a claim, a wager win, a cancel, a withdraw) fails while the caller is blocked and stays open until they are unblocked.
  • Taking funds from a blocked address fails.
• What must hold after every call:
  • Each person's owed in both contracts equals what the test predicted.
  • Each contract holds exactly its open stakes and fees plus everything it owes.
  • No tokens appear or vanish, finished markets and wagers never reopen, and the oracle is paid once per question.
• Coverage check: a fixed-sequence test plus a throwaway probe confirmed the random runs actually reach every blocked case: a payment recorded as owed, a withdraw while blocked, a successful withdraw, a claim while blocked, a blocked wager winner, and a settlement that goes through despite a blocked party.

Updated:

• test/RobinhoodSystemInvariant.t.sol: last round I reported that SwarmWager left its fee field set after a cancel or abandon. That is now fixed, so the old comment is replaced by an assertion that every finished wager's fee is zero.
• test/TESTING.md: describes the new suite and the fix.

Findings (.imd-findings.json). All three are info-level; I found nothing more serious:

1. The brief says wagers settle "the same way" as markets, but they don't. A market ignores an answer from a panel smaller than 7 or one issued after its answer deadline, and treats the question as unresolved; a wager pays out on either. An answer from a panel of 5 resolves the wager and leaves the market unresolved.
2. SwarmMarket rounds each winner's share down, so up to 1 wei per winner stays in the contract for good.
3. A blocked winner's own payout (a wager win or a market claim) waits until the token unblocks them. Nobody else's money is held up.

A fork run against the live oracle and IMD on Robinhood Chain is still owed; there is no network access here.

Review complete. The findings file is written and validated, and the working tree holds nothing else (test/scratch was removed after the proof runs).

Settled from round 1

• Both mediums are fixed. The attached proofs for the blocked-creator/treasury freeze in SwarmMarket and the blocked-party freeze in SwarmWager now pass on the revised code. Every push to a third party in resolve, settle, _void, _refund and abandon goes through a new credit-on-revert path, with a per-address withdraw. I checked the new code as fresh code: a false or malformed reply still rolls the whole call back, so nothing can be paid twice, and a caller cannot force the credit path by gas starvation because the 63/64 rule leaves too little gas for the credit's storage write.
• Body cap in SwarmWager.create is fixed. The specialist proof's lock scenario can no longer be set up because create now reverts with BadTerms above 16,384 bytes.
• Fee field zeroing in cancel and abandon is fixed and tested.
• Rounding dust is now stated in the contract's invariants, which is what I asked for. Dropped.

Kept as low advisory, unchanged by the author's choice

1. SwarmMarket's 1-hour resolve window on a single-sequencer chain.
2. SwarmWager's unbounded resolve overlapping abandon.
3. SwarmWager settling on late-issued or small-panel answers that SwarmMarket would void.

All three still reproduce (the two attached proofs fail exactly as before). The author's answer that each is a requester-level design choice documented in ADAPTATION.md is reasonable, so none blocks the launch.

Nothing new. The full suite passes with the recorded seed (234 passed, 1 fork-only skip). The manifest uses only the schema's keys, the brief's static addresses and a backward contract reference, and the empty-chain CREATE2 rehearsal test passes. The coverage record answers all 22 entry points plus three invariant rows.