The two SqueekBoard contracts are built, tested and documented. forge build, forge test (56 tests, with the verifier's fuzz seed and in isolated mode) and forge fmt --check all pass on solc 0.8.26.

What was built

• HamsterBadge (src/HamsterBadge.sol): ERC-721 "Hamster Badge" / HBADGE on OpenZeppelin v5.4.0.
  • Hard cap of 10,000, with token ids 1 to 10,000.
  • mint() is free and allowed once per wallet, ever.
  • There is no owner mint, no burn and no admin.
  • Metadata and the SVG image are generated on-chain.
• WheelSpinCheckIn (src/WheelSpinCheckIn.sol): a badge holder calls spin() once per UTC day.
  • It stores each wallet's current streak, longest streak and total check-ins.
  • It keeps an on-chain leaderboard of the 100 longest streaks, readable in one call.
• ABI exports: docs/abi/HamsterBadge.json and docs/abi/WheelSpinCheckIn.json.
• README: behaviour, chosen constants, assumptions, deployment parameters and operational responsibilities.

Deployment parameters

Order	Contract	Constructor arguments
1	HamsterBadge	none
2	WheelSpinCheckIn	the badge address ($contract:HamsterBadge)

Neither contract has an owner, so $owner is not used and nothing needs setting after launch. I did not write launch.json.

Decisions the brief left open

• Badges are transferable. Streaks belong to wallets, and the holder check happens at spin time, so one badge passed between wallets lets each of them spin that day.
• A day is a UTC calendar day. Missing a whole UTC day resets the streak to 1 on the next spin.
• The leaderboard ranks by best-ever streak. Each row also carries the live current streak; ties are in no guaranteed order.
• The leaderboard holds 100 wallets (LEADERBOARD_SIZE), my choice.
• mint() uses _mint rather than _safeMint. The badge always goes to the caller, so minting makes no external call. I silenced the matching forge lint warning in place, along with the timestamp and zero-balance ones; reasons are in the README.
• A spin has no random outcome and awards nothing. It is a check-in only.

Checks

• The tests cover success and failure paths, fuzzed spin schedules and a stateful invariant test against a reference model. Six bugs I seeded on purpose were all caught.
• The protected deployment test passed locally against the built bytecode. The owners test could not be run because its OwnerChecks.sol was not supplied.
• Slither and Mythril were not available here, so the six rejecting detectors were designed around rather than run.
• The independent security review is still to come.

Dependencies (forge-std v1.9.7 and the OpenZeppelin files this project compiles) are vendored under lib/ as ordinary files. Nothing is committed: I left the work in the working tree because .git/ is off limits.

Created launch.json with HamsterBadge first, followed by WheelSpinCheckIn referencing its address. Constructor arguments match the accepted ABIs.

Validation passed: forge build and all 56 tests with the supplied fuzz seed. Only launch.json changed.

The review is finished: I found no critical, high or medium defects in the control-flow area, and wrote three low-severity findings plus the coverage record to .imd-findings.json. No tracked file was changed, and the scratch tests were removed.

Findings (all low)

1. One account can mint the whole supply (src/HamsterBadge.sol:47). The mint limit is keyed by caller only, so a throwaway contract that mints and forwards its badge is a fresh "wallet" each time. I ran the full drain: 125 calls of 80 badges from one account (about 115,000 gas per badge), ending with 10,000 badges in one wallet and MaxSupplyReached() for everyone else, permanently. This matches the brief as written and the README accepts "many wallets"; any real mitigation is a scope decision for the requester. It is outside my assigned area, reported because the effect cannot be undone.
2. One badge backs unlimited spins per day (src/WheelSpinCheckIn.sol:107). The holder check is only at the instant of the call, so a smart account can borrow a badge, spin and return it in one transaction. Reproduced: with a single badge in existence, 150 wallets spun on the same day and filled all 100 leaderboard rows while holding no badge. The README accepts badge passing because "a free mint already gives this", which stops being true once the supply is minted out.
3. canSpin(address(0)) reverts instead of returning false (src/WheelSpinCheckIn.sol:178). It fails with ERC721InvalidOwner(address(0)), while every other per-wallet read answers for the zero address. A Foundry proof that fails on the current code is attached to this finding.

Coverage

All seven listed entry points have a row, plus five extra rows for invariants, views and launch wiring.

• Execution Trace: spin() and mint() traced by hand through every branch. No stale read, no partial update, and the memory copy written back at the end of spin() never overwrites another wallet's rank change. The three leaderboard placement branches keep the board sorted and duplicate-free.
• Periphery: the vendored OpenZeppelin files match upstream v5.4.0 apart from formatting. Base64Encoder and tokenURI hold (about 1.26M gas per call), and both docs/abi files equal the compiled ABIs.
• First Principles: the day boundary, first-spin and rank sentinels, eviction at the board edge and tie handling behave as documented. The existing 56 tests pass.

Not reached

• launch.json does not exist yet, so its constructor arguments were not reviewed. The expected wiring is HamsterBadge with no arguments, then WheelSpinCheckIn with $contract:HamsterBadge.
• The static-analysis lines were checked as leads and none became a finding on its own.
• I did not verify that the pinned launch policy targets Sepolia, the chain the brief and README name.

The review is written to .imd-findings.json: two findings and a coverage row for each of the seven entry points, with no tracked file changed. Neither finding is a bookkeeping bug; both are economic gaps in the design as built, and both need a requester decision rather than a simple patch.

Findings

1. Medium — one script can mint all 10,000 badges for gas only (src/HamsterBadge.sol:47). The per-address flag is the only limit on the shared cap, and throwaway contracts can call mint().

   • Cost: I measured about 107,000 gas per badge, roughly 1.07 billion gas for the whole supply, in 100 transactions of test ETH.
   • Effect: mint() then reverts MaxSupplyReached for everyone, permanently, since there is no burn or owner. If the badges are left in the constructor-only contracts they can never move, so nobody can ever spin.
   • Status in the brief: the "one free mint per wallet" rule is implemented as written, and the README already says one wallet is not one person. What it doesn't state is the cost and that the result is irreversible.
   • Decision for the requester: accept the risk in writing, or change scope (rate limit, signed allowlist, or a nominal price), each of which departs from "free, permissionless".

2. Low — one badge lets unlimited wallets spin on the same day (src/WheelSpinCheckIn.sol:107). spin() checks only the caller's balance at that moment, so a single badge passed between wallets authorises a spin for each.

   • Reproduced: 100 wallets spun on one day with totalSupply() == 1, filling all 100 leaderboard rows. A single-transaction version cost about 17.1M gas.
   • README claim is wrong in one case: it says the relay "gains nothing a free mint does not already give", which stops being true once the collection is minted out.
   • Fix option: spin(uint256 tokenId) with a per-token last-spin day caps it at one spin per badge per day, but changes the signature the web app calls.

What held

• Supply and mint rules: mint() is the only writer of totalSupply and hasMinted, and there is no other mint or burn path.
• Leaderboard: sorted order, rank-to-row consistency and the top-100 property held in my own fuzz (200 runs, 25 days, 140 wallets, skipped days and evictions) against a reference model. I also traced all three branches of _place by hand.
• Views against writes: canMint/mint and canSpin/spin agree, and the live streak reads 0 after a missed day in every view.
• ABI docs: docs/abi/*.json match the compiled ABIs.
• Existing suite: all 56 tests pass.

Not reached

There is no launch.json in the tree yet, so the WheelSpinCheckIn constructor argument could not be checked. A wrong non-zero badge address would make every spin revert permanently, so the manifest review must confirm it is $contract:HamsterBadge.

Neither finding carries a proof test; both are below high. The scratch tests I used to reproduce them were deleted, so the judge will need to rebuild them from the call sequences in the reproduction fields.

The review is complete. The findings file is written and validated, and no source, configuration or vendored file was changed; the only files I created are the findings JSON and two probe tests under test/scratch, which is not kept.

Result: no defects found in the math area. The findings list is empty and the coverage record answers all seven entry points plus seven invariant and periphery rows, all holds.

What I checked, against the Math Precision, Boundary and Numerical Gap guides:

• Day arithmetic. The day number is the timestamp divided by 86400 and cast with SafeCast to 48 bits. The cast only fails at day 2^48, far beyond any realistic chain time. The live-streak window is exact: alive through the day after the last spin, zero from the second day after.
• Packed counters. Streak and total check-ins are 48-bit and grow by at most one per day, so they cannot overflow. The rank field is 16-bit and never exceeds 100.
• Leaderboard single-swap argument. I traced all three branches of the placement routine. A longest streak grows by exactly one per spin, so every entry a wallet overtakes holds exactly one less, and one swap keeps the board sorted. An off-board wallet always has a longest streak no greater than the board minimum, because the board never shrinks and the minimum never decreases. Probe tests for a full board of ties, a unique minimum growing, eviction and re-entry after a reset all pass, as does the existing stateful invariant suite.
• Supply cap. Minting all 10,000 badges in a probe gives id 10000 to the last minter and reverts the next call with MaxSupplyReached. Remaining supply cannot underflow.
• Base64. The length formula is the correct padded ceiling, and the sextet shifts and masks are right. Lengths 0 through 6 plus edge bytes match RFC 4648 vectors.
• Static-analysis leads. All were traced and none reproduce. The divide-before-multiply is an intended ceiling, the strict equalities are the intended day and holder semantics, and the flagged "reentrancy" is a view call compiled as STATICCALL.

Checks outside the strict math area that I also ran: the vendored OpenZeppelin files match upstream v5.4.0 except for formatting, the ABI exports in docs/abi are set-equal to the compiled ABIs, and the README constructor table matches the source. The full project suite of 56 tests passes.

Two measurements for the judge's reference:

Call	Gas
tokenURI for id 10000	1,268,948
leaderboard() with 100 entries	619,474

Not reached: nothing in scope was left unexamined. Launch.json does not exist yet, which is expected at this stage.

The permissions review is complete. The findings file is written at .imd-findings.json with one info-level finding and a coverage row for every listed entry point.

Outcome. No permission bypass, escalation path, unguarded writer, or paired-function asymmetry was found in either contract. Neither contract has an owner, initializer, proxy, or privileged function. The factory and the IMD launch wallet receive no role at deployment, since no constructor reads the caller.

What I verified

• Access control. All seven state-changing entry points were traced. The four ERC-721 transfer and approval functions come from OpenZeppelin v5.4.0 unchanged, which I confirmed by fetching upstream and comparing all 14 vendored files. They differ only in line wrapping.
• Asymmetry. The spin, canSpin, hasSpunToday, statsOf and live-streak paths agree on the same day and badge conditions. The leaderboard swap argument holds, and the rank writes for other wallets cannot be overwritten by the caller's record write. The existing 56 tests, including the stateful invariant test, pass.
• Trust gap. The ABI exports match the compiler output exactly. The static-analysis leads (strict equality, timestamp, reentrancy after external call, memory array edit) do not reproduce as defects.

The one finding, severity info. The badge-holder gate is a point-in-time balance check on a transferable token. A scratch test showed one badge authorising 50 wallets' spins in a single transaction, and still acting as a credential after the supply cap. The README documents this as a deliberate design choice, and it does not violate the brief, so it is recorded as a trust assumption rather than a defect.

Not reached. No launch.json exists yet. The later manifest review must confirm the check-in constructor receives the badge contract reference, because any other nonzero address is accepted and would leave spinning permanently broken with no admin to fix it.

Added 25 tests covering authorization failures, callback rollback, supply limits, and stateful invariants. Only test/ changed.

forge build and forge test pass: 81 tests, including 16,384 new invariant calls, using the supplied seed. No reproducible contract defects found.

The review is complete and written to .imd-findings.json. No tracked file was changed; the only new files are the findings JSON and my scratch tests under test/scratch/.

Outcome: three low findings, all merged from the specialists, nothing new of my own. The code does what the approved brief asks and the build, the 81 existing tests, and my own leaderboard fuzzing all pass.

Findings kept, each reproduced with a Foundry scratch test:

1. Sybil mint-out (low, merged from flow and economics). Throwaway constructor-only contracts step around the per-wallet limit. I measured 114,822 gas per badge, so one account can consume the whole 10,000 supply for about 1.07 billion Sepolia gas, after which mint and spin are closed to newcomers forever. The brief's rule is implemented exactly, and the README already states that one wallet is not one person, so I rated this a design-acceptance item rather than the medium the economics specialist gave it. The README should state the cost and irreversibility, and any mitigation changes the brief.

2. Bearer badge relay (low, merged from flow, economics and permissions). The holder gate is a point-in-time balance check. One badge backed 150 wallets' spins on the same day, filled all 100 leaderboard rows, and still works as a credential after mint-out. The README's claim that this gains nothing over a free mint fails in those two states.

3. canSpin(address(0)) reverts (low). It should return false but hits OpenZeppelin's ERC721InvalidOwner revert. The flow specialist's proof fails on this tree for exactly that reason, so I attached it.

Dropped or confirmed as non-issues: every slither and aderyn line (the reentrancy flag is a view call on the immutable badge, the Base64 rounding is intentional and tested, the strict equalities compare day numbers). The vendored OpenZeppelin files match upstream v5.4.0 apart from formatting. The manifest has the right keys, constructor arguments, and dependency order, and correctly omits an owner since neither contract has one. The ABI exports match the compiled ABIs exactly.

Coverage: all 7 entry points answered (5 hold, mint and spin carry findings 1 and 2), plus 5 invariant rows covering the leaderboard bookkeeping, the manifest, the ABI exports, factory deployability, and the static-analysis leads.

Area	Result
Requirements, grouped	17 met · 1 missing · 0 faked · 3 after review · 1 needs requester
Broken features	3
Product on first screen	Yes, at 390 × 844
taste@1	16/16 passed
Copy findings	0
Share card	Missing image; HTTP 404

Saved four findings to .imd-findings.json:

• High — fidelity: required frontend validation evidence is absent.
• Medium — bug: the mobile wallet picker hides discovered EIP-6963 wallets without window.ethereum.
• Medium — bug: failed supply and totals reads remain labelled as loading.
• Medium — bug: both share cards reference missing og.png.

Each finding includes an exact source citation, proposed change, and reproduction. Website files remain unchanged.

The grouped requirement review:

• Met — “SqueekBoard” community app, without a fungible token: header and two-contract deployment configuration.
• Met — Sepolia ERC-721 named “Hamster Badge,” symbol “HBADGE,” capped at 10,000, with one free mint per wallet: src/HamsterBadge.sol and manifest.
• Met — badge holders record one daily onchain check-in, storing streak and totals: src/WheelSpinCheckIn.sol.
• Met — “connect a wallet”: ConnectSheet; the mobile discovery defect is recorded above.
• Met — “mint their badge”: Mint badge control and useTx.
• Met — “button for today’s spin”: Spin today control.
• Met — “see their streak and total check-ins”: Current streak, Longest streak and Check-ins fields.
• Met — “public leaderboard of the longest streaks”: public contract read and Longest streaks table.
• After review — GitHub publication, IPFS hosting and public URL: publisher responsibility.
• After review — independent security review: separate contract-review work.
• Met — source, package, lockfile and configuration under web/; export under dist/; documentation paths respected.
• Missing — committed “validation evidence”: no frontend validation report or retained browser evidence.
• Met — preserve deployed source; no publishing or redeployment: deployed contract source remains unchanged.
• Met — implementation-derived ABIs from the pinned commit, with verified hashes: both docs/abi/ files match.
• Met — build, typecheck and interaction checks: clean build, two unit tests and 14 Chromium tests passed; mocked mint/spin also passed in WebKit.
• Met — manifest schema, deployment identifiers and exact contract set: dist/imd-deployment.json.
• Met — unchanged network and wallet-add-chain blocks; conditional pool key: copied blocks match, and the handoff has no pool key.
• Met — runtime manifest and referenced ABI loading, without a separate deployment map: web/src/config.ts; paths are relative.
• Met — every export file hashed, including HTML and ABIs, excluding the manifest itself: all nine asset hashes match.
• Met — asset and response-budget limits: nine assets; total export 758,986 bytes.
• After review — fixed-CID, named-entrypoint and publication checks: control-plane gates.
• Needs requester — live wallet/signature and chain verification from an accessible environment: interactions used mocks; live RPC requests returned HTTP 403.

The clean build reproduced the committed export byte for byte. The probe passed because its share check verifies metadata presence; direct image requests exposed the missing asset.

SqueekBoard is a daily check-in dashboard carried by its hamster-wheel illustration and warm cream interface.

Fixed all four findings, rebuilt dist/, and wrote .imd-responses.json.

Build/typecheck, ABI/manifest verification, 19 Chromium tests, and 16 design checks passed. Validation and screenshots document remaining limits: WebKit/device/live-transaction checks are untested; browser RPC requests failed while curl succeeded. Nothing was fabricated.

Files are ready, but a read-only Git index prevented staging and committing.

Area	Previous review	This review
Requirements	1 missing reported	18 met; 0 missing; 0 faked; 3 after review; 1 needs requester
Broken features	3	0 reproduced
First screen at 390px	Not supplied	Product and main controls visible
taste@1	Not supplied	16/16 passed
Copy findings	None reported	0
Share card	Missing image	1/1 working

All four previous findings are resolved. .imd-findings.json contains {"findings":[]}. No site files were changed.

Previous finding	Recheck
fidelity: missing validation evidence	Fixed. VALIDATION.md and retained evidence document results and limitations.
bug: missing share image	Fixed. Gateway-path request returns HTTP 200, image/png, and 1200 × 630 dimensions. Its manifest hash matches.
bug: failed public reads remain loading	Fixed at 390px and 1440px. Isolated supply-batch failures show an error and dedicated retry; recovery works. Failed refreshes retain and label previous values.
bug: mobile picker hides discovered wallets	Fixed at 390px with the supplied iPhone emulation and no window.ethereum. Mock Wallet appears and connects successfully.

The requirement checklist groups repeated wording from the brief:

Requirement	Status	Evidence
“SqueekBoard… community companion… Sepolia”	Met	Branding, hamster artwork and network configuration
“does not launch a fungible ERC-20 token”	Met	Deployment contains only badge and check-in contracts
ERC-721 “Hamster Badge”, “HBADGE”, 10,000 cap, one free mint per wallet, gas only	Met	Preserved src/HamsterBadge.sol; mint control and supply display
Badge-holder daily spin storing streak and total check-ins	Met	Preserved src/WheelSpinCheckIn.sol
“Visitors connect a wallet”	Met	ConnectSheet.tsx; connection regression passed
“mint their badge”	Met	Mint badge control; mocked receipt-driven interaction passed
“button for today’s spin”	Met	Spin today control; mocked interaction passed
“see their streak and total check-ins”	Met	Current streak and Check-ins displays
“public leaderboard of the longest streaks”	Met	Longest streaks table; public contract reads
“independent security review”	Needs requester	Separate contributor’s review record; README.md:157 identifies the separate stage
“source code published to GitHub”	After review	Publisher responsibility
Public website hosted on IPFS	After review	Publisher responsibility
“contracts deployed on chain”	Met	All three configured RPCs returned chain 11155111 and nonempty code at both addresses
Source/packages/configuration under web/, export under dist/, documentation under permitted paths	Met	Delivered tree
Preserve deployed source; obtain pinned implementation ABIs and verify hashes	Met	Protected source unchanged; both ABI files match pinned bytes and canonical hashes
Exact deployment manifest schema, identifiers and contract set	Met	dist/imd-deployment.json; independent verification passed
Preserve conditional poolKey, network and supplied wallet-add parameters	Met	No pool key supplied; network and wallet parameters match exactly
Runtime loads the same manifest and referenced ABIs	Met	web/src/config.ts; browser request assertions passed
Relative paths, complete SHA-256 inventory excluding manifest, final-export consistency and size limits	Met	All 10 assets verified; total export 810,035 bytes
Build, typecheck, browser/interaction validation and retained evidence	Met	Rebuild matches committed assets byte-for-byte; typecheck, 2 unit tests and 19 Chromium