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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.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 {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {WordsmithHook} from "src/WordsmithHook.sol";

contract PartialFillFeeTest is Test {
    address constant RECIPIENT = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    uint160 constant SQRT_1_1 = 79228162514264337593543950336;
    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;
    MockERC20 token;
    WordsmithHook hook;
    PoolKey key;
    address alice = makeAddr("alice");

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        token = new MockERC20("Word", "WORD", 18);
        token.mint(address(this), 100_000 ether);
        token.approve(address(lpRouter), type(uint256).max);
        address hookAddr = address(uint160(0x4444 << 144) | FLAGS);
        deployCodeTo("WordsmithHook.sol:WordsmithHook", abi.encode(manager), hookAddr);
        hook = WordsmithHook(hookAddr);
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 3000, 60, IHooks(hookAddr));
        manager.initialize(key, SQRT_1_1);
        vm.deal(address(this), 1000 ether);
        lpRouter.modifyLiquidity{value: 300 ether}(key, ModifyLiquidityParams(-6000, 6000, 1000 ether, 0), "");
        vm.deal(alice, 100 ether);
        token.mint(alice, 1000 ether);
        vm.prank(alice);
        token.approve(address(swapRouter), type(uint256).max);
        // past the launch window so the buy cap is not involved
        vm.warp(block.timestamp + 31 minutes);
    }

    /// Exact-input buy of 10 ETH whose price limit lets only ~0.5 ETH trade:
    /// the fee must be 0.5% of the ETH actually swapped, not of the 10 ETH requested.
    function test_exactInputBuyPartialFillFeeOnSwappedEthOnly() public {
        uint256 ethBefore = alice.balance;
        vm.prank(alice, alice);
        try swapRouter.swap{value: 10 ether}(
            key, SwapParams(true, -10 ether, TickMath.getSqrtPriceAtTick(-10)), PoolSwapTest.TestSettings(false, false), ""
        ) {} catch {
            return; // a fix that refuses partial fills also keeps the buyer from overpaying
        }
        uint256 spent = ethBefore - alice.balance;
        uint256 fee = RECIPIENT.balance;
        uint256 swapped = spent - fee;
        emit log_named_uint("ETH that entered the pool", swapped);
        emit log_named_uint("fee taken", fee);
        assertLe(fee, swapped * 50 / 10_000 + 1, "fee exceeds 0.5% of the ETH side of the trade");
    }

    /// Exact-output sell asking for 10 ETH whose price limit lets only ~0.5 ETH out:
    /// a seller must never pay ETH to sell tokens.
    function test_exactOutputSellPartialFillNeverChargesSellerEth() public {
        uint256 ethBefore = alice.balance;
        vm.prank(alice, alice);
        try swapRouter.swap{value: 1 ether}(
            key, SwapParams(false, 10 ether, TickMath.getSqrtPriceAtTick(1)), PoolSwapTest.TestSettings(false, false), ""
        ) {} catch {
            return; // a fix that refuses partial fills also keeps the seller from paying ETH
        }
        uint256 fee = RECIPIENT.balance;
        emit log_named_uint("fee taken", fee);
        emit log_named_uint("tokens sold", 1000 ether - token.balanceOf(alice));
        assertGe(alice.balance, ethBefore, "seller paid ETH on a sell");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.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 {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {WordsmithHook} from "src/WordsmithHook.sol";

contract WindowPreInitTest is Test {
    uint160 constant SQRT_1_1 = 79228162514264337593543950336;
    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;

    receive() external payable {}

    function test_sniperPreInitializesSoWindowIsOverWhenTradingOpens() public {
        PoolManager manager = new PoolManager(address(this));
        PoolSwapTest swapRouter = new PoolSwapTest(manager);
        PoolModifyLiquidityTest lpRouter = new PoolModifyLiquidityTest(manager);
        MockERC20 token = new MockERC20("Word", "WORD", 18);
        token.mint(address(this), 1000 ether);
        token.approve(address(lpRouter), type(uint256).max);
        address hookAddr = address(uint160(0x4444 << 144) | FLAGS);
        deployCodeTo("WordsmithHook.sol:WordsmithHook", abi.encode(manager), hookAddr);
        PoolKey memory key =
            PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 3000, 60, IHooks(hookAddr));

        // sniper initializes the creator's PoolKey ahead of time (no liquidity, nothing to trade)
        address sniper = makeAddr("sniper");
        vm.prank(sniper);
        manager.initialize(key, SQRT_1_1);

        // creator adds liquidity 31 minutes later: this is when trading actually opens
        vm.warp(block.timestamp + 31 minutes);
        vm.deal(address(this), 1000 ether);
        lpRouter.modifyLiquidity{value: 300 ether}(key, ModifyLiquidityParams(-6000, 6000, 1000 ether, 0), "");

        // first buy after opening: sniper takes 10 tokens = 1% of supply (cap is 0.5% = 5 tokens)
        vm.deal(sniper, 100 ether);
        vm.prank(sniper, sniper);
        try swapRouter.swap{value: 20 ether}(
            key, SwapParams(true, 10 ether, TickMath.MIN_SQRT_PRICE + 1), PoolSwapTest.TestSettings(false, false), ""
        ) {} catch {
            return; // cap enforced: the over-limit buy is refused
        }
        assertLe(token.balanceOf(sniper), token.totalSupply() * 50 / 10_000, "first buy after opening exceeded cap");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {WordsmithHook} from "src/WordsmithHook.sol";

/// @notice When ETH is the specified currency, WordsmithHook.beforeSwap charges 0.5% of
/// params.amountSpecified, not of the ETH the pool actually moved. A swap that stops at its
/// sqrtPriceLimitX96 (partial fill) therefore pays a fee that is a multiple of the trade.
///
/// A fixed hook may either charge 0.5% of the ETH actually moved or refuse partially filled swaps
/// whose fee was pre-charged; both tests accept either outcome and fail only on the overcharge.
contract PartialFillFeeTest is Test {
    address constant RECIPIENT = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    uint160 constant SQRT_1_1 = 79228162514264337593543950336;
    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;
    MockERC20 token;
    WordsmithHook hook;
    PoolKey key;
    address alice = makeAddr("alice");

    function setUp() public {
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        token = new MockERC20("Word", "WORD", 18);
        token.mint(address(this), 1000 ether);
        token.approve(address(lpRouter), type(uint256).max);

        address hookAddr = address(uint160(0x4444 << 144) | FLAGS);
        deployCodeTo("WordsmithHook.sol:WordsmithHook", abi.encode(manager), hookAddr);
        hook = WordsmithHook(hookAddr);

        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 3000, 60, IHooks(hookAddr));
        manager.initialize(key, SQRT_1_1);
        vm.deal(address(this), 1000 ether);
        lpRouter.modifyLiquidity{value: 300 ether}(key, ModifyLiquidityParams(-6000, 6000, 1000 ether, 0), "");

        vm.deal(alice, 1000 ether);
        token.mint(alice, 1000 ether);
        vm.prank(alice);
        token.approve(address(swapRouter), type(uint256).max);
        // the launch-window buy limit is not what is under test here
        vm.warp(hook.windowClosesAt(key.toId()));
    }

    receive() external payable {}

    /// Returns false if the swap reverted (a fixed hook may refuse partial fills with a pre-charged fee).
    function _trySwap(bool zeroForOne, int256 amount, uint160 limit, uint256 value) internal returns (bool ok) {
        vm.prank(alice, alice);
        try swapRouter.swap{value: value}(
            key, SwapParams(zeroForOne, amount, limit), PoolSwapTest.TestSettings(false, false), ""
        ) {
            ok = true;
        } catch {
            ok = false;
        }
    }

    /// Exact-input buy of 100 ETH with a price limit 0.1% below spot. The pool only absorbs about
    /// 1 ETH of the input, but the fee is 0.5 ETH (0.5% of the 100 ETH specified): ~50% of the trade.
    function test_exactInputBuyPartialFillChargesFeeOnUnfilledInput() public {
        uint256 managerBefore = address(manager).balance;
        uint160 limit = SQRT_1_1 - SQRT_1_1 / 1000;
        if (!_trySwap(true, -100 ether, limit, 100 ether)) return;
        uint256 fee = RECIPIENT.balance;
        // ETH the pool actually absorbed: the manager's balance grew by what alice settled minus the fee
        // that left to the recipient, so gross ETH side = growth + fee.
        uint256 ethToPool = address(manager).balance - managerBefore;
        emit log_named_uint("eth actually swapped into pool", ethToPool);
        emit log_named_uint("fee paid", fee);
        assertLe(fee, (ethToPool + fee) * 50 / 10_000 + 1, "fee exceeds 0.5% of the ETH the swap moved");
    }

    /// Exact-output sell asking for 100 ETH with a price limit 0.1% above spot. The pool pays out
    /// about 1 ETH, yet the hook keeps 0.5 ETH of it: the seller loses ~50% of the sale to the fee.
    function test_exactOutputSellPartialFillTakesMoreThanTheSwapPaid() public {
        uint256 managerBefore = address(manager).balance;
        uint160 limit = SQRT_1_1 + SQRT_1_1 / 1000;
        if (!_trySwap(false, 100 ether, limit, 0)) return;
        uint256 fee = RECIPIENT.balance;
        // gross ETH paid out by the pool = everything that left the manager (seller's share + fee)
        uint256 grossOut = managerBefore - address(manager).balance;
        emit log_named_uint("gross eth out of pool", grossOut);
        emit log_named_uint("fee paid", fee);
        assertLe(fee, grossOut * 50 / 10_000 + 1, "fee exceeds 0.5% of the ETH the pool paid out");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.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 {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {WordsmithHook} from "src/WordsmithHook.sol";

/// @notice Fee on ETH-specified swaps is computed from params.amountSpecified, not from the ETH the pool
/// actually moved. When the swap only partially fills (liquidity range exhausted), the swapper pays 0.5% of the
/// requested amount, which can be many times 0.5% of the executed amount. Fails now; passes once the fee
/// charged is at most 0.5% of the ETH actually swapped (or the hook rejects the partial fill).
contract PartialFillFeeTest is Test {
    address constant RECIPIENT = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    uint160 constant SQRT_1_1 = 79228162514264337593543950336;
    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;
    MockERC20 token;
    WordsmithHook hook;
    PoolKey key;
    address alice = makeAddr("alice");

    function setUp() public {
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        token = new MockERC20("Word", "WORD", 18);
        token.mint(address(this), 1000 ether);
        token.approve(address(lpRouter), type(uint256).max);

        address hookAddr = address(uint160(0x4444 << 144) | FLAGS);
        deployCodeTo("WordsmithHook.sol:WordsmithHook", abi.encode(manager), hookAddr);
        hook = WordsmithHook(hookAddr);

        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 3000, 60, IHooks(hookAddr));
        manager.initialize(key, SQRT_1_1);
        vm.deal(address(this), 1000 ether);
        // concentrated position: a large swap exits the range and is only partially filled
        lpRouter.modifyLiquidity{value: 300 ether}(key, ModifyLiquidityParams(-600, 600, 1000 ether, 0), "");

        vm.deal(alice, 1000 ether);
        token.mint(alice, 1000 ether);
        vm.prank(alice);
        token.approve(address(swapRouter), type(uint256).max);
        vm.warp(block.timestamp + 31 minutes); // outside the launch window so the buy cap does not interfere
    }

    receive() external payable {}

    function _try(bool zeroForOne, int256 amount, uint256 value) internal returns (bool ok) {
        vm.prank(alice, alice);
        try swapRouter.swap{value: value}(
            key,
            SwapParams(zeroForOne, amount, zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        ) {
            ok = true;
        } catch {
            ok = false;
        }
    }

    /// Exact-input buy of 500 ETH into a pool whose range only absorbs ~30 ETH.
    function test_exactInputBuyFeeTracksExecutedEth() public {
        uint256 ethBefore = alice.balance;
        uint256 feeBefore = RECIPIENT.balance + hook.pendingFees();
        bool ok = _try(true, -500 ether, 500 ether);
        if (!ok) return; // rejecting the partial fill is an acceptable fix
        uint256 fee = RECIPIENT.balance + hook.pendingFees() - feeBefore;
        uint256 poolReceived = ethBefore - alice.balance - fee;
        // fee must be 0.5% of the ETH the pool actually took (1 wei rounding slack)
        assertLe(fee, poolReceived * 50 / 10_000 + 1, "fee exceeds 0.5% of ETH actually swapped");
    }

    /// Exact-output sell asking for 200 ETH from a pool whose range only yields ~30 ETH.
    function test_exactOutputSellFeeTracksExecutedEth() public {
        uint256 ethBefore = alice.balance;
        uint256 feeBefore = RECIPIENT.balance + hook.pendingFees();
        bool ok = _try(false, 200 ether, 0);
        if (!ok) return;
        uint256 fee = RECIPIENT.balance + hook.pendingFees() - feeBefore;
        uint256 received = alice.balance - ethBefore;
        // fee must be 0.5% of the ETH the pool actually paid out (received + fee)
        assertLe(fee, (received + fee) * 50 / 10_000 + 1, "fee exceeds 0.5% of ETH actually swapped");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {WordsmithHook} from "src/WordsmithHook.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 {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, CurrencyLibrary} 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";

// Minimal standard transfer/approval token, wholly contained in this proof file.
contract ProofToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

// A complete unlock/swap/settle transaction, with no dependency on other test files.
contract ProofRouter is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }
    receive() external payable {}

    function provide(PoolKey calldata key) external payable {
        manager.unlock(abi.encode(true, key, SwapParams(false, 0, 0), msg.sender));
        _refund();
    }

    function trade(PoolKey calldata key, SwapParams calldata params) external payable returns (BalanceDelta delta) {
        delta = abi.decode(manager.unlock(abi.encode(false, key, params, msg.sender)), (BalanceDelta));
        _refund();
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool adding, PoolKey memory key, SwapParams memory params, address actor) =
            abi.decode(data, (bool, PoolKey, SwapParams, address));
        BalanceDelta delta;
        if (adding) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-6000, 6000, 1000 ether, 0), "");
        } else {
            delta = manager.swap(key, params, "");
        }
        _settle(key.currency0, delta.amount0(), actor);
        _settle(key.currency1, delta.amount1(), actor);
        return abi.encode(delta);
    }

    function _settle(Currency currency, int128 delta, address actor) internal {
        if (delta > 0) manager.take(currency, actor, uint256(int256(delta)));
        if (delta < 0) {
            uint256 amount = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) {
                manager.settle{value: amount}();
            } else {
                manager.sync(currency);
                ProofToken(Currency.unwrap(currency)).transferFrom(actor, address(manager), amount);
                manager.settle();
            }
        }
    }

    function _refund() internal {
        if (address(this).balance > 0) {
            (bool ok,) = msg.sender.call{value: address(this).balance}("");
            require(ok);
        }
    }
}

contract WordsmithPartialFillProof is Test {
    address constant RECIPIENT = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    PoolManager manager;
    WordsmithHook hook;
    ProofToken token;
    ProofRouter router;
    PoolKey key;
    address buyer;

    function setUp() public {
        vm.warp(1000);
        manager = new PoolManager(address(this));
        router = new ProofRouter(manager);
        token = new ProofToken();
        token.mint(address(this), 1000 ether);
        token.approve(address(router), type(uint256).max);
        uint160 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;
        address hookAddress = address(uint160(0x7777 << 144) | flags);
        deployCodeTo("WordsmithHook.sol:WordsmithHook", abi.encode(manager), hookAddress);
        hook = WordsmithHook(hookAddress);
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 3000, 60, IHooks(hookAddress));
        manager.initialize(key, uint160(1 << 96));
        vm.deal(address(this), 1000 ether);
        router.provide{value: 300 ether}(key);
        buyer = makeAddr("partial-fill-buyer");
        vm.deal(buyer, 100 ether);
    }

    receive() external payable {}

    function test_partialFillMustNotChargeForUnspentInput() public {
        uint256 ethBefore = buyer.balance;
        uint256 recipientBefore = RECIPIENT.balance;
        vm.prank(buyer, buyer);
        // The limit permits only one tick of price movement. Most of the 10 ETH is refunded.
        BalanceDelta delta =
            router.trade{value: 10 ether}(key, SwapParams(true, -10 ether, TickMath.getSqrtPriceAtTick(-1)));
        uint256 spent = ethBefore - buyer.balance;
        uint256 fee = RECIPIENT.balance - recipientBefore;
        assertGt(delta.amount1(), 0, "a real buy must occur");
        assertLt(spent, 10 ether, "the price limit must cause a partial fill");
        emit log_named_uint("actual ETH debited", spent);
        emit log_named_uint("fee paid to recipient", fee);
        // Even if the fee base includes the fee itself, it cannot exceed 0.5% of spent ETH.
        assertLe(fee, spent / 200, "fee exceeds 0.5% of the ETH actually spent");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {WordsmithHook} from "src/WordsmithHook.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 {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, CurrencyLibrary} 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";

// Minimal standard transfer/approval token, wholly contained in this proof file.
contract ProofToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

// A complete unlock/swap/settle transaction, with no dependency on other test files.
contract ProofRouter is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }
    receive() external payable {}

    function provide(PoolKey calldata key) external payable {
        manager.unlock(abi.encode(true, key, SwapParams(false, 0, 0), msg.sender));
        _refund();
    }

    function trade(PoolKey calldata key, SwapParams calldata params) external payable returns (BalanceDelta delta) {
        delta = abi.decode(manager.unlock(abi.encode(false, key, params, msg.sender)), (BalanceDelta));
        _refund();
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool adding, PoolKey memory key, SwapParams memory params, address actor) =
            abi.decode(data, (bool, PoolKey, SwapParams, address));
        BalanceDelta delta;
        if (adding) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-6000, 6000, 1000 ether, 0), "");
        } else {
            delta = manager.swap(key, params, "");
        }
        _settle(key.currency0, delta.amount0(), actor);
        _settle(key.currency1, delta.amount1(), actor);
        return abi.encode(delta);
    }

    function _settle(Currency currency, int128 delta, address actor) internal {
        if (delta > 0) manager.take(currency, actor, uint256(int256(delta)));
        if (delta < 0) {
            uint256 amount = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) {
                manager.settle{value: amount}();
            } else {
                manager.sync(currency);
                ProofToken(Currency.unwrap(currency)).transferFrom(actor, address(manager), amount);
                manager.settle();
            }
        }
    }

    function _refund() internal {
        if (address(this).balance > 0) {
            (bool ok,) = msg.sender.call{value: address(this).balance}("");
            require(ok);
        }
    }
}

contract WordsmithWalletCapProof is Test {
    address constant RECIPIENT = 0x5Bff2a2FEcD1d6152676813b21346238733bEAB1;
    PoolManager manager;
    WordsmithHook hook;
    ProofToken token;
    ProofRouter router;
    PoolKey key;
    address buyer;

    function setUp() public {
        vm.warp(1000);
        manager = new PoolManager(address(this));
        router = new ProofRouter(manager);
        token = new ProofToken();
        token.mint(address(this), 1000 ether);
        token.approve(address(router), type(uint256).max);
        uint160 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;
        address hookAddress = address(uint160(0x7777 << 144) | flags);
        deployCodeTo("WordsmithHook.sol:WordsmithHook", abi.encode(manager), hookAddress);
        hook = WordsmithHook(hookAddress);
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 3000, 60, IHooks(hookAddress));
        manager.initialize(key, uint160(1 << 96));
        vm.deal(address(this), 1000 ether);
        router.provide{value: 300 ether}(key);
        buyer = makeAddr("partial-fill-buyer");
        vm.deal(buyer, 100 ether);
    }

    receive() external payable {}

    function test_sameWalletCannotBuyOverCapThroughDifferentExecutors() public {
        address first = makeAddr("executor-one");
        address second = makeAddr("executor-two");
        ProofSmartWallet wallet = new ProofSmartWallet(manager, first, second);
        vm.deal(address(wallet), 100 ether);
        vm.prank(first, first);
        wallet.buy(key, 3 ether);
        assertEq(token.balanceOf(address(wallet)), 3 ether, "first buy is below the five token cap");
        vm.prank(second, second);
        try wallet.buy(key, 3 ether) {} catch {}
        emit log_named_uint("tokens bought by the same wallet", token.balanceOf(address(wallet)));
        emit log_named_uint("wallet limit", token.totalSupply() / 200);
        assertLe(
            token.balanceOf(address(wallet)),
            token.totalSupply() / 200,
            "one wallet exceeded the cap by changing tx.origin"
        );
    }
}

contract ProofSmartWallet is ProofRouter {
    address immutable executorOne;
    address immutable executorTwo;

    constructor(IPoolManager manager_, address first, address second) ProofRouter(manager_) {
        executorOne = first;
        executorTwo = second;
    }

    function buy(PoolKey calldata key, uint256 amount) external {
        require(msg.sender == executorOne || msg.sender == executorTwo, "unauthorized executor");
        // The wallet itself is the v4 swap caller, payer and output recipient.
        manager.unlock(
            abi.encode(false, key, SwapParams(true, int256(amount), TickMath.MIN_SQRT_PRICE + 1), address(this))
        );
    }
}