// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";
import {HookFlags} from "src/HookFlags.sol";

contract PImd is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

contract PRouter is IUnlockCallback {
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    function swap(PoolKey memory key, SwapParams memory p) external returns (BalanceDelta d) {
        d = abi.decode(m.unlock(abi.encode(uint8(1), key, p)), (BalanceDelta));
    }
    function add(PoolKey memory key, ModifyLiquidityParams memory p) external {
        m.unlock(abi.encode(uint8(2), key, p));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        uint8 k = abi.decode(data, (uint8));
        BalanceDelta d; PoolKey memory key;
        if (k == 1) { SwapParams memory p; (, key, p) = abi.decode(data, (uint8, PoolKey, SwapParams)); d = m.swap(key, p, ""); }
        else { ModifyLiquidityParams memory p; (, key, p) = abi.decode(data, (uint8, PoolKey, ModifyLiquidityParams)); (d,) = m.modifyLiquidity(key, p, ""); }
        _s(key.currency0, d.amount0()); _s(key.currency1, d.amount1());
        return abi.encode(d);
    }
    function _s(Currency c, int128 a) private {
        if (a < 0) { m.sync(c); IERC20(Currency.unwrap(c)).transfer(address(m), uint128(-a)); m.settle(); }
        else if (a > 0) m.take(c, address(this), uint128(a));
    }
}

/// An exact-input buy that the price limit stops early is charged 2% of the requested input, not of what it paid.
contract PartialFillFeeTest is Test {
    uint160 constant FLAGS = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP
        | HookFlags.BEFORE_SWAP_RETURN_DELTA | HookFlags.AFTER_SWAP_RETURN_DELTA;

    function test_partialFillBuyChargedOnRequestedInput() public {
        PoolManager manager = new PoolManager(address(this));
        DeezToken token = new DeezToken();
        PImd imd = new PImd();
        bytes memory code = abi.encodePacked(type(DeezHook).creationCode, abi.encode(address(manager), address(token), address(imd)));
        DeezHook hook;
        for (uint256 i; i < 300_000; i++) {
            address pred = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), keccak256(code))))));
            if (!HookFlags.matches(pred, FLAGS)) continue;
            hook = new DeezHook{salt: bytes32(i)}(IPoolManager(address(manager)), address(token), address(imd));
            break;
        }
        bool t0 = address(token) < address(imd);
        PoolKey memory key = t0
            ? PoolKey(Currency.wrap(address(token)), Currency.wrap(address(imd)), 12_500, 60, IHooks(address(hook)))
            : PoolKey(Currency.wrap(address(imd)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, TickMath.getSqrtPriceAtTick(0));

        PRouter r = new PRouter(manager);
        token.transfer(address(r), 1_000_000 ether);
        imd.mint(address(r), 10_000_000 ether);
        r.add(key, ModifyLiquidityParams(-6000, 6000, 1_000_000 ether, 0));

        // Buy DEEZ with exact 1,000,000 IMD in, but with a price limit 60 ticks away (normal slippage protection).
        bool zeroForOne = !t0;
        uint160 limit = TickMath.getSqrtPriceAtTick(zeroForOne ? int24(-60) : int24(60));
        uint256 imdBefore = imd.balanceOf(address(r));
        r.swap(key, SwapParams(zeroForOne, -1_000_000 ether, limit));
        uint256 paid = imdBefore - imd.balanceOf(address(r));
        uint256 fee = hook.pendingFees();
        emit log_named_uint("trader paid", paid);
        emit log_named_uint("hook fee", fee);
        // Advertised: exactly 2% of what the trader pays.
        assertLe(fee, paid * 200 / 10_000 + 1, "fee exceeds 2% of what the trader paid");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezRewards} from "src/DeezRewards.sol";

contract Imd is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

/// @dev Stands in for the swarm's Merkle distributor: holds DEEZ, has no way to move any other token.
contract Distributor {}

contract ClaimForContractTest is Test {
    function test_thirdPartyCannotStrandShareOfContractHolder() public {
        vm.warp(10 days);
        DeezToken token = new DeezToken();
        Imd imd = new Imd();
        DeezRewards rewards = new DeezRewards(address(token), address(imd), address(0xBEEF1), address(0xBEEF2));
        Distributor dist = new Distributor();
        address holder = address(0xA11CE);
        token.transfer(address(dist), 100_000_000 ether); // swarm 10%
        token.transfer(holder, 900_000_000 ether);

        imd.mint(address(rewards), 1000 ether);
        rewards.accrue();
        uint256 epoch = rewards.currentEpoch();
        vm.warp(block.timestamp + 2 days);

        // Any third party pays the distributor's share to a contract that can never move it.
        uint256[] memory epochs = new uint256[](1);
        epochs[0] = epoch;
        vm.prank(address(0xBAD));
        try rewards.claim(address(dist), epochs) {} catch {}

        // The holder ends up with the full 10% that a contract which can't spend it would otherwise freeze.
        assertEq(imd.balanceOf(address(dist)), 0, "IMD stranded in non-claiming contract");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";

contract ScratchIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Minimal router paying from its own balance; lets the caller pick the price limit.
contract ScratchRouter is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, bool zeroForOne, int256 amountSpecified, uint160 limit)
        external
        returns (BalanceDelta)
    {
        return abi.decode(manager.unlock(abi.encode(uint8(1), key, SwapParams(zeroForOne, amountSpecified, limit))), (BalanceDelta));
    }

    function addLiquidity(PoolKey memory key, int24 lower, int24 upper, int256 liquidity) external {
        manager.unlock(abi.encode(uint8(2), key, lower, upper, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        uint8 kind = abi.decode(data, (uint8));
        PoolKey memory key;
        BalanceDelta delta;
        if (kind == 1) {
            SwapParams memory p;
            (, key, p) = abi.decode(data, (uint8, PoolKey, SwapParams));
            delta = manager.swap(key, p, "");
        } else {
            int24 lower;
            int24 upper;
            int256 liq;
            (, key, lower, upper, liq) = abi.decode(data, (uint8, PoolKey, int24, int24, int256));
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liq, bytes32(0)), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency c, int128 amount) private {
        if (amount < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(uint128(-amount)));
            manager.settle();
        } else if (amount > 0) {
            manager.take(c, address(this), uint256(uint128(amount)));
        }
    }
}

contract FeeOnRequestedAmountTest is Test {
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant SPACING = 60;

    PoolManager manager;
    DeezToken token;
    ScratchIMD imd;
    DeezHook hook;
    ScratchRouter router;
    PoolKey key;
    bool tokenIsCurrency0;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new DeezToken();
        imd = new ScratchIMD();
        tokenIsCurrency0 = address(token) < address(imd);

        bytes memory creation = abi.encodePacked(
            type(DeezHook).creationCode, abi.encode(IPoolManager(address(manager)), address(token), address(imd))
        );
        bytes32 h = keccak256(creation);
        for (uint256 i = 0; i < 500_000; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if ((uint160(p) & ((1 << 14) - 1)) == FLAGS && p.code.length == 0) {
                hook = new DeezHook{salt: bytes32(i)}(IPoolManager(address(manager)), address(token), address(imd));
                break;
            }
        }
        require(address(hook) != address(0), "no salt");

        (Currency c0, Currency c1) = tokenIsCurrency0
            ? (Currency.wrap(address(token)), Currency.wrap(address(imd)))
            : (Currency.wrap(address(imd)), Currency.wrap(address(token)));
        key = PoolKey(c0, c1, 12_500, SPACING, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);

        router = new ScratchRouter(manager);
        // The launch pool holds $DEEZ only, in the range just above the opening price.
        token.transfer(address(router), 100_000_000 ether);
        (int24 lower, int24 upper) = tokenIsCurrency0
            ? (SPACING, TickMath.maxUsableTick(SPACING))
            : (TickMath.minUsableTick(SPACING), -SPACING);
        router.addLiquidity(key, lower, upper, 1e24);
        imd.mint(address(router), 1_000_000 ether);
    }

    /// Exact-output sell of 1000 $IMD on a pool with no $IMD liquidity: the pool fills nothing, but the hook still
    /// charges 2/98 of the requested 1000 $IMD. The trader pays ~20.41 $IMD and receives nothing.
    function test_exactOutputSellThatFillsNothingStillChargesTheFee() public {
        uint256 imdBefore = imd.balanceOf(address(router));
        uint256 deezBefore = token.balanceOf(address(router));

        // sell = token in, IMD out: zeroForOne when token is currency0. Full price limit, as routers set it.
        bool zeroForOne = tokenIsCurrency0;
        uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        // A fix that refuses partial fills is acceptable: a revert here is a pass.
        try router.swap(key, zeroForOne, int256(1_000 ether), limit) {} catch { return; }

        uint256 imdPaid = imdBefore - imd.balanceOf(address(router));
        uint256 deezPaid = deezBefore - token.balanceOf(address(router));
        emit log_named_uint("DEEZ paid", deezPaid);
        emit log_named_uint("IMD paid (should be 0: nothing was received)", imdPaid);
        emit log_named_uint("hook pendingFees", hook.pendingFees());

        assertEq(deezPaid, 0, "pool swapped nothing");
        // A fee on a swap that moved nothing is wrong: the trader must not pay IMD on a sell that returned none.
        assertEq(imdPaid, 0, "trader charged a fee although no IMD was received");
        assertEq(hook.pendingFees(), 0);
    }

    /// Exact-input buy of 1000 $IMD with a price limit just above the opening price: the pool takes only part of
    /// the input, but the hook charges 2% of the full requested 1000 $IMD.
    function test_exactInputBuyPartialFillIsChargedOnTheRequestedInput() public {
        uint256 imdBefore = imd.balanceOf(address(router));
        bool zeroForOne = !tokenIsCurrency0; // IMD in, token out
        // Limit: the price right after the first liquidity tick, so the swap fills only a sliver.
        int24 limitTick = tokenIsCurrency0 ? int24(SPACING + 5) : int24(-SPACING - 5);
        uint160 limit = TickMath.getSqrtPriceAtTick(limitTick);
        // A fix that refuses partial fills is acceptable: a revert here is a pass.
        try router.swap(key, zeroForOne, -int256(1_000 ether), limit) {} catch { return; }
        uint256 imdPaid = imdBefore - imd.balanceOf(address(router));
        uint256 fee = hook.pendingFees();
        emit log_named_uint("IMD paid total", imdPaid);
        emit log_named_uint("IMD to the pool", imdPaid - fee);
        emit log_named_uint("hook fee", fee);
        // The fee must be 2% of what the trader actually paid in total (1 wei of rounding allowed).
        assertApproxEqAbs(fee, imdPaid * 200 / 10_000, 1, "fee is not 2% of the gross IMD actually paid");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";

contract PairToken is ERC20 {
    constructor() ERC20("IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Router that passes the caller's price limit through, as production routers do.
contract LimitRouter is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function swap(PoolKey memory key, SwapParams memory params) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, key, params, int24(0), int24(0))), (BalanceDelta));
    }

    function addLiquidity(PoolKey memory key, int24 lower, int24 upper, int256 liquidity) external {
        manager.unlock(abi.encode(false, key, SwapParams(false, liquidity, 0), lower, upper));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool isSwap, PoolKey memory key, SwapParams memory params, int24 lower, int24 upper) =
            abi.decode(data, (bool, PoolKey, SwapParams, int24, int24));
        BalanceDelta delta;
        if (isSwap) {
            delta = manager.swap(key, params, "");
        } else {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, params.amountSpecified, 0), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency currency, int128 amount) private {
        if (amount < 0) {
            manager.sync(currency);
            ERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(uint128(-amount)));
            manager.settle();
        } else if (amount > 0) {
            manager.take(currency, address(this), uint256(uint128(amount)));
        }
    }
}

/// @notice The hook must take 2% of the $IMD that actually changes hands. When a swap stops at the trader's
/// price limit, a fee computed in beforeSwap from the requested amount is charged on volume that never traded.
contract PartialFillFeeTest is Test {
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    PoolManager manager;
    DeezToken token;
    PairToken imd;
    DeezHook hook;
    LimitRouter router;
    PoolKey key;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new DeezToken();
        imd = new PairToken();
        tokenIs0 = address(token) < address(imd);
        bytes memory code =
            abi.encodePacked(type(DeezHook).creationCode, abi.encode(address(manager), address(token), address(imd)));
        bytes32 h = keccak256(code);
        for (uint256 i = 0;; i++) {
            address p =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if (uint160(p) & ((1 << 14) - 1) != FLAGS) continue;
            hook = new DeezHook{salt: bytes32(i)}(IPoolManager(address(manager)), address(token), address(imd));
            break;
        }
        (address c0, address c1) = tokenIs0 ? (address(token), address(imd)) : (address(imd), address(token));
        key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, TickMath.getSqrtPriceAtTick(0));
        router = new LimitRouter(manager);
        token.transfer(address(router), 1_000_000 ether);
        imd.mint(address(router), 1_000_000 ether);
        router.addLiquidity(key, -600, 600, 100_000 ether);
    }

    function test_exactInputBuyStoppedByPriceLimitIsChargedTwoPercentOfWhatTraded() public {
        bool zeroForOne = !tokenIs0; // buy: $IMD in
        int24 limitTick = zeroForOne ? int24(-5) : int24(5);
        uint256 requested = 10_000 ether;
        uint256 imdBefore = imd.balanceOf(address(router));
        router.swap(key, SwapParams(zeroForOne, -int256(requested), TickMath.getSqrtPriceAtTick(limitTick)));
        uint256 paid = imdBefore - imd.balanceOf(address(router));
        uint256 fee = hook.pendingFees();
        assertLt(paid, requested, "the swap stopped at the limit");
        // Expected: fee == 2% of the $IMD the trader actually paid. Actual: 2% of the requested input (200 IMD
        // of the ~225 IMD paid).
        assertApproxEqAbs(fee, paid * 200 / 10_000, 1, "fee is 2% of the IMD that changed hands");
    }

    function test_exactOutputSellStoppedByPriceLimitIsChargedTwoPercentOfWhatTraded() public {
        bool zeroForOne = tokenIs0; // sell: $DEEZ in, $IMD out
        int24 limitTick = zeroForOne ? int24(-5) : int24(5);
        uint256 requested = 10_000 ether;
        uint256 imdBefore = imd.balanceOf(address(router));
        router.swap(key, SwapParams(zeroForOne, int256(requested), TickMath.getSqrtPriceAtTick(limitTick)));
        int256 received = int256(imd.balanceOf(address(router))) - int256(imdBefore);
        uint256 fee = hook.pendingFees();
        // Expected: a seller never pays $IMD, and the fee is 2% of the gross $IMD the pool paid out.
        // Actual: the fee is 2/98 of the requested output, more than the pool paid out, so the seller pays $IMD too.
        assertGe(received, 0, "a sell never costs the seller IMD");
        assertLt(uint256(received), requested, "the swap stopped at the limit");
        assertApproxEqAbs(fee, (uint256(received) + fee) * 200 / 10_000, 1, "fee is 2% of the IMD that changed hands");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";

contract ScratchIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Minimal router paying from its own balance; lets the caller pick the price limit.
contract ScratchRouter is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, bool zeroForOne, int256 amountSpecified, uint160 limit)
        external
        returns (BalanceDelta)
    {
        return abi.decode(manager.unlock(abi.encode(uint8(1), key, SwapParams(zeroForOne, amountSpecified, limit))), (BalanceDelta));
    }

    function addLiquidity(PoolKey memory key, int24 lower, int24 upper, int256 liquidity) external {
        manager.unlock(abi.encode(uint8(2), key, lower, upper, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        uint8 kind = abi.decode(data, (uint8));
        PoolKey memory key;
        BalanceDelta delta;
        if (kind == 1) {
            SwapParams memory p;
            (, key, p) = abi.decode(data, (uint8, PoolKey, SwapParams));
            delta = manager.swap(key, p, "");
        } else {
            int24 lower;
            int24 upper;
            int256 liq;
            (, key, lower, upper, liq) = abi.decode(data, (uint8, PoolKey, int24, int24, int256));
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liq, bytes32(0)), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency c, int128 amount) private {
        if (amount < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(uint128(-amount)));
            manager.settle();
        } else if (amount > 0) {
            manager.take(c, address(this), uint256(uint128(amount)));
        }
    }
}

contract FeeOnRequestedAmountTest is Test {
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant SPACING = 60;

    PoolManager manager;
    DeezToken token;
    ScratchIMD imd;
    DeezHook hook;
    ScratchRouter router;
    PoolKey key;
    bool tokenIsCurrency0;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new DeezToken();
        imd = new ScratchIMD();
        tokenIsCurrency0 = address(token) < address(imd);

        bytes memory creation = abi.encodePacked(
            type(DeezHook).creationCode, abi.encode(IPoolManager(address(manager)), address(token), address(imd))
        );
        bytes32 h = keccak256(creation);
        for (uint256 i = 0; i < 500_000; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if ((uint160(p) & ((1 << 14) - 1)) == FLAGS && p.code.length == 0) {
                hook = new DeezHook{salt: bytes32(i)}(IPoolManager(address(manager)), address(token), address(imd));
                break;
            }
        }
        require(address(hook) != address(0), "no salt");

        (Currency c0, Currency c1) = tokenIsCurrency0
            ? (Currency.wrap(address(token)), Currency.wrap(address(imd)))
            : (Currency.wrap(address(imd)), Currency.wrap(address(token)));
        key = PoolKey(c0, c1, 12_500, SPACING, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);

        router = new ScratchRouter(manager);
        // The launch pool holds $DEEZ only, in the range just above the opening price.
        token.transfer(address(router), 100_000_000 ether);
        (int24 lower, int24 upper) = tokenIsCurrency0
            ? (SPACING, TickMath.maxUsableTick(SPACING))
            : (TickMath.minUsableTick(SPACING), -SPACING);
        router.addLiquidity(key, lower, upper, 1e24);
        imd.mint(address(router), 1_000_000 ether);
    }

    /// Exact-output sell of 1000 $IMD on a pool with no $IMD liquidity: the pool fills nothing, but the hook still
    /// charges 2/98 of the requested 1000 $IMD. The trader pays ~20.41 $IMD and receives nothing.
    function test_exactOutputSellThatFillsNothingStillChargesTheFee() public {
        uint256 imdBefore = imd.balanceOf(address(router));
        uint256 deezBefore = token.balanceOf(address(router));

        // sell = token in, IMD out: zeroForOne when token is currency0. Full price limit, as routers set it.
        bool zeroForOne = tokenIsCurrency0;
        uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        // A fix that refuses partial fills is acceptable: a revert here is a pass.
        try router.swap(key, zeroForOne, int256(1_000 ether), limit) {} catch { return; }

        uint256 imdPaid = imdBefore - imd.balanceOf(address(router));
        uint256 deezPaid = deezBefore - token.balanceOf(address(router));
        emit log_named_uint("DEEZ paid", deezPaid);
        emit log_named_uint("IMD paid (should be 0: nothing was received)", imdPaid);
        emit log_named_uint("hook pendingFees", hook.pendingFees());

        assertEq(deezPaid, 0, "pool swapped nothing");
        // A fee on a swap that moved nothing is wrong: the trader must not pay IMD on a sell that returned none.
        assertEq(imdPaid, 0, "trader charged a fee although no IMD was received");
        assertEq(hook.pendingFees(), 0);
    }

    /// Exact-input buy of 1000 $IMD with a price limit just above the opening price: the pool takes only part of
    /// the input, but the hook charges 2% of the full requested 1000 $IMD.
    function test_exactInputBuyPartialFillIsChargedOnTheRequestedInput() public {
        uint256 imdBefore = imd.balanceOf(address(router));
        bool zeroForOne = !tokenIsCurrency0; // IMD in, token out
        // Limit: the price right after the first liquidity tick, so the swap fills only a sliver.
        int24 limitTick = tokenIsCurrency0 ? int24(SPACING + 5) : int24(-SPACING - 5);
        uint160 limit = TickMath.getSqrtPriceAtTick(limitTick);
        // A fix that refuses partial fills is acceptable: a revert here is a pass.
        try router.swap(key, zeroForOne, -int256(1_000 ether), limit) {} catch { return; }
        uint256 imdPaid = imdBefore - imd.balanceOf(address(router));
        uint256 fee = hook.pendingFees();
        emit log_named_uint("IMD paid total", imdPaid);
        emit log_named_uint("IMD to the pool", imdPaid - fee);
        emit log_named_uint("hook fee", fee);
        // The fee must be 2% of what the trader actually paid in total (1 wei of rounding allowed).
        assertApproxEqAbs(fee, imdPaid * 200 / 10_000, 1, "fee is not 2% of the gross IMD actually paid");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezRewards} from "src/DeezRewards.sol";

contract Imd is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

/// @dev Stands in for the swarm's Merkle distributor: holds DEEZ, has no way to move any other token.
contract Distributor {}

contract ClaimForContractTest is Test {
    function test_thirdPartyCannotStrandShareOfContractHolder() public {
        vm.warp(10 days);
        DeezToken token = new DeezToken();
        Imd imd = new Imd();
        DeezRewards rewards = new DeezRewards(address(token), address(imd), address(0xBEEF1), address(0xBEEF2));
        Distributor dist = new Distributor();
        address holder = address(0xA11CE);
        token.transfer(address(dist), 100_000_000 ether); // swarm 10%
        token.transfer(holder, 900_000_000 ether);

        imd.mint(address(rewards), 1000 ether);
        rewards.accrue();
        uint256 epoch = rewards.currentEpoch();
        vm.warp(block.timestamp + 2 days);

        // Any third party pays the distributor's share to a contract that can never move it.
        uint256[] memory epochs = new uint256[](1);
        epochs[0] = epoch;
        vm.prank(address(0xBAD));
        try rewards.claim(address(dist), epochs) {} catch {}

        // The holder ends up with the full 10% that a contract which can't spend it would otherwise freeze.
        assertEq(imd.balanceOf(address(dist)), 0, "IMD stranded in non-claiming contract");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezRewards} from "src/DeezRewards.sol";

contract ProofIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @notice A holder who claims an ended epoch before the hook has harvested all of that epoch's fees never
/// receives its share of the rest: `DeezHook.harvest()` credits the previous epoch's fees to that epoch through
/// `DeezRewards.credit`, but `claimed[epoch][account]` is a bool, so the early claimer is refused for good.
/// This test plays the hook (the only `credit` caller) to keep the proof self-contained.
contract LateCreditProof is Test {
    uint256 constant EPOCH = 1 days;
    uint256 constant START = 100;

    DeezToken token;
    ProofIMD imd;
    DeezRewards rewards;
    address poolManager = address(0x9001);
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    function setUp() public {
        vm.warp(START * EPOCH);
        token = new DeezToken();
        imd = new ProofIMD();
        rewards = new DeezRewards(address(token), address(imd), poolManager, address(this));
        token.transfer(poolManager, 900_000_000 ether);
        token.transfer(alice, 75_000_000 ether); // 75% of the eligible supply all epoch
        token.transfer(bob, 25_000_000 ether); // 25%
    }

    /// @dev What DeezHook._harvest does: transfer the $IMD in, then credit it to the epoch it was traded in.
    function harvestAsHook(uint256 epoch, uint256 amount) internal {
        imd.mint(address(rewards), amount);
        rewards.credit(epoch, amount);
    }

    function claim(address account, uint256 epoch) internal returns (uint256) {
        uint256[] memory list = new uint256[](1);
        list[0] = epoch;
        vm.prank(account);
        return rewards.claim(account, list);
    }

    function test_earlyClaimerReceivesItsShareOfFeesHarvestedLater() public {
        // Midday harvest: 100 IMD of epoch START's fees reach its pot.
        vm.warp(START * EPOCH + 12 hours);
        harvestAsHook(START, 100 ether);
        // Another 100 IMD of fees are traded later in epoch START and sit in the hook unharvested.

        // First second of the next epoch: alice claims epoch START at once.
        vm.warp((START + 1) * EPOCH);
        assertEq(claim(alice, START), 75 ether);

        // Anyone then calls harvest(), which credits the late fees to epoch START, as designed.
        harvestAsHook(START, 100 ether);
        assertEq(claim(bob, START), 50 ether, "bob, claiming after the harvest, gets 25% of all 200");

        // Alice held 75% of the eligible supply for the whole epoch, so she is owed 75% of the 200 IMD of fees
        // traded in it. She can never get the second 75: a second claim reverts AlreadyClaimed.
        uint256[] memory list = new uint256[](1);
        list[0] = START;
        vm.prank(alice);
        try rewards.claim(alice, list) {} catch {}
        assertEq(imd.balanceOf(alice), 150 ether, "alice is paid 75% of every fee traded in the epoch");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";
import {DeezRewards} from "src/DeezRewards.sol";

contract ScratchIMD is ERC20 {
    constructor() ERC20("IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Minimal router paying from its own balance; lets the caller pick the price limit.
contract ScratchRouter is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, bool zeroForOne, int256 amountSpecified, uint160 limit)
        external
        returns (BalanceDelta)
    {
        return abi.decode(manager.unlock(abi.encode(uint8(1), key, SwapParams(zeroForOne, amountSpecified, limit))), (BalanceDelta));
    }

    function addLiquidity(PoolKey memory key, int24 lower, int24 upper, int256 liquidity) external {
        manager.unlock(abi.encode(uint8(2), key, lower, upper, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        uint8 kind = abi.decode(data, (uint8));
        PoolKey memory key;
        BalanceDelta delta;
        if (kind == 1) {
            SwapParams memory p;
            (, key, p) = abi.decode(data, (uint8, PoolKey, SwapParams));
            delta = manager.swap(key, p, "");
        } else {
            int24 lower;
            int24 upper;
            int256 liq;
            (, key, lower, upper, liq) = abi.decode(data, (uint8, PoolKey, int24, int24, int256));
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liq, bytes32(0)), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency c, int128 amount) private {
        if (amount < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(manager), uint256(uint128(-amount)));
            manager.settle();
        } else if (amount > 0) {
            manager.take(c, address(this), uint256(uint128(amount)));
        }
    }
}

contract LateHarvestProof is Test {
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant SPACING = 60;

    PoolManager manager;
    DeezToken token;
    ScratchIMD imd;
    DeezHook hook;
    ScratchRouter router;
    PoolKey key;
    bool tokenIsCurrency0;

    function setUp() public {
        vm.warp(START * 1 days);
        manager = new PoolManager(address(this));
        token = new DeezToken();
        imd = new ScratchIMD();
        tokenIsCurrency0 = address(token) < address(imd);

        bytes memory creation = abi.encodePacked(
            type(DeezHook).creationCode, abi.encode(IPoolManager(address(manager)), address(token), address(imd))
        );
        bytes32 h = keccak256(creation);
        for (uint256 i = 0; i < 500_000; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if ((uint160(p) & ((1 << 14) - 1)) == FLAGS && p.code.length == 0) {
                hook = new DeezHook{salt: bytes32(i)}(IPoolManager(address(manager)), address(token), address(imd));
                break;
            }
        }
        require(address(hook) != address(0), "no salt");

        (Currency c0, Currency c1) = tokenIsCurrency0
            ? (Currency.wrap(address(token)), Currency.wrap(address(imd)))
            : (Currency.wrap(address(imd)), Currency.wrap(address(token)));
        key = PoolKey(c0, c1, 12_500, SPACING, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);

        router = new ScratchRouter(manager);
        // The launch pool holds $DEEZ only, in the range just above the opening price.
        token.transfer(address(router), 100_000_000 ether);
        token.transfer(alice, 75_000_000 ether);
        token.transfer(bob, 25_000_000 ether);
        token.transfer(address(manager), token.balanceOf(address(this)));
        (int24 lower, int24 upper) = tokenIsCurrency0
            ? (SPACING, TickMath.maxUsableTick(SPACING))
            : (TickMath.minUsableTick(SPACING), -SPACING);
        router.addLiquidity(key, lower, upper, 1e24);
        imd.mint(address(router), 1_000_000 ether);
    }


    uint256 constant START = 20_000;
    address alice = address(0xA11CE);
    address bob = address(0xB0B);

    function buy(uint256 amountIn) internal {
        bool zeroForOne = !tokenIsCurrency0;
        uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        router.swap(key, zeroForOne, -int256(amountIn), limit);
    }

    function claimOne(address account, uint256 epoch) internal returns (uint256 paid) {
        uint256[] memory list = new uint256[](1);
        list[0] = epoch;
        DeezRewards rewards = hook.rewards();
        vm.prank(account);
        try rewards.claim(account, list) returns (uint256 p) { paid = p; } catch {}
    }

    /// Fees of epoch START traded after the last harvest are credited to epoch START by the next harvest(),
    /// but a holder who already claimed START (bool `claimed`) can never collect its share of them.
    function test_earlyClaimerLosesFeesHarvestedIntoTheEpochLater() public {
        DeezRewards rewards = hook.rewards();
        vm.warp(START * 1 days + 12 hours);
        buy(5_000 ether); // fee 100 IMD
        hook.harvest();
        vm.warp(START * 1 days + 23 hours);
        buy(5_000 ether); // another 100 IMD, traded in epoch START, still pending in the hook
        assertEq(hook.pendingFeesOf(START), 100 ether);

        vm.warp((START + 1) * 1 days); // first second of the next epoch
        uint256 first = claimOne(alice, START);
        hook.harvest(); // credits the pending 100 IMD to epoch START, as designed
        (uint128 total,,,) = rewards.pots(START);
        assertEq(uint256(total), 200 ether);

        uint256 owed = uint256(total) * rewards.weightOf(alice, START) / rewards.eligibleSupplyAt(START);
        uint256 second = claimOne(alice, START); // reverts AlreadyClaimed: caught, pays 0
        emit log_named_uint("alice first claim", first);
        emit log_named_uint("alice second claim", second);
        emit log_named_uint("alice owed for the epoch", owed);
        assertApproxEqAbs(first + second, owed, 1e6, "early claimer must receive its share of every fee of the epoch");
    }
}