// 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/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";

import {UnlockV2Token} from "src/UnlockV2Token.sol";
import {UnlockV2Hook} from "src/UnlockV2Hook.sol";
import {MigrationVault} from "src/MigrationVault.sol";
import {RewardPot} from "src/RewardPot.sol";

contract ScratchERC20 is ERC20 {
    constructor(string memory n, string memory s) ERC20(n, s) {}

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

contract ScratchFeed {
    uint8 public decimals = 8;
    int256 public answer;
    uint256 public updatedAt;

    function set(int256 a, uint256 t) external {
        answer = a;
        updatedAt = t;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @dev Anyone: settles 1 wei of IMD into the PoolManager and mints the ERC-6909 claim to the hook.
contract ClaimDonor is IUnlockCallback {
    IPoolManager immutable manager;
    ScratchERC20 immutable imd;
    address immutable target;

    constructor(IPoolManager m, ScratchERC20 i, address t) {
        manager = m;
        imd = i;
        target = t;
    }

    function donate() external {
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        Currency c = Currency.wrap(address(imd));
        manager.sync(c);
        imd.transfer(address(manager), 1);
        manager.settle();
        manager.mint(target, c.toId(), 1);
        return "";
    }
}

contract DonationBricksRedeemTest is Test {
    address constant OWNER = 0x48E4E74fE1d0c14404cEB57B9fec5b21329C6ec9;
    uint160 constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
        | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    ScratchERC20 imd;
    ScratchERC20 v1;
    ScratchFeed feed;
    UnlockV2Token token;
    UnlockV2Hook hook;
    RewardPot pot;
    PoolKey key;
    PoolKey refKey;
    bool tokenIs0;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_700_000_000);
        vm.roll(20_000_000);
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new ScratchERC20("IMD", "IMD");
        v1 = new ScratchERC20("UNLOCK", "UNLK");
        feed = new ScratchFeed();
        feed.set(3000e8, block.timestamp);

        token = new UnlockV2Token(); // this test is the launch factory
        address hookAddr = address(uint160(uint160(0x1234) << 20) | FLAGS);
        deployCodeTo(
            "UnlockV2Hook.sol:UnlockV2Hook",
            abi.encode(
                IPoolManager(address(manager)),
                address(token),
                address(imd),
                address(this),
                OWNER,
                address(v1),
                address(feed),
                block.chainid
            ),
            hookAddr
        );
        hook = UnlockV2Hook(hookAddr);
        pot = hook.rewardPot();

        tokenIs0 = address(token) < address(imd);
        key = PoolKey(
            Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            12500,
            60,
            IHooks(hookAddr)
        );
        refKey = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(imd)), 10000, 200, IHooks(address(0)));

        imd.mint(address(this), 1e30);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1000 ether);

        int24 t = tokenIs0 ? int24(-92100) : int24(92100);
        manager.initialize(key, TickMath.getSqrtPriceAtTick(t));
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(t - 6000, t + 6000, 1e24, 0), "");
        manager.initialize(refKey, TickMath.getSqrtPriceAtTick(80000));
        lpRouter.modifyLiquidity{value: 10 ether}(refKey, ModifyLiquidityParams(79000, 81000, 1e21, 0), "");

        token.transfer(OWNER, 750_000_000e18);
        token.transfer(alice, 1e18);
        vm.startPrank(OWNER);
        token.transfer(address(hook.migrationVault()), 700_000_000e18);
        hook.activate();
        vm.stopPrank();
    }

    function test_oneWeiClaimDonationLocksRewardsForever() public {
        // alice burns 1 UNLK2 -> the only points holder
        vm.prank(alice);
        token.burn(1e18);

        // bob buys with 1,000 IMD exact input: the hook earns a 10 IMD reward fee for alice
        imd.mint(bob, 1_000e18);
        vm.startPrank(bob);
        imd.approve(address(swapRouter), type(uint256).max);
        bool zeroForOne = !tokenIs0;
        swapRouter.swap(
            key,
            SwapParams(zeroForOne, -1_000e18, zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        vm.stopPrank();
        assertEq(pot.totalAccrued(), 10e18);
        assertEq(hook.pendingFees(), 10e18);

        // attacker gives the hook a 1-wei IMD ERC-6909 claim (costs 1 wei IMD + gas)
        imd.mint(attacker, 1);
        ClaimDonor donor = new ClaimDonor(manager, imd, address(hook));
        vm.prank(attacker);
        imd.transfer(address(donor), 1);
        donor.donate();
        assertEq(hook.pendingFees(), 10e18 + 1);

        // after the epoch closes alice should be able to claim her ~10 IMD
        vm.warp(block.timestamp + 8 days);
        feed.set(3000e8, block.timestamp);
        vm.prank(alice);
        uint256 paid = pot.claim(); // reverts RedeemExceedsAccrued on the current code
        assertGt(paid, 9.99e18);
        assertEq(imd.balanceOf(alice), 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/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";

import {UnlockV2Token} from "src/UnlockV2Token.sol";
import {UnlockV2Hook} from "src/UnlockV2Hook.sol";
import {MigrationVault} from "src/MigrationVault.sol";
import {RewardPot} from "src/RewardPot.sol";

contract ScratchERC20 is ERC20 {
    constructor(string memory n, string memory s) ERC20(n, s) {}

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

contract ScratchFeed {
    uint8 public decimals = 8;
    int256 public answer;
    uint256 public updatedAt;

    function set(int256 a, uint256 t) external {
        answer = a;
        updatedAt = t;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @dev Anyone: settles 1 wei of IMD into the PoolManager and mints the ERC-6909 claim to the hook.
contract ClaimDonor is IUnlockCallback {
    IPoolManager immutable manager;
    ScratchERC20 immutable imd;
    address immutable target;

    constructor(IPoolManager m, ScratchERC20 i, address t) {
        manager = m;
        imd = i;
        target = t;
    }

    function donate() external {
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        Currency c = Currency.wrap(address(imd));
        manager.sync(c);
        imd.transfer(address(manager), 1);
        manager.settle();
        manager.mint(target, c.toId(), 1);
        return "";
    }
}

contract PartialFillFeeTest is Test {
    address constant OWNER = 0x48E4E74fE1d0c14404cEB57B9fec5b21329C6ec9;
    uint160 constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
        | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    ScratchERC20 imd;
    ScratchERC20 v1;
    ScratchFeed feed;
    UnlockV2Token token;
    UnlockV2Hook hook;
    RewardPot pot;
    PoolKey key;
    PoolKey refKey;
    bool tokenIs0;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_700_000_000);
        vm.roll(20_000_000);
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new ScratchERC20("IMD", "IMD");
        v1 = new ScratchERC20("UNLOCK", "UNLK");
        feed = new ScratchFeed();
        feed.set(3000e8, block.timestamp);

        token = new UnlockV2Token(); // this test is the launch factory
        address hookAddr = address(uint160(uint160(0x1234) << 20) | FLAGS);
        deployCodeTo(
            "UnlockV2Hook.sol:UnlockV2Hook",
            abi.encode(
                IPoolManager(address(manager)),
                address(token),
                address(imd),
                address(this),
                OWNER,
                address(v1),
                address(feed),
                block.chainid
            ),
            hookAddr
        );
        hook = UnlockV2Hook(hookAddr);
        pot = hook.rewardPot();

        tokenIs0 = address(token) < address(imd);
        key = PoolKey(
            Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            12500,
            60,
            IHooks(hookAddr)
        );
        refKey = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(imd)), 10000, 200, IHooks(address(0)));

        imd.mint(address(this), 1e30);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1000 ether);

        int24 t = tokenIs0 ? int24(-92100) : int24(92100);
        manager.initialize(key, TickMath.getSqrtPriceAtTick(t));
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(t - 6000, t + 6000, 1e24, 0), "");
        manager.initialize(refKey, TickMath.getSqrtPriceAtTick(80000));
        lpRouter.modifyLiquidity{value: 10 ether}(refKey, ModifyLiquidityParams(79000, 81000, 1e21, 0), "");

        token.transfer(OWNER, 750_000_000e18);
        token.transfer(alice, 1e18);
        vm.startPrank(OWNER);
        token.transfer(address(hook.migrationVault()), 700_000_000e18);
        hook.activate();
        vm.stopPrank();
    }

    function test_partialFillPaysFeeOnUnexecutedAmount() public {
        imd.mint(bob, 1_000e18);
        vm.startPrank(bob);
        imd.approve(address(swapRouter), type(uint256).max);
        bool zeroForOne = !tokenIs0;
        int24 t = tokenIs0 ? int24(-92100) : int24(92100);
        uint160 limit = TickMath.getSqrtPriceAtTick(zeroForOne ? t - 60 : t + 60);
        uint256 before = imd.balanceOf(bob);
        swapRouter.swap(key, SwapParams(zeroForOne, -1_000e18, limit), PoolSwapTest.TestSettings(false, false), "");
        vm.stopPrank();
        uint256 paid = before - imd.balanceOf(bob);
        uint256 fee = hook.pendingFees();
        uint256 executed = paid - fee;
        emit log_named_uint("paid", paid);
        emit log_named_uint("fee", fee);
        // reward fee should be 1% of the executed IMD leg (rounded down)
        assertLe(fee, executed / 100 + 1);
    }
}

// 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/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";

import {UnlockV2Token} from "src/UnlockV2Token.sol";
import {UnlockV2Hook} from "src/UnlockV2Hook.sol";
import {MigrationVault} from "src/MigrationVault.sol";
import {RewardPot} from "src/RewardPot.sol";

contract ScratchERC20 is ERC20 {
    constructor(string memory n, string memory s) ERC20(n, s) {}

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

contract ScratchFeed {
    int256 public answer;
    uint256 public updatedAt;

    function set(int256 a, uint256 t) external {
        answer = a;
        updatedAt = t;
    }

    function decimals() external pure returns (uint8) {
        return 8;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @dev Unprivileged attacker: mints 1 wei of IMD ERC-6909 claims to the hook and pays for it.
contract ClaimDonor is IUnlockCallback {
    IPoolManager immutable manager;
    IERC20 immutable imd;

    constructor(IPoolManager m, IERC20 t) {
        manager = m;
        imd = t;
    }

    function donate(address to, uint256 amount) external {
        manager.unlock(abi.encode(to, amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address to, uint256 amount) = abi.decode(data, (address, uint256));
        Currency c = Currency.wrap(address(imd));
        manager.mint(to, c.toId(), amount);
        manager.sync(c);
        imd.transfer(address(manager), amount);
        manager.settle();
        return "";
    }
}

contract RedeemDonationDosTest is Test {
    address constant OWNER = 0x48E4E74fE1d0c14404cEB57B9fec5b21329C6ec9;
    uint160 constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
        | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    ScratchERC20 imd;
    ScratchERC20 v1;
    ScratchFeed feed;
    UnlockV2Token token;
    UnlockV2Hook hook;
    MigrationVault vault;
    RewardPot pot;
    PoolKey key;
    PoolKey refKey;
    bool tokenIs0;

    address alice = makeAddr("alice");
    address attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_700_000_000);
        vm.roll(20_000_000);
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new ScratchERC20("IMD", "IMD");
        v1 = new ScratchERC20("UNLOCK", "UNLK");
        feed = new ScratchFeed();
        feed.set(3000e8, block.timestamp);

        token = new UnlockV2Token();
        address hookAddr = address(uint160(uint160(0x1234) << 20) | FLAGS);
        bytes memory args = abi.encode(
            IPoolManager(address(manager)),
            address(token),
            address(imd),
            address(this),
            OWNER,
            address(v1),
            address(feed),
            block.chainid
        );
        deployCodeTo("UnlockV2Hook.sol:UnlockV2Hook", args, hookAddr);
        hook = UnlockV2Hook(hookAddr);
        vault = hook.migrationVault();
        pot = hook.rewardPot();

        tokenIs0 = address(token) < address(imd);
        key = PoolKey({
            currency0: Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            currency1: Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            fee: 12500,
            tickSpacing: 60,
            hooks: IHooks(hookAddr)
        });
        refKey = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(imd)),
            fee: 10000,
            tickSpacing: 200,
            hooks: IHooks(address(0))
        });

        imd.mint(address(this), 1e30);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1000 ether);

        int24 t = tokenIs0 ? int24(-92100) : int24(92100);
        manager.initialize(key, TickMath.getSqrtPriceAtTick(t));
        lpRouter.modifyLiquidity(
            key, ModifyLiquidityParams({tickLower: t - 6000, tickUpper: t + 6000, liquidityDelta: 1e24, salt: 0}), ""
        );
        manager.initialize(refKey, TickMath.getSqrtPriceAtTick(80000));
        lpRouter.modifyLiquidity{value: 10 ether}(
            refKey, ModifyLiquidityParams({tickLower: 79000, tickUpper: 81000, liquidityDelta: 1e21, salt: 0}), ""
        );

        token.transfer(OWNER, 750_000_000e18);
        vm.startPrank(OWNER);
        token.transfer(address(vault), 700_000_000e18);
        hook.activate();
        vm.stopPrank();
    }

    function _buy(address who, int256 amountSpecified) internal {
        bool zeroForOne = !tokenIs0;
        vm.prank(who);
        swapRouter.swap(
            key,
            SwapParams({
                zeroForOne: zeroForOne,
                amountSpecified: amountSpecified,
                sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    /// Fails on the current code: after a 1-wei ERC-6909 donation to the hook, redeemFees() reverts
    /// with RewardPot.RedeemExceedsAccrued forever, so earned reward fees never reach the pot.
    function test_redeemFeesSurvivesClaimDonation() public {
        // attacker (no role) mints 1 wei of IMD claim tokens to the hook
        ClaimDonor donor = new ClaimDonor(manager, IERC20(address(imd)));
        imd.mint(address(donor), 1);
        donor.donate(address(hook), 1);
        assertEq(hook.pendingFees(), 1);

        // honest trading earns a real reward fee
        imd.mint(alice, 1_000e18);
        vm.prank(alice);
        imd.approve(address(swapRouter), type(uint256).max);
        _buy(alice, -100e18);
        uint256 accrued = pot.totalAccrued();
        assertGt(accrued, 0);

        // expected: the attributed fees can be moved to the pot
        vm.prank(attacker);
        hook.redeemFees();
        assertGe(imd.balanceOf(address(pot)), accrued);
    }
}

// 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/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";

import {UnlockV2Token} from "src/UnlockV2Token.sol";
import {UnlockV2Hook} from "src/UnlockV2Hook.sol";
import {MigrationVault} from "src/MigrationVault.sol";
import {RewardPot} from "src/RewardPot.sol";

contract ScratchERC20 is ERC20 {
    constructor(string memory n, string memory s) ERC20(n, s) {}

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

contract ScratchFeed {
    uint8 public decimals = 8;
    int256 public answer;
    uint256 public updatedAt;

    function set(int256 a, uint256 t) external {
        answer = a;
        updatedAt = t;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @dev Anyone: settles 1 wei of IMD into the PoolManager and mints the ERC-6909 claim to the hook.
contract ClaimDonor is IUnlockCallback {
    IPoolManager immutable manager;
    ScratchERC20 immutable imd;
    address immutable target;

    constructor(IPoolManager m, ScratchERC20 i, address t) {
        manager = m;
        imd = i;
        target = t;
    }

    function donate() external {
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        Currency c = Currency.wrap(address(imd));
        manager.sync(c);
        imd.transfer(address(manager), 1);
        manager.settle();
        manager.mint(target, c.toId(), 1);
        return "";
    }
}

contract DonationBricksRedeemTest is Test {
    address constant OWNER = 0x48E4E74fE1d0c14404cEB57B9fec5b21329C6ec9;
    uint160 constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
        | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    ScratchERC20 imd;
    ScratchERC20 v1;
    ScratchFeed feed;
    UnlockV2Token token;
    UnlockV2Hook hook;
    RewardPot pot;
    PoolKey key;
    PoolKey refKey;
    bool tokenIs0;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_700_000_000);
        vm.roll(20_000_000);
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new ScratchERC20("IMD", "IMD");
        v1 = new ScratchERC20("UNLOCK", "UNLK");
        feed = new ScratchFeed();
        feed.set(3000e8, block.timestamp);

        token = new UnlockV2Token(); // this test is the launch factory
        address hookAddr = address(uint160(uint160(0x1234) << 20) | FLAGS);
        deployCodeTo(
            "UnlockV2Hook.sol:UnlockV2Hook",
            abi.encode(
                IPoolManager(address(manager)),
                address(token),
                address(imd),
                address(this),
                OWNER,
                address(v1),
                address(feed),
                block.chainid
            ),
            hookAddr
        );
        hook = UnlockV2Hook(hookAddr);
        pot = hook.rewardPot();

        tokenIs0 = address(token) < address(imd);
        key = PoolKey(
            Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            12500,
            60,
            IHooks(hookAddr)
        );
        refKey = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(imd)), 10000, 200, IHooks(address(0)));

        imd.mint(address(this), 1e30);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1000 ether);

        int24 t = tokenIs0 ? int24(-92100) : int24(92100);
        manager.initialize(key, TickMath.getSqrtPriceAtTick(t));
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(t - 6000, t + 6000, 1e24, 0), "");
        manager.initialize(refKey, TickMath.getSqrtPriceAtTick(80000));
        lpRouter.modifyLiquidity{value: 10 ether}(refKey, ModifyLiquidityParams(79000, 81000, 1e21, 0), "");

        token.transfer(OWNER, 750_000_000e18);
        token.transfer(alice, 1e18);
        vm.startPrank(OWNER);
        token.transfer(address(hook.migrationVault()), 700_000_000e18);
        hook.activate();
        vm.stopPrank();
    }

    function test_oneWeiClaimDonationLocksRewardsForever() public {
        // alice burns 1 UNLK2 -> the only points holder
        vm.prank(alice);
        token.burn(1e18);

        // bob buys with 1,000 IMD exact input: the hook earns a 10 IMD reward fee for alice
        imd.mint(bob, 1_000e18);
        vm.startPrank(bob);
        imd.approve(address(swapRouter), type(uint256).max);
        bool zeroForOne = !tokenIs0;
        swapRouter.swap(
            key,
            SwapParams(zeroForOne, -1_000e18, zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        vm.stopPrank();
        assertEq(pot.totalAccrued(), 10e18);
        assertEq(hook.pendingFees(), 10e18);

        // attacker gives the hook a 1-wei IMD ERC-6909 claim (costs 1 wei IMD + gas)
        imd.mint(attacker, 1);
        ClaimDonor donor = new ClaimDonor(manager, imd, address(hook));
        vm.prank(attacker);
        imd.transfer(address(donor), 1);
        donor.donate();
        assertEq(hook.pendingFees(), 10e18 + 1);

        // after the epoch closes alice should be able to claim her ~10 IMD
        vm.warp(block.timestamp + 8 days);
        feed.set(3000e8, block.timestamp);
        vm.prank(alice);
        uint256 paid = pot.claim(); // reverts RedeemExceedsAccrued on the current code
        assertGt(paid, 9.99e18);
        assertEq(imd.balanceOf(alice), 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/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";

import {UnlockV2Token} from "src/UnlockV2Token.sol";
import {UnlockV2Hook} from "src/UnlockV2Hook.sol";
import {MigrationVault} from "src/MigrationVault.sol";
import {RewardPot} from "src/RewardPot.sol";

contract ScratchERC20 is ERC20 {
    constructor(string memory n, string memory s) ERC20(n, s) {}

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

contract ScratchFeed {
    uint8 public decimals = 8;
    int256 public answer;
    uint256 public updatedAt;

    function set(int256 a, uint256 t) external {
        answer = a;
        updatedAt = t;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @dev Anyone: settles 1 wei of IMD into the PoolManager and mints the ERC-6909 claim to the hook.
contract ClaimDonor is IUnlockCallback {
    IPoolManager immutable manager;
    ScratchERC20 immutable imd;
    address immutable target;

    constructor(IPoolManager m, ScratchERC20 i, address t) {
        manager = m;
        imd = i;
        target = t;
    }

    function donate() external {
        manager.unlock("");
    }

    function unlockCallback(bytes calldata) external returns (bytes memory) {
        Currency c = Currency.wrap(address(imd));
        manager.sync(c);
        imd.transfer(address(manager), 1);
        manager.settle();
        manager.mint(target, c.toId(), 1);
        return "";
    }
}

contract PartialFillFeeTest is Test {
    address constant OWNER = 0x48E4E74fE1d0c14404cEB57B9fec5b21329C6ec9;
    uint160 constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
        | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    ScratchERC20 imd;
    ScratchERC20 v1;
    ScratchFeed feed;
    UnlockV2Token token;
    UnlockV2Hook hook;
    RewardPot pot;
    PoolKey key;
    PoolKey refKey;
    bool tokenIs0;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");
    address attacker = makeAddr("attacker");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_700_000_000);
        vm.roll(20_000_000);
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new ScratchERC20("IMD", "IMD");
        v1 = new ScratchERC20("UNLOCK", "UNLK");
        feed = new ScratchFeed();
        feed.set(3000e8, block.timestamp);

        token = new UnlockV2Token(); // this test is the launch factory
        address hookAddr = address(uint160(uint160(0x1234) << 20) | FLAGS);
        deployCodeTo(
            "UnlockV2Hook.sol:UnlockV2Hook",
            abi.encode(
                IPoolManager(address(manager)),
                address(token),
                address(imd),
                address(this),
                OWNER,
                address(v1),
                address(feed),
                block.chainid
            ),
            hookAddr
        );
        hook = UnlockV2Hook(hookAddr);
        pot = hook.rewardPot();

        tokenIs0 = address(token) < address(imd);
        key = PoolKey(
            Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            12500,
            60,
            IHooks(hookAddr)
        );
        refKey = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(imd)), 10000, 200, IHooks(address(0)));

        imd.mint(address(this), 1e30);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1000 ether);

        int24 t = tokenIs0 ? int24(-92100) : int24(92100);
        manager.initialize(key, TickMath.getSqrtPriceAtTick(t));
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(t - 6000, t + 6000, 1e24, 0), "");
        manager.initialize(refKey, TickMath.getSqrtPriceAtTick(80000));
        lpRouter.modifyLiquidity{value: 10 ether}(refKey, ModifyLiquidityParams(79000, 81000, 1e21, 0), "");

        token.transfer(OWNER, 750_000_000e18);
        token.transfer(alice, 1e18);
        vm.startPrank(OWNER);
        token.transfer(address(hook.migrationVault()), 700_000_000e18);
        hook.activate();
        vm.stopPrank();
    }

    function test_partialFillPaysFeeOnUnexecutedAmount() public {
        imd.mint(bob, 1_000e18);
        vm.startPrank(bob);
        imd.approve(address(swapRouter), type(uint256).max);
        bool zeroForOne = !tokenIs0;
        int24 t = tokenIs0 ? int24(-92100) : int24(92100);
        uint160 limit = TickMath.getSqrtPriceAtTick(zeroForOne ? t - 60 : t + 60);
        uint256 before = imd.balanceOf(bob);
        swapRouter.swap(key, SwapParams(zeroForOne, -1_000e18, limit), PoolSwapTest.TestSettings(false, false), "");
        vm.stopPrank();
        uint256 paid = before - imd.balanceOf(bob);
        uint256 fee = hook.pendingFees();
        uint256 executed = paid - fee;
        emit log_named_uint("paid", paid);
        emit log_named_uint("fee", fee);
        // reward fee should be 1% of the executed IMD leg (rounded down)
        assertLe(fee, executed / 100 + 1);
    }
}

// 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/PoolManager.sol";
import {IPoolManager} from "v4-core/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/test/PoolModifyLiquidityTest.sol";

import {UnlockV2Token} from "src/UnlockV2Token.sol";
import {UnlockV2Hook} from "src/UnlockV2Hook.sol";
import {MigrationVault} from "src/MigrationVault.sol";
import {RewardPot} from "src/RewardPot.sol";

contract ScratchERC20 is ERC20 {
    constructor(string memory n, string memory s) ERC20(n, s) {}

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

contract ScratchFeed {
    uint8 public decimals = 8;
    int256 public answer;
    uint256 public updatedAt;

    function set(int256 a, uint256 t) external {
        answer = a;
        updatedAt = t;
    }

    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        return (1, answer, updatedAt, updatedAt, 1);
    }
}

/// @dev A migrated holder (0% sell allowance before gate 1) converts UNLK2 to IMD inside the official pool
///      by parking it as a token-only range order and removing it after a buyer swaps through the range.
contract LiquidityBypassTest is Test {
    address constant OWNER = 0x48E4E74fE1d0c14404cEB57B9fec5b21329C6ec9;
    uint160 constant FLAGS = Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
        | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    ScratchERC20 imd;
    ScratchERC20 v1;
    ScratchFeed feed;
    UnlockV2Token token;
    UnlockV2Hook hook;
    MigrationVault vault;
    PoolKey key;
    PoolKey refKey;
    bool tokenIs0;
    int24 t;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    receive() external payable {}

    function setUp() public {
        vm.warp(1_700_000_000);
        vm.roll(20_000_000);
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new ScratchERC20("IMD", "IMD");
        v1 = new ScratchERC20("UNLOCK", "UNLK");
        feed = new ScratchFeed();
        feed.set(3000e8, block.timestamp);

        token = new UnlockV2Token(); // this test is the launch factory
        address hookAddr = address(uint160(uint160(0x1234) << 20) | FLAGS);
        deployCodeTo(
            "UnlockV2Hook.sol:UnlockV2Hook",
            abi.encode(
                IPoolManager(address(manager)),
                address(token),
                address(imd),
                address(this),
                OWNER,
                address(v1),
                address(feed),
                block.chainid
            ),
            hookAddr
        );
        hook = UnlockV2Hook(hookAddr);
        vault = hook.migrationVault();

        tokenIs0 = address(token) < address(imd);
        key = PoolKey(
            Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            12500,
            60,
            IHooks(hookAddr)
        );
        refKey = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(imd)), 10000, 200, IHooks(address(0)));

        imd.mint(address(this), 1e30);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 1000 ether);

        t = tokenIs0 ? int24(-92100) : int24(92100);
        manager.initialize(key, TickMath.getSqrtPriceAtTick(t));
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(t - 6000, t + 6000, 1e24, 0), "");
        manager.initialize(refKey, TickMath.getSqrtPriceAtTick(80000));
        lpRouter.modifyLiquidity{value: 10 ether}(refKey, ModifyLiquidityParams(79000, 81000, 1e21, 0), "");

        token.transfer(OWNER, 750_000_000e18);
        vm.startPrank(OWNER);
        token.transfer(address(vault), 700_000_000e18);
        hook.activate();
        vm.stopPrank();
    }

    function test_migratedHolderExitsThroughRangeOrder() public {
        // alice migrates 1,000,000 V1 -> V2: origin "migration", 0% before gate 1
        v1.mint(alice, 1_000_000e18);
        vm.startPrank(alice);
        v1.approve(address(vault), type(uint256).max);
        vault.migrate(1_000_000e18);
        assertEq(hook.sellAllowance(alice), 0);
        assertEq(hook.gatesOpen(), 0);

        // a direct sell is refused by the hook
        token.approve(address(swapRouter), type(uint256).max);
        bool sellZeroForOne = tokenIs0;
        vm.expectRevert();
        swapRouter.swap(
            key,
            SwapParams(sellZeroForOne, -1_000e18, sellZeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );

        // but a token-only range order just past the current price is accepted: no hook callback runs
        token.approve(address(lpRouter), type(uint256).max);
        (int24 lo, int24 hi) = tokenIs0 ? (t + 60, t + 660) : (t - 660, t - 60);
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, 1e23, 0), "");
        vm.stopPrank();
        assertEq(imd.balanceOf(alice), 0);

        // bob buys through the range
        imd.mint(bob, 1_000e18);
        vm.startPrank(bob);
        imd.approve(address(swapRouter), type(uint256).max);
        bool buyZeroForOne = !tokenIs0;
        swapRouter.swap(
            key,
            SwapParams(buyZeroForOne, -1_000e18, buyZeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        vm.stopPrank();

        // alice removes the position and walks away with IMD; no sale was recorded
        vm.prank(alice);
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(lo, hi, -1e23, 0), "");
        assertEq(hook.sellAllowance(alice), 0);
        assertEq(hook.gatesOpen(), 0);
        assertEq(imd.balanceOf(alice), 0, "a 0% holder must not receive IMD from the official pool");
    }
}