A Uniswap v4 hook that charges a fixed 5% fee on every swap.

Use a NonPayableOwner contract with deployHook(manager) and withdraw(currency) forwarding methods but no receive or fallback.

Have it deploy the hook; initialize an address(0)/ERC20 pool at 1:1, add native liquidity, and execute oneForZero exact input -1e14 so accruedFees(address(0)) > 0 (the same swap state as test_withdrawingNativeCurrency).

Call NonPayableOwner.withdraw(address(0)).

Expected: the deployer receives all accrued native fees.

Actual: PoolManager.take calls the nonpayable owner with ETH and reverts NativeTransferFailed; accruedFees and the hook's claims roll back and no other address can withdraw or redirect them.

Setup: a fresh PoolManager whose only pool is a 1:1 hooked pool (fee tier 3000, tickSpacing 60) with modifyLiquidity(tickLower: -60, tickUpper: 60, liquidityDelta: 1e3). Measured PoolManager balance afterwards: 3 base units of currency0. The trader is funded with far more than 1e18 of currency0 and has approved the router.

Submit an exact-input zeroForOne swap, amountSpecified = -1e18, sqrtPriceLimitX96 = MIN_SQRT_PRICE + 1. The hook computes feeAmount = 5e16 and calls poolManager.take(currency0, hook, 5e16); the manager holds 3, so the ERC20 transfer reverts with Panic(0x11), surfaced as CustomRevert.WrappedError (selector 0x90bfb865) and the whole swap reverts.

Control: the identical pool with no hook, same manager shape, same swap. Measured: it partially fills — BalanceDelta.amount0() == -5, BalanceDelta.amount1() == 2.

Expected: the hooked swap also partially fills, settling out of the input the trader supplies and charging 5% of what executed. Actual: no swap executes at all.

Initialize a hooked 1:1 full-range pool with liquidityDelta = 1e3 and no other pool using its currencies, leaving the PoolManager with roughly 1e3 currency0.

Submit an exact-input zeroForOne swap with amountSpecified = -1e18 from a trader funded for 1e18.

The computed fee is 5e16, so poolManager.take(currency0, hook, 5e16) fails because the manager has less than 5e16 before settlement and the whole swap reverts.

Expected: as in the same hookless pool, the swap can partially fill and settle from the trader's supplied input while charging 5% of what executes; actual: no swap executes.

Setup: PoolManager, pool (currency0/currency1, fee 3000, tickSpacing 60) with the hook, initialised at SQRT_PRICE_1_1, full-range liquidity 1e21.

(a) EXACT INPUT WITH A BINDING PRICE LIMIT. Call manager.swap(key, {zeroForOne: true, amountSpecified: -1e18, sqrtPriceLimitX96: spot - 1}, "").

actual: trader's BalanceDelta = (amount0 = -50000000000000002, amount1 = 0); hook.accruedFees(currency0) = 50000000000000000. The pool absorbed 2 base units; the trader paid 5e16 and received nothing at all.

expected: 5% of the 2 units actually swapped, i.e. 0.

(b) EXACT OUTPUT WITH A BINDING PRICE LIMIT. Same pool, {zeroForOne: true, amountSpecified: +1e18, sqrtPriceLimitX96: spot - 1}.

actual: BalanceDelta = (amount0 = -2, amount1 = -50000000000000000); hook.accruedFees(currency1) = 50000000000000000. The trader asked to buy 1e18 of currency1 and instead paid out 5e16 of currency1, receiving nothing.

expected: the trader is never made to pay the currency they are buying; fee = 5% of the ~0 that filled.

(c) ORDINARY SLIPPAGE GUARD. Pool with full-range liquidity 1e15 (deep hookless pool alongside it so the manager can cover the take). {zeroForOne: true, amountSpecified: -1e18, sqrtPriceLimitX96: spot * 995 / 1000} (~1% below spot).

actual: trader pays 50005040246367243 of currency0, of which 50000000000000000 is the hook fee and 5040246367243 was actually swapped; receives 5000000000000 of currency1. Effective fee rate on the executed trade ~992,000%.

expected: 5% of 5040246367243, i.e. 252012318367.

(d) NO PRICE LIMIT AT ALL. Pool with full-range liquidity ~1e15, sqrtPriceLimitX96 = MIN_SQRT_PRICE + 1 (what v4-periphery's router passes), exact output amountSpecified: +2e15 -- more currency1 than the pool holds.

actual: pool fills ~999999999999977, hook takes 100000000000000 (5% of the 2e15 requested), trader nets 899999999999977. The fee is ~10% of the swap that executed.

expected: 5% of the ~1e15 that executed, i.e. ~5e13.

Setup: pool (currency0/currency1, fee 3000, tickSpacing 60) with the hook, SQRT_PRICE_1_1, full-range liquidity 1e21.

Issue 10 exact-input swaps of amountSpecified = -19 (zeroForOne).

actual: hook.accruedFees(currency0) = 0. 190 base units moved through the pool for no fee.

Then issue one exact-input swap of amountSpecified = -190.

actual: hook.accruedFees(currency0) = 9.

expected: the same volume should cost the same either way -- 9 (or 10) in both cases, or the sub-threshold swap should revert rather than be free.

Threshold: any abs(amountSpecified) <= 19 is free, in both directions and for both exact-input and exact-output; abs(amountSpecified) == 20 is the first that charges (1 unit).

Setup: PoolManager, pool (currency0/currency1, fee 3000, tickSpacing 60) with the hook, SQRT_PRICE_1_1, full-range liquidity 1e3, and no other pool using currency0 -- so the manager holds ~1000 base units of currency0.

Call swap(key, zeroForOne: true, amountSpecified: -1e18, sqrtPriceLimitX96: MIN_SQRT_PRICE + 1).

actual: reverts. _beforeSwap computes feeAmount = 5e16 and calls poolManager.take, whose ERC20 transfer fails for want of balance; the failure is wrapped and rethrown by Hooks.callHook. hook.accruedFees(currency0) stays 0.

expected: the same swap against the same pool without the hook succeeds (it fills against the available liquidity at a poor price), so with the hook it should fill and be charged 5%, not revert.