Approved workflow

I've built the MOMO token and the MomentumFeeHook, with tests, ABI exports and a README. After a clean rebuild, forge build, forge test (42 passed, 0 failed) and forge fmt --check all pass on solc 0.8.26. The protected floor checks (6 token, 3 hook) also pass when run against the real creation code, with the PoolManager address and flags 0x44 passed in the environment variables those tests read.

Contracts

• src/Momentum.sol: the token, built on OpenZeppelin's ERC-20. It mints 1,000,000,000 MOMO (18 decimals) once to the deployer. No constructor arguments, no mint function, no owner.
• src/MomentumFeeHook.sol: built on BaseHook, taking only the PoolManager as its constructor argument. It enables exactly afterSwap and afterSwapReturnDelta.
  • Fee: the per-pool streak rule, taken on the unspecified currency and rounded up. It is credited to the hook as ERC-6909 claims; nothing is sent out during a swap.
  • Donation: anyone can call donateFees to pass the fees to in-range LPs. It reverts NoLiquidity when there are none, and the fees wait.
  • Callback: unlockCallback only accepts the PoolManager, and only during a donateFees call the hook started itself.
• src/HookFlags.sol: the permission-bit helper the protected tests import.

Tests all run against a real v4-core PoolManager:

• Fee accuracy: each swap is also run on an identical pool with no hook, so the fee is checked exactly for exact-input and exact-output buys and sells.
• Schedule: fees go 30, 40, … 200 bps, capped from the 18th same-direction swap. A qualifying swap the other way resets to 30. A 0.0009 ETH swap leaves the streak unchanged.
• Launch rehearsal: one-sided MOMO below the opening price, a first buy into the pool while it holds no ETH, then a sell, plus the NoLiquidity path.
• Invariants: fees held match fees recorded, every fee matches the schedule, and the streak matches an independent model.
• Bug detection: I deliberately broke the hook in 13 ways. The tests caught 12. The 13th change gives the same result as the original, because 30 + 10×17 is already 200.

Choices the reviewer should check (all in the README):

1. Non-ETH pools: any pool may attach the hook. On a pool without native ETH, the 0.001 threshold is applied to currency0's raw units.
2. Two small additions: donateFees also reverts NothingToDonate when nothing has accrued, and WrongHook for a key that names a different hook. The spec doesn't list these.
3. Event value: the streak in the Momentum event is the length after the swap.
4. hookData: ignored. The hook never needs to know who the swapper is, and the README says hookData is unauthenticated.
5. Library source: BaseHook comes from v4-periphery commit 3779387e, the last one before it was moved out of that repo.

Also in the README: that resetting a streak costs a qualifying counter-swap (two hook fees plus LP fees), the deployment parameters, and who has to do what once it's live. For example, someone must call donateFees, and liquidity added just before a donation can take a share of it.

The ABIs are in docs/abi/Momentum.json and docs/abi/MomentumFeeHook.json. Everything the build needs is copied into lib/ as plain files, with no git submodules. I haven't written launch.json or the website: launch.json belongs to the manifest step, and the site is built after deployment. I haven't made a git commit either, because the rules don't allow touching .git/.

This hook holds users' fees, so the independent adversarial review is still needed before release.

I added one new file, test/MomentumFeeHook.sequence.t.sol, with 13 tests. forge build succeeds and forge test passes 55/55: the 42 tests that were already there plus the 13 new ones. I found no defects in the hook, so I did not write .imd-findings.json.

What every fuzzed swap is checked for. Each swap runs on the hooked pool and on an identical pool with no hook. The no-hook pool gives the swap's exact amounts before the hook fee. Each swap is then compared with my own record of what the streak should be:

• Fee rate: the quoted rate and the rate in the Momentum event must match the schedule and stay between 30 and 200 bps.
• Fee amount: it must equal ceil(amount × bps / 10,000), capped at the amount, and be charged only in the unspecified currency. It must be at least 30 bps and at most 200 bps plus rounding.
• Hook balances: the fee credited to the hook must equal the increase in accrued, and the hook's total credits must equal accrued.
• Deltas settle: the ETH and MOMO balances of the swapper and the PoolManager change by exactly the reported amounts. The PoolManager ends each swap locked with no unpaid balances for the hook or the router, and no ETH or MOMO is sent to the hook.
• Events: exactly one Momentum event per swap, with the right direction, rate, currency, fee and resulting streak.
• Streak: any swap whose ETH amount is under 0.001 ETH leaves the streak exactly as it was. The hooked pool's price always stays equal to the no-hook pool's.

Sequences.

• Random: up to 16 swaps mixing direction, exact input/output and sizes: dust, within 3 wei of 0.001 ETH, just around 0.001 ETH, large, and a few wei.
• Streaky: 18–40 swaps that rarely change direction, so the fee reaches and holds 200 bps.
• Dust only: runs of under-0.001 ETH swaps on top of any streak.
• Schedule sweep: 20 streak lengths with dust swaps both ways at each one.

Threshold edges. Where the ETH amount is the one you specify, the cutoff holds to the wei (0.001 ETH ± 2000 wei). Where the pool works out the ETH amount (exact-input sells, exact-output buys), the pool's own amount decides. When a price limit cuts a swap short, the ETH that actually moved counts, not the size requested, in both directions.

Failure paths. Each of these reverts and leaves the streak, accrued and the hook's credits unchanged:

• a zero-amount swap;
• a buy that big enough to reset the streak but not fully paid for;
• a price limit on the wrong side;
• a price limit equal to the current price.

Checking the tests themselves. I ran the new suite against four deliberately broken copies of the hook, in scratch only; the real hook was never changed. It caught every one: the threshold using <=, dust able to flip the direction, the cap raised to 210 bps, and qualifying on the wrong side of the swap. Each broken copy failed several tests.

Two things to be aware of, neither a bug:

• Tiny swaps can pay more than 200 bps in effect. The spec says to round the fee up, so a swap of a few wei still pays at least 1 wei. My tests check the fee rate and allow one wei of rounding on the amount, rather than claiming the effective percentage never exceeds 200 bps.
• "Swap size" means the pool's amount before the hook fee. The spec defines it that way. So an exact-input sell whose pool output is exactly 0.001 ETH counts toward the streak, even though the seller receives slightly less after the fee.

Created launch.json with matching contract permissions, constructor argument, token metadata and the rehearsed pool price.

Validation passed: supplied schema constraints, forge build, and all 53 tests. Notes are 1,968/4,000 characters. Only launch.json is included in the submission.

No substantiated findings in the requested scope. Wrote {"findings":[]} to .imd-findings.json.

Seven targeted local EVM probes passed. ABI exports match compiled source. Implementation and tests remain unchanged.

Implemented the frontend, static export, runtime manifest, and validation evidence.

Passed build, typecheck, 7 unit tests, 32 browser checks, and live RPC reads. No transactions broadcast.

Validation report · Design documentation

Commit remains blocked because .git is read-only. Root DESIGN.md was placed under docs/ to respect the authorized paths.