I found two defects and wrote them to .imd-findings.json. One is high and blocks the launch: the hook can't be deployed where the launch's own checks build it. The other is low. No source or config files were changed; the only file left in the repo is the findings file. My proof tests went under test/scratch/, which I deleted afterwards; the proof's source is embedded in the finding.

forge build succeeds and the project's own forge test passes (116 tests across 16 suites).

Findings

1. High: the constructor refuses an engine address that has no code (src/IMDuelHook.sol:194). The launch's protected checks (Hook.protected.t.sol, Owners.protected.t.sol) deploy the hook off-fork. They only place stand-in code at IMD, never at the engine address 0xc21788…. So the constructor reverts with BadConfig and every protected test fails in setUp, even though the hook would deploy on mainnet where the engine exists.

   • Proof: a CREATE2 deployment with launch.json's nine arguments reverts.
   • Control: with any code placed at the engine address, the same deployment succeeds.
   • Fix: drop the engine_.code.length check from the constructor.

2. Low: a reward owed to an address that can't receive it is locked forever (src/IMDuelHook.sol:372). When a bounty payment fails, withdraw(who, c) can only pay who. If who is a contract with no way to receive ETH, or a token blocks it, every withdrawal fails and the claim stays in the hook. The finding gives the exact steps in an ETH-paired duel.

Checked with no defect found

• Delta accounting: the fee claims in beforeSwap and afterSwap net to zero for exact-input and exact-output swaps. The partial-fill check is correct.
• Bookkeeping: what the hook holds always equals the reward pools plus waiting fees plus owed rewards.
• Access control:
  • The callbacks and unlockCallback accept only the PoolManager.
  • payOut and convertBatch accept only the hook itself.
  • withdraw, fundChest and convert can't move other people's funds.
• Conversion price limits: batches buy only near the main duel's price at the start of the block, which can't be moved within a block without that being recorded first.
• Engine safety: the engine's gas cap and failure fallback hold. Starving it deliberately reverts the swap rather than playing a weak fallback move.
• Bounty math: reward pools can't overflow, and payouts round down.
• Opening surcharge and fee rates: these match the brief, and the surcharge applies only in the main duel.
• Permissions: getHookPermissions matches launch.json and the address flags.
• Forbidden features: there is no owner, pause or upgrade path, and the deployed code (18,179 bytes) has no reachable DELEGATECALL, CALLCODE or SELFDESTRUCT.
• Manifest: launch.json has 9 arguments in declaration order, and the notes are 2,688 characters. The route pool id in the notes matches IMD / native ETH at fee 10000, tick spacing 200.
• Slither: I installed it in /tmp and it reported nothing for arbitrary-send-erc20, arbitrary-send-eth, reentrancy-eth, unchecked-transfer or controlled-delegatecall. So I didn't report the callback-data transferFrom that the reference warns about.

Contracts read

• Read fully: src/IMDuelHook.sol, src/Strength.sol, src/IChessEngine.sol, launch.json, launch/hook.json, launch/engine.json, launch/deployed.json, the protected tests, and the setup of test/Launch.t.sol.
• Not audited in depth (out of budget): src/ChessEngineV5.sol, src/Bitboard.sol, src/Rules.sol and src/Chess.sol. The engine is already deployed, and the hook calls it read-only with a gas cap, catching any failure.
• Couldn't reach: the factory's standard launch token, which isn't in the repo, and the on-chain state of the mainnet IMD / ETH route pool.

Fixed both reproduced findings: off-fork engine construction and claimant-only withdrawTo reward recovery.

forge build and seeded forge test pass: 132 passed, zero failures, including factory launches in both token orders. Manifest, constructor arguments, permissions, and compiler settings remain unchanged.

Details: ADAPTATION.md.

The permissions review of IMDuelHook is complete. The findings file is written at .imd-findings.json with one low finding and thirteen coverage rows. No repository source was changed; the only new files are the findings JSON and a scratch proof under test/scratch/.

Result

The permission model holds. The hook has no owner, admin, pause, upgrade or signer path. All three pool callbacks and unlockCallback refuse any caller but the PoolManager, and the manager only calls unlockCallback on its own unlocker, so the three self-encoded actions are unreachable from outside. payOut and convertBatch are self-only. Withdrawals pay only the owed party, and redirection needs the owed party's own call. fundChest pulls tokens only from its caller. Chests are keyed by pool, so a hostile token in a side duel cannot reach the main duel's money.

One finding, low severity

• Bid owner falls back to tx.origin. A swap sent without 20-byte hookData credits the transaction signer with the bid and any bounty it later earns. For an ERC-4337 account, a Safe run by a relayer, or an intent solver, that signer is the relayer, not the trader. The scratch test test/scratch/TxOrigin.t.sol reproduces it with vm.prank(account, bundler) and fails on the current code. The suggested fix is to place no bid when hookData is absent rather than guess the owner.

Manifest and trust anchors, all verified

• The nine constructor arguments match the declaration order, IMD equals the paired currency, and the permissions list equals getHookPermissions.
• Mainnet code at the engine address is byte-identical to the local ChessEngineV5 build.
• The IMD/ETH route pool id in the notes recomputes from the key, and that pool is initialized on the mainnet PoolManager with fee 10000.

Leads examined and dropped

Cross-block price pushes before a public convert call, nested swaps from a payout callback, and re-entry through a hostile token's transferFrom during fundChest were traced. Each is bounded by the block-start price band, the 100k payout gas cap, or harms only the funder of the hostile pool, so none produced a reproducible loss.

Not covered

Math precision, economic manipulation profitability, and the chess-engine control flow belong to the other specialists and were only touched where they met a permission question.

The review is complete and .imd-findings.json holds the result. Git shows no tracked-file changes (the findings file and test/scratch/ are untracked, and nothing under src/, launch.json or configuration was touched).

Outcome

• Build and baseline: forge build succeeds and the full suite passes (130 tests, 18 suites), including the factory-shaped launches in both token orders.
• Control flow of the hook holds across the three assigned guides. Callback caller checks, selector returns, the before/after-swap fee deltas, the PartialFill guard, the transient stash and re-entry lock, the self-call gates on payOut and convertBatch, the unlock dispatch, payout/withdraw rollback, and claims solvency all traced cleanly. The hook's own swaps are skipped by the v4 Hooks library, so conversions place no bids and pay no hook fee. Constructor argument order, permission set, and the hookless IMD/ETH route pool id all match launch.json.

Findings reported (2)

1. Medium, with proof. The main-duel conversion batch uses the block-start price recorded by the first observer in the block, and the attacker's own convert(imd) can be that observer. Pushing the main duel's price at the end of block N-1, then calling convert first in block N, sells the entire IMD pile for $IMDUEL at the pushed price from the attacker's own liquidity band. The self-contained proof at test/scratch/BatchCrossBlockProof.t.sol fails on the current code at the launch fee tier: the pile goes from ~5.0 IMD to 0 and the attacker nets ~1.75 IMD. The existing sandwich test covers only the single-block case. The ETH leg has a per-block cap for this reason; the IMD leg has none.
2. Low. When hookData is not exactly 20 bytes the bid owner is tx.origin, so swaps routed through bundlers, solvers or relayers credit the move and bounty to the originator EOA rather than the trader.

Coverage: 14 of 15 rows answered (all 10 ABI entry points plus four invariants). The one unreached row is the deployed ChessEngineV5/Bitboard chess logic, which the hook trusts for board state and game status and which I could not trace within budget beyond the project's own chess.js-derived tests.

I added test/Production.t.sol, and the full suite now passes with the verifier's fuzz seed: 160 passed, 0 failed, 0 skipped (130 existing + 30 new). forge build succeeds, and I changed nothing outside test/. The new file is not committed; it is in the working tree as test/Production.t.sol.

The existing tests mostly use a test harness that can switch off the opening surcharge. The new suite instead runs the real IMDuelHook, built from the nine launch.json arguments, in both token orders (IMDUEL below and above IMD). The test setup includes:

• IMD placed at its mainnet address and ChessEngineV5 installed at 0xc217…5a27.
• The hookless IMD/ETH route pool (fee 10000, spacing 200) and the main duel (fee 12500, spacing 60).
• A second duel of native ETH against another token, so the ETH slice converts through the route.

Invariant tests over random call sequences (2 token orders × 32 runs × 80 calls, fail-on-revert on, 0 reverts). The random actions are swaps in both pools, both directions, exact input and output, plus time jumps, chest funding, withdrawals, redirects by an owner that refuses ETH, and conversions. The invariants:

• What the hook holds in IMD, IMDUEL, ETH and the other token always equals the chests plus the slice pile plus every failed payout still owed.
• The hook never holds raw tokens or ETH, only pool-manager claims, and the manager always holds enough to back them.
• The burn address's IMDUEL equals the sum of reported burns, the main duel never changes, and a later duel never gets the opening window.
• After every swap: the chest share is at most 0.4% (at most the decaying surcharge rate in the main duel's first 300 seconds), the slice is at most 0.1%, and the share goes to one chest only.

Unit and fuzz tests, in both orders:

• Opening surcharge (fuzzed): at any age it equals 0.4% plus 25% falling linearly to zero over 300 seconds, then a flat 0.4%. The ETH duel opened at the same time always pays 0.4%.
• ETH slice conversion: at most 0.2 ETH per batch, one batch per block, and the IMDUEL bought splits half to the main chest, half burned.
• Failure paths:
  • An exact-output trade stopped by its price limit is refused and charges nothing.
  • Funding a chest without allowance, beyond the balance, with the wrong ETH amount, or on the hookless route pool is refused.
  • Withdrawing when nothing is owed does nothing, and redirecting to the zero address is refused.
  • Converting an empty or unrelated currency does nothing.
  • A dust trade pays no fee.
  • A pool with no route can't open, and a second IMD/IMDUEL pool never becomes the main duel.

Behaviour to know about: a bid's owner is taken from the hook data only if it is exactly 20 bytes. An address encoded to 32 bytes falls back to the transaction's sender, which matches the documented "else the signing wallet" rule. A tool sending 32 bytes would bid in the wrong wallet's name without any error.

Findings: none, so I didn't write .imd-findings.json. A deeper run (6 runs × 500 calls per order) did fail once on the fee bound, but that was my test's mistake. The same swap had also paid a bounty out of that chest, which hid part of the fee. With that fixed, the deep run passes in both orders with 0 reverts.

These are local tests only; nothing ran against a live chain.

Confirmed in the trace: the griefer's reward is pushed with paid: true, then the swap and every later swap revert with CurrencyNotSettled. The findings file is written and validated. Final recap:

Outcome. The economics review of IMDuelHook found one substantiated defect of medium severity, one low, and one informational note. The fee split, opening surcharge, chest accounting, payout caps, withdrawal paths and slice conversions otherwise hold against the Economic Security, Invariant and Flow Gap checklists. Results are in .imd-findings.json with coverage rows for all ten entry points plus five invariant and economics rows.

Finding 1, medium, with a proof test. Rewards are pushed mid-swap through payOut, which calls the PoolManager's take while the manager is unlocked. A move owner that is a contract (chosen freely via hookData) can, in its receive, open a 1 wei debt on the manager and return normally. The payout counts as paid, but the trader's unlock then fails with CurrencyNotSettled. Because the revert undoes the move, every later swap of that duel replays the same payout and reverts too, in both directions and for every trader, until the window's block hash expires (about 27 hours on mainnet), and the attacker can repeat it. Only native-ETH duels are exposed. The launch's own IMD/IMDUEL pool pays in ERC-20s and is not affected. The proof at test/scratch/PayoutCallbackBrick.t.sol fails on the current code: the griefer's resolving trade reverts, and two later honest trades of both teams revert, with nothing recorded as owed.

Finding 2, low. When no hookData is supplied, the move owner defaults to tx.origin, so bounties for trades made from smart accounts or through relayers go to the bundler or relayer, not the trader.

Finding 3, info. IMD slice batches have no size cap and price against the first main-duel swap of the block, which an attacker can supply after a prior-block push. The code documents this as accepted, and with the pile converting at 10 IMD it is not profitable today. The note records the state in which it would matter.

Not reached. Whether any legal position makes ChessEngineV5 revert at its 3M gas cap, which would strand that pool's chests since there is no admin path. That row is marked unreached.

The math audit of the IMDuelHook is complete and recorded in .imd-findings.json (2 findings, 16 coverage rows).

Outcome. The hook's value-moving arithmetic holds up under the Math Precision, Boundary and Numerical Gap checklists. I traced every fee, chest, bounty, batch and strength formula with concrete bounds and found no overflow, truncation, wrong-direction rounding or sign-loss path that reaches a loss of funds. The one reproducible defect is a boundary case in the slice conversion.

• Low, with a failing proof test. In _swapClaims the batch price limit is the reference sqrt price times 0.999 or 1.001, and the only guard is whether the pool is already past the band. Within 0.1% of v4's minimum or maximum sqrt price the limit lands outside v4's bounds and Pool.swap reverts with PriceLimitOutOfBounds. Inside a trade the try/catch hides it, but the public convert() reverts for everyone until the price moves back. The scratch test in test/scratch/Limit.t.sol fails on the current code with exactly PriceLimitOutOfBounds(4290833611). A clamp or an early (0, 0) return fixes it without touching the economics.
• Info. The ETH batch cap compares the truncated quotient amount / 10 with the minimum, so a pile between ten minimums and ten minimums plus 9 wei is sold whole. Up to 9 wei over the documented cap, no economic effect.

Verified as holding. The 0.5% split and the opening surcharge (2540 bps falling to 40 over 300 s, main duel only), the exact-input and exact-output delta accounting including the PartialFill equality, the int128 and uint128 casts (unreachable overflow because the manager's own SafeCast reverts first), the packed chest halves and the 2^128 cap, the bounty cap at twice the trade output, the mulDiv intermediates in _smallerChest and _trade, the strength curve's shifts and log2 fraction, the repetition ring's lane parity, and the manifest's nine constructor arguments, permissions and route-pool id (recomputed from the PoolKey hash, matches).

Test status. The sandbox cgroup caps memory at 1.5 GB, so a single via-IR solc run over the whole project is OOM-killed. Built in chunks, the Money, Slice, Launch and Bidding suites compile and all 50 tests pass, including both token orders and the ETH-paired launch. The Hostile, Invariant, InvariantDuels, Teams, WithdrawTo, Predict, LaunchAdmission, LaunchFiles, GasEstimate, HookGas, Size and Strength suites could not be compiled in the time available and are marked unreached in the coverage record.

No repository files were changed. The scratch test lives only under test/scratch/.