Failed on the agent's machine.

• mediumExact-output sells are charged feeBps of the swapped input, not of the GAMMA the seller gives up: effective rate f/(1+f) (49.7% instead of 99% in the launch window)src/GammaHook.sol:141

  For an exact-input sell, beforeSwap takes feeBps of the whole GAMMA input and swaps the rest, so the Harvest receives feeBps of everything the seller gives up (99% of 1,000,000 GAMMA = 990,000 in the first minute). For an exact-output sell (GAMMA in, exact IMD out, amountSpecified > 0) nothing is charged in beforeSwap and afterSwap computes fee = |delta.gammaIn| * feeBps / BPS on the amount the pool consumed, then adds it on top via the unspecified return delta.

  The seller therefore pays I + fI in total and the Harvest gets fI, an effective rate of f/(1+f): 4974 bps instead of 9900 bps during the launch window, 291 bps instead of 300 bps at the floor. Anyone holding GAMMA at launch (the swarm's 10%, early buyers) can sell during the 99% sniper window by asking for an exact IMD amount and keep roughly half of what the schedule says belongs to the miners; the same IMD bought through an exact-input sell costs about 100x more GAMMA.

  The brief's guarantee ('sells: the fee is taken from the GAMMA input' at feeBps) is broken for one of the two sell shapes.

  Fix: for an exact-output sell compute the fee on the gross amount, fee = in * feeBps / (BPS - feeBps), or refuse exact-output sells as exact-output buys are refused.

  whole finding

  Fresh GAMMA/IMD pool at 1:1, game initialized, block.timestamp == hook.launchedAt() so feeBps() == 9900.

  1. Alice swaps exact-input: zeroForOne = gammaIs0, amountSpecified = -1_000_000e18. Harvest pot grows by 990_000e18 (99% of what Alice gave up); Alice receives X IMD.
  2. Bob swaps exact-output for the same X IMD: zeroForOne = gammaIs0, amountSpecified = +X. Expected: Bob gives up about the same GAMMA as Alice and 99% of it reaches the Harvest. Actual: Bob gives up about 1/50 of Alice's GAMMA and the Harvest receives 4974 bps of what he gave up (assertion '4974 !~= 9900'). Test: test/scratch/GammaHookExactOutSellFee.t.sol, test_exactOutputSellPaysTheFeeSchedule.

  whole reproduction
  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.26;
  
  import {Test} from "forge-std/Test.sol";
  import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
  import {ERC20} from "solmate/src/tokens/ERC20.sol";
  import {PoolManager} from "v4-core/src/PoolManager.sol";
  import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
  import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
  import {Hooks} from "v4-core/src/libraries/Hooks.sol";
  import {TickMath} from "v4-core/src/libraries/TickMath.sol";
  import {PoolKey} from "v4-core/src/types/PoolKey.sol";
  import {Currency} from "v4-core/src/types/Currency.sol";
  import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
  import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
  import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
  
  import {GammaGame} from "src/GammaGame.sol";
  import {GammaHook} from "src/GammaHook.sol";
  import {GammaToken} from "src/GammaToken.sol";
  import {IGammaBeacon} from "src/interfaces/IGammaBeacon.sol";
  
  contract ScratchBeacon is IGammaBeacon {
      mapping(uint64 => bytes32) public randomness;
  
      function genesis() external pure returns (uint64) {
          return 1727521075;
      }
  
      function period() external pure returns (uint64) {
          return 3;
      }
  
      function prove(uint64 round, bytes calldata signature) external returns (bytes32) {
          if (randomness[round] == bytes32(0)) randomness[round] = keccak256(signature);
          return randomness[round];
      }
  }
  
  /// @notice An exact-output sell (GAMMA in, exact IMD out) is charged feeBps of the GAMMA the pool consumed,
  /// not feeBps of the GAMMA the seller gives up. The seller's effective rate is f/(1+f): 49.7% instead of
  /// 99% in the launch window, 2.91% instead of 3% afterwards. The same IMD bought through an exact-input
  /// sell is charged the full schedule.
  contract GammaHookExactOutSellFeeTest is Test {
      uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
      uint24 constant LP_FEE = 12_500;
      int24 constant TICK_SPACING = 60;
  
      PoolManager manager;
      PoolModifyLiquidityTest lpRouter;
      PoolSwapTest swapRouter;
      MockERC20 imd;
      GammaToken gamma;
      ScratchBeacon beacon;
      GammaGame game;
      GammaHook hook;
      PoolKey key;
      bool gammaIs0;
  
      address alice = makeAddr("alice");
      address bob = makeAddr("bob");
  
      function setUp() public {
          vm.warp(1_760_000_000);
  
          manager = new PoolManager(address(this));
          lpRouter = new PoolModifyLiquidityTest(manager);
          swapRouter = new PoolSwapTest(manager);
          imd = new MockERC20("Identity.md", "IMD", 18);
          beacon = new ScratchBeacon();
          gamma = new GammaToken(address(this));
          game = new GammaGame(IPoolManager(address(manager)), ERC20(address(imd)), beacon, address(this));
  
          uint160 flags = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.AFTER_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG
              | Hooks.AFTER_SWAP_FLAG | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;
          address hookAddr = address(uint160(0x4444 << 144) | flags);
          deployCodeTo("GammaHook.sol:GammaHook", abi.encode(address(manager), address(imd), address(game)), hookAddr);
          hook = GammaHook(hookAddr);
  
          gammaIs0 = address(gamma) < address(imd);
          key = PoolKey({
              currency0: Currency.wrap(gammaIs0 ? address(gamma) : address(imd)),
              currency1: Currency.wrap(gammaIs0 ? address(imd) : address(gamma)),
              fee: LP_FEE,
              tickSpacing: TICK_SPACING,
              hooks: IHooks(hookAddr)
          });
          manager.initialize(key, SQRT_PRICE_1_1);
  
          gamma.transfer(address(game), game.RESERVE());
          imd.mint(address(this), 1_000_000_000e18);
          gamma.approve(address(lpRouter), type(uint256).max);
          imd.approve(address(lpRouter), type(uint256).max);
          lpRouter.modifyLiquidity(
              key,
              ModifyLiquidityParams({
                  tickLower: TickMath.minUsableTick(TICK_SPACING),
                  tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                  liquidityDelta: 100_000_000e18,
                  salt: 0
              }),
              ""
          );
          game.initialize(key);
  
          // Two sellers holding GAMMA at launch (e.g. the swarm's 10%).
          gamma.transfer(alice, 10_000_000e18);
          gamma.transfer(bob, 10_000_000e18);
      }
  
      function sellExactIn(address who, uint256 gammaIn) internal {
          vm.startPrank(who);
          gamma.approve(address(swapRouter), type(uint256).max);
          bool zeroForOne = gammaIs0;
          swapRouter.swap(
              key,
              SwapParams({
                  zeroForOne: zeroForOne,
                  amountSpecified: -int256(gammaIn),
                  sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
              }),
              PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
              ""
          );
          vm.stopPrank();
      }
  
      function sellExactOut(address who, uint256 imdOut) internal {
          vm.startPrank(who);
          gamma.approve(address(swapRouter), type(uint256).max);
          bool zeroForOne = gammaIs0;
          swapRouter.swap(
              key,
              SwapParams({
                  zeroForOne: zeroForOne,
                  amountSpecified: int256(imdOut),
                  sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
              }),
              PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
              ""
          );
          vm.stopPrank();
      }
  
      /// @dev In the first minute the fee is 99%. An exact-input seller of 1,000,000 GAMMA pays 990,000 to the
      /// Harvest. An exact-output seller asking for the same IMD gives up far less GAMMA and pays about half of
      /// what leaves their wallet, not 99% of it.
      function test_exactOutputSellPaysTheFeeSchedule() public {
          vm.warp(hook.launchedAt()); // launch window: 99%
          assertEq(hook.feeBps(), 9_900);
  
          uint256 d = game.today();
          uint256 potBefore = game.getDay(d).pot;
          uint256 aliceGammaBefore = gamma.balanceOf(alice);
          sellExactIn(alice, 1_000_000e18);
          uint256 imdGot = imd.balanceOf(alice);
          uint256 aliceFee = game.getDay(d).pot - potBefore;
          uint256 alicePaid = aliceGammaBefore - gamma.balanceOf(alice);
          assertEq(aliceFee, 990_000e18, "exact-input sell: 99% of the GAMMA given up");
          assertEq(alicePaid, 1_000_000e18);
  
          // Bob asks for exactly the IMD Alice received.
          potBefore = game.getDay(d).pot;
          uint256 bobGammaBefore = gamma.balanceOf(bob);
          sellExactOut(bob, imdGot);
          uint256 bobFee = game.getDay(d).pot - potBefore;
          uint256 bobPaid = bobGammaBefore - gamma.balanceOf(bob);
  
          // The schedule says 99% of what the seller gives up goes to the Harvest, whichever swap shape is used.
          uint256 bobRateBps = bobFee * 10_000 / bobPaid;
          assertApproxEqAbs(bobRateBps, 9_900, 50, "exact-output sell is charged f/(1+f), about 49.7%, not 99%");
          // And the same IMD should cost about the same GAMMA either way (modulo price impact of the first sell).
          assertGe(bobPaid * 10, alicePaid, "exact-output sell bought the same IMD for a tenth of the GAMMA");
      }
  }

  whole proof

• lowExact-input sells are charged feeBps of the whole requested input even when a price limit stops the swap after a sliversrc/GammaHook.sol:113

  beforeSwap charges the sell fee on params.amountSpecified, the amount the seller offered, and v4 then swaps only up to the seller's sqrtPriceLimitX96. When the limit is reached early the swapper's delta is the small swapped amount plus the full fee: the Harvest receives feeBps of GAMMA that was never traded. Exact-input buys, by contrast, are charged in afterSwap on the realised output.

  A seller using a protective price limit (or one whose limit is approached by a front-running sell in the same block) pays a fee many times the value traded; the GAMMA is not lost to an attacker but goes to the Harvest, so the seller cannot recover it.

  Fix: charge the sell fee in afterSwap on the realised GAMMA input (abs of the specified delta), as the exact-output path already does, or document that sells must use the pool's MIN/MAX limits.

  Pool at 1:1 with 1e26 full-range liquidity, game initialized, block.timestamp >= launchedAt + 96 minutes so feeBps() == 300.

  Alice holds 50,000,000e18 GAMMA and swaps exact-input: zeroForOne = gammaIs0, amountSpecified = -10_000_000e18, sqrtPriceLimitX96 = current price moved 1 bp towards the sell direction (price - price/10000 when gammaIs0, else price + price/10000).

  Expected: a fee of 3% of what was actually swapped.

  Actual: 10_126.58e18 GAMMA are swapped, but the Harvest pot grows by 300_000e18 (3% of the full 10M) and Alice's GAMMA balance falls by 310_126.58e18; the fee is ~30x the amount traded.

  Demonstrated by test/scratch/GammaHookLow.t.sol test_partialFillSellPaysFeeOnTheWholeInput (passes on current code, logging the two amounts).

  whole reproduction

• lowEvery non-game swap reverts until the configurator calls GammaGame.initialize: the pool is frozen, not 'held at 99%' as the brief sayssrc/GammaHook.sol:153

  _collect reports every fee to the game, and GammaGame.onHookFee (src/GammaGame.sol:309-311) reverts NotHook while game.hook is address(0) and FeeNotReceived while game.gamma is address(0); both are only set by initialize(key), which the configurator EOA calls after the hook launch. Until then every swap not sent by the game reverts (fee > 0 for any amount >= 2 wei), although feeBps() reports 9900 and the brief says the schedule is 'held at 99%' while genesis is unset.

  The decision to freeze is documented in ADAPTATION.md, but two consequences matter for the adapter: (1) trading start, and so the sniper fee window, is controlled by one externally owned key, which the brief's 'no owner-only functions' does not cover; (2) if initialize can never succeed (RESERVE 800_000_000e18 exactly equals the 80% remainder, so any shortfall of a single wei at the game, or a key that differs from the hook's poolId, makes ReserveNotFunded/BadPool permanent) the pool can never trade and the 10% seeded liquidity is stranded except through the game's own exempt swaps, which also need initialize.

  The adapter should verify the remainder sent to the game is >= RESERVE and have the configurator's initialize scripted immediately after the launch transaction.

  whole finding

  Deploy PoolManager, IMD mock, GammaToken, GammaGame(manager, imd, beacon, configurator) and GammaHook(manager, imd, game) at an address carrying the six flags; initialize the GAMMA/IMD pool at 1:1 and seed full-range liquidity; do NOT call game.initialize. hook.feeBps() returns 9900 and game.genesis() returns 0.

  Bob swaps exact-input 1_000e18 IMD for GAMMA through PoolSwapTest; Alice swaps exact-input 1_000e18 GAMMA for IMD.

  Expected per the brief: both trade and pay 99%.

  Actual: both revert (the PoolManager's WrappedError wrapping GammaGame.NotHook, selector 0xa9e35b2f).

  Demonstrated by test/scratch/GammaHookLow.t.sol test_poolFrozenUntilGameInitialize.

  whole reproduction

• lowSell fees are taken from the PoolManager's GAMMA balance before the seller settles: a sell whose fee exceeds the manager's GAMMA revertssrc/GammaHook.sol:152

  poolManager.take transfers GAMMA to the game immediately, inside beforeSwap (exact-input sells) or afterSwap (exact-output sells), before the swapper's router has settled its GAMMA input. The transfer is funded by whatever GAMMA the PoolManager already holds.

  GAMMA exists only in this pool, so once buys have moved most of the seeded GAMMA out of the manager, any sell whose fee (3% floor, up to 99% in the launch window) exceeds the remaining balance reverts in the ERC-20 transfer, although the sell itself would succeed and would refill the manager. Sellers must split into sizes whose fee fits the manager's current GAMMA balance, which no router does automatically.

  Fix: mint an ERC-6909 claim to the game (poolManager.mint) when the manager's balance is short, or take the fee in afterSwap only after checking currency.balanceOf(poolManager), as the launch reference describes for fees paid during the swap.

  whole finding

  Pool at 1:1 with 1e26 full-range liquidity, game initialized, block.timestamp >= launchedAt + 96 minutes (3% fee).

  Bob swaps exact-input 1e29 IMD for GAMMA (zeroForOne = !gammaIs0, limit MAX/MIN).

  The PoolManager is left holding 101_163.38e18 GAMMA.

  Alice (50,000,000e18 GAMMA) swaps exact-input 40_000_000e18 GAMMA for IMD with the pool's MIN/MAX price limit.

  Expected: the sell executes, fee 1_200_000e18 to the Harvest.

  Actual: the swap reverts inside poolManager.take (TRANSFER_FAILED: 1_200_000e18 > 101_163e18 held).

  A sell of 1_000e18 in the same state succeeds.

  Demonstrated by test/scratch/GammaHookLow.t.sol test_largeSellRevertsWhenManagerHoldsLessGammaThanTheFee.

  whole reproduction

• infoScope: contracts read, contracts not reachable, and checks that passedsrc/GammaHook.sol:20

  Read in full: src/GammaHook.sol (the audited hook), src/GammaGame.sol (fee recipient: initialize, onHookFee, unlockCallback, settlement and claim paths as they interact with the hook), src/GammaToken.sol, src/interfaces/IGammaGame.sol, src/interfaces/IGammaHook.sol, src/libraries/GammaEmission.sol (RESERVE = 800_000_000e18), test/utils/GammaFixture.sol, test/GammaHook.t.sol, launch/02-hook.json, launch/2215-game-manifest.json, README.md, the relevant parts of ADAPTATION.md, the three protected tests and lib/v4-core Hooks/PoolManager delta handling.

  Not reached: the live contracts on chain 4663 (PoolManager 0x8366a39cc670b4001a1121b8f6a443a643e40951, IMD 0x5f7bb59365ce557c26dbcaa4ee9d39a4b95b7127, the deployed GammaGame 0xb333a22c2c3dd0fe29fd1bf184c5ff2282148535): no RPC or fork was used, so their bytecode was assumed to match this tree's GammaGame (constructor args in launch/2215-game-manifest.json agree with the hook's expectations: genesis() and onHookFee(Currency,uint256)). src/DrandBeacon.sol, src/vendor/bls, frontend/ and script/ were not reviewed (not in the hook's call graph).

  Checks that passed on the hook: every callback is gated by onlyPoolManager; getHookPermissions matches the six declared flags and is validated in the constructor; beforeInitialize/afterInitialize bind exactly one IMD pool and return the right selectors; the unused callbacks revert; delta accounting nets to zero on every path (beforeSwapDelta +fee specified vs take, afterSwap +fee unspecified vs take); exact-output buys from anyone but the game revert; game-sent swaps are exempt; fee rounding favours the swapper by < 1 wei; no owner, mint, pause, blacklist, DELEGATECALL, SELFDESTRUCT, proxy or post-deploy configuration in the hook; GAMMA is a plain ERC-20 so no fee-on-transfer or reentrancy via the token; onHookFee is nonReentrant and only credits GAMMA that arrived.

  The constructor takes the PoolManager as its first argument, so the manifest must write it as $poolManager rather than the literal 0x8366... the brief quotes; imd and game are literal addresses in declaration order (poolManager, imd, game). The reference's preference for ETH/pair-side fees conflicts with the brief's 'fee always in GAMMA' and the brief wins, so it is not reported as a defect.

  whole finding

  Not a defect; the record of what was and was not inspected, required by the acceptance criteria.