Added failure-path, fuzz, and invariant tests, confined to test/.

• Build passed.
• Offline: 64 passed, 2 fork skips.
• Mainnet fork: 14 passed at block 26,145,919.
• Four specialist reviews found no reproducible defects.

Results and review disposition: test/REVIEW.md.

Updated only launch.json.

Validated the supplied schema, constructor placeholders, permissions, and pool settings. Notes describe the implementation within the 4,000-character limit.

forge build passed. forge test: 64 passed, 0 failed; 2 fork suites skipped because no mainnet fork was configured.

I found one high-severity defect: a swapper can take back almost all of their own 1% staking fee, so real stakers lose it. The finding and its coverage record are in .imd-findings.json, and no source files were changed. The proof test fails on the current code as intended; the existing suite has 64 tests and all pass.

Finding 1 (high): stakes that last only one swap still earn that swap's staking fee. (src/SIMDTESTVault.sol:116, queue = queuedRewards + hook.totalStakingFees() - accountedFees;)

• Cause: the vault credits rewards the moment the hook records a staking fee during a swap. stake and unstake have no lock, block delay or reward streaming.
• How it's exploited: inside its own PoolManager unlock, a swapper borrows SIMDTEST from the pool's own reserves, stakes it, swaps, unstakes and pays the SIMDTEST back. It needs no capital of its own.
• Measured result: with Alice staking 10,000 and the swapper borrowing 500,000, a 100,000 IMD buy pays a 1,000 IMD staking fee. The swapper's claim() returns 980.39 IMD and Alice earns only 19.61 IMD.
• Wider reach:
  • Anyone already holding SIMDTEST can do the same across transactions by staking just before another trader's swap and unstaking just after.
  • It also lets anyone take the rewards queued while nobody is staked in a single call with zero capital.
• Proof: a self-contained Foundry test is in the finding's proof field. It also passes if the fix simply refuses the zero-duration stake.
• Suggested fixes:
  • Let a stake earn only fees from after the block it was made.
  • Or pay rewards out gradually over a period instead of crediting them instantly.
  • A guard that blocks staking while the PoolManager is unlocked only stops the borrow-from-the-pool version, not the cross-transaction one.

Coverage: the record has a row for all 12 entry points plus 3 invariant rows; none are unreached.

• Finding: stake, unstake and claim, plus the invariant that staking fees go to stakers for time actually staked.
• Holds, swap fees: the fee calculation is consistent across buys and sells, exact input and exact output, and partial fills, and the 30% fee decays to 0 by block 10.
• Holds, claims and payouts: the hook's IMD claim balance always equals the fees owed to the two destinations. The vault always holds enough IMD to pay rewards once swept.
• Holds, sweep: I checked the IMD contract on mainnet. It is a standard LayerZero token with no pause, blacklist or transfer fee, so a refused IMD transfer cannot block sweep() or, through it, claim().

Not reported:

• The rule that the first staker after an empty period takes all queued rewards. The earlier judge accepted it as disclosed design; the exploit above only makes it free to capture.
• The static-analysis leads. The strict-equality and reentrancy warnings did not lead to anything I could reproduce.

The findings file is valid, the quoted snippet matches line 77 exactly, and no tracked file was changed.

Outcome: no reproducible defect in the assigned area. The review covered the Execution Trace, Periphery and First Principles guides against the hook, vault and token, and wrote .imd-findings.json with one informational note and a full coverage record for all 12 entry points plus four invariant rows.

What I verified:

• Swap control flow in all four modes. The specified-side fee is taken in beforeSwap, the unspecified side in afterSwap, and the hook's minted ERC-6909 claims always net against the credited hook delta, so settlement never fails. The self-quote only runs when the caller is the hook itself, v4 skips the hook's callbacks on its own swap, and the forced revert rolls back pool and transient state. I confirmed the gross-up window of four candidates contains every exact inverse and that type(int256).min requests flow through v4's unchecked swap math without a panic.
• Sweep and claim paths. Storage is zeroed before burn and take, the hook delta nets to zero in both the locked and already-unlocked branches, and claims are always backed by IMD held in the PoolManager. The vault's notify check cannot strand claims because notified plus unswept staking fees always equals cumulative staking fees.
• Periphery. Permission mask 0x20cc matches the implementation and manifest, the mining script hashes creation code plus constructor args in manifest order, and the quote decoder reads the 36-byte revert correctly.
• Live dependency. I fetched the mainnet IMD bytecode through a public RPC. It is a LayerZero OFT-style ERC-20 with plain transfer selectors and no pause, blocklist, fee, delegatecall or selfdestruct. The project's fork suites then passed against current mainnet state alongside the 64-test offline suite.

The one note recorded is the disclosed zero-staker queue policy: fees accrued before anyone stakes go entirely to the first staker, even a 1-wei stake. It is documented in the README and manifest and was accepted by the prior judge, so it is filed as informational with a concrete sequence rather than as a defect. All static-analysis leads were traced and found benign.

The review is complete. The findings file is written and validated, the scratch test is removed, and the working tree is otherwise untouched.

Outcome. No access-control defect found. Every enabled callback authenticates the PoolManager, the self-quote is self-only and always reverts, the sweep has fixed destinations, the unlock callback requires an active sweep, the vault's notify path is hook-only, and nothing in the hook, vault or token has an owner, setter, proxy or forbidden opcode. I also ran the project's own mainnet-fork suites, which the author could not, against a working public RPC: all 13 tests pass on the deployed PoolManager and the real IMD token. IMD itself is a LayerZero OFT with an owner but no pause, blacklist, transfer fee or delegatecall, so the sweep and claim paths hold on live state.

Two low-severity trust-gap findings were recorded in .imd-findings.json, each with a numeric reproduction:

• Fee-free exit through liquidity positions. The hook taxes swaps only. During the 30% anti-snipe block, a holder minted a SIMDTEST-only position next to the spot price, a buyer swapped through it, and the holder removed it, converting 8,986 SIMDTEST into 9,127 IMD with zero hook fee. A swap-sell of the same IMD would have paid 2,829 IMD. The README discloses that liquidity changes are not intercepted, so this is flagged as a design-boundary question for the judge.
• Just-in-time staking. Rewards are credited at the instant a fee accrues with no holding period. A staker who front-ran a 1,000 IMD buy with a 9,000 SIMDTEST stake captured 9 of the 10 IMD fee and unstaked in the same block, leaving the sole long-term staker 1 IMD. The README discloses immediate eligibility; a streaming window would preserve any-time unstaking while closing the race.

Coverage. All 12 listed entry points have rows, plus five invariant and external-dependency rows. Only the vault's stake function and the "every conversion pays the fee" invariant carry a finding reference. Nothing was left unreached.

Not covered: the fuzz variant of the fork suite was not run against the live RPC, and the launch factory's actual seeding and distributor flow was not available to exercise.

Done. The review is written to .imd-findings.json, both quoted snippets match the tree at the cited lines, the scratch directory is removed, and the working tree is clean.

Outcome: no exploitable math defect found. The hook fee arithmetic and the vault accumulator both hold under every Math Precision, Boundary and Numerical Gap check I could reach, confirmed by targeted probes on top of the delivered suite. Two low-impact observations are recorded at info severity.

What I verified

• Fee inverse is exact. The four-candidate gross-up search always picks the smallest exact inverse. Brute-force forward scan over every net below 400,000 at all eleven decay rates gave zero mismatches, matching the analytic window bound.
• Quote fill equals real fill. For both specified-IMD modes the real swap requests at least as much as the self-quote and both are limited by the same price limit, so partial fills are never over-charged. Six hundred large partial fills at every rate, all four modes, matched the fee formula exactly against the real local PoolManager.
• No overflow in the accepted domain. Fees fit int128 whenever pool deltas do. The int256.min and 2^255 requests are handled by the pool's own fill limits, and UnrepresentableFee fires only above 0.69 × 2^255 as documented.
• Vault stays solvent. Total credited never exceeds total accrued because the remainder carry is in scaled reward units and bounded below totalStaked. Three hundred randomized 60-step sequences with 1-wei stakers beside a near-whole-supply whale lost nobody more than one wei and let nobody capture another's rewards.
• Decay schedule is exact integer math. 3000 minus 300 per block, zero from block ten on, no underflow.

Two observations reported

1. Dust rounding. Both fees floor, so a swap under 100 wei IMD pays no staking fee, and anti-snipe vanishes under 4 wei at 30%. Gas makes this unfarmable. Already stated in the README.
2. Bundled redemption coupling. The anti-snipe payout and the staking notification share one atomic sweep. If IMD ever delivered fewer units than requested, the vault's funding check would strand the hackathon fees too, with no recovery path. Not reachable with a standard ERC-20, and the mainnet IMD code could not be inspected offline.

Coverage lists all twelve entry points plus five invariants. Everything is holds or finding except the mainnet fork rehearsal, which is unreached because this environment has no network.

The review is complete. The findings file is written and valid, and the working tree has no stray files.

Outcome: one high finding kept with a failing proof, one low, two informational; nothing new beyond the specialists' leads. The full delivered suite passes at baseline (64 passed, 2 fork skips), and the manifest, permission mask, and bytecode sizes check out.

What I kept in .imd-findings.json:

• High, merged from economics and permissions: zero-duration staking recaptures the 1% staking fee. The vault credits fees to whoever is staked the instant the hook accrues them, and stake and unstake have no duration or unlock guard. A swapper can take pool-held SIMDTEST inside its own unlock, stake it, swap, unstake, and return it, paying only gas. The specialist's proof fails on this tree with the swapper refunded 980.39 of a 1,000 IMD fee while the only real staker gets 19.61. I also reproduced the cross-transaction sandwich variant. The proof is attached.
• Low: a one-sided SIMDTEST position converts to IMD through buyers' swaps with no seller-side hook fee, even at 30% in the opening block. Reproduced: a 9,127 IMD exit accrued zero fee where a swap-sell would owe 2,829.
• Info: fees accrued with no stakers go wholly to a 1-wei first staker. Disclosed policy, reproduced.
• Info: sweep couples both fee streams, so a shaved IMD transfer would strand the hackathon payout along with staking fees. Reproduced only by replacing IMD with a non-standard token.

Dropped the math specialist's dust-rounding item as a non-defect, and all slither and aderyn lines after tracing them. My own pass over the swap paths confirmed the self-quote rollback, the gross-up inverse always existing within the search window, int128 safety of fee casts, callback authentication, and zero-sum delta accounting. Coverage records all 12 entry points plus three invariants.

Still owed outside this review: the mainnet fork rehearsal against the real IMD token and PoolManager, which no offline run can substitute for.

Done. The suite builds and passes again against the revised implementation, with new coverage aimed at the code that changed.

What was wrong at the start. The build was broken: the vault's fee-source interface gained lastAccrualBlock and stakingFeesAtEndOf after my first round, and my VaultRewardSource helper did not implement them. Beyond that, five of my tests asserted same-block staking rewards that the reworked vault now correctly withholds until the next block.

What I changed, all under test/:

• helpers/VaultRewardSource.sol now mirrors the hook's per-block boundary recording exactly.
• VaultModelInvariant.t.sol has an independent oracle that models blocks: a roll action, eager maturation, same-block cancellation earning nothing, and queued fees going to the first matured stakes. It also pins the vault's pending and active buckets to the model.
• VaultFailurePaths.t.sol matures stakes before asserting earnings and adds four tests on the pending mechanism, including a 1,000-case fuzz that a same-block stake never takes that block's fees across up to 50 untouched blocks.
• FeeBoundaries.t.sol is new. It drives random swap and block walks through the real local PoolManager and checks every recorded end-of-block fee total against an independent ledger, then checks that an untouched vault settles each block to exactly the eligible stake, with equality rather than tolerance.
• LaunchFailurePaths.t.sol and TokenOnlyPool.t.sol received minimal block rolls. The token-only first buy now also checks the fee is queued and lands on maturity.
• REVIEW.md records this round.

Results:

No defects found. I reviewed the new boundary fallback on every path, including underflow and bucket-refill cases, and the model and end-to-end fuzzes agree with the implementation. No .imd-findings.json was written. Formatting is clean. Nothing outside test/ was touched, and I left committing to the harness as in earlier rounds.

Review complete. The findings record is written to .imd-findings.json and no source, test, manifest or configuration file was changed.

Outcome: the high finding is fixed and nothing blocks this launch.

Settlement of the prior round:

• Flash/JIT stake recaptures the 1% staking fee (high, 99a14f0d): fixed. Both attached proofs now pass on the revised tree. The vault holds a stake as pending for its own block and makes it eligible from the next block, with the hook recording per-block fee boundaries so the split is exact even with no checkpoint between the stake and the next interaction. I probed the new logic beyond the author's tests: a bucket flushed by a stranger before a later accrual, repeated stakes by one user across blocks, a cancelled first stake with the queue surviving, and a mixed pending/active partial exit. All settle exactly, with one wei of accumulator remainder retained as the README discloses. The remaining residual is a real-capital sandwich that stakes one block ahead, which is pro rata and documented.
• Atomic redeem strands the hackathon payout on short delivery (info, 0d9a350d): fixed. The hook now notifies the vault with the IMD actually received, and the shaving-token test shows the sweep completes.
• LP exit untaxed during the anti-snipe window (low, 8287d4ad): dispute accepted. The brief's fees are swap fees, taxing liquidity would change the permission bits and manifest, and the README now states the boundary. Downgraded to info and closed.
• Zero-staker queue goes to the first matured stake (info, 6f74dafb): unchanged policy. The fix removed the zero-capital variant since the stake must survive a block. Recorded as info only.

No new defects. The slither and aderyn leads were checked: the strict equalities are intentional block and exact-inverse comparisons, the ignored unlock return is empty bytes, and the state write after the unlock call is behind the reentrancy guard and the sweepActive gate.

Coverage: all 12 entry points answered as holds, plus four invariant rows. Full suite: 81 passed, 0 failed, 2 fork tests skipped offline. The live mainnet-fork rehearsal against the real IMD token is still owed, as the author notes.