Implemented CAT WARS contracts, MEOW token, keeper, ABI exports, and deployment/review documentation.

Verified:

• forge build, forge test, and forge fmt --check
• All 500 engine vectors
• 12,288 invariant calls
• 17 keeper tests

Offline and empty-environment checks passed. The required Chainlink constructor adaptation is documented for independent review.

Done. I wrote launch.json for the accepted CAT WARS tree and verified it.

What the manifest contains

• Token: LaunchToken, name "CAT WARS", symbol "MEOW", 18 decimals, as src/LaunchToken.sol sets them.
• One application contract, CatWars, with constructor arguments in declaration order: the requester-specified Sepolia Chainlink VRF wrapper address (lowercased) and $owner for the owner parameter. The owner also becomes initial treasury and keeper inside the constructor.
• CatWarsEngine is an internal library compiled into CatWars. The built artifact has no link placeholders, so it is correctly omitted from the contracts list.
• Pool: native ETH zero address, fee 12500, tickSpacing 60, initialPrice 79228162514264337593543950336, exactly as the launch facts give them.
• Notes of 745 characters explaining the constructor inputs and the engine library.

Verification

• The manifest's constructor args match the exported docs/abi/CatWars.json constructor (vrfWrapper address, owner_ address).
• Only the schema's five top-level keys are present, no chainId or supply fields.
• forge build succeeds and forge test passes all 39 tests across 6 suites, including the Deployment test that deploys the same creation code with these arguments on an empty chain.
• git status shows launch.json as the only new or changed file.

The review is complete and the findings file is written. Here is the recap.

Outcome: no arithmetic, boundary or numerical-gap defect found in the application code. The findings file at .imd-findings.json holds one informational finding and a coverage row for all 23 entry points plus four invariants.

What I verified in my area (Math Precision, Boundary, Numerical Gap):

• Payout and rake math uses Math.mulDiv with round-down, no overflow, no underflow (rake is capped at 10% of the pool), and the winning-side divisor is always non-zero because a round can only reach Requested when both sides hold stakes.
• Time boundaries are consistent. Betting rejects exactly at lockAt, requesting accepts exactly at lockAt, and both public timeouts are strict as the spec requires.
• The VRF payment path never spends player stakes. The caller's value is checked against the quote, re-checked against the actual price paid, and the remainder is refunded or credited.
• The engine, its vector test and vectors.json are byte-identical to the reference in the spec repository, and all 500 vectors pass. The static-analysis leads on the engine are its intended integer steps and must not be changed.
• The exported docs/abi/CatWars.json is set-equal to the compiled ABI.
• The full suite passes: 39 tests including the two stateful solvency invariants.

The one informational finding: because rake is charged on the whole pot, a winning side receives less than it staked whenever the losing side is smaller than the rake. With the maximum 10% rake, 100 ETH versus 1 ETH yields a 90.9 ETH payout to the 100 ETH winner. This follows the spec's formula exactly, so it is reported as an economic property for the requester, not as a defect.

Not reached: no launch.json exists yet, so the manifest row is marked unreached. The README's stated constructor order and pool values match the spec and the two-argument constructor.

The review is complete. Findings and coverage are written to .imd-findings.json, and the working tree has no modified tracked files.

Outcome: no reproducible defect in the contracts. The CatWars control flow holds under the Execution Trace, Periphery and First Principles checks. One informational, conditional item is recorded for the manifest reviewer.

What I verified

• Every state transition in CatWars was traced from entry to final state: open, bet, request, callback, settle, the three cancel branches, the three claim paths and withdraw. Guards, checks-effects-interactions ordering, the 50k-gas payout path with credit fallback, and the status-gated callback all behave as the spec requires.
• Stakes never fund VRF. The request path sets status before the external call, re-checks the wrapper's second quote against the caller's payment, rejects duplicate request IDs, and refunds or credits excess. Wrapper failure rolls back atomically.
• The engine library and its vector test are byte-identical to the upstream spec commit. I fetched the three reference files from GitHub and matched their SHA-256 hashes, so the engine cannot revert for any seed and settlement cannot be bricked. The slither leads on that file are intentional verbatim arithmetic.
• The vendored Chainlink base differs from upstream only by lazy LINK resolution. The native request helper and the wrapper-authenticated callback are logically unchanged.
• The full Foundry suite passes, including the stateful solvency invariant. The ABI export check and all 17 keeper tests pass. The keeper quotes the VRF price at the same explicit gas price it submits with, which is the correct handling of Chainlink's tx.gasprice dependency.

The one recorded item (info)

The constructor accepts any nonzero wrapper address with no code check, which the launch's empty-chain rule requires. If launch.json puts anything other than the live VRF v2.5 wrapper of the actual launch chain in the first constructor argument, every two-sided round reverts at request time and can only be refunded after the one-hour timeout, so no fight ever settles. I reproduced this with a scratch test on a chain without wrapper code. It is correct for the spec's Sepolia target; it becomes blocking only if the manifest targets another chain or address. No launch.json exists yet, so the coverage row for it is marked unreached.

Not covered as findings

• The README states the factory split as 10/88/2. The launch guidance I was given describes the requester's share as a choice defaulting to 80%. I could not verify which is right for this launch; it is a documentation point, not a contract defect.
• Slither and Mythril did not run on my side. I used the provided static leads only as leads, and each one resolved as intended behavior.

The review is complete. The findings file is written and the tree is otherwise untouched (git reports no changes because the findings file and build outputs are ignored).

Outcome: the permission model of CatWars matches the spec and I found no access-control bypass. Two findings are recorded, both low or informational.

What I checked

• Every role path: owner-only setters, pause and ownership transfer, owner/keeper round opening and early cancel, wrapper-only VRF callback, and the permissionless request, settle, cancel-on-timeout, claim and withdraw paths.
• Paired surfaces for asymmetry: bet versus claim, request versus fulfill versus settle, open versus cancel, single claim versus batch claim, and every setter against its readers.
• The vendored Chainlink base against the saved upstream copy. The only change is the documented lazy LINK lookup plus formatting.
• ABI exports and the engine file hashes, which match the documentation. The full suite passes, 39 tests including the solvency invariants.

Findings

1. Low, src/CatWars.sol line 207. After 24 hours, anyone can cancel a Requested round with no reason. A late Chainlink fulfillment carries the random word in its calldata, so a losing bettor can read it, front-run with a cancel, and convert a loss into a refund while the winner loses the payout. This is what the spec asks for, so it is a design trust assumption rather than a bypass. I confirmed it with a scratch test and then removed the test.
2. Info, README.md line 30. The README and deployment test name a literal wallet as the resolution of the launch owner. The launch facts I was given name no owner. The manifest must pass the owner reference string, not the literal, or every privileged role and the rake would go to a contributor-chosen wallet.

Coverage: all 23 listed entry points have a row, 22 hold and one carries finding 1, plus three invariant rows. Not reached: the keeper script internals and the frontend, and launch.json, which does not exist in this tree yet. The static-analysis leads were all traced and none reproduced as a defect.

The review is complete. The findings file is written and validated, and no tracked file was changed.

Outcome. CatWars' economics hold up under the Economic Security, Invariant and Flow Gap checklists. I found no critical, high or medium defect. Three substantiated items are in .imd-findings.json, each with an exact snippet, a concrete call sequence, and a scratch test that reproduces the sequence.

• Low, src/CatWars.sol line 207. After the 24-hour request timeout, anyone may cancel a Requested round, and this races the Chainlink fulfillment. The fulfillment's calldata reveals the random word and the engine is public, so the losing side can front-run a losing fulfillment with a cancel and turn a certain loss into a full refund. The winner gets only their stake back instead of 1.9 ETH in the reproduction. Precondition is a fulfillment delayed past 24 hours, which the attacker cannot cause, hence low. A two-step cancel would remove the option but deviates from the spec, so it is a scope decision.
• Low, keeper/core.mjs line 61. The keeper requests randomness for every two-sided round regardless of pool size. Two minimum bets cost a griefer exactly the rake, 0.0001 ETH per round, while the keeper pays the full VRF quote. I read the live Sepolia wrapper: 0.00623 ETH per request at 20 gwei, 0.00031 ETH at 1 gwei, flat fee zero. The contract already lets the keeper cancel Open rounds, so a minimum-pool policy in the keeper is the fix, again a spec deviation for the requester to decide.
• Info, src/CatWars.sol line 203. Trust assumption: the owner or keeper can cancel a locked round after seeing final odds. If that account also bets, it holds a free selection option over which pools resolve. By design per the spec; the README should state the operator must not bet.

Verified as holding. Solvency and conservation on every refund, claim and owed path. Stakes can never fund VRF. Status transitions are one-way and mutually exclusive. Rake snapshot, pro-rata payout rounding, reentrancy coverage, and the callback's gas budget. I also confirmed against the live Sepolia coordinator that 3 confirmations and the 150k callback limit are accepted, so requests will not revert on chain. The coverage record answers all 23 entry points plus three invariants.

Observations outside the findings.

• No launch.json exists in this tree, so there was no manifest to review.
• The README states the factory allocates 88% to liquidity and 2% to the payer. The canonical rule given to me is 10% swarm, 80% pool unless chosen otherwise, remainder to the wallet. I could not verify what the requester chose, so this is flagged for the manifest reviewer rather than reported.
• The verbatim engine seeds its PRNG from only the top 16 bytes of the word, so every test word below 2^128 yields the same fight. Several repo tests use such words. Real VRF words are full-width, so this is a test-authoring caveat, not a production defect.

Not reached. No fork test against the live wrapper and no measurement of per-matchup win skew, which would only sharpen the info item.

Added failure-path tests, arithmetic fuzzing, and game/token invariants with independent accounting and complete withdrawal checks. Only test/ changed.

Offline validation passed: forge build and forge test — 54 tests, zero failures or skips.

No reproducible contract defects found. Live Chainlink integration remains unverified.

The review is complete. The findings file is written and validated, the scratch tests are removed, and no tracked file changed.

Outcome. No critical, high, or medium defects. The contract follows the spec closely and the full suite passes (54 Foundry tests, 17 keeper tests). I kept 2 low and 3 info findings, all reproduced with a scratch Foundry test before reporting.

Findings kept, in .imd-findings.json:

• Low, merged duplicate. The permissions and economics specialists both reported the same root cause at src/CatWars.sol:207. After a request is 24 hours old, anyone can cancel it, and a loser who reads the pending VRF word in the mempool can cancel selectively. The winner then gets a refund instead of the pot. It is spec-conformant, so the fix is a scope decision for the requester.
• Low, keeper script. The keeper requests randomness for any two-sided round regardless of pool size, so two minimum bets cost the operator the whole VRF fee against 0.0001 ETH of rake. Reproduced numerically at keeper/core.mjs:61.
• Info. Owner or keeper can cancel a locked round after seeing final odds. Spec-granted trust assumption, worth stating in the README.
• Info. Rake on the whole pot makes a lopsided winner net negative. Exactly the spec formula, so no code change required.
• Info. The manifest hard-codes the Sepolia wrapper and the chain is chosen by policy. Admission should confirm chain 11155111.

Dropped. The README literal-owner note from the permissions specialist. The manifest already passes the literal string $owner, which is correct, and the launch facts I have name no owner to check the README's claim against.

Own pass. I traced all 23 entry points plus solvency, deployment, and manifest schema. The vendored Chainlink base differs from upstream only by formatting and the documented lazy-LINK change. Fulfillment fits comfortably in the 150k callback gas. Bet and request windows are disjoint, so no bet can follow a known word.

One item unverified. The sandbox denied access to github.com, so I could not diff the engine against the upstream spec commit directly. The 500 reference vectors pass and the file hashes match the dependency record, which I recorded as an honest unreached row rather than a claim.

Requirements

• "frontend source ... under web/" met: web/src, package.json, lockfile, vite config.
• "static export at repository-root dist/" met: dist/index.html plus assets.
• "validation evidence within its write scope" missing: no document under web/ or docs/ records a frontend build, typecheck, test or browser run. docs/VALIDATION.md covers contracts only.
• "Emit dist/imd-deployment.json" with the stated schema met: version, launchId, chainId, sourceCommit, attestationHash, contracts, assets, poolKey, network, walletAddChain and no other key.
• "copy launchId, chainId, sourceCommit, attestationHash, contract set" met: all values equal the handoff.
• "poolKey copied exactly" met: five fields unchanged.
• "network and walletAddChain copied unchanged" met.
• "ABI hashes verified against the handoff" met: manifest.mjs computes canonical keccak and refuses on mismatch.
• "frontend loads imd-deployment.json as runtime configuration" met: loadConfig in web/src/config.ts fetches the manifest and the two ABI files, and no address map exists elsewhere.
• "every exported file hashed, manifest excludes itself" met: all ten SHA-256 values recomputed and equal.
• "at most 128 assets, 8 MiB per file, well under the budget" met: ten assets, 856 KiB total.
• "wallet connect: injected wallets" met: Header.tsx with EIP-6963 discovery.
• "plus WalletConnect" missing: only the injected connector is registered. The project id needs the requester, but the connector wiring is the builder's.
• "read-only mode without a wallet" met: the page reads settings, rounds and swap quotes with no wallet.
• "switch-network prompt" met: NetworkGate and SwitchButton with the add-chain fallback.
• "TESTNET badge on Sepolia" met: header badge.
• "live data: round, cats, stats, countdown, totals, pool %, multiplier, backers, own bet" met: Arena.tsx reads getRound, getBet and BetPlaced logs.
• "bet: amount input with chips, side buttons, placeBet with pending, confirmed, error states" met: BetPanel and TxStatus.
• "replay with engine.simulate from bytes32(randomWord), verified note and seed" met: replayRound in lib/engine.ts pads the word to 32 bytes big-endian and compares winner and turns.
• "claim across past rounds and withdraw owed" met: Claims.tsx.
• "history with matchup, winner, pool, seed, explorer link" met: History.tsx.
• "portraits from art/catart.js, engine from engine/engine.js" met: both vendored files hash-identical to the spec commit.
• "footer disclaimer" met: exact text in App.tsx.
• "no fake bots, balances or simulated bets" met: every number is read from the chain, the swap price comes from StateView and the quoter.
• "source published, site hosted on IPFS" after review.
• "WalletConnect project id" needs the requester.

The idea. A dark betting arena where two cat portraits face off over a pot, and the eight canonical portraits are the one visual device. Nothing competes with them.

Findings in .imd-findings.json, four in total:

• High, fidelity. No frontend validation evidence is committed. The brief names it as a deliverable.
• Medium, fidelity. WalletConnect is not wired. The config reads a project id it never uses.
• Low, taste. In the How it works panel the two full addresses wrap into a jumble at 390 with a lone full stop on the last line.
• Low, taste. The history table uses an em dash as its empty placeholder. It will show as soon as a round opens.

No file in the tree was changed. The probe ran and passed every check, and its output stayed in test/scratch. I could not exercise the live round layout (cat cards, timer ring, tug bar) because no round has been opened on the deployed

All four findings are answered in .imd-responses.json and the revision is committed as 5d8cc00 on top of the accepted tree.

What reproduced and what changed

• Missing validation evidence (high): fixed. The tree had no frontend evidence at all. I added docs/FRONTEND-VALIDATION.md, web/README.md and web/DESIGN.md (the root is outside the write scope, so DESIGN.md lives under web/). The evidence comes from runs made this round, not from the previous session.
• WalletConnect not wired (medium): fixed. The connector is added when a project id is supplied at build time through a Vite define, so a build without one statically drops it and its 80 modal chunks. The committed export stays at 10 files and 819 KiB. A trial build with an id produced 91 files and about 2 MiB, inside the limits. While testing I found that pressing Connect with no wallet attempted a connection with an empty connector instead of showing the hint, so the hint is now a popover that also names the missing WalletConnect option.
• Address sentence wrapping (low): fixed. Two labelled rows with the full address wrapping inside its link and Copy beside it, measured at 320, 390 and 1440.
• Em-dash placeholders (low): fixed. History cells are empty, and the matching trade-panel cells were changed for the same reason.

Validation run this round

The walk exercised read-only live reads, the no-wallet prompt, a mock wallet on chain 1 with the 4902 add-chain flow checked byte-for-byte against the chain table, a live quoter quote, and a swap taken to the signing step with nothing broadcast.

Limitations, recorded in the evidence file: WebKit cannot launch on this host (missing system libraries, no root), so all rendered checks are Chromium only. No round exists on chain, so betting, VRF request, settle, claim and cancel were not exercised live. No WalletConnect project id was supplied, so that path was verified to compile and bundle, not connected end to end.